blas.py has been modified in order to respect the flake8 style.

theano/sandbox/cuda/blas.py

 from __future__ import absolute_import, print_function, division
-import copy
 import os
 import logging
-_logger = logging.getLogger(__name__)
-
 from six import integer_types
 from six.moves import StringIO, reduce
-
 import theano
 from theano import Apply
 from theano import tensor
@@ -15,6 +11,7 @@ from theano.sandbox.cuda import GpuOp
 from theano.sandbox.cuda.basic_ops import (as_cuda_ndarray_variable,
                                            gpu_contiguous)
 from theano.tensor import as_tensor_variable
+_logger = logging.getLogger(__name__)
 
 
 class GpuBatchedDot(GpuOp):
@@ -183,8 +180,7 @@ class GpuBatchedDot(GpuOp):
             }
         } else {
             // copy inputs if not contiguous
-            """ +
-            ("\n".join("""
+            """ + ("\n".join("""
              if ((   CudaNdarray_HOST_DIMS(%(var)s)[0] > 1 && CudaNdarray_HOST_STRIDES(%(var)s)[0] != 1
                   && CudaNdarray_HOST_DIMS(%(var)s)[1] > 1 && CudaNdarray_HOST_STRIDES(%(var)s)[1] != 1
                   && CudaNdarray_HOST_DIMS(%(var)s)[2] > 1 && CudaNdarray_HOST_STRIDES(%(var)s)[2] != 1)
@@ -198,8 +194,7 @@ class GpuBatchedDot(GpuOp):
                  Py_XDECREF(%(var)s);
                  %(var)s = _copy;
              }
-             """ % dict(var=var, fail=fail) for var in (bx, by)))
-            + """
+             """ % dict(var=var, fail=fail) for var in (bx, by))) + """
 
             // fail if the output is not contiguous; we can't copy it because we
             // need to write to the original memory
@@ -537,8 +532,8 @@ class GpuGemm(GpuOp):
             return 'GpuGemm{no_inplace}'
 
     def __eq__(self, other):
-        return (type(self) == type(other)\
-                and self.inplace == other.inplace)
+        return (type(self) == type(other) and
+                self.inplace == other.inplace)
 
     def __hash__(self):
         return hash(type(self)) ^ hash(self.inplace)
@@ -562,7 +557,7 @@ class GpuGemm(GpuOp):
         return (4,)
 
     def c_code(self, node, name, inputs, outputs, sub):
-        #z_out = alpha * dot(x,y) + beta * z_in
+        # z_out = alpha * dot(x,y) + beta * z_in
         # inplace version, set set z_out = z_in
         # not inplace version, we copy z_in to z_out.
         z_in, a, x, y, b = inputs
@@ -657,8 +652,8 @@ class GpuGemv(GpuOp):
             return 'GpuGemv{no_inplace}'
 
     def __eq__(self, other):
-        return (type(self) == type(other)\
-                and self.inplace == other.inplace)
+        return (type(self) == type(other) and
+                self.inplace == other.inplace)
 
     def __hash__(self):
         return hash(type(self)) ^ hash(self.inplace)
@@ -682,7 +677,7 @@ class GpuGemv(GpuOp):
         return (3,)
 
     def c_code(self, node, name, inputs, outputs, sub):
-        #z_out = alpha * dot(x,y) + beta * z_in
+        # z_out = alpha * dot(x,y) + beta * z_in
         # inplace version, set set z_out = z_in
         # not inplace version, we copy z_in to z_out.
         z_in, a, x, y, b = inputs
@@ -757,8 +752,8 @@ class GpuGer(GpuOp):
             return 'GpuGer{no_inplace}'
 
     def __eq__(self, other):
-        return (type(self) == type(other)\
-                and self.inplace == other.inplace)
+        return (type(self) == type(other) and
+                self.inplace == other.inplace)
 
     def __hash__(self):
         return hash(type(self)) ^ hash(self.inplace)
@@ -782,7 +777,7 @@ class GpuGer(GpuOp):
         return (2,)
 
     def c_code(self, node, name, inputs, outputs, sub):
-        #z_out = alpha * dot(x,y) + beta * z_in
+        # z_out = alpha * dot(x,y) + beta * z_in
         # inplace version, set set z_out = z_in
         # not inplace version, we copy z_in to z_out.
         z_in, a, x, y = inputs
@@ -1283,11 +1278,15 @@ class GpuCorrMM_gradWeights(BaseGpuCorrMM):
         bottom, top = inp[:2]
         weights, = grads
         weights = gpu_contiguous(weights)
-        d_bottom = GpuCorrMM_gradInputs(self.border_mode, self.subsample)(
-                weights, top, bottom.shape[-2:])
-        d_top = GpuCorrMM(self.border_mode, self.subsample)(
-                bottom, weights)
-        d_height_width = (theano.gradient.DisconnectedType()(),) * 2 if len(inp) == 4 else ()
+        d_bottom = GpuCorrMM_gradInputs(
+            self.border_mode, self.subsample)(weights,
+                                              top,
+                                              bottom.shape[-2:])
+        d_top = GpuCorrMM(
+            self.border_mode, self.subsample)(bottom, weights)
+        d_height_width = (
+            theano.gradient.DisconnectedType()(),
+            ) * 2 if len(inp) == 4 else ()
         return (d_bottom, d_top) + d_height_width
 
     def connection_pattern(self, node):
@@ -1342,11 +1341,14 @@ class GpuCorrMM_gradInputs(BaseGpuCorrMM):
         weights, top = inp[:2]
         bottom, = grads
         bottom = gpu_contiguous(bottom)
-        d_weights = GpuCorrMM_gradWeights(self.border_mode, self.subsample)(
+        d_weights = GpuCorrMM_gradWeights(
+            self.border_mode, self.subsample)(
                 bottom, top, weights.shape[-2:])
-        d_top = GpuCorrMM(self.border_mode, self.subsample)(
-                bottom, weights)
-        d_height_width = (theano.gradient.DisconnectedType()(),) * 2 if len(inp) == 4 else ()
+        d_top = GpuCorrMM(
+            self.border_mode, self.subsample)(bottom, weights)
+        d_height_width = (
+            theano.gradient.DisconnectedType()(),
+            ) * 2 if len(inp) == 4 else ()
         return (d_weights, d_top) + d_height_width
 
     def connection_pattern(self, node):
@@ -1755,10 +1757,16 @@ class GpuCorr3dMM(BaseGpuCorr3dMM):
         bottom, weights = inp
         top, = grads
         top = gpu_contiguous(top)
-        d_bottom = GpuCorr3dMM_gradInputs(self.border_mode, self.subsample, self.pad)(
-                weights, top, bottom.shape[-3:])
-        d_weights = GpuCorr3dMM_gradWeights(self.border_mode, self.subsample, self.pad)(
-                bottom, top, weights.shape[-3:])
+        d_bottom = GpuCorr3dMM_gradInputs(self.border_mode,
+                                          self.subsample,
+                                          self.pad)(weights,
+                                                    top,
+                                                    bottom.shape[-3:])
+        d_weights = GpuCorr3dMM_gradWeights(self.border_mode,
+                                            self.subsample,
+                                            self.pad)(bottom,
+                                                      top,
+                                                      weights.shape[-3:])
         return d_bottom, d_weights
 
 
@@ -1863,11 +1871,14 @@ class GpuCorr3dMM_gradInputs(BaseGpuCorr3dMM):
         weights, top = inp[:2]
         bottom, = grads
         bottom = gpu_contiguous(bottom)
-        d_weights = GpuCorr3dMM_gradWeights(self.border_mode, self.subsample, self.pad)(
+        d_weights = GpuCorr3dMM_gradWeights(
+            self.border_mode, self.subsample, self.pad)(
                 bottom, top, weights.shape[-3:])
-        d_top = GpuCorr3dMM(self.border_mode, self.subsample, self.pad)(
+        d_top = GpuCorr3dMM(
+            self.border_mode, self.subsample, self.pad)(
                 bottom, weights)
-        d_height_width_depth = (theano.gradient.DisconnectedType()(),) * 3 if len(inp) == 5 else ()
+        d_height_width_depth = (theano.gradient.DisconnectedType()(),)\
+            * 3 if len(inp) == 5 else ()
         return (d_weights, d_top) + d_height_width_depth
 
     def connection_pattern(self, node):
@@ -2186,7 +2197,7 @@ class GpuDownsampleFactorMax(GpuOp):
         return Apply(self, [x], [x.type()])
 
     # def perform(self, node, input_storage, output_storage):
-        #raise NotImplementedError('only C is implemented')
+        # raise NotImplementedError('only C is implemented')
     def c_code_cache_version(self):
         return (6)