numba-cuda 0.8.1__py3-none-any.whl → 0.10.0__py3-none-any.whl

numba_cuda/numba/cuda/tests/cudapy/test_record_dtype.py

@@ -78,24 +78,17 @@ def record_read_2d_array(r, a):
 
 recordtype = np.dtype(
     [
-        ('a', np.float64),
-        ('b', np.int32),
-        ('c', np.complex64),
-        ('d', (np.uint8, 5))
+        ("a", np.float64),
+        ("b", np.int32),
+        ("c", np.complex64),
+        ("d", (np.uint8, 5)),
     ],
-    align=True
+    align=True,
 )
 
-recordwitharray = np.dtype(
-    [
-        ('g', np.int32),
-        ('h', np.float32, 2)
-    ],
-    align=True
-)
+recordwitharray = np.dtype([("g", np.int32), ("h", np.float32, 2)], align=True)
 
-recordwith2darray = np.dtype([('i', np.int32),
-                              ('j', np.float32, (3, 2))])
+recordwith2darray = np.dtype([("i", np.int32), ("j", np.float32, (3, 2))])
 
 nested_array1_dtype = np.dtype([("array1", np.int16, (3,))], align=True)
 
@@ -104,12 +97,13 @@ nested_array2_dtype = np.dtype([("array2", np.int16, (3, 2))], align=True)
 
 # Functions used for "full array" tests
 
+
 def record_write_full_array(rec):
     rec.j[:, :] = np.ones((3, 2))
 
 
 def record_write_full_array_alt(rec):
-    rec['j'][:, :] = np.ones((3, 2))
+    rec["j"][:, :] = np.ones((3, 2))
 
 
 def recarray_set_record(ary, rec):
@@ -122,7 +116,7 @@ def recarray_write_array_of_nestedarray_broadcast(ary):
 
 
 def record_setitem_array(rec_source, rec_dest):
-    rec_dest['j'] = rec_source['j']
+    rec_dest["j"] = rec_source["j"]
 
 
 def recarray_write_array_of_nestedarray(ary):
@@ -135,7 +129,7 @@ def recarray_getitem_return(ary):
 
 
 def recarray_getitem_field_return(ary):
-    return ary['h']
+    return ary["h"]
 
 
 def recarray_getitem_field_return2(ary):
@@ -171,15 +165,14 @@ def record_read_2d_array01(ary):
 
 
 def assign_array_to_nested(dest, src):
-    dest['array1'] = src
+    dest["array1"] = src
 
 
 def assign_array_to_nested_2d(dest, src):
-    dest['array2'] = src
+    dest["array2"] = src
 
 
 class TestRecordDtype(CUDATestCase):
-
     def _createSampleArrays(self):
         self.sample1d = np.recarray(3, dtype=recordtype)
         self.samplerec1darr = np.recarray(1, dtype=recordwitharray)[0]
@@ -192,10 +185,10 @@ class TestRecordDtype(CUDATestCase):
         ary = self.sample1d
         for i in range(ary.size):
             x = i + 1
-            ary[i]['a'] = x / 2
-            ary[i]['b'] = x
-            ary[i]['c'] = x * 1j
-            ary[i]['d'] = "%d" % x
+            ary[i]["a"] = x / 2
+            ary[i]["b"] = x
+            ary[i]["c"] = x * 1j
+            ary[i]["d"] = "%d" % x
 
     def get_cfunc(self, pyfunc, argspec):
         return cuda.jit()(pyfunc)
@@ -221,7 +214,7 @@ class TestRecordDtype(CUDATestCase):
     def test_set_a(self):
         self._test_set_equal(set_a, 3.1415, types.float64)
         # Test again to check if coercion works
-        self._test_set_equal(set_a, 3., types.float32)
+        self._test_set_equal(set_a, 3.0, types.float32)
 
     def test_set_b(self):
         self._test_set_equal(set_b, 123, types.int32)
@@ -259,13 +252,13 @@ class TestRecordDtype(CUDATestCase):
         np.testing.assert_equal(rec[f], v)
 
     def test_rec_set_a(self):
-        self._test_rec_set(np.float64(1.5), record_set_a, 'a')
+        self._test_rec_set(np.float64(1.5), record_set_a, "a")
 
     def test_rec_set_b(self):
-        self._test_rec_set(np.int32(2), record_set_b, 'b')
+        self._test_rec_set(np.int32(2), record_set_b, "b")
 
     def test_rec_set_c(self):
-        self._test_rec_set(np.complex64(4.0 + 5.0j), record_set_c, 'c')
+        self._test_rec_set(np.complex64(4.0 + 5.0j), record_set_c, "c")
 
     def _test_rec_read(self, v, pyfunc, f):
         rec = self.sample1d.copy()[0]
@@ -277,81 +270,83 @@ class TestRecordDtype(CUDATestCase):
         np.testing.assert_equal(arr[0], v)
 
     def test_rec_read_a(self):
-        self._test_rec_read(np.float64(1.5), record_read_a, 'a')
+        self._test_rec_read(np.float64(1.5), record_read_a, "a")
 
     def test_rec_read_b(self):
-        self._test_rec_read(np.int32(2), record_read_b, 'b')
+        self._test_rec_read(np.int32(2), record_read_b, "b")
 
     def test_rec_read_c(self):
-        self._test_rec_read(np.complex64(4.0 + 5.0j), record_read_c, 'c')
+        self._test_rec_read(np.complex64(4.0 + 5.0j), record_read_c, "c")
 
     def test_record_write_1d_array(self):
-        '''
+        """
         Test writing to a 1D array within a structured type
-        '''
+        """
         rec = self.samplerec1darr.copy()
         nbrecord = numpy_support.from_dtype(recordwitharray)
         cfunc = self.get_cfunc(record_write_array, (nbrecord,))
 
         cfunc[1, 1](rec)
         expected = self.samplerec1darr.copy()
-        expected['g'] = 2
-        expected['h'][0] = 3.0
-        expected['h'][1] = 4.0
+        expected["g"] = 2
+        expected["h"][0] = 3.0
+        expected["h"][1] = 4.0
 
         np.testing.assert_equal(expected, rec)
 
     def test_record_write_2d_array(self):
-        '''
+        """
         Test writing to a 2D array within a structured type
-        '''
+        """
         rec = self.samplerec2darr.copy()
         nbrecord = numpy_support.from_dtype(recordwith2darray)
         cfunc = self.get_cfunc(record_write_2d_array, (nbrecord,))
         cfunc[1, 1](rec)
 
         expected = self.samplerec2darr.copy()
-        expected['i'] = 3
-        expected['j'][:] = np.asarray([5.0, 6.0, 7.0, 8.0, 9.0, 10.0],
-                                      np.float32).reshape(3, 2)
+        expected["i"] = 3
+        expected["j"][:] = np.asarray(
+            [5.0, 6.0, 7.0, 8.0, 9.0, 10.0], np.float32
+        ).reshape(3, 2)
         np.testing.assert_equal(expected, rec)
 
     def test_record_read_1d_array(self):
-        '''
+        """
         Test reading from a 1D array within a structured type
-        '''
+        """
         rec = self.samplerec1darr.copy()
-        rec['h'][0] = 4.0
-        rec['h'][1] = 5.0
+        rec["h"][0] = 4.0
+        rec["h"][1] = 5.0
 
         nbrecord = numpy_support.from_dtype(recordwitharray)
         cfunc = self.get_cfunc(record_read_array, (nbrecord,))
-        arr = np.zeros(2, dtype=rec['h'].dtype)
+        arr = np.zeros(2, dtype=rec["h"].dtype)
         cfunc[1, 1](rec, arr)
 
-        np.testing.assert_equal(rec['h'], arr)
+        np.testing.assert_equal(rec["h"], arr)
 
     def test_record_read_2d_array(self):
-        '''
+        """
         Test reading from a 2D array within a structured type
-        '''
+        """
         rec = self.samplerec2darr.copy()
-        rec['j'][:] = np.asarray([5.0, 6.0, 7.0, 8.0, 9.0, 10.0],
-                                 np.float32).reshape(3, 2)
+        rec["j"][:] = np.asarray(
+            [5.0, 6.0, 7.0, 8.0, 9.0, 10.0], np.float32
+        ).reshape(3, 2)
 
         nbrecord = numpy_support.from_dtype(recordwith2darray)
         cfunc = self.get_cfunc(record_read_2d_array, (nbrecord,))
-        arr = np.zeros((3,2), dtype=rec['j'].dtype)
+        arr = np.zeros((3, 2), dtype=rec["j"].dtype)
         cfunc[1, 1](rec, arr)
 
-        np.testing.assert_equal(rec['j'], arr)
+        np.testing.assert_equal(rec["j"], arr)
 
 
-@skip_on_cudasim('Structured array attr access not supported in simulator')
+@skip_on_cudasim("Structured array attr access not supported in simulator")
 class TestRecordDtypeWithStructArrays(TestRecordDtype):
-    '''
+    """
     Same as TestRecordDtype, but using structured arrays instead of recarrays.
-    '''
+    """
 
     def _createSampleArrays(self):
         self.sample1d = np.zeros(3, dtype=recordtype)
@@ -360,7 +355,6 @@ class TestRecordDtypeWithStructArrays(TestRecordDtype):
 
 
 class TestNestedArrays(CUDATestCase):
-
     # These tests mirror those from
     # numba.tests.test_record_dtype.TestNestedArrays added in PR
     # #7359: https://github.com/numba/numba/pull/7359
@@ -405,8 +399,9 @@ class TestNestedArrays(CUDATestCase):
     def test_record_read_2d_array(self):
         # Test reading from a 2D array within a structured type
         nbval = np.recarray(1, dtype=recordwith2darray)
-        nbval[0].j = np.asarray([1.5, 2.5, 3.5, 4.5, 5.5, 6.5],
-                                np.float32).reshape(3, 2)
+        nbval[0].j = np.asarray(
+            [1.5, 2.5, 3.5, 4.5, 5.5, 6.5], np.float32
+        ).reshape(3, 2)
         cfunc = self.get_cfunc(record_read_2d_array00, np.float32)
         res = cfunc(nbval[0])
         np.testing.assert_equal(res, nbval[0].j[0, 0])
@@ -422,12 +417,15 @@ class TestNestedArrays(CUDATestCase):
     def test_setitem(self):
         def gen():
             nbarr1 = np.recarray(1, dtype=recordwith2darray)
-            nbarr1[0] = np.array([(1, ((1, 2), (4, 5), (2, 3)))],
-                                 dtype=recordwith2darray)[0]
+            nbarr1[0] = np.array(
+                [(1, ((1, 2), (4, 5), (2, 3)))], dtype=recordwith2darray
+            )[0]
             nbarr2 = np.recarray(1, dtype=recordwith2darray)
-            nbarr2[0] = np.array([(10, ((10, 20), (40, 50), (20, 30)))],
-                                 dtype=recordwith2darray)[0]
+            nbarr2[0] = np.array(
+                [(10, ((10, 20), (40, 50), (20, 30)))], dtype=recordwith2darray
+            )[0]
             return nbarr1[0], nbarr2[0]
+
         pyfunc = record_setitem_array
         pyargs = gen()
         pyfunc(*pyargs)
@@ -453,7 +451,7 @@ class TestNestedArrays(CUDATestCase):
 
     # Writing to records / recarrays
 
-    @skip_on_cudasim('Structured array attr access not supported in simulator')
+    @skip_on_cudasim("Structured array attr access not supported in simulator")
     def test_set_record(self):
         # Test setting an entire record
         rec = np.ones(2, dtype=recordwith2darray).view(np.recarray)[0]
@@ -492,20 +490,18 @@ class TestNestedArrays(CUDATestCase):
         np.testing.assert_array_equal(expected, got)
 
     def test_issue_7693(self):
-        src_dtype = np.dtype([
-            ("user", np.float64),
-            ("array", np.int16, (3,))],
-            align=True)
+        src_dtype = np.dtype(
+            [("user", np.float64), ("array", np.int16, (3,))], align=True
+        )
 
-        dest_dtype = np.dtype([
-            ("user1", np.float64),
-            ("array1", np.int16, (3,))],
-            align=True)
+        dest_dtype = np.dtype(
+            [("user1", np.float64), ("array1", np.int16, (3,))], align=True
+        )
 
         @cuda.jit
         def copy(index, src, dest):
-            dest['user1'] = src[index]['user']
-            dest['array1'] = src[index]['array']
+            dest["user1"] = src[index]["user"]
+            dest["array1"] = src[index]["array"]
 
         source = np.zeros(2, dtype=src_dtype)
         got = np.zeros(2, dtype=dest_dtype)
@@ -528,10 +524,13 @@ class TestNestedArrays(CUDATestCase):
         # This test returning a record when passing an array and
         # return the first item when passing a record
         nbarr = np.recarray(2, dtype=recordwith2darray)
-        nbarr[0] = np.array([(1, ((1,2),(4,5),(2,3)))],
-                            dtype=recordwith2darray)[0]
-        for arg, retty in [(nbarr, recordwith2darray),
-                           (nbarr[0], (np.float32, (3, 2)))]:
+        nbarr[0] = np.array(
+            [(1, ((1, 2), (4, 5), (2, 3)))], dtype=recordwith2darray
+        )[0]
+        for arg, retty in [
+            (nbarr, recordwith2darray),
+            (nbarr[0], (np.float32, (3, 2))),
+        ]:
             pyfunc = recarray_getitem_field_return2_2d
             arr_expected = pyfunc(arg)
             cfunc = self.get_cfunc(pyfunc, retty)
@@ -545,10 +544,12 @@ class TestNestedArrays(CUDATestCase):
         # This tests returning a array of nestedarrays when passing an array and
         # returning a nestedarray when passing a record
         nbarr = np.recarray(2, dtype=recordwitharray)
-        nbarr[0] = np.array([(1, (2,3))], dtype=recordwitharray)[0]
+        nbarr[0] = np.array([(1, (2, 3))], dtype=recordwitharray)[0]
         for arg, retty in [(nbarr, recordwitharray), (nbarr[0], np.float32)]:
-            for pyfunc in [recarray_getitem_field_return,
-                           recarray_getitem_field_return2]:
+            for pyfunc in [
+                recarray_getitem_field_return,
+                recarray_getitem_field_return2,
+            ]:
                 arr_expected = pyfunc(arg)
                 cfunc = self.get_cfunc(pyfunc, retty)
                 arr_res = cfunc(arg)
@@ -570,17 +571,17 @@ class TestNestedArrays(CUDATestCase):
     def test_return_array(self):
         # Test getitem record AND array within record and returning it
         nbval = np.recarray(2, dtype=recordwitharray)
-        nbval[0] = np.array([(1, (2,3))], dtype=recordwitharray)[0]
+        nbval[0] = np.array([(1, (2, 3))], dtype=recordwitharray)[0]
         pyfunc = record_read_array0
         arr_expected = pyfunc(nbval)
         cfunc = self.get_cfunc(pyfunc, np.float32)
         arr_res = cfunc(nbval)
         np.testing.assert_equal(arr_expected, arr_res)
 
-    @skip_on_cudasim('Will unexpectedly pass on cudasim')
+    @skip_on_cudasim("Will unexpectedly pass on cudasim")
     @unittest.expectedFailure
     def test_set_array(self):
-        #Test setting an entire array within one record
+        # Test setting an entire array within one record
         arr = np.zeros(2, dtype=recordwith2darray).view(np.recarray)
         rec = arr[0]
         nbarr = np.zeros(2, dtype=recordwith2darray).view(np.recarray)
@@ -597,8 +598,8 @@ class TestNestedArrays(CUDATestCase):
         arr = np.zeros(2, dtype=recordwith2darray).view(np.recarray)
         nbarr = np.zeros(2, dtype=recordwith2darray).view(np.recarray)
         for pyfunc in (
-                recarray_write_array_of_nestedarray_broadcast,
-                recarray_write_array_of_nestedarray,
+            recarray_write_array_of_nestedarray_broadcast,
+            recarray_write_array_of_nestedarray,
         ):
             arr_expected = pyfunc(arr)
             cfunc = self.get_cfunc(pyfunc, nbarr.dtype)
@@ -606,5 +607,5 @@ class TestNestedArrays(CUDATestCase):
             np.testing.assert_equal(arr_res, arr_expected)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_recursion.py

@@ -6,11 +6,11 @@ import unittest
 
 
 class TestSelfRecursion(CUDATestCase):
-
     def setUp(self):
         # Avoid importing this module at the top level, as it triggers
         # compilation and can therefore fail
         from numba.cuda.tests.cudapy import recursion_usecases
+
         self.mod = recursion_usecases
         super().setUp()
 
@@ -36,19 +36,20 @@ class TestSelfRecursion(CUDATestCase):
     def test_global_implicit_sig(self):
         self.check_fib(self.mod.fib3)
 
-    @skip_on_cudasim('Simulator does not compile')
+    @skip_on_cudasim("Simulator does not compile")
     def test_runaway(self):
         with self.assertRaises(TypingError) as raises:
             cfunc = self.mod.runaway_self
 
-            @cuda.jit('void()')
+            @cuda.jit("void()")
             def kernel():
                 cfunc(1)
 
-        self.assertIn("cannot type infer runaway recursion",
-                      str(raises.exception))
+        self.assertIn(
+            "cannot type infer runaway recursion", str(raises.exception)
+        )
 
-    @unittest.skip('Needs insert_unresolved_ref support in target')
+    @unittest.skip("Needs insert_unresolved_ref support in target")
     def test_type_change(self):
         pfunc = self.mod.type_change_self.py_func
         cfunc = self.mod.type_change_self
@@ -79,7 +80,7 @@ class TestSelfRecursion(CUDATestCase):
 
         self.assertEqual(str(raises.exception), "raise_self")
 
-    @unittest.skip('Needs insert_unresolved_ref support in target')
+    @unittest.skip("Needs insert_unresolved_ref support in target")
     def test_optional_return(self):
         pfunc = self.mod.make_optional_return_case()
         cfunc = self.mod.make_optional_return_case(cuda.jit)
@@ -106,12 +107,13 @@ class TestSelfRecursion(CUDATestCase):
 
             self.assertEqual(expected, actual)
 
-    @skip_on_cudasim('Recursion handled because simulator does not compile')
+    @skip_on_cudasim("Recursion handled because simulator does not compile")
     def test_growing_return_tuple(self):
         cfunc = self.mod.make_growing_tuple_case(cuda.jit)
 
         with self.assertRaises(TypingError) as raises:
-            @cuda.jit('void()')
+
+            @cuda.jit("void()")
             def kernel():
                 cfunc(100)
 
@@ -121,5 +123,5 @@ class TestSelfRecursion(CUDATestCase):
         )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_reduction.py

@@ -10,7 +10,7 @@ sum_reduce = cuda.Reduce(lambda a, b: a + b)
 
 class TestReduction(CUDATestCase):
     def _sum_reduce(self, n):
-        A = (np.arange(n, dtype=np.float64) + 1)
+        A = np.arange(n, dtype=np.float64) + 1
         expect = A.sum()
         got = sum_reduce(A)
         self.assertEqual(expect, got)
@@ -19,24 +19,39 @@ class TestReduction(CUDATestCase):
         if ENABLE_CUDASIM:
             # Minimal test set for the simulator (which only wraps
             # functools.reduce)
-            test_sizes = [ 1, 16 ]
+            test_sizes = [1, 16]
         else:
             # Tests around the points where blocksize changes, and around larger
             # powers of two, sums of powers of two, and some "random" sizes
-            test_sizes = [ 1, 15, 16, 17, 127, 128, 129, 1023, 1024,
-                           1025, 1536, 1048576, 1049600, 1049728, 34567 ]
+            test_sizes = [
+                1,
+                15,
+                16,
+                17,
+                127,
+                128,
+                129,
+                1023,
+                1024,
+                1025,
+                1536,
+                1048576,
+                1049600,
+                1049728,
+                34567,
+            ]
         # Avoid recompilation by keeping sum_reduce here
         for n in test_sizes:
             self._sum_reduce(n)
 
     def test_empty_array_host(self):
-        A = (np.arange(0, dtype=np.float64) + 1)
+        A = np.arange(0, dtype=np.float64) + 1
         expect = A.sum()
         got = sum_reduce(A)
         self.assertEqual(expect, got)
 
     def test_empty_array_device(self):
-        A = (np.arange(0, dtype=np.float64) + 1)
+        A = np.arange(0, dtype=np.float64) + 1
         dA = cuda.to_device(A)
         expect = A.sum()
         got = sum_reduce(dA)
@@ -44,27 +59,27 @@ class TestReduction(CUDATestCase):
 
     def test_prod_reduce(self):
         prod_reduce = cuda.reduce(lambda a, b: a * b)
-        A = (np.arange(64, dtype=np.float64) + 1)
+        A = np.arange(64, dtype=np.float64) + 1
         expect = A.prod()
         got = prod_reduce(A, init=1)
         np.testing.assert_allclose(expect, got)
 
     def test_max_reduce(self):
         max_reduce = cuda.Reduce(lambda a, b: max(a, b))
-        A = (np.arange(3717, dtype=np.float64) + 1)
+        A = np.arange(3717, dtype=np.float64) + 1
         expect = A.max()
         got = max_reduce(A, init=0)
         self.assertEqual(expect, got)
 
     def test_non_identity_init(self):
         init = 3
-        A = (np.arange(10, dtype=np.float64) + 1)
+        A = np.arange(10, dtype=np.float64) + 1
         expect = A.sum() + init
         got = sum_reduce(A, init=init)
         self.assertEqual(expect, got)
 
     def test_result_on_device(self):
-        A = (np.arange(10, dtype=np.float64) + 1)
+        A = np.arange(10, dtype=np.float64) + 1
         got = cuda.to_device(np.zeros(1, dtype=np.float64))
         expect = A.sum()
         res = sum_reduce(A, res=got)
@@ -72,5 +87,5 @@ class TestReduction(CUDATestCase):
         self.assertEqual(expect, got[0])
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_retrieve_autoconverted_arrays.py

@@ -21,13 +21,10 @@ def set_array_to_three(arr):
 
 
 def set_record_to_three(rec):
-    rec[0]['b'] = 3
+    rec[0]["b"] = 3
 
 
-recordtype = np.dtype(
-    [('b', np.int32)],
-    align=True
-)
+recordtype = np.dtype([("b", np.int32)], align=True)
 
 
 class TestRetrieveAutoconvertedArrays(CUDATestCase):
@@ -61,23 +58,23 @@ class TestRetrieveAutoconvertedArrays(CUDATestCase):
     def test_record_in(self):
         host_rec = np.zeros(1, dtype=recordtype)
         self.set_record_to_three[1, 1](cuda.In(host_rec))
-        self.assertEqual(0, host_rec[0]['b'])
+        self.assertEqual(0, host_rec[0]["b"])
 
     def test_record_inout(self):
         host_rec = np.zeros(1, dtype=recordtype)
         self.set_record_to_three[1, 1](cuda.InOut(host_rec))
-        self.assertEqual(3, host_rec[0]['b'])
+        self.assertEqual(3, host_rec[0]["b"])
 
     def test_record_default(self):
         host_rec = np.zeros(1, dtype=recordtype)
         self.set_record_to_three[1, 1](host_rec)
-        self.assertEqual(3, host_rec[0]['b'])
+        self.assertEqual(3, host_rec[0]["b"])
 
     def test_record_in_from_config(self):
         host_rec = np.zeros(1, dtype=recordtype)
         self.set_record_to_three_nocopy[1, 1](host_rec)
-        self.assertEqual(0, host_rec[0]['b'])
+        self.assertEqual(0, host_rec[0]["b"])
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_serialize.py

@@ -7,9 +7,8 @@ import unittest
 from numba.np import numpy_support
 
 
-@skip_on_cudasim('pickling not supported in CUDASIM')
+@skip_on_cudasim("pickling not supported in CUDASIM")
 class TestPickle(CUDATestCase):
-
     def check_call(self, callee):
         arr = np.array([100])
         expected = callee[1, 1](arr)
@@ -41,14 +40,13 @@ class TestPickle(CUDATestCase):
         def inner(a):
             return a + 1
 
-        @cuda.jit('void(intp[:])')
+        @cuda.jit("void(intp[:])")
         def foo(arr):
             arr[0] = inner(arr[0])
 
         self.check_call(foo)
 
     def test_pickling_jit(self):
-
         @cuda.jit(device=True)
         def inner(a):
             return a + 1
@@ -60,7 +58,7 @@ class TestPickle(CUDATestCase):
         self.check_call(foo)
 
     def test_pickling_vectorize(self):
-        @vectorize(['intp(intp)', 'float64(float64)'], target='cuda')
+        @vectorize(["intp(intp)", "float64(float64)"], target="cuda")
         def cuda_vect(x):
             return x * 2
 
@@ -81,5 +79,5 @@ class TestPickle(CUDATestCase):
         np.testing.assert_equal(expected, got2)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_slicing.py

@@ -33,5 +33,5 @@ class TestCudaSlicing(CUDATestCase):
         arr[:] = cuda.to_device(a)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()