Flake8

Author: abergeron

pygpu/dtypes.py

@@ -71,18 +71,20 @@ def register_dtype(dtype, c_names):
 
 
 def _fill_dtype_registry():
-    from sys import platform
-
     register_dtype(np.bool, ["ga_bool", "bool"])
     register_dtype(np.int8, ["ga_byte", "char", "signed char"])
     register_dtype(np.uint8, ["ga_ubyte", "unsigned char"])
-    register_dtype(np.int16, ["ga_short", "short", "signed short", "signed short int", "short signed int"])
-    register_dtype(np.uint16, ["ga_ushort", "unsigned short", "unsigned short int", "short unsigned int"])
+    register_dtype(np.int16, ["ga_short", "short", "signed short",
+                              "signed short int", "short signed int"])
+    register_dtype(np.uint16, ["ga_ushort", "unsigned short",
+                               "unsigned short int", "short unsigned int"])
     register_dtype(np.int32, ["ga_int", "int", "signed int"])
     register_dtype(np.uint32, ["ga_uint", "unsigned", "unsigned int"])
 
-    register_dtype(np.int64, ["ga_long", "long int", "signed long int", "long signed int"])
-    register_dtype(np.uint64, ["ga_ulong", "unsigned long", "unsigned long int", "long unsigned int"])
+    register_dtype(np.int64, ["ga_long", "long int", "signed long int",
+                              "long signed int"])
+    register_dtype(np.uint64, ["ga_ulong", "unsigned long",
+                               "unsigned long int", "long unsigned int"])
 
     register_dtype(np.intp, ["ga_ssize", "ssize_t"])
     register_dtype(np.uintp, ["ga_size", "size_t"])

pygpu/operations.py

@@ -2,7 +2,7 @@
 
 from .gpuarray import _split, _concatenate, dtype_to_typecode
 from .dtypes import upcast
-from . import array, asarray
+from . import asarray
 
 
 def atleast_1d(*arys):
@@ -82,7 +82,8 @@ def array_split(ary, indices_or_sections, axis=0):
         # this madness is to support the numpy interface
         # it is supported by tests, but little else
         divs = (list(range(neach + 1, (neach + 1) * extra + 1, neach + 1)) +
-                list(range((neach + 1) * extra + neach, ary.shape[axis], neach)))
+                list(range((neach + 1) * extra + neach,
+                           ary.shape[axis], neach)))
         res = _split(ary, divs, axis)
     return res
 

pygpu/reduction.py

@@ -29,6 +29,7 @@ def _ceil_log2(x):
     else:
         return 0
 
+
 basic_kernel = Template("""
 ${preamble}
 
@@ -141,14 +142,16 @@ def __init__(self, context, dtype_out, neutral, reduce_expr, redux,
         if isinstance(arguments, str):
             self.arguments = parse_c_args(arguments)
         elif arguments is None:
-            self.arguments = [ArrayArg(numpy.dtype(self.dtype_out), '_reduce_input')]
+            self.arguments = [ArrayArg(numpy.dtype(self.dtype_out),
+                                       '_reduce_input')]
         else:
             self.arguments = arguments
 
         if (self.dtype_out == numpy.dtype('float16') or
                 any(ar.dtype == numpy.dtype('float16')
                     for ar in self.arguments)):
-            raise NotImplementedError('float16 not supported for the reduction interface')
+            raise NotImplementedError('float16 not supported for the '
+                                      'reduction interface')
 
         self.reduce_expr = reduce_expr
         if map_expr is None:

pygpu/tests/main.py

@@ -1,5 +1,4 @@
 import os
-import nose.plugins.builtin
 
 from nose.config import Config
 from nose.plugins.manager import PluginManager
@@ -29,25 +28,23 @@ def _test_argv(self, verbose, extra_argv):
             List with any extra arguments to pass to nosetests.
 
         """
-        #self.package_path = os.path.abspath(self.package_path)
+        # self.package_path = os.path.abspath(self.package_path)
         argv = [__file__, self.package_path]
         argv += ['--verbosity', str(verbose)]
         if extra_argv:
             argv += extra_argv
         return argv
 
     def _show_system_info(self):
-        nose = import_nose()
-
         import pygpu
-        #print ("pygpu version %s" % pygpu.__version__)
+        # print ("pygpu version %s" % pygpu.__version__)
         pygpu_dir = os.path.dirname(pygpu.__file__)
-        print ("pygpu is installed in %s" % pygpu_dir)
+        print("pygpu is installed in %s" % pygpu_dir)
 
         super(NoseTester, self)._show_system_info()
 
     def prepare_test_args(self, verbose=1, extra_argv=None, coverage=False,
-            capture=True, knownfailure=True):
+                          capture=True, knownfailure=True):
         """
         Prepare arguments for the `test` method.
 
@@ -61,8 +58,9 @@ def prepare_test_args(self, verbose=1, extra_argv=None, coverage=False,
 
         # numpy way of doing coverage
         if coverage:
-            argv += ['--cover-package=%s' % self.package_name, '--with-coverage',
-                    '--cover-tests', '--cover-inclusive', '--cover-erase']
+            argv += ['--cover-package=%s' % self.package_name,
+                     '--with-coverage', '--cover-tests', '--cover-inclusive',
+                     '--cover-erase']
 
         # Capture output only if needed
         if not capture:
@@ -77,7 +75,7 @@ def prepare_test_args(self, verbose=1, extra_argv=None, coverage=False,
         return argv, plugins
 
     def test(self, verbose=1, extra_argv=None, coverage=False, capture=True,
-            knownfailure=True):
+             knownfailure=True):
         """
         Run tests for module using nose.
 
@@ -122,28 +120,11 @@ def test(self, verbose=1, extra_argv=None, coverage=False, capture=True,
                 "launch pygpu.test()."))
 
         argv, plugins = self.prepare_test_args(verbose, extra_argv, coverage,
-                capture, knownfailure)
+                                               capture, knownfailure)
 
         # The "plugins" keyword of NumpyTestProgram gets ignored if config is
         # specified. Moreover, using "addplugins" instead can lead to strange
         # errors. So, we specify the plugins in the Config as well.
         cfg = Config(includeExe=True, plugins=PluginManager(plugins=plugins))
         t = NumpyTestProgram(argv=argv, exit=False, config=cfg)
         return t.result
-
-
-def main(modulename):
-    debug = False
-
-    if 0:
-        unittest.main()
-    elif len(sys.argv)==2 and sys.argv[1]=="--debug":
-        module = __import__(modulename)
-        tests = unittest.TestLoader().loadTestsFromModule(module)
-        tests.debug()
-    elif len(sys.argv)==1:
-        module = __import__(modulename)
-        tests = unittest.TestLoader().loadTestsFromModule(module)
-        unittest.TextTestRunner(verbosity=2).run(tests)
-    else:
-        print ("options: [--debug]")

pygpu/tests/support.py

@@ -1,6 +1,7 @@
 from __future__ import print_function
 
-import os, sys
+import os
+import sys
 import numpy
 from nose.plugins.skip import SkipTest
 
@@ -22,11 +23,14 @@
 dtypes_no_complex_big = ["float32", "float64", "int16", "uint16",
                          "int32", "int64", "uint32", "uint64"]
 
+
 def get_env_dev():
     for name in ['GPUARRAY_TEST_DEVICE', 'DEVICE']:
         if name in os.environ:
             return os.environ[name]
-    raise RuntimeError("No test device specified.  Specify one using the DEVICE or GPUARRAY_TEST_DEVICE environment variables.")
+    raise RuntimeError(
+        "No test device specified.  Specify one using the DEVICE "
+        "or GPUARRAY_TEST_DEVICE environment variables.")
 
 
 context = gpuarray.init(get_env_dev())

pygpu/tests/test_blas.py

@@ -15,25 +15,27 @@
 
 import pygpu.blas as gblas
 
+
 def test_dot():
     bools = [True, False]
     for N, dtype, offseted_i, sliced in product(
-        [1, 256, 1337], ['float32', 'float64'], bools, bools):
+            [1, 256, 1337], ['float32', 'float64'], bools, bools):
         yield dot, N, dtype, offseted_i, sliced, True, False
     for overwrite, init_z in product(bools, bools):
         yield dot, 666, 'float32', False, False, overwrite, init_z
 
+
 @guard_devsup
 def dot(N, dtype, offseted_i, sliced, overwrite, init_z):
     cX, gX = gen_gpuarray((N,), dtype, offseted_inner=offseted_i,
                           sliced=sliced, ctx=context)
     cY, gY = gen_gpuarray((N,), dtype, offseted_inner=offseted_i,
                           sliced=sliced, ctx=context)
     if init_z:
-        _, gZ = gen_gpuarray((), dtype, offseted_inner=offseted_i,
-            sliced=sliced, ctx=context)
+        gZ = gen_gpuarray((), dtype, offseted_inner=offseted_i,
+                          sliced=sliced, ctx=context)[1]
     else:
-        _, gZ = None, None
+        gZ = None
 
     if dtype == 'float32':
         cr = fblas.sdot(cX, cY)
@@ -46,21 +48,22 @@ def dot(N, dtype, offseted_i, sliced, overwrite, init_z):
 def test_gemv():
     bools = [False, True]
     for shape, order, trans, offseted_i, sliced in product(
-        [(100, 128), (128, 50)], 'fc', bools, bools, [1, 2, -1, -2]):
+            [(100, 128), (128, 50)], 'fc', bools, bools, [1, 2, -1, -2]):
         yield gemv, shape, 'float32', order, trans, \
             offseted_i, sliced, True, False
     for overwrite, init_y in product(bools, bools):
         yield gemv, (4, 3), 'float32', 'f', False, False, 1, \
             overwrite, init_y
     yield gemv, (32, 32), 'float64', 'f', False, False, 1, True, False
     for alpha, beta, overwrite in product(
-        [0, 1, -1, 0.6], [0, 1, -1, 0.6], bools):
+            [0, 1, -1, 0.6], [0, 1, -1, 0.6], bools):
         yield gemv, (32, 32), 'float32', 'f', False, False, 1, \
             overwrite, True, alpha, beta
 
+
 @guard_devsup
 def gemv(shp, dtype, order, trans, offseted_i, sliced,
-          overwrite, init_y, alpha=1.0, beta=0.0):
+         overwrite, init_y, alpha=1.0, beta=0.0):
     cA, gA = gen_gpuarray(shp, dtype, order=order, offseted_inner=offseted_i,
                           sliced=sliced, ctx=context)
     if trans:
@@ -92,31 +95,31 @@ def test_gemm():
     bools = [False, True]
     for (m, n, k), order, trans, offseted_o in product(
         [(48, 15, 32), (15, 32, 48)], list(product(*['fc']*3)),
-        list(product(bools, bools)), bools):
+            list(product(bools, bools)), bools):
         yield gemm, m, n, k, 'float32', order, trans, \
             offseted_o, 1, False, False
-    for sliced, overwrite, init_res in product(
-        [1, 2, -1, -2], bools, bools):
+    for sliced, overwrite, init_res in product([1, 2, -1, -2], bools, bools):
         yield gemm, 4, 3, 2, 'float32', ('f', 'f', 'f'), \
             (False, False), False, sliced, overwrite, init_res
     yield gemm, 32, 32, 32, 'float64', ('f', 'f', 'f'), (False, False), \
         False, 1, False, False
     for alpha, beta, overwrite in product(
-        [0, 1, -1, 0.6], [0, 1, -1, 0.6], bools):
+            [0, 1, -1, 0.6], [0, 1, -1, 0.6], bools):
         yield gemm, 32, 23, 32, 'float32', ('f', 'f', 'f'), \
             (False, False), False, 1, overwrite, True, alpha, beta
 
+
 @guard_devsup
 def gemm(m, n, k, dtype, order, trans, offseted_o, sliced, overwrite,
          init_res, alpha=1.0, beta=0.0):
     if trans[0]:
-        shpA = (k,m)
+        shpA = (k, m)
     else:
-        shpA = (m,k)
+        shpA = (m, k)
     if trans[1]:
-        shpB = (n,k)
+        shpB = (n, k)
     else:
-        shpB = (k,n)
+        shpB = (k, n)
 
     cA, gA = gen_gpuarray(shpA, dtype, order=order[0],
                           offseted_outer=offseted_o,
@@ -125,7 +128,7 @@ def gemm(m, n, k, dtype, order, trans, offseted_o, sliced, overwrite,
                           offseted_outer=offseted_o,
                           sliced=sliced, ctx=context)
     if init_res:
-        cC, gC = gen_gpuarray((m,n), dtype, order=order[2], ctx=context)
+        cC, gC = gen_gpuarray((m, n), dtype, order=order[2], ctx=context)
     else:
         cC, gC = None, None
 
@@ -143,13 +146,14 @@ def gemm(m, n, k, dtype, order, trans, offseted_o, sliced, overwrite,
 
 def test_ger():
     bools = [False, True]
-    for (m,n), order, sliced_x, sliced_y in product(
-        [(4,5)], 'fc', [1, 2, -2, -1], [1, 2, -2, -1]):
+    for (m, n), order, sliced_x, sliced_y in product(
+            [(4, 5)], 'fc', [1, 2, -2, -1], [1, 2, -2, -1]):
         yield ger, m, n, 'float32', order, sliced_x, sliced_y, False
     yield ger, 4, 5, 'float64', 'f', 1, 1, False
     for init_res, overwrite in product(bools, bools):
         yield ger, 4, 5, 'float32', 'f', 1, 1, init_res, overwrite
 
+
 def ger(m, n, dtype, order, sliced_x, sliced_y, init_res, overwrite=False):
     cX, gX = gen_gpuarray((m,), dtype, order, sliced=sliced_x, ctx=context)
     cY, gY = gen_gpuarray((n,), dtype, order, sliced=sliced_y, ctx=context)
@@ -168,35 +172,37 @@ def ger(m, n, dtype, order, sliced_x, sliced_y, init_res, overwrite=False):
 
     numpy.testing.assert_allclose(cr, numpy.asarray(gr), rtol=1e-6)
 
+
 def test_rgemmBatch_3d():
     bools = [False, True]
     for b, (m, n, k), order, trans, offseted_o in product(
-        [1, 17, 31], [(24, 7, 16), (7, 16, 24)], list(product('fc', 'fc', 'c')),
-        list(product(bools, bools)), bools):
+        [1, 17, 31], [(24, 7, 16), (7, 16, 24)],
+        list(product('fc', 'fc', 'c')),
+            list(product(bools, bools)), bools):
         yield rgemmBatch_3d, b, m, n, k, 'float32', order, trans, \
             offseted_o, 1, False, False
-    for sliced, overwrite, init_res in product(
-        [1, 2, -1, -2], bools, bools):
+    for sliced, overwrite, init_res in product([1, 2, -1, -2], bools, bools):
         yield rgemmBatch_3d, 5, 4, 3, 2, 'float32', ('f', 'f', 'c'), \
             (False, False), False, sliced, overwrite, init_res
-    yield rgemmBatch_3d, 16, 16, 16, 16, 'float64', ('f', 'f', 'c'), (False, False), \
-        False, 1, False, False
+    yield rgemmBatch_3d, 16, 16, 16, 16, 'float64', ('f', 'f', 'c'), \
+        (False, False), False, 1, False, False
     for alpha, beta, overwrite in product(
-        [0, 1, -1, 0.6], [0, 1, -1, 0.6], bools):
+            [0, 1, -1, 0.6], [0, 1, -1, 0.6], bools):
         yield rgemmBatch_3d, 16, 16, 9, 16, 'float32', ('f', 'f', 'c'), \
             (False, False), False, 1, overwrite, True, alpha, beta
 
+
 @guard_devsup
-def rgemmBatch_3d(b, m, n, k, dtype, order, trans, offseted_o, sliced, overwrite,
-         init_res, alpha=1.0, beta=0.0):
+def rgemmBatch_3d(b, m, n, k, dtype, order, trans, offseted_o, sliced,
+                  overwrite, init_res, alpha=1.0, beta=0.0):
     if trans[0]:
-        shpA = (b,k,m)
+        shpA = (b, k, m)
     else:
-        shpA = (b,m,k)
+        shpA = (b, m, k)
     if trans[1]:
-        shpB = (b,n,k)
+        shpB = (b, n, k)
     else:
-        shpB = (b,k,n)
+        shpB = (b, k, n)
 
     cA, gA = gen_gpuarray(shpA, dtype, order=order[0],
                           offseted_outer=offseted_o,
@@ -205,21 +211,21 @@ def rgemmBatch_3d(b, m, n, k, dtype, order, trans, offseted_o, sliced, overwrite
                           offseted_outer=offseted_o,
                           sliced=sliced, ctx=context)
     if init_res:
-        cC, gC = gen_gpuarray((b,m,n), dtype, order=order[2], ctx=context)
+        cC, gC = gen_gpuarray((b, m, n), dtype, order=order[2], ctx=context)
     else:
         cC, gC = None, None
 
-    cr = numpy.empty((b,m,n), dtype=dtype)
+    cr = numpy.empty((b, m, n), dtype=dtype)
     if dtype == 'float32':
         fn_gemm_c = fblas.sgemm
     else:
         fn_gemm_c = fblas.dgemm
     for i in range(b):
         cCi = cC if cC is None else cC[i]
         cr[i] = fn_gemm_c(alpha, cA[i], cB[i], beta, cCi, trans_a=trans[0],
-                         trans_b=trans[1], overwrite_c=overwrite)
+                          trans_b=trans[1], overwrite_c=overwrite)
 
     gr = gblas.gemmBatch_3d(alpha, gA, gB, beta, gC, trans_a=trans[0],
-                    trans_b=trans[1], overwrite_c=overwrite)
+                            trans_b=trans[1], overwrite_c=overwrite)
 
     numpy.testing.assert_allclose(cr, numpy.asarray(gr), rtol=1e-5)