numba-cuda 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

numba_cuda/numba/cuda/tests/cudadrv/test_cuda_memory.py

@@ -7,7 +7,7 @@ from numba.cuda.testing import unittest, ContextResettingTestCase
 from numba.cuda.testing import skip_on_cudasim
 
 
-@skip_on_cudasim('CUDA Memory API unsupported in the simulator')
+@skip_on_cudasim("CUDA Memory API unsupported in the simulator")
 class TestCudaMemory(ContextResettingTestCase):
     def setUp(self):
         super().setUp()
@@ -24,8 +24,7 @@ class TestCudaMemory(ContextResettingTestCase):
             expected_class = driver.binding.CUdeviceptr
         else:
             expected_class = drvapi.cu_device_ptr
-        self.assertTrue(isinstance(obj.device_ctypes_pointer,
-                                   expected_class))
+        self.assertTrue(isinstance(obj.device_ctypes_pointer, expected_class))
 
     def test_device_memory(self):
         devmem = self.context.memalloc(1024)
@@ -41,9 +40,9 @@ class TestCudaMemory(ContextResettingTestCase):
 
     def test_pinned_memory(self):
         ary = np.arange(10)
-        devmem = self.context.mempin(ary, ary.ctypes.data,
-                                     ary.size * ary.dtype.itemsize,
-                                     mapped=True)
+        devmem = self.context.mempin(
+            ary, ary.ctypes.data, ary.size * ary.dtype.itemsize, mapped=True
+        )
         self._template(devmem)
 
     def test_managed_memory(self):
@@ -69,8 +68,7 @@ class TestCudaMemory(ContextResettingTestCase):
             v2 = v1.view(offset)
             self.assertEqual(handle_val(v2.owner), handle_val(m))
             self.assertEqual(handle_val(v2.owner), handle_val(m))
-            self.assertEqual(handle_val(v2) - offset * 2,
-                             handle_val(v2.owner))
+            self.assertEqual(handle_val(v2) - offset * 2, handle_val(v2.owner))
             self.assertEqual(m.refct, 3)
             del v2
             self.assertEqual(m.refct, 2)
@@ -84,22 +82,24 @@ class TestCudaMemory(ContextResettingTestCase):
     def test_user_extension(self):
         # User can use MemoryPointer to wrap externally defined pointers.
         # This test checks if the finalizer is invokded at correct time
-        fake_ptr = ctypes.c_void_p(0xdeadbeef)
+        fake_ptr = ctypes.c_void_p(0xDEADBEEF)
         dtor_invoked = [0]
 
         def dtor():
             dtor_invoked[0] += 1
 
         # Ensure finalizer is called when pointer is deleted
-        ptr = driver.MemoryPointer(context=self.context, pointer=fake_ptr,
-                                   size=40, finalizer=dtor)
+        ptr = driver.MemoryPointer(
+            context=self.context, pointer=fake_ptr, size=40, finalizer=dtor
+        )
         self.assertEqual(dtor_invoked[0], 0)
         del ptr
         self.assertEqual(dtor_invoked[0], 1)
 
         # Ensure removing derived pointer doesn't call finalizer
-        ptr = driver.MemoryPointer(context=self.context, pointer=fake_ptr,
-                                   size=40, finalizer=dtor)
+        ptr = driver.MemoryPointer(
+            context=self.context, pointer=fake_ptr, size=40, finalizer=dtor
+        )
         owned = ptr.own()
         del owned
         self.assertEqual(dtor_invoked[0], 1)
@@ -128,16 +128,16 @@ class TestCudaMemoryFunctions(ContextResettingTestCase):
         self.assertTrue(np.all(hstary == hstary2))
 
     def test_memset(self):
-        dtype = np.dtype('uint32')
+        dtype = np.dtype("uint32")
         n = 10
         sz = dtype.itemsize * 10
         devary = self.context.memalloc(sz)
-        driver.device_memset(devary, 0xab, sz)
+        driver.device_memset(devary, 0xAB, sz)
 
         hstary = np.empty(n, dtype=dtype)
         driver.device_to_host(hstary, devary, sz)
 
-        hstary2 = np.array([0xabababab] * n, dtype=np.dtype('uint32'))
+        hstary2 = np.array([0xABABABAB] * n, dtype=np.dtype("uint32"))
         self.assertTrue(np.all(hstary == hstary2))
 
     def test_d2d(self):
@@ -152,7 +152,7 @@ class TestCudaMemoryFunctions(ContextResettingTestCase):
         self.assertTrue(np.all(hst == hst2))
 
 
-@skip_on_cudasim('CUDA Memory API unsupported in the simulator')
+@skip_on_cudasim("CUDA Memory API unsupported in the simulator")
 class TestMVExtent(ContextResettingTestCase):
     def test_c_contiguous_array(self):
         ary = np.arange(100)
@@ -177,7 +177,7 @@ class TestMVExtent(ContextResettingTestCase):
 
     def test_ctypes_struct(self):
         class mystruct(ctypes.Structure):
-            _fields_ = [('x', ctypes.c_int), ('y', ctypes.c_int)]
+            _fields_ = [("x", ctypes.c_int), ("y", ctypes.c_int)]
 
         data = mystruct(x=123, y=432)
         sz = driver.host_memory_size(data)
@@ -189,5 +189,5 @@ class TestMVExtent(ContextResettingTestCase):
         self.assertTrue(ctypes.sizeof(data) == sz)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudadrv/test_cuda_ndarray.py

@@ -57,10 +57,7 @@ class TestCudaNDArray(CUDATestCase):
     def test_stream_bind(self):
         stream = cuda.stream()
         with stream.auto_synchronize():
-            arr = cuda.device_array(
-                (3, 3),
-                dtype=np.float64,
-                stream=stream)
+            arr = cuda.device_array((3, 3), dtype=np.float64, stream=stream)
             self.assertEqual(arr.bind(stream).stream, stream)
             self.assertEqual(arr.stream, stream)
 
@@ -90,8 +87,8 @@ class TestCudaNDArray(CUDATestCase):
 
         self.assertTrue(np.all(array == 0))
 
-        right.copy_to_host(array[N // 2:])
-        left.copy_to_host(array[:N // 2])
+        right.copy_to_host(array[N // 2 :])
+        left.copy_to_host(array[: N // 2])
 
         self.assertTrue(np.all(array == original))
 
@@ -104,7 +101,7 @@ class TestCudaNDArray(CUDATestCase):
         gpumem.copy_to_host(array)
         np.testing.assert_array_equal(array, original * 2)
 
-    @skip_on_cudasim('This works in the simulator')
+    @skip_on_cudasim("This works in the simulator")
     def test_devicearray_transpose_wrongdim(self):
         gpumem = cuda.to_device(np.array(np.arange(12)).reshape(3, 4, 1))
 
@@ -113,13 +110,15 @@ class TestCudaNDArray(CUDATestCase):
 
         self.assertEqual(
             "transposing a non-2D DeviceNDArray isn't supported",
-            str(e.exception))
+            str(e.exception),
+        )
 
     def test_devicearray_transpose_identity(self):
         # any-shape identities should work
         original = np.array(np.arange(24)).reshape(3, 4, 2)
-        array = np.transpose(cuda.to_device(original),
-                             axes=(0, 1, 2)).copy_to_host()
+        array = np.transpose(
+            cuda.to_device(original), axes=(0, 1, 2)
+        ).copy_to_host()
         self.assertTrue(np.all(array == original))
 
     def test_devicearray_transpose_duplicatedaxis(self):
@@ -131,9 +130,10 @@ class TestCudaNDArray(CUDATestCase):
         self.assertIn(
             str(e.exception),
             container=[
-                'invalid axes list (0, 0)',  # GPU
-                'repeated axis in transpose',  # sim
-            ])
+                "invalid axes list (0, 0)",  # GPU
+                "repeated axis in transpose",  # sim
+            ],
+        )
 
     def test_devicearray_transpose_wrongaxis(self):
         gpumem = cuda.to_device(np.array(np.arange(12)).reshape(3, 4))
@@ -144,10 +144,11 @@ class TestCudaNDArray(CUDATestCase):
         self.assertIn(
             str(e.exception),
             container=[
-                'invalid axes list (0, 2)',  # GPU
-                'invalid axis for this array',
-                'axis 2 is out of bounds for array of dimension 2',  # sim
-            ])
+                "invalid axes list (0, 2)",  # GPU
+                "invalid axis for this array",
+                "axis 2 is out of bounds for array of dimension 2",  # sim
+            ],
+        )
 
     def test_devicearray_view_ok(self):
         original = np.array(np.arange(12), dtype="i2").reshape(3, 4)
@@ -155,8 +156,7 @@ class TestCudaNDArray(CUDATestCase):
         for dtype in ("i4", "u4", "i8", "f8"):
             with self.subTest(dtype=dtype):
                 np.testing.assert_array_equal(
-                    array.view(dtype).copy_to_host(),
-                    original.view(dtype)
+                    array.view(dtype).copy_to_host(), original.view(dtype)
                 )
 
     def test_devicearray_view_ok_not_c_contig(self):
@@ -164,8 +164,7 @@ class TestCudaNDArray(CUDATestCase):
         array = cuda.to_device(original)[:, ::2]
         original = original[:, ::2]
         np.testing.assert_array_equal(
-            array.view("u2").copy_to_host(),
-            original.view("u2")
+            array.view("u2").copy_to_host(), original.view("u2")
         )
 
     def test_devicearray_view_bad_not_c_contig(self):
@@ -175,12 +174,14 @@ class TestCudaNDArray(CUDATestCase):
             array.view("i4")
 
         msg = str(e.exception)
-        self.assertIn('To change to a dtype of a different size,', msg)
+        self.assertIn("To change to a dtype of a different size,", msg)
 
-        contiguous_pre_np123 = 'the array must be C-contiguous' in msg
-        contiguous_post_np123 = 'the last axis must be contiguous' in msg
-        self.assertTrue(contiguous_pre_np123 or contiguous_post_np123,
-                        'Expected message to mention contiguity')
+        contiguous_pre_np123 = "the array must be C-contiguous" in msg
+        contiguous_post_np123 = "the last axis must be contiguous" in msg
+        self.assertTrue(
+            contiguous_pre_np123 or contiguous_post_np123,
+            "Expected message to mention contiguity",
+        )
 
     def test_devicearray_view_bad_itemsize(self):
         original = np.array(np.arange(12), dtype="i2").reshape(4, 3)
@@ -191,7 +192,8 @@ class TestCudaNDArray(CUDATestCase):
             "When changing to a larger dtype,"
             " its size must be a divisor of the total size in bytes"
             " of the last axis of the array.",
-            str(e.exception))
+            str(e.exception),
+        )
 
     def test_devicearray_transpose_ok(self):
         original = np.array(np.arange(12)).reshape(3, 4)
@@ -206,7 +208,7 @@ class TestCudaNDArray(CUDATestCase):
     def test_devicearray_contiguous_slice(self):
         # memcpys are dumb ranges of bytes, so trying to
         # copy to a non-contiguous range shouldn't work!
-        a = np.arange(25).reshape(5, 5, order='F')
+        a = np.arange(25).reshape(5, 5, order="F")
         s = np.full(fill_value=5, shape=(5,))
 
         d = cuda.to_device(a)
@@ -216,9 +218,7 @@ class TestCudaNDArray(CUDATestCase):
         # (40-byte strides). This means we can't memcpy to it!
         with self.assertRaises(ValueError) as e:
             d[2].copy_to_device(s)
-        self.assertEqual(
-            devicearray.errmsg_contiguous_buffer,
-            str(e.exception))
+        self.assertEqual(devicearray.errmsg_contiguous_buffer, str(e.exception))
 
         # if d[2].copy_to_device(s), then this would pass:
         # self.assertTrue((a == d.copy_to_host()).all())
@@ -236,9 +236,9 @@ class TestCudaNDArray(CUDATestCase):
             (a_c, a_f),
             (a_c, a_c),
         ]:
-            msg = '%s => %s' % (
-                'C' if original.flags.c_contiguous else 'F',
-                'C' if copy.flags.c_contiguous else 'F',
+            msg = "%s => %s" % (
+                "C" if original.flags.c_contiguous else "F",
+                "C" if copy.flags.c_contiguous else "F",
             )
 
             d = cuda.to_device(original)
@@ -248,17 +248,17 @@ class TestCudaNDArray(CUDATestCase):
 
     def test_devicearray_contiguous_copy_host_3d(self):
         a_c = np.arange(5 * 5 * 5).reshape(5, 5, 5)
-        a_f = np.array(a_c, order='F')
+        a_f = np.array(a_c, order="F")
         self._test_devicearray_contiguous_host_copy(a_c, a_f)
 
     def test_devicearray_contiguous_copy_host_1d(self):
         a_c = np.arange(5)
-        a_f = np.array(a_c, order='F')
+        a_f = np.array(a_c, order="F")
         self._test_devicearray_contiguous_host_copy(a_c, a_f)
 
     def test_devicearray_contiguous_copy_device(self):
         a_c = np.arange(5 * 5 * 5).reshape(5, 5, 5)
-        a_f = np.array(a_c, order='F')
+        a_f = np.array(a_c, order="F")
         self.assertTrue(a_c.flags.c_contiguous)
         self.assertTrue(a_f.flags.f_contiguous)
 
@@ -268,7 +268,8 @@ class TestCudaNDArray(CUDATestCase):
             d.copy_to_device(cuda.to_device(a_f))
         self.assertEqual(
             "incompatible strides: {} vs. {}".format(a_c.strides, a_f.strides),
-            str(e.exception))
+            str(e.exception),
+        )
 
         d.copy_to_device(cuda.to_device(a_c))
         self.assertTrue(np.all(d.copy_to_host() == a_c))
@@ -279,7 +280,8 @@ class TestCudaNDArray(CUDATestCase):
             d.copy_to_device(cuda.to_device(a_c))
         self.assertEqual(
             "incompatible strides: {} vs. {}".format(a_f.strides, a_c.strides),
-            str(e.exception))
+            str(e.exception),
+        )
 
         d.copy_to_device(cuda.to_device(a_f))
         self.assertTrue(np.all(d.copy_to_host() == a_f))
@@ -288,8 +290,8 @@ class TestCudaNDArray(CUDATestCase):
         broadsize = 4
         coreshape = (2, 3)
         coresize = np.prod(coreshape)
-        core_c = np.arange(coresize).reshape(coreshape, order='C')
-        core_f = np.arange(coresize).reshape(coreshape, order='F')
+        core_c = np.arange(coresize).reshape(coreshape, order="C")
+        core_f = np.arange(coresize).reshape(coreshape, order="F")
         for dim in range(len(coreshape)):
             newindex = (slice(None),) * dim + (np.newaxis,)
             broadshape = coreshape[:dim] + (broadsize,) + coreshape[dim:]
@@ -318,11 +320,9 @@ class TestCudaNDArray(CUDATestCase):
 
         with self.assertRaises(ValueError) as e:
             d.copy_to_device(cuda.to_device(arr)[::2])
-        self.assertEqual(
-            devicearray.errmsg_contiguous_buffer,
-            str(e.exception))
+        self.assertEqual(devicearray.errmsg_contiguous_buffer, str(e.exception))
 
-    @skip_on_cudasim('DeviceNDArray class not present in simulator')
+    @skip_on_cudasim("DeviceNDArray class not present in simulator")
     def test_devicearray_relaxed_strides(self):
         # From the reproducer in Issue #6824.
 
@@ -334,86 +334,88 @@ class TestCudaNDArray(CUDATestCase):
 
         # Ensure we still believe the array to be contiguous because
         # strides checking is relaxed.
-        self.assertTrue(arr.flags['C_CONTIGUOUS'])
-        self.assertTrue(arr.flags['F_CONTIGUOUS'])
+        self.assertTrue(arr.flags["C_CONTIGUOUS"])
+        self.assertTrue(arr.flags["F_CONTIGUOUS"])
 
     def test_c_f_contiguity_matches_numpy(self):
         # From the reproducer in Issue #4943.
 
         shapes = ((1, 4), (4, 1))
-        orders = ('C', 'F')
+        orders = ("C", "F")
 
         for shape, order in itertools.product(shapes, orders):
             arr = np.ndarray(shape, order=order)
             d_arr = cuda.to_device(arr)
-            self.assertEqual(arr.flags['C_CONTIGUOUS'],
-                             d_arr.flags['C_CONTIGUOUS'])
-            self.assertEqual(arr.flags['F_CONTIGUOUS'],
-                             d_arr.flags['F_CONTIGUOUS'])
+            self.assertEqual(
+                arr.flags["C_CONTIGUOUS"], d_arr.flags["C_CONTIGUOUS"]
+            )
+            self.assertEqual(
+                arr.flags["F_CONTIGUOUS"], d_arr.flags["F_CONTIGUOUS"]
+            )
 
-    @skip_on_cudasim('Typing not done in the simulator')
+    @skip_on_cudasim("Typing not done in the simulator")
     def test_devicearray_typing_order_simple_c(self):
         # C-order 1D array
-        a = np.zeros(10, order='C')
+        a = np.zeros(10, order="C")
         d = cuda.to_device(a)
-        self.assertEqual(d._numba_type_.layout, 'C')
+        self.assertEqual(d._numba_type_.layout, "C")
 
-    @skip_on_cudasim('Typing not done in the simulator')
+    @skip_on_cudasim("Typing not done in the simulator")
     def test_devicearray_typing_order_simple_f(self):
         # F-order array that is also C layout.
-        a = np.zeros(10, order='F')
+        a = np.zeros(10, order="F")
         d = cuda.to_device(a)
-        self.assertEqual(d._numba_type_.layout, 'C')
+        self.assertEqual(d._numba_type_.layout, "C")
 
-    @skip_on_cudasim('Typing not done in the simulator')
+    @skip_on_cudasim("Typing not done in the simulator")
     def test_devicearray_typing_order_2d_c(self):
         # C-order 2D array
-        a = np.zeros((2, 10), order='C')
+        a = np.zeros((2, 10), order="C")
         d = cuda.to_device(a)
-        self.assertEqual(d._numba_type_.layout, 'C')
+        self.assertEqual(d._numba_type_.layout, "C")
 
-    @skip_on_cudasim('Typing not done in the simulator')
+    @skip_on_cudasim("Typing not done in the simulator")
     def test_devicearray_typing_order_2d_f(self):
         # F-order array that can only be F layout
-        a = np.zeros((2, 10), order='F')
+        a = np.zeros((2, 10), order="F")
         d = cuda.to_device(a)
-        self.assertEqual(d._numba_type_.layout, 'F')
+        self.assertEqual(d._numba_type_.layout, "F")
 
-    @skip_on_cudasim('Typing not done in the simulator')
+    @skip_on_cudasim("Typing not done in the simulator")
     def test_devicearray_typing_order_noncontig_slice_c(self):
         # Non-contiguous slice of C-order array
-        a = np.zeros((5, 5), order='C')
-        d = cuda.to_device(a)[:,2]
-        self.assertEqual(d._numba_type_.layout, 'A')
+        a = np.zeros((5, 5), order="C")
+        d = cuda.to_device(a)[:, 2]
+        self.assertEqual(d._numba_type_.layout, "A")
 
-    @skip_on_cudasim('Typing not done in the simulator')
+    @skip_on_cudasim("Typing not done in the simulator")
     def test_devicearray_typing_order_noncontig_slice_f(self):
         # Non-contiguous slice of F-order array
-        a = np.zeros((5, 5), order='F')
-        d = cuda.to_device(a)[2,:]
-        self.assertEqual(d._numba_type_.layout, 'A')
+        a = np.zeros((5, 5), order="F")
+        d = cuda.to_device(a)[2, :]
+        self.assertEqual(d._numba_type_.layout, "A")
 
-    @skip_on_cudasim('Typing not done in the simulator')
+    @skip_on_cudasim("Typing not done in the simulator")
     def test_devicearray_typing_order_contig_slice_c(self):
         # Contiguous slice of C-order array
-        a = np.zeros((5, 5), order='C')
-        d = cuda.to_device(a)[2,:]
-        self.assertEqual(d._numba_type_.layout, 'C')
+        a = np.zeros((5, 5), order="C")
+        d = cuda.to_device(a)[2, :]
+        self.assertEqual(d._numba_type_.layout, "C")
 
-    @skip_on_cudasim('Typing not done in the simulator')
+    @skip_on_cudasim("Typing not done in the simulator")
     def test_devicearray_typing_order_contig_slice_f(self):
         # Contiguous slice of F-order array - is both C- and F-contiguous, so
         # types as 'C' layout
-        a = np.zeros((5, 5), order='F')
-        d = cuda.to_device(a)[:,2]
-        self.assertEqual(d._numba_type_.layout, 'C')
+        a = np.zeros((5, 5), order="F")
+        d = cuda.to_device(a)[:, 2]
+        self.assertEqual(d._numba_type_.layout, "C")
 
-    @skip_on_cudasim('Typing not done in the simulator')
+    @skip_on_cudasim("Typing not done in the simulator")
     def test_devicearray_typing_order_broadcasted(self):
         # Broadcasted array, similar to that used for passing scalars to ufuncs
         a = np.broadcast_to(np.array([1]), (10,))
         d = cuda.to_device(a)
-        self.assertEqual(d._numba_type_.layout, 'A')
+        self.assertEqual(d._numba_type_.layout, "A")
 
     def test_bug6697(self):
         ary = np.arange(10, dtype=np.int16)
@@ -421,7 +423,7 @@ class TestCudaNDArray(CUDATestCase):
         got = np.asarray(dary)
         self.assertEqual(got.dtype, dary.dtype)
 
-    @skip_on_cudasim('DeviceNDArray class not present in simulator')
+    @skip_on_cudasim("DeviceNDArray class not present in simulator")
     def test_issue_8477(self):
         # Ensure that we can copy a zero-length device array to a zero-length
         # host array when the strides of the device and host arrays differ -
@@ -430,8 +432,9 @@ class TestCudaNDArray(CUDATestCase):
         # https://github.com/numba/numba/issues/8477.
 
         # Create a device array with shape (0,) and strides (8,)
-        dev_array = devicearray.DeviceNDArray(shape=(0,), strides=(8,),
-                                              dtype=np.int8)
+        dev_array = devicearray.DeviceNDArray(
+            shape=(0,), strides=(8,), dtype=np.int8
+        )
 
         # Create a host array with shape (0,) and strides (0,)
         host_array = np.ndarray(shape=(0,), strides=(0,), dtype=np.int8)
@@ -470,8 +473,7 @@ class TestArrayMethod(CUDATestCase):
         dev_array = cuda.to_device(np.asarray([1.0, 2.0, 3.0]))
         host_array = np.array(dev_array, dtype=dtype)
         np.testing.assert_equal(
-            host_array,
-            dev_array.copy_to_host().astype(dtype)
+            host_array, dev_array.copy_to_host().astype(dtype)
         )
 
     @unittest.skipUnless(IS_NUMPY_2, "NumPy 1.x does not pass copy kwarg")
@@ -490,10 +492,13 @@ class TestArrayMethod(CUDATestCase):
 class TestRecarray(CUDATestCase):
     def test_recarray(self):
         # From issue #4111
-        a = np.recarray((16,), dtype=[
-            ("value1", np.int64),
-            ("value2", np.float64),
-        ])
+        a = np.recarray(
+            (16,),
+            dtype=[
+                ("value1", np.int64),
+                ("value2", np.float64),
+            ],
+        )
         a.value1 = np.arange(a.size, dtype=np.int64)
         a.value2 = np.arange(a.size, dtype=np.float64) / 100
 
@@ -518,39 +523,39 @@ class TestCoreContiguous(CUDATestCase):
     def _test_against_array_core(self, view):
         self.assertEqual(
             devicearray.is_contiguous(view),
-            devicearray.array_core(view).flags['C_CONTIGUOUS']
+            devicearray.array_core(view).flags["C_CONTIGUOUS"],
         )
 
     def test_device_array_like_1d(self):
-        d_a = cuda.device_array(10, order='C')
+        d_a = cuda.device_array(10, order="C")
         self._test_against_array_core(d_a)
 
     def test_device_array_like_2d(self):
-        d_a = cuda.device_array((10, 12), order='C')
+        d_a = cuda.device_array((10, 12), order="C")
         self._test_against_array_core(d_a)
 
     def test_device_array_like_2d_transpose(self):
-        d_a = cuda.device_array((10, 12), order='C')
+        d_a = cuda.device_array((10, 12), order="C")
         self._test_against_array_core(d_a.T)
 
     def test_device_array_like_3d(self):
-        d_a = cuda.device_array((10, 12, 14), order='C')
+        d_a = cuda.device_array((10, 12, 14), order="C")
         self._test_against_array_core(d_a)
 
     def test_device_array_like_1d_f(self):
-        d_a = cuda.device_array(10, order='F')
+        d_a = cuda.device_array(10, order="F")
         self._test_against_array_core(d_a)
 
     def test_device_array_like_2d_f(self):
-        d_a = cuda.device_array((10, 12), order='F')
+        d_a = cuda.device_array((10, 12), order="F")
         self._test_against_array_core(d_a)
 
     def test_device_array_like_2d_f_transpose(self):
-        d_a = cuda.device_array((10, 12), order='F')
+        d_a = cuda.device_array((10, 12), order="F")
         self._test_against_array_core(d_a.T)
 
     def test_device_array_like_3d_f(self):
-        d_a = cuda.device_array((10, 12, 14), order='F')
+        d_a = cuda.device_array((10, 12, 14), order="F")
         self._test_against_array_core(d_a)
 
     def test_1d_view(self):
@@ -560,7 +565,7 @@ class TestCoreContiguous(CUDATestCase):
 
     def test_1d_view_f(self):
         shape = 10
-        view = np.zeros(shape, order='F')[::2]
+        view = np.zeros(shape, order="F")[::2]
         self._test_against_array_core(view)
 
     def test_2d_view(self):
@@ -570,9 +575,9 @@ class TestCoreContiguous(CUDATestCase):
 
     def test_2d_view_f(self):
         shape = (10, 12)
-        view = np.zeros(shape, order='F')[::2, ::2]
+        view = np.zeros(shape, order="F")[::2, ::2]
         self._test_against_array_core(view)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudadrv/test_deallocations.py

@@ -3,14 +3,18 @@ from contextlib import contextmanager
 import numpy as np
 
 from numba import cuda
-from numba.cuda.testing import (unittest, skip_on_cudasim,
-                                skip_if_external_memmgr, CUDATestCase)
+from numba.cuda.testing import (
+    unittest,
+    skip_on_cudasim,
+    skip_if_external_memmgr,
+    CUDATestCase,
+)
 from numba.tests.support import captured_stderr
 from numba.core import config
 
 
-@skip_on_cudasim('not supported on CUDASIM')
-@skip_if_external_memmgr('Deallocation specific to Numba memory management')
+@skip_on_cudasim("not supported on CUDASIM")
+@skip_if_external_memmgr("Deallocation specific to Numba memory management")
 class TestDeallocation(CUDATestCase):
     def test_max_pending_count(self):
         # get deallocation manager and flush it
@@ -41,8 +45,9 @@ class TestDeallocation(CUDATestCase):
             config.CUDA_DEALLOCS_RATIO = max_pending / mi.total
             # due to round off error (floor is used in calculating
             # _max_pending_bytes) it can be off by 1.
-            self.assertAlmostEqual(deallocs._max_pending_bytes, max_pending,
-                                   delta=1)
+            self.assertAlmostEqual(
+                deallocs._max_pending_bytes, max_pending, delta=1
+            )
 
             # allocate half the max size
             # this will not trigger deallocation
@@ -51,8 +56,11 @@ class TestDeallocation(CUDATestCase):
 
             # allocate another remaining
             # this will not trigger deallocation
-            cuda.to_device(np.ones(deallocs._max_pending_bytes -
-                                   deallocs._size, dtype=np.int8))
+            cuda.to_device(
+                np.ones(
+                    deallocs._max_pending_bytes - deallocs._size, dtype=np.int8
+                )
+            )
             self.assertEqual(len(deallocs), 2)
 
             # another byte to trigger .clear()
@@ -64,7 +72,7 @@ class TestDeallocation(CUDATestCase):
 
 
 @skip_on_cudasim("defer_cleanup has no effect in CUDASIM")
-@skip_if_external_memmgr('Deallocation specific to Numba memory management')
+@skip_if_external_memmgr("Deallocation specific to Numba memory management")
 class TestDeferCleanup(CUDATestCase):
     def test_basic(self):
         harr = np.arange(5)
@@ -138,11 +146,12 @@ class TestDeferCleanupAvail(CUDATestCase):
             pass
 
 
-@skip_on_cudasim('not supported on CUDASIM')
+@skip_on_cudasim("not supported on CUDASIM")
 class TestDel(CUDATestCase):
     """
     Ensure resources are deleted properly without ignored exception.
     """
+
     @contextmanager
     def check_ignored_exception(self, ctx):
         with captured_stderr() as cap:
@@ -245,5 +254,5 @@ class TestDel(CUDATestCase):
                     pass
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()