[pep8] Fix most remaining lint manually

Author: lukeyeager

test/test_autograd.py

@@ -1079,7 +1079,7 @@ def check(name):
             try:
                 check(inplace_name)
             except Exception as e:
-                if not 'only supports scalar' in e.args[0]:
+                if 'only supports scalar' not in e.args[0]:
                     raise
 
     assert not hasattr(TestAutograd, test_name), 'Two tests have the same name: ' + test_name

test/test_legacy_nn.py

@@ -927,8 +927,10 @@ def test_DepthConcat(self):
         gradInputConcat = concat.backward(input, gradOutput)
         # the spatial dims are the largest, the nFilters is the sum
         output = torch.Tensor(2, int(outputSize.sum()), 12, 12).zero_()  # zero for padding
-        narrows = ((slice(None), slice(0, 5), slice(None), slice(None)), (slice(None), slice(5, 11), slice(1, 11), slice(
-            1, 11)), (slice(None), slice(11, 18), slice(1, 10), slice(1, 10)), (slice(None), slice(18, 26), slice(2, 10), slice(2, 10)))
+        narrows = ((slice(None), slice(0, 5), slice(None), slice(None)),
+                   (slice(None), slice(5, 11), slice(1, 11), slice(1, 11)),
+                   (slice(None), slice(11, 18), slice(1, 10), slice(1, 10)),
+                   (slice(None), slice(18, 26), slice(2, 10), slice(2, 10)))
         gradInput = input.clone().zero_()
         for i in range(4):
             conv = concat.get(i)
@@ -1120,8 +1122,9 @@ def test_ParallelCriterion(self):
         pc = nn.ParallelCriterion().add(nll, 0.5).add(mse)
         pc2 = nn.ParallelCriterion().add(nll2, 0.4).add(pc)
         output = pc2.forward(input, target)
-        output2 = nll2.forward(input[0], target[0]) * 0.4 + nll.forward(input[1][0],
-                                                                        target[1][0]) / 2 + mse.forward(input[1][1], target[1][1])
+        output2 = (nll2.forward(input[0], target[0]) * 0.4 +
+                   nll.forward(input[1][0], target[1][0]) / 2 +
+                   mse.forward(input[1][1], target[1][1]))
         self.assertEqual(output, output2)
         gradInput2 = [
             nll2.backward(input[0], target[0]).clone().mul(0.4),

tools/cwrap/cwrap.py

@@ -98,10 +98,10 @@ def wrap_declarations(self, declarations):
     def set_declaration_defaults(self, declaration):
         declaration.setdefault('arguments', [])
         declaration.setdefault('return', 'void')
-        if not 'cname' in declaration:
+        if 'cname' not in declaration:
             declaration['cname'] = declaration['name']
         # Simulate multiple dispatch, even if it's not necessary
-        if not 'options' in declaration:
+        if 'options' not in declaration:
             declaration['options'] = [{'arguments': declaration['arguments']}]
             del declaration['arguments']
         # Parse arguments (some of them can be strings)
@@ -183,7 +183,7 @@ def map_selected_arguments(self, base_fn_name, plugin_fn_name, option, arguments
 
     def generate_option(self, option, is_first):
         checked_args = list(filter(
-            lambda arg: not 'ignore_check' in arg or not arg['ignore_check'],
+            lambda arg: 'ignore_check' not in arg or not arg['ignore_check'],
             option['arguments']))
         option['num_checked_args'] = len(checked_args)
         idx_args = list(filter(

tools/cwrap/plugins/CuDNNPlugin.py

@@ -124,7 +124,8 @@ def process_declarations(self, declarations):
 
     def filter_unique_options(self, options):
         def signature(option):
-            return '#'.join(arg['type'] for arg in option['arguments'] if not 'ignore_check' in arg or not arg['ignore_check'])
+            return '#'.join(arg['type'] for arg in option['arguments']
+                            if 'ignore_check' not in arg or not arg['ignore_check'])
         seen_signatures = set()
         unique = []
         for option in options:

tools/cwrap/plugins/ReturnArguments.py

@@ -17,4 +17,5 @@ def get_return_wrapper(self, option):
             if len(args) == 1:
                 return Template(self.ARGUMENT_RETURN_TEMPLATE.safe_substitute(arg=accessors[0]))
             else:
-                return Template(self.TUPLE_RETURN_TEMPLATE.safe_substitute(num_args=len(args), args=', '.join(accessors)))
+                return Template(self.TUPLE_RETURN_TEMPLATE.safe_substitute(num_args=len(args),
+                                                                           args=', '.join(accessors)))

tools/cwrap/plugins/THPPlugin.py

@@ -199,8 +199,8 @@ def format_arg(arg, var_args=False):
         def format_args(args, var_args=False):
             option_desc = [format_arg(arg, var_args)
                            for arg in args
-                           if not arg.get('ignore_check', False)
-                           and not arg.get('output')]
+                           if not arg.get('ignore_check', False) and
+                           not arg.get('output')]
             output_args = list(filter(lambda a: a.get('output'), args))
             if output_args:
                 if len(output_args) > 1:
@@ -392,12 +392,12 @@ def declare_methods(self, stateless, sparse):
     def process_full_file(self, code):
         # We have to find a place before all undefs
         idx = code.find('// PUT DEFINITIONS IN HERE PLEASE')
-        return (code[:idx]
-                + self.declare_methods(False, False)
-                + self.declare_methods(True, False)
-                + self.declare_methods(False, True)
-                + self.declare_methods(True, True)
-                + code[idx:]
+        return (code[:idx] +
+                self.declare_methods(False, False) +
+                self.declare_methods(True, False) +
+                self.declare_methods(False, True) +
+                self.declare_methods(True, True) +
+                code[idx:]
                 )
 
     def preprocessor_guard(self, code, condition):

tools/nnwrap/generate_wrappers.py

@@ -93,7 +93,7 @@ def wrap_function(name, type, arguments):
             declaration += prefix + TYPE_TRANSFORMS[type].get(arg.type, arg.type) + ' ' + arg.name + '\n'
         else:
             t = TYPE_TRANSFORMS[type].get(arg.type, arg.type)
-            declaration += prefix + 'type: ' + t        + '\n' + \
+            declaration += prefix + 'type: ' + t + '\n' + \
                 dict_indent + 'name: ' + arg.name + '\n' + \
                 dict_indent + 'nullable: True' + '\n'
     declaration += ']]\n\n\n'

torch/__init__.py

@@ -105,7 +105,7 @@ def get_rng_state():
 
 
 def manual_seed(seed):
-    r"""Sets the seed for generating random numbers. And returns a 
+    r"""Sets the seed for generating random numbers. And returns a
     `torch._C.Generator` object.
 
     Args:
@@ -115,7 +115,7 @@ def manual_seed(seed):
 
 
 def initial_seed():
-    r"""Returns the initial seed for generating random numbers as a 
+    r"""Returns the initial seed for generating random numbers as a
     python `long`.
     """
     return default_generator.initial_seed()

torch/_torch_docs.py

@@ -1469,13 +1469,13 @@
            r"""
 geqrf(input, out=None) -> (Tensor, Tensor)
 
-This is a low-level function for calling LAPACK directly. 
+This is a low-level function for calling LAPACK directly.
 
 You'll generally want to use :func:`torch.qr` instead.
 
-Computes a QR decomposition of :attr:`input`, but without constructing `Q` and `R` as explicit separate matrices. 
+Computes a QR decomposition of :attr:`input`, but without constructing `Q` and `R` as explicit separate matrices.
 
-Rather, this directly calls the underlying LAPACK function `?geqrf` which produces a sequence of 'elementary reflectors'. 
+Rather, this directly calls the underlying LAPACK function `?geqrf` which produces a sequence of 'elementary reflectors'.
 
 See `LAPACK documentation`_ for further details.
 
@@ -1517,17 +1517,17 @@
 gesv(B, A, out=None) -> (Tensor, Tensor)
 
 `X, LU = torch.gesv(B, A)` returns the solution to the system of linear
-equations represented by :math:`AX = B` 
+equations represented by :math:`AX = B`
 
 `LU` contains `L` and `U` factors for LU factorization of `A`.
 
 :attr:`A` has to be a square and non-singular matrix (2D Tensor).
 
-If `A` is an `m x m` matrix and `B` is `m x k`, 
+If `A` is an `m x m` matrix and `B` is `m x k`,
 the result `LU` is `m x m` and `X` is `m x k` .
 
-.. note:: Irrespective of the original strides, the returned matrices 
-          `X` and `LU` will be transposed, i.e. with strides `(1, m)` 
+.. note:: Irrespective of the original strides, the returned matrices
+          `X` and `LU` will be transposed, i.e. with strides `(1, m)`
            instead of `(m, 1)`.
 
 Args:
@@ -3052,19 +3052,19 @@
            """
 qr(input, out=None) -> (Tensor, Tensor)
 
-Computes the QR decomposition of a matrix :attr:`input`: returns matrices 
-`q` and `r` such that :math:`x = q * r`, with `q` being an orthogonal matrix 
-and `r` being an upper triangular matrix. 
+Computes the QR decomposition of a matrix :attr:`input`: returns matrices
+`q` and `r` such that :math:`x = q * r`, with `q` being an orthogonal matrix
+and `r` being an upper triangular matrix.
 
 This returns the thin (reduced) QR factorization.
 
 .. note:: precision may be lost if the magnitudes of the elements of `input` are large
 
-.. note:: while it should always give you a valid decomposition, it may not 
-          give you the same one across platforms - it will depend on your 
+.. note:: while it should always give you a valid decomposition, it may not
+          give you the same one across platforms - it will depend on your
           LAPACK implementation.
 
-.. note:: Irrespective of the original strides, the returned matrix `q` will be 
+.. note:: Irrespective of the original strides, the returned matrix `q` will be
           transposed, i.e. with strides `(1, m)` instead of `(m, 1)`.
 
 Args:
@@ -3708,7 +3708,7 @@
            """
 svd(input, some=True, out=None) -> (Tensor, Tensor, Tensor)
 
-`U, S, V = torch.svd(A)` returns the singular value decomposition of a 
+`U, S, V = torch.svd(A)` returns the singular value decomposition of a
 real matrix `A` of size `(n x m)` such that :math:`A = USV'*`.
 
 `U` is of shape `n x n`
@@ -3717,10 +3717,10 @@
 
 `V` is of shape `m x m`.
 
-:attr:`some` represents the number of singular values to be computed. 
+:attr:`some` represents the number of singular values to be computed.
 If `some=True`, it computes some and `some=False` computes all.
 
-.. note:: Irrespective of the original strides, the returned matrix `U` 
+.. note:: Irrespective of the original strides, the returned matrix `U`
           will be transposed, i.e. with strides `(1, n)` instead of `(n, 1)`.
 
 Args:
@@ -3783,26 +3783,26 @@
            """
 symeig(input, eigenvectors=False, upper=True, out=None) -> (Tensor, Tensor)
 
-`e, V = torch.symeig(input)` returns eigenvalues and eigenvectors 
+`e, V = torch.symeig(input)` returns eigenvalues and eigenvectors
 of a symmetric real matrix :attr:`input`.
 
 `input` and `V` are `m x m` matrices and `e` is a `m` dimensional vector.
 
-This function calculates all eigenvalues (and vectors) of `input` 
+This function calculates all eigenvalues (and vectors) of `input`
 such that `input = V diag(e) V'`
 
-The boolean argument :attr:`eigenvectors` defines computation of 
+The boolean argument :attr:`eigenvectors` defines computation of
 eigenvectors or eigenvalues only.
 
-If it is `False`, only eigenvalues are computed. If it is `True`, 
+If it is `False`, only eigenvalues are computed. If it is `True`,
 both eigenvalues and eigenvectors are computed.
 
-Since the input matrix `input` is supposed to be symmetric, 
-only the upper triangular portion is used by default. 
+Since the input matrix `input` is supposed to be symmetric,
+only the upper triangular portion is used by default.
 
 If :attr:`upper` is `False`, then lower triangular portion is used.
 
-Note: Irrespective of the original strides, the returned matrix `V` will 
+Note: Irrespective of the original strides, the returned matrix `V` will
 be transposed, i.e. with strides `(1, m)` instead of `(m, 1)`.
 
 Args:

torch/autograd/variable.py

@@ -152,7 +152,8 @@ def backward(self, gradient=None, retain_variables=False):
         if gradient is None and self.requires_grad:
             if self.data.numel() != 1:
                 raise RuntimeError(
-                    'backward should be called only on a scalar (i.e. 1-element tensor) or with gradient w.r.t. the variable')
+                    'backward should be called only on a scalar (i.e. 1-element tensor) '
+                    'or with gradient w.r.t. the variable')
             gradient = self.data.new().resize_as_(self.data).fill_(1)
         self._execution_engine.run_backward((self,), (gradient,), retain_variables)