some pep8

theano/scalar/basic.py

@@ -148,7 +148,8 @@ class Scalar(Type):
                 return py_type(data)
             else:
                 raise TypeError('Value cannot accurately be converted to dtype'
-                          ' (%s) and allow_downcast is not True' % self.dtype)
+                                ' (%s) and allow_downcast is not True' %
+                                self.dtype)
         except Exception, e:
             raise TypeError("Could not convert %s (value=%s) to %s" % (
                 type(data), data, self.dtype), e)
@@ -777,17 +778,18 @@ class ScalarOp(Op):
         if output_types_preference is not None:
             if not callable(output_types_preference):
                 raise TypeError(
-                    "Expected a callable for the 'output_types_preference' argument to %s. (got: %s)" % (self.__class__, output_types_preference))
+                    "Expected a callable for the 'output_types_preference' argument to %s. (got: %s)" %
+                    self.__class__, output_types_preference)
             self.output_types_preference = output_types_preference
 
     def make_node(self, *inputs):
         if self.nin >= 0:
             if len(inputs) != self.nin:
-                raise TypeError("Wrong number of inputs for %s.make_node (got %i(%s), expected %i)" \
-                                    % (self, len(inputs), str(inputs), self.nin))
+                raise TypeError("Wrong number of inputs for %s.make_node (got %i(%s), expected %i)" %
+                                self, len(inputs), str(inputs), self.nin)
         inputs = [as_scalar(input) for input in inputs]
-        outputs = [t() for t in self.output_types([input.
-            type for input in inputs])]
+        outputs = [t() for t in self.output_types([input.type
+                                                   for input in inputs])]
         if len(outputs) != self.nout:
             raise TypeError("Not the right number of outputs produced for %s(%s). Expected %s, got %s."
                             % (self, ", ".join(str(input) for input in inputs), self.nout, len(outputs)))
@@ -895,6 +897,7 @@ class UnaryScalarOp(ScalarOp):
         %(fct)s(n, x, z);
         """ % locals()
 
+
 class BinaryScalarOp(ScalarOp):
     # One may define in subclasses the following fields:
     #   - `identity`: for an associative operation, identity corresponds to
@@ -929,7 +932,7 @@ class FixedLogicalComparison(UnaryScalarOp):
         return [int8]
 
     def grad(self, inputs, output_gradients):
-        x ,= inputs
+        x, = inputs
         out = self(x)
         assert str(out.type.dtype).find('int') != -1
         return [x.zeros_like().astype(theano.config.floatX)]
@@ -1158,8 +1161,9 @@ class BinaryBitOp(BinaryScalarOp):
         return upcast_out(*input_types[0])
 
     def grad(self, inputs, output_gradients):
-        a,b = inputs
-        return [a.zeros_like().astype(theano.config.floatX), b.zeros_like().astype(theano.config.floatX)]
+        a, b = inputs
+        return [a.zeros_like().astype(theano.config.floatX),
+                b.zeros_like().astype(theano.config.floatX)]
 
 
 class OR(BinaryBitOp):
@@ -1331,8 +1335,9 @@ class Mul(ScalarOp):
         output_type = self.output_types([i.type for i in inputs])[0]
         if output_type in complex_types:
             if not gz.type in complex_types:
-                raise TypeError('Mul with output_type ' + str(output_type) +\
-                        ' expected gz type to be complex, got gz with type ' +\
+                raise TypeError(
+                    'Mul with output_type ' + str(output_type) +
+                    ' expected gz type to be complex, got gz with type ' +
                     str(gz.type))
 
         if output_type in discrete_types: