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

theano/sandbox/cuda/type.py

@@ -130,10 +130,10 @@ class CudaNdarrayType(Type):
                         type(data) is float and
                         self.dtype == theano.config.floatX):
                     return cuda.filter(converted_data, self.broadcastable,
-                            strict, old_data)
+                                       strict, old_data)
                 elif numpy.all(data == converted_data):
                     return cuda.filter(converted_data, self.broadcastable,
-                            strict, old_data)
+                                       strict, old_data)
                 else:
                     raise TypeError(
                         '%s, with dtype %s, cannot store accurately value %s, '
@@ -259,8 +259,8 @@ class CudaNdarrayType(Type):
                     'complex64': (complex, 'theano_complex64',
                                   'NPY_COMPLEX64')}[self.dtype]
         except KeyError:
-            raise TypeError("Unsupported dtype for %s: %s" % (
-                    self.__class__.__name__, self.dtype))
+            raise TypeError("Unsupported dtype for %s: %s" %
+                            (self.__class__.__name__, self.dtype))
 
     def __eq__(self, other):
         """
@@ -271,10 +271,11 @@ class CudaNdarrayType(Type):
                 other.broadcastable == self.broadcastable)
 
     def convert_variable(self, var):
-        if (type(self) == type(var.type) and
-            self.ndim == var.type.ndim and
-            all(sb == ob or ob for sb, ob in zip(self.broadcastable,
-                                                 var.type.broadcastable))):
+        if (isinstance(self, type(var.type)) and
+                self.ndim == var.type.ndim and
+                all(sb == ob or ob for sb, ob in zip(
+                    self.broadcastable,
+                    var.type.broadcastable))):
             return theano.tensor.patternbroadcast(var, self.broadcastable)
 
     def __hash__(self):
@@ -312,7 +313,7 @@ class CudaNdarrayType(Type):
             return self.name
         else:
             b = self.broadcastable
-            #bcast = str(self.broadcastable)
+            # bcast = str(self.broadcastable)
             if not numpy.any(b):
                 s = "%iD" % len(b)
             else:
@@ -327,7 +328,7 @@ class CudaNdarrayType(Type):
 
     def __repr__(self):
         return str(self)
-        #"CudaNdarrayType{%s, %s}" % (str(self.dtype), str(self.broadcastable))
+        # "CudaNdarrayType{%s, %s}" % (str(self.dtype), str(self.broadcastable))
 
     def c_declare(self, name, sub, check_input=True):
         return """ CudaNdarray * %(name)s;""" % locals()
@@ -417,7 +418,7 @@ class CudaNdarrayType(Type):
         return sio.getvalue()
 
     def c_extract_out(self, name, sub, check_input=True, check_broadcast=True):
-        """ 
+        """
         To allow the hack to skip check_broadcast.
 
         """
@@ -528,13 +529,13 @@ theano.compile.ops.expandable_types += (CudaNdarrayType,)
 
 # Register C code for ViewOp on CudaNdarrayType
 theano.compile.register_view_op_c_code(
-        CudaNdarrayType,
-        """
-        Py_XDECREF(%(oname)s);
-        %(oname)s = %(iname)s;
-        Py_XINCREF(%(oname)s);
-        """,
-        version=1)
+    CudaNdarrayType,
+    """
+    Py_XDECREF(%(oname)s);
+    %(oname)s = %(iname)s;
+    Py_XINCREF(%(oname)s);
+    """,
+    version=1)
 
 theano.compile.register_shape_i_c_code(
     CudaNdarrayType,
@@ -555,16 +556,15 @@ theano.compile.register_shape_i_c_code(
 
 # Register CudaNdarrayType to the DeepCopyOp list of types with c code.
 theano.compile.register_deep_copy_op_c_code(
-        CudaNdarrayType,
-        """
-        int alloc = %(oname)s == NULL;
-        for(int i=0; !alloc && i<CudaNdarray_NDIM(%(oname)s); i++) {
-           if(CudaNdarray_HOST_DIMS(%(iname)s)[i] !=
-              CudaNdarray_HOST_DIMS(%(oname)s)[i]) {
-               alloc = true;
-               break;
-           }
-        }
+    CudaNdarrayType,
+    """
+    int alloc = %(oname)s == NULL;
+    for(int i=0; !alloc && i<CudaNdarray_NDIM(%(oname)s); i++) {
+    if(CudaNdarray_HOST_DIMS(%(iname)s)[i] !=
+    CudaNdarray_HOST_DIMS(%(oname)s)[i]) {
+    alloc = true;
+    break;
+    }}
         if(alloc) {
             Py_XDECREF(%(oname)s);
             %(oname)s = (CudaNdarray*)CudaNdarray_Copy(%(iname)s);
@@ -581,8 +581,7 @@ theano.compile.register_deep_copy_op_c_code(
                 %(fail)s;
             }
         }
-        """,
-        version=3)
+        """, version=3)
 
 
 # THIS WORKS But CudaNdarray instances don't compare equal to one
@@ -608,5 +607,5 @@ def CudaNdarray_pickler(cnda):
 
 # In case cuda is not imported.
 if cuda is not None:
-    copyreg.pickle(cuda.CudaNdarray, CudaNdarray_pickler,
-                    CudaNdarray_unpickler)
+    copyreg.pickle(
+        cuda.CudaNdarray, CudaNdarray_pickler, CudaNdarray_unpickler)