Merge pull request #2952 from abergeron/flake8

theano/compile/builders.py

@@ -15,7 +15,9 @@ class OpFromGraph(gof.Op):
 
     TODO:
         - examples for a multi-layer mlp. where?
-        - __hash__, __eq__ otherwise won't merge, try gof.opt.is_same_graph_with_merge(op1.new_outputs, op2, new_outputs)
+        - __hash__, __eq__ otherwise won't merge, try
+          gof.opt.is_same_graph_with_merge(op1.new_outputs, op2,
+          new_outputs)
         - c_code() to remove the double overhead?
         - opt to unfold it, work inplace on inputs
         - grad() make it support DisconnectedType and the new interface
@@ -68,7 +70,7 @@ class OpFromGraph(gof.Op):
         for i in inputs + outputs:
             if not isinstance(i, gof.Variable):
                 raise TypeError(
-                        'inputs and outputs must be Variable instances', i)
+                    'inputs and outputs must be Variable instances', i)
         if 'updates' in kwargs:
             raise TypeError('updates are not allowed in kwargs')
 
@@ -76,8 +78,6 @@ class OpFromGraph(gof.Op):
         # not see them. Otherwise their is problem with the gradient.
         self.shared_inputs = [var for var in gof.graph.inputs(outputs)
                               if isinstance(var, SharedVariable)]
-        used_inputs = [var for var in gof.graph.inputs(outputs)
-                       if not isinstance(var, gof.Constant)]
         shared_vars = [var.type() for var in self.shared_inputs]
         new = rebuild_collect_shared(outputs, inputs=inputs + shared_vars,
                                      replace=dict(zip(self.shared_inputs,
@@ -110,8 +110,8 @@ class OpFromGraph(gof.Op):
     def make_node(self, *inputs):
         for input, type in zip(inputs, self.input_types):
             if not type == input.type:
-                raise TypeError("Wrong type, expected %s but got %s"
-                        % (type, input.type))
+                raise TypeError("Wrong type, expected %s but got %s" %
+                                (type, input.type))
         return gof.Apply(self,
                          list(inputs) + self.shared_inputs,
                          [type() for type in self.output_types])
@@ -143,9 +143,10 @@ class OpFromGraph(gof.Op):
             grad_ops = self.grad_ops
         else:
             gs = theano.gradient.grad(cost=None,
-                        known_grads=dict(zip(self.new_outputs, output_grads)),
-                        wrt=self.new_inputs,
-                        disconnected_inputs='ignore')
+                                      known_grads=dict(zip(self.new_outputs,
+                                                           output_grads)),
+                                      wrt=self.new_inputs,
+                                      disconnected_inputs='ignore')
 
             grad_ops = []
             for g in gs:

theano/compile/io.py

 """Define `SymbolicInput`, `SymbolicOutput`, `In`, `Out` """
-__docformat__ = 'restructuredtext en'
 
 from theano import gof
 from sharedvalue import SharedVariable
@@ -7,6 +6,8 @@ from sharedvalue import SharedVariable
 import logging
 _logger = logging.getLogger("theano.compile.io")
 
+__docformat__ = 'restructuredtext en'
+
 
 class SymbolicInput(object):
     """
@@ -17,42 +18,55 @@ class SymbolicInput(object):
         not computed from its owner.
 
     name: Any type. (If autoname=True, defaults to variable.name).
-        If name is a valid Python identifier, this input can be set by kwarg, and its value
-        can be accessed by self.<name>.
+        If name is a valid Python identifier, this input can be set by
+        kwarg, and its value can be accessed by self.<name>.
 
     update: Variable instance (default: None)
-        value (see previous) will be replaced with this expression variable after each function call.
-        If update is None, the update will be the default value of the input.
+        value (see previous) will be replaced with this expression
+        variable after each function call.  If update is None, the
+        update will be the default value of the input.
+
+    mutable: Bool (default: False if update is None, True if update is
+        not None)
+
+        True: permit the compiled function to modify the python object
+        being passed as the input
 
-    mutable: Bool (default: False if update is None, True if update is not None)
-        True: permit the compiled function to modify the python object being passed as the input
-        False: do not permit the compiled function to modify the python object being passed as the input.
+        False: do not permit the compiled function to modify the
+        python object being passed as the input.
 
     strict: Bool (default: False)
-        True: means that the value you pass for this input must have exactly the right type
-        False: the value you pass for this input may be cast automatically to the proper type
+
+        True: means that the value you pass for this input must have
+        exactly the right type
+
+        False: the value you pass for this input may be cast
+        automatically to the proper type
 
     allow_downcast: Bool or None (default: None)
         Only applies when `strict` is False.
+
         True: the value you pass for this input can be silently
         downcasted to fit the right type, which may lose precision.
-        False: the value will only be cast to a more general, or precise, type.
-        None: Almost like False, but allows downcast of Python floats to floatX.
+
+        False: the value will only be cast to a more general, or
+        precise, type.  None: Almost like False, but allows downcast
+        of Python floats to floatX.
 
     autoname: Bool (default: True)
         See the name option.
 
     implicit: Bool (default: False)
-        See help(In). Note that 'None' is not allowed here, since we are in the
-        symbolic case.
+        See help(In). Note that 'None' is not allowed here, since we
+        are in the symbolic case.
     """
 
     def __init__(self, variable, name=None, update=None, mutable=None,
-            strict=False, allow_downcast=None, autoname=True,
-            implicit=False):
+                 strict=False, allow_downcast=None, autoname=True,
+                 implicit=False):
         assert implicit is not None  # Safety check.
         self.variable = variable
-        if  (autoname and name is None):
+        if (autoname and name is None):
             self.name = variable.name
         else:
             self.name = name
@@ -146,36 +160,54 @@ class In(SymbolicInput):
         not computed from its owner.
 
     name: Any type. (If autoname=True, defaults to variable.name).
-        If name is a valid Python identifier, this input can be set by kwarg, and its value
-        can be accessed by self.<name>.
+        If name is a valid Python identifier, this input can be set by
+        kwarg, and its value can be accessed by self.<name>.
 
     value: Any type.
-        The initial/default value for this input. If update is None, this input acts just like
-        an argument with a default value in Python. If update is not None, changes to this
-        value will "stick around", whether due to an update or a user's explicit action.
+        The initial/default value for this input. If update is None,
+        this input acts just like an argument with a default value in
+        Python. If update is not None, changes to this value will
+        "stick around", whether due to an update or a user's explicit
+        action.
 
     update: Variable instance (default: None)
-        value (see previous) will be replaced with this expression variable after each function call.
-        If update is None, the update will be the default value of the input.
+        value (see previous) will be replaced with this expression
+        variable after each function call.  If update is None, the
+        update will be the default value of the input.
 
-    mutable: Bool (default: False if update is None, True if update is not None)
-        True: permit the compiled function to modify the python object being passed as the input
-        False: do not permit the compiled function to modify the python object being passed as the input.
+    mutable: Bool (default: False if update is None, True if update is
+             not None)
+
+        True: permit the compiled function to modify the python object
+        being passed as the input
+
+        False: do not permit the compiled function to modify the
+        python object being passed as the input.
 
     borrow: Bool (default: take the same value as mutable)
-        True: permit the output of the compiled function to be aliased to the input
+
+        True: permit the output of the compiled function to be aliased
+        to the input
+
         False: do not permit any output to be aliased to the input
 
     strict: Bool (default: False)
-        True: means that the value you pass for this input must have exactly the right type
-        False: the value you pass for this input may be cast automatically to the proper type
+
+        True: means that the value you pass for this input must have
+        exactly the right type
+
+        False: the value you pass for this input may be cast
+        automatically to the proper type
 
     allow_downcast: Bool or None (default: None)
         Only applies when `strict` is False.
+
         True: the value you pass for this input can be silently
         downcasted to fit the right type, which may lose precision.
-        False: the value will only be cast to a more general, or precise, type.
-        None: Almost like False, but allows downcast of Python floats to floatX.
+
+        False: the value will only be cast to a more general, or
+        precise, type.  None: Almost like False, but allows downcast
+        of Python floats to floatX.
 
     autoname: Bool (default: True)
         See the name option.
@@ -194,11 +226,11 @@ class In(SymbolicInput):
     # Note: the documentation above is duplicated in doc/topics/function.txt,
     # try to keep it synchronized.
     def __init__(self, variable, name=None, value=None, update=None,
-            mutable=None, strict=False, allow_downcast=None, autoname=True,
-            implicit=None, borrow=None, shared=False):
-
-        # if shared, an input's value comes from its persistent storage, not from a default stored
-        # in the function or from the caller
+                 mutable=None, strict=False, allow_downcast=None,
+                 autoname=True, implicit=None, borrow=None, shared=False):
+        # if shared, an input's value comes from its persistent
+        # storage, not from a default stored in the function or from
+        # the caller
         self.shared = shared
 
         if borrow is None:
@@ -211,25 +243,25 @@ class In(SymbolicInput):
         # aliased to the input. Thus mutable=True should require borrow=True.
         if mutable and not self.borrow:
             raise AssertionError(
-                    "Symbolic input for variable %s (name=%s) has "
-                    "flags mutable=True, borrow=False. This combination is "
-                    "incompatible since mutable=True implies that the "
-                    "input variable may be both aliased (borrow=True) and "
-                    "overwritten.",
-                    variable, name)
+                "Symbolic input for variable %s (name=%s) has "
+                "flags mutable=True, borrow=False. This combination is "
+                "incompatible since mutable=True implies that the "
+                "input variable may be both aliased (borrow=True) and "
+                "overwritten.",
+                variable, name)
 
         if implicit is None:
             implicit = (isinstance(value, gof.Container) or
-                    isinstance(value, SharedVariable))
+                        isinstance(value, SharedVariable))
         super(In, self).__init__(
-                variable=variable,
-                name=name,
-                update=update,
-                mutable=mutable,
-                strict=strict,
-                allow_downcast=allow_downcast,
-                autoname=autoname,
-                implicit=implicit)
+            variable=variable,
+            name=name,
+            update=update,
+            mutable=mutable,
+            strict=strict,
+            allow_downcast=allow_downcast,
+            autoname=autoname,
+            implicit=implicit)
         self.value = value
         if self.implicit and value is None:
             raise TypeError('An implicit input must be given a default value')

theano/compile/mode.py

@@ -2,35 +2,33 @@
 """
 from __future__ import print_function
 import logging
-import warnings
-from textwrap import dedent
 
 import numpy
 
-import  theano
+import theano
 from theano import gof
 import theano.gof.vm
 from theano.configparser import config, AddConfigVar, StrParam
-from theano.compile.ops import register_view_op_c_code, _output_guard
+from theano.compile.ops import _output_guard
 
 
 _logger = logging.getLogger('theano.compile.mode')
 
 AddConfigVar('optimizer_excluding',
-        ("When using the default mode, we will remove optimizer with these "
-         "tags. Separate tags with ':'."),
-        StrParam("", allow_override=False),
-        in_c_key=False)
+             ("When using the default mode, we will remove optimizer with "
+              "these tags. Separate tags with ':'."),
+             StrParam("", allow_override=False),
+             in_c_key=False)
 AddConfigVar('optimizer_including',
-        ("When using the default mode, we will add optimizer with these tags. "
-         "Separate tags with ':'."),
-        StrParam("", allow_override=False),
-        in_c_key=False)
+             ("When using the default mode, we will add optimizer with "
+              "these tags. Separate tags with ':'."),
+             StrParam("", allow_override=False),
+             in_c_key=False)
 AddConfigVar('optimizer_requiring',
-        ("When using the default mode, we will require optimizer with these "
-         "tags. Separate tags with ':'."),
-        StrParam("", allow_override=False),
-        in_c_key=False)
+             ("When using the default mode, we will require optimizer with "
+              "these tags. Separate tags with ':'."),
+             StrParam("", allow_override=False),
+             in_c_key=False)
 
 
 def check_equal(x, y):
@@ -50,15 +48,15 @@ def check_equal(x, y):
         y = y.todense()
 
     if isinstance(x, numpy.ndarray) and isinstance(y, numpy.ndarray):
-        if (x.dtype != y.dtype
-                or x.shape != y.shape
-                or numpy.any(abs(x - y) > 1e-10)):
+        if (x.dtype != y.dtype or
+                x.shape != y.shape or
+                numpy.any(abs(x - y) > 1e-10)):
             raise Exception("Output mismatch.",
-                    {'performlinker': x, 'clinker': y})
+                            {'performlinker': x, 'clinker': y})
     else:
         if x != y:
             raise Exception("Output mismatch.",
-                    {'performlinker': x, 'clinker': y})
+                            {'performlinker': x, 'clinker': y})
 
 
 # If a string is passed as the linker argument in the constructor for
@@ -144,11 +142,11 @@ class AddDestroyHandler(gof.Optimizer):
         for o in fgraph.outputs:
             try:
                 fgraph.replace_validate(o, _output_guard(o),
-                        reason='output_guard')
+                                        reason='output_guard')
                 _logger.info("Output variable %s required output_guard, "
-                        "how was this output left unprotected against "
-                        "destructive operations?"
-                        % o)
+                             "how was this output left unprotected against "
+                             "destructive operations?"
+                             % o)
             except gof.InconsistencyError:
                 # This output is already impossible to destroy.
                 # No guard necessary
@@ -188,50 +186,50 @@ class PrintCurrentFunctionGraph(gof.Optimizer):
 
 optdb = gof.SequenceDB()
 optdb.register('merge1', gof.MergeOptimizer(),
-        0, 'fast_run', 'fast_compile', 'merge')
+               0, 'fast_run', 'fast_compile', 'merge')
 
 # rearranges elemwise expressions
 optdb.register('canonicalize', gof.EquilibriumDB(),
-        1, 'fast_run', 'fast_compile')
+               1, 'fast_run', 'fast_compile')
 
 optdb.register('merge1.2', gof.MergeOptimizer(),
-        1.2, 'fast_run', 'fast_compile', 'merge')
+               1.2, 'fast_run', 'fast_compile', 'merge')
 
 optdb.register('Print1.21', PrintCurrentFunctionGraph('Post-canonicalize'),
-        1.21,)  # 'fast_run', 'fast_compile')
+               1.21,)  # 'fast_run', 'fast_compile')
 
 # replace unstable subgraphs
 optdb.register('stabilize', gof.EquilibriumDB(),
-        1.5, 'fast_run')
+               1.5, 'fast_run')
 
 optdb.register('Print1.51', PrintCurrentFunctionGraph('Post-stabilize'),
-        1.51,)  # 'fast_run', 'fast_compile')
+               1.51,)  # 'fast_run', 'fast_compile')
 
 # misc special cases for speed
 optdb.register('specialize', gof.EquilibriumDB(),
-        2, 'fast_run', 'fast_compile_gpu')
+               2, 'fast_run', 'fast_compile_gpu')
 
 # misc special cases for speed that break canonicalization
 optdb.register('uncanonicalize', gof.EquilibriumDB(),
-        3, 'fast_run')
+               3, 'fast_run')
 
 # misc special cases for speed that are dependent on the device.
 optdb.register('specialize_device', gof.EquilibriumDB(),
-        48.6, 'fast_run')  # must be after gpu stuff at 48.5
+               48.6, 'fast_run')  # must be after gpu stuff at 48.5
 
 # especially constant merge
 optdb.register('merge2', gof.MergeOptimizer(),
-        49, 'fast_run', 'merge')
+               49, 'fast_run', 'merge')
 
 optdb.register('add_no_output_from_inplace', AddNoOutputFromInplace(),
-        49.4)
+               49.4)
 
 optdb.register('add_destroy_handler', AddDestroyHandler(),
-        49.5, 'fast_run', 'inplace')
+               49.5, 'fast_run', 'inplace')
 
 # final pass just to make sure
 optdb.register('merge3', gof.MergeOptimizer(),
-        100, 'fast_run', 'merge')
+               100, 'fast_run', 'merge')
 
 
 class Mode(object):
@@ -287,7 +285,8 @@ class Mode(object):
 
     def __str__(self):
         return "%s(linker = %s, optimizer = %s)" % (self.__class__.__name__,
-                self.provided_linker, self.provided_optimizer)
+                                                    self.provided_linker,
+                                                    self.provided_optimizer)
 
     def __get_optimizer(self):
         if isinstance(self._optimizer, gof.Query):
@@ -306,19 +305,19 @@ class Mode(object):
 
     def including(self, *tags):
         link, opt = self.get_linker_optimizer(self.provided_linker,
-                self.provided_optimizer)
+                                              self.provided_optimizer)
         # N.B. opt might be a Query instance, not sure what else it might be...
         #     string? Optimizer? OptDB? who knows???
         return self.__class__(linker=link, optimizer=opt.including(*tags))
 
     def excluding(self, *tags):
         link, opt = self.get_linker_optimizer(self.provided_linker,
-                self.provided_optimizer)
+                                              self.provided_optimizer)
         return self.__class__(linker=link, optimizer=opt.excluding(*tags))
 
     def requiring(self, *tags):
         link, opt = self.get_linker_optimizer(self.provided_linker,
-                self.provided_optimizer)
+                                              self.provided_optimizer)
         return self.__class__(linker=link, optimizer=opt.requiring(*tags))
 
 # If a string is passed as the mode argument in function or
@@ -364,10 +363,11 @@ def get_mode(orig_string):
             # DebugMode use its own linker.
             ret = DebugMode(optimizer=config.optimizer)
         else:
-            # The import is needed in case string is ProfileMode
-            from profilemode import ProfileMode, prof_mode_instance_to_print
-            ret = eval(string
-                    + '(linker=config.linker, optimizer=config.optimizer)')
+            # This might be required if the string is 'ProfileMode'
+            from profilemode import ProfileMode  # noqa
+            from profilemode import prof_mode_instance_to_print
+            ret = eval(string +
+                       '(linker=config.linker, optimizer=config.optimizer)')
     elif string in predefined_modes:
         ret = predefined_modes[string]
     else:

theano/compile/monitormode.py

 from __future__ import print_function
 # Note: this code was initially copied from the 'pyutools' package by its
 # original author, and re-licensed under Theano's license.
-
+import numpy
 
 import theano
 from theano.compile.mode import Mode
@@ -48,7 +48,7 @@ class MonitorMode(Mode):
         if optimizer == 'default':
             optimizer = theano.config.optimizer
         if (linker is not None and
-            not isinstance(linker.mode, MonitorMode)):
+                not isinstance(linker.mode, MonitorMode)):
             raise Exception("MonitorMode can only use its own linker! You "
                             "should not provide one.", linker)
 
@@ -86,7 +86,7 @@ class MonitorMode(Mode):
 def detect_nan(i, node, fn):
     for output in fn.outputs:
         if (not isinstance(numpy.random.RandomState, output[0]) and
-            numpy.isnan(output[0]).any()):
+                numpy.isnan(output[0]).any()):
             print('*** NaN detected ***')
             theano.printing.debugprint(node)
             print('Inputs : %s' % [input[0] for input in fn.inputs])