pep8

theano/gradient.py

@@ -78,8 +78,7 @@ def grad_not_implemented(op, x_pos, x, comment=""):
     gradient is not implemented.
     """
 
-    return (NullType(
-        (
+    return (NullType((
         "This variable is Null because the grad method for "
         "input %s (%s) of the %s op is not implemented. %s"
         ) % (x_pos, x, op, comment)))()
@@ -406,17 +405,16 @@ def grad(cost, wrt, consider_constant=None,
 
     if cost is not None and isinstance(cost.type, NullType):
         raise ValueError("Can't differentiate a NaN cost."
-            "cost is NaN because " + \
+                         "cost is NaN because " +
                          cost.type.why_null)
 
     if cost is not None and cost.ndim != 0:
         raise TypeError("cost must be a scalar.")
 
-
     if isinstance(wrt, set):
         raise TypeError("wrt must not be a set. sets have no defined "
-                "iteration order, so we can't return gradients in a matching"
-                " order.")
+                        "iteration order, so we can't return gradients in a"
+                        "  matching order.")
 
     using_list = isinstance(wrt, list)
     using_tuple = isinstance(wrt, tuple)
@@ -426,7 +424,7 @@ def grad(cost, wrt, consider_constant=None,
     for elem in wrt:
         if not isinstance(elem, Variable):
             raise TypeError("Expected Variable, got " + str(elem) +
-                    " of type "+str(type(elem)))
+                            " of type " + str(type(elem)))
 
     outputs = []
     if cost is not None:
@@ -452,7 +450,8 @@ def grad(cost, wrt, consider_constant=None,
         # g_cost may be Disconnected or NullType. A creative use of the function,
         # sure, but nonetheless one we can and should support. So before we try
         # to cast it make sure it even has a dtype
-        if hasattr(g_cost.type, 'dtype') and cost.type.dtype not in tensor.discrete_dtypes:
+        if (hasattr(g_cost.type, 'dtype') and
+            cost.type.dtype not in tensor.discrete_dtypes):
             # Here we enforce the constraint that floating point variables have
             # the same dtype as their gradient.
             g_cost = g_cost.astype(cost.type.dtype)
@@ -471,8 +470,8 @@ def grad(cost, wrt, consider_constant=None,
                 'Ambiguous whether %s should be made into tensor'
                 ' or sparse theano variable' % str(type(g_var)))
 
-        if not isinstance(g_var.type, (NullType, DisconnectedType)) and 'float' \
-            not in str(g_var.type.dtype):
+        if (not isinstance(g_var.type, (NullType, DisconnectedType)) and
+            'float' not in str(g_var.type.dtype)):
             raise TypeError("Gradients must always be NullType, "
                     "DisconnectedType, or continuous, but grad was "
                     "given a known_grad of type "+str(g_var.type))
@@ -728,11 +727,13 @@ def _populate_var_to_app_to_idx(outputs, wrt, consider_constant):
 
     return var_to_app_to_idx
 
+
 class NullTypeGradError(TypeError):
     """
     Raised when grad encounters a NullType.
     """
 
+
 class DisconnectedInputError(ValueError):
     """
     Raised when grad is asked to compute the gradient
@@ -740,6 +741,7 @@ class DisconnectedInputError(ValueError):
     disconnected_inputs='raise'.
     """
 
+
 def _populate_grad_dict(var_to_app_to_idx,
                         grad_dict, wrt, cost_name=None):
     """
@@ -902,7 +904,7 @@ def _populate_grad_dict(var_to_app_to_idx,
                                     "expected iterable." % str(node.op))
 
                 if len(input_grads) != len(inputs):
-                    raise ValueError(("%s returned the wrong number of" +\
+                    raise ValueError(("%s returned the wrong number of" +
                                       " gradient terms.") % str(node.op))
 
             # must convert to list in case the op returns a tuple
@@ -926,7 +928,7 @@ def _populate_grad_dict(var_to_app_to_idx,
                     # used to mean undefined, zero, or disconnected.
                     # We therefore don't allow it because its usage has become
                     # so muddied.
-                    raise TypeError(('%s.grad returned None for' +\
+                    raise TypeError(('%s.grad returned None for' +
                              ' a gradient term, '
                             'this is prohibited. Instead of None,'
                             'return zeros_like(input), DisconnectedType()(),'
@@ -980,8 +982,8 @@ def _populate_grad_dict(var_to_app_to_idx,
 
             #Check that op.connection_pattern matches the connectivity
             #logic driving the op.grad method
-            for i, packed in \
-                enumerate(zip(inputs, input_grads, inputs_connected)):
+            for i, packed in enumerate(zip(inputs, input_grads,
+                                           inputs_connected)):
                 ipt, ig, connected = packed
                 actually_connected = \
                     not isinstance(ig.type, DisconnectedType)
@@ -1031,7 +1033,7 @@ def _populate_grad_dict(var_to_app_to_idx,
 
                         if isinstance(term.type, NullType):
                             raise NullTypeGradError("tensor.grad "
-                                "encountered a NaN. " +\
+                                "encountered a NaN. " +
                                     term.type.why_null)
 
                         #Don't try to sum up DisconnectedType placeholders
@@ -1243,14 +1245,12 @@ class numeric_grad(object):
 
         """
         if len(g_pt) != len(self.gf):
-            raise ValueError(
-                    'argument has wrong number of elements',
+            raise ValueError('argument has wrong number of elements',
                              len(g_pt))
         errs = []
         for i, (a, b) in enumerate(zip(g_pt, self.gf)):
             if a.shape != b.shape:
-                raise ValueError(
-                        'argument element %i has wrong shape %s' % (
+                raise ValueError('argument element %i has wrong shape %s' % (
                     i, str((a.shape, b.shape))))
             errs.append(numeric_grad.abs_rel_err(a, b))
         return errs
@@ -1368,7 +1368,8 @@ def verify_grad(fun, pt, n_tests=2, rng=None, eps=None,
     def function(inputs, output):
         if mode is None:
             f = compile.function(inputs, output, accept_inplace=True,
-                    allow_input_downcast=True, on_unused_input='ignore')
+                                 allow_input_downcast=True,
+                                 on_unused_input='ignore')
         else:
             f = compile.function(inputs, output, accept_inplace=True,
                                  allow_input_downcast=True, mode=mode,

theano/sandbox/linalg/tests/test_linalg.py

@@ -561,6 +561,7 @@ class test_Eigh(test_Eig):
 class test_Eigh_float32(test_Eigh):
     dtype = 'float32'
 
+
 def test_matrix_inverse_solve():
     if not imported_scipy:
         raise SkipTest("Scipy needed for the Solve op.")