Flake8 for compile/pfunc.py

theano/compile/pfunc.py

@@ -199,7 +199,7 @@ def rebuild_collect_shared(outputs,
         # filter_variable ensure smooth conversion of cpu/gpu Types
         try:
             update_val = store_into.type.filter_variable(update_val)
-        except TypeError as e:
+        except TypeError:
             err_msg = ('An update must have the same type as the'
                        ' original shared variable (shared_var=%s,'
                        ' shared_var.type=%s,'
@@ -275,35 +275,38 @@ def rebuild_collect_shared(outputs,
 
 class Param(object):
     def __init__(self, variable, default=None, name=None, mutable=False,
-            strict=False, allow_downcast=None, implicit=None, borrow=None):
+                 strict=False, allow_downcast=None, implicit=None,
+                 borrow=None):
         """
         :param variable: A variable in an expression graph to use as a
             compiled-function parameter
 
-        :param default: The default value to use at call-time (can also be a Container where
-            the function will find a value at call-time.)
+        :param default: The default value to use at call-time (can
+            also be a Container where the function will find a value
+            at call-time.)
 
         :param name: A string to identify this parameter from function kwargs.
 
         :param mutable: True -> function is allowed to modify this argument.
 
-        :param borrow: Whether the function is allowed to alias some output to
-            this input. Using None (default) means we re-use the same value as the
-            `mutable` flag.
+        :param borrow: Whether the function is allowed to alias some
+            output to this input. Using None (default) means we re-use
+            the same value as the `mutable` flag.
             False: do not permit any output to be aliased to the input
 
-        :param strict: False -> function arguments may be copied or cast to match the
-            type required by the parameter `variable`.
+        :param strict: False -> function arguments may be copied or
+            cast to match the type required by the parameter
+            `variable`.
             True -> function arguments must exactly match the type
             required by `variable`.
 
         :param allow_downcast: Only applies if `strict` is False.
-        True -> allow assigned value to lose precision when cast during assignment.
+        True -> allow assigned value to lose precision when cast
+            during assignment.
         False -> never allow precision loss.
         None -> only allow downcasting of a Python float to a scalar floatX.
 
         :param implicit: see help(theano.io.In)
-
         """
         self.variable = variable
         self.default = default
@@ -335,7 +338,7 @@ class Param(object):
 def pfunc(params, outputs=None, mode=None, updates=None, givens=None,
           no_default_updates=False, accept_inplace=False, name=None,
           rebuild_strict=True, allow_input_downcast=None,
-        profile=None, on_unused_input=None,output_keys=None):
+          profile=None, on_unused_input=None, output_keys=None):
     """Function-constructor for graphs with shared variables.
 
     :type params: list of either Variable or Param instances.
@@ -348,30 +351,35 @@ def pfunc(params, outputs=None, mode=None, updates=None, givens=None,
     :type mode: string or `theano.compile.Mode` instance.
     :param mode: compilation mode
 
-    :type updates: iterable over pairs (shared_variable, new_expression). List, tuple or dict.
-    :param updates: update the values for SharedVariable inputs according to these expressions
+    :type updates: iterable over pairs (shared_variable,
+        new_expression). List, tuple or dict.
+    :param updates: update the values for SharedVariable inputs
+        according to these expressions
 
-    :type givens: iterable over pairs (Var1, Var2) of Variables. List, tuple or dict.  The Var1
-    and Var2 in each pair must have the same Type.
+    :type givens: iterable over pairs (Var1, Var2) of Variables. List,
+        tuple or dict.  The Var1 and Var2 in each pair must have the
+        same Type.
 
-    :param givens: specific substitutions to make in the computation graph (Var2 replaces
-    Var1).
+    :param givens: specific substitutions to make in the computation
+        graph (Var2 replaces Var1).
 
     :type no_default_updates: either bool or list of Variables
-    :param no_default_updates: if True, do not perform any automatic update on Variables.
-    If False (default), perform them all. Else, perform automatic updates on all Variables
-    that are neither in "updates" nor in "no_default_updates".
+    :param no_default_updates: if True, do not perform any automatic
+        update on Variables.  If False (default), perform them
+        all. Else, perform automatic updates on all Variables that are
+        neither in "updates" nor in "no_default_updates".
 
     :type name: None or string
     :param name: attaches a name to the profiling result of this function.
 
     :type allow_input_downcast: Boolean
     :param allow_input_downcast: True means that the values passed as
-    inputs when calling the function can be silently downcasted to fit
-    the dtype of the corresponding Variable, which may lose precision.
-    False means that it will only be cast to a more general, or
-    precise, type. None (default) is almost like False, but allows
-    downcasting of Python float scalars to floatX.
+        inputs when calling the function can be silently downcasted to
+        fit the dtype of the corresponding Variable, which may lose
+        precision.  False means that it will only be cast to a more
+        general, or precise, type. None (default) is almost like
+        False, but allows downcasting of Python float scalars to
+        floatX.
 
     :type profile: None, True, str, or ProfileStats instance
     :param profile: accumulate profiling information into a given ProfileStats
@@ -389,30 +397,32 @@ def pfunc(params, outputs=None, mode=None, updates=None, givens=None,
 
 
     :rtype: theano.compile.Function
-    :returns: a callable object that will compute the outputs (given the inputs)
-    and update the implicit function arguments according to the `updates`.
-
+    :returns: a callable object that will compute the outputs (given
+        the inputs) and update the implicit function arguments
+        according to the `updates`.
 
-    :note: Regarding givens: Be careful to make sure that these substitutions are
-    independent--behaviour when Var1 of one pair appears in the graph leading to Var2 in
-    another expression is undefined.  Replacements specified with givens are different from
-    optimizations in that Var2 is not expected to be equivalent to Var1.
 
+    :note: Regarding givens: Be careful to make sure that these
+        substitutions are independent--behaviour when Var1 of one pair
+        appears in the graph leading to Var2 in another expression is
+        undefined.  Replacements specified with givens are different
+        from optimizations in that Var2 is not expected to be
+        equivalent to Var1.
     """
     #
-    # This function works by cloning the graph (except for the inputs), and then shipping it
-    # off to compile.function
-    # (There it will be cloned again, unnecessarily, because it doesn't know that we already
-    # cloned it.)
+    # This function works by cloning the graph (except for the
+    # inputs), and then shipping it off to compile.function (There it
+    # will be cloned again, unnecessarily, because it doesn't know
+    # that we already cloned it.)
     #
-    # First, it clones the replacements named in the givens argument, and points each Var1 to
-    # the clone of Var2.
-    # Then it sets the inputs in the clone dictionary.
-    # After these steps, we are assuming that the clone dictionary contains all the inputs to
+    # First, it clones the replacements named in the givens argument,
+    # and points each Var1 to the clone of Var2.  Then it sets the
+    # inputs in the clone dictionary.  After these steps, we are
+    # assuming that the clone dictionary contains all the inputs to
     # the computation graph.
     #
-    # Then it clones the outputs and the update expressions.  This rebuilds a computation graph
-    # from the inputs and the givens.
+    # Then it clones the outputs and the update expressions.  This
+    # rebuilds a computation graph from the inputs and the givens.
     #
     if updates is None:
         updates = []
@@ -431,11 +441,13 @@ def pfunc(params, outputs=None, mode=None, updates=None, givens=None,
     # useful.
 
     if not isinstance(params, (list, tuple)):
-        raise Exception("in pfunc() the first argument must be a list or a tuple")
+        raise Exception("in pfunc() the first argument must be a list or "
+                        "a tuple")
 
     if not isinstance(no_default_updates, bool)\
             and not isinstance(no_default_updates, list):
-        raise TypeError("no_default_update should be either a boolean or a list")
+        raise TypeError("no_default_update should be either a boolean or "
+                        "a list")
 
     if len(updates) > 0 and any(isinstance(v, Variable)
                                 for v in iter_over_pairs(updates)):
@@ -494,9 +506,10 @@ def pfunc(params, outputs=None, mode=None, updates=None, givens=None,
         i.variable = iv
 
     for sv in shared_inputs:
-        # pass value of None here
-        # value will be stored in the resulting functions' defaults list
-        # but since the value of shared variables never needs to be refed, it is not needed
+        # pass value of None
+        # value will be stored in the resulting functions' defaults
+        # list but since the value of shared variables never needs to
+        # be refed, it is not needed
         if sv in update_d:
             si = In(variable=sv, value=sv.container, mutable=True,
                     borrow=True, update=update_d[sv], shared=True)
@@ -506,8 +519,9 @@ def pfunc(params, outputs=None, mode=None, updates=None, givens=None,
         inputs.append(si)
 
     return orig_function(inputs, cloned_outputs, mode,
-            accept_inplace=accept_inplace, name=name, profile=profile,
-            on_unused_input=on_unused_input, output_keys=output_keys)
+                         accept_inplace=accept_inplace, name=name,
+                         profile=profile, on_unused_input=on_unused_input,
+                         output_keys=output_keys)
 
 
 def _pfunc_param_to_in(param, strict=False, allow_downcast=None):

theano/tests/test_flake8.py

@@ -38,7 +38,6 @@ whitelist_flake8 = [
     "tests/test_tutorial.py",
     "tests/disturb_mem.py",
     "tests/unittest_tools.py",
-    "compile/pfunc.py",
     "compile/mode.py",
     "compile/profilemode.py",
     "compile/builders.py",