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

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

@@ -3,9 +3,14 @@ from __future__ import print_function
 import numpy as np
 
 from numba import config, cuda, int32
-from numba.cuda.testing import (unittest, CUDATestCase, skip_on_cudasim,
-                                skip_unless_cc_60, skip_if_cudadevrt_missing,
-                                skip_if_mvc_enabled)
+from numba.cuda.testing import (
+    unittest,
+    CUDATestCase,
+    skip_on_cudasim,
+    skip_unless_cc_60,
+    skip_if_cudadevrt_missing,
+    skip_if_mvc_enabled,
+)
 
 
 @cuda.jit
@@ -47,7 +52,7 @@ def sequential_rows(M):
 
 
 @skip_if_cudadevrt_missing
-@skip_if_mvc_enabled('CG not supported with MVC')
+@skip_if_mvc_enabled("CG not supported with MVC")
 class TestCudaCooperativeGroups(CUDATestCase):
     @skip_unless_cc_60
     def test_this_grid(self):
@@ -55,11 +60,12 @@ class TestCudaCooperativeGroups(CUDATestCase):
         this_grid[1, 1](A)
 
         # Ensure the kernel executed beyond the call to cuda.this_grid()
-        self.assertFalse(np.isnan(A[0]), 'Value was not set')
+        self.assertFalse(np.isnan(A[0]), "Value was not set")
 
     @skip_unless_cc_60
-    @skip_on_cudasim("Simulator doesn't differentiate between normal and "
-                     "cooperative kernels")
+    @skip_on_cudasim(
+        "Simulator doesn't differentiate between normal and cooperative kernels"
+    )
     def test_this_grid_is_cooperative(self):
         A = np.full(1, fill_value=np.nan)
         this_grid[1, 1](A)
@@ -74,11 +80,12 @@ class TestCudaCooperativeGroups(CUDATestCase):
         sync_group[1, 1](A)
 
         # Ensure the kernel executed beyond the call to cuda.sync_group()
-        self.assertFalse(np.isnan(A[0]), 'Value was not set')
+        self.assertFalse(np.isnan(A[0]), "Value was not set")
 
     @skip_unless_cc_60
-    @skip_on_cudasim("Simulator doesn't differentiate between normal and "
-                     "cooperative kernels")
+    @skip_on_cudasim(
+        "Simulator doesn't differentiate between normal and cooperative kernels"
+    )
     def test_sync_group_is_cooperative(self):
         A = np.full(1, fill_value=np.nan)
         sync_group[1, 1](A)
@@ -99,7 +106,7 @@ class TestCudaCooperativeGroups(CUDATestCase):
         for key, overload in no_sync.overloads.items():
             self.assertFalse(overload.cooperative)
             for link in overload._codelibrary._linking_files:
-                self.assertNotIn('cudadevrt', link)
+                self.assertNotIn("cudadevrt", link)
 
     @skip_unless_cc_60
     def test_sync_at_matrix_row(self):
@@ -113,7 +120,7 @@ class TestCudaCooperativeGroups(CUDATestCase):
         blockdim = 32
         griddim = A.shape[1] // blockdim
 
-        sig = (int32[:,::1],)
+        sig = (int32[:, ::1],)
         c_sequential_rows = cuda.jit(sig)(sequential_rows)
 
         overload = c_sequential_rows.overloads[sig]
@@ -133,7 +140,7 @@ class TestCudaCooperativeGroups(CUDATestCase):
         # doesn't error, and that varying the number of dimensions of the block
         # whilst keeping the total number of threads constant doesn't change
         # the maximum to validate some of the logic.
-        sig = (int32[:,::1],)
+        sig = (int32[:, ::1],)
         c_sequential_rows = cuda.jit(sig)(sequential_rows)
         overload = c_sequential_rows.overloads[sig]
         blocks1d = overload.max_cooperative_grid_blocks(256)
@@ -143,5 +150,5 @@ class TestCudaCooperativeGroups(CUDATestCase):
         self.assertEqual(blocks1d, blocks3d)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -9,12 +9,13 @@ from numba.tests.support import linux_only, override_config
 from unittest.mock import call, patch
 
 
-@skip_on_cudasim('CUDA Array Interface is not supported in the simulator')
+@skip_on_cudasim("CUDA Array Interface is not supported in the simulator")
 class TestCudaArrayInterface(ContextResettingTestCase):
     def assertPointersEqual(self, a, b):
         if driver.USE_NV_BINDING:
-            self.assertEqual(int(a.device_ctypes_pointer),
-                             int(b.device_ctypes_pointer))
+            self.assertEqual(
+                int(a.device_ctypes_pointer), int(b.device_ctypes_pointer)
+            )
 
     def test_as_cuda_array(self):
         h_arr = np.arange(10)
@@ -37,7 +38,7 @@ class TestCudaArrayInterface(ContextResettingTestCase):
         else:
             return stream.handle.value
 
-    @skip_if_external_memmgr('Ownership not relevant with external memmgr')
+    @skip_if_external_memmgr("Ownership not relevant with external memmgr")
     def test_ownership(self):
         # Get the deallocation queue
         ctx = cuda.current_context()
@@ -82,7 +83,7 @@ class TestCudaArrayInterface(ContextResettingTestCase):
         np.testing.assert_array_equal(d_arr.copy_to_host(), h_arr + val)
 
     def test_ufunc_arg(self):
-        @vectorize(['f8(f8, f8)'], target='cuda')
+        @vectorize(["f8(f8, f8)"], target="cuda")
         def vadd(a, b):
             return a + b
 
@@ -99,7 +100,7 @@ class TestCudaArrayInterface(ContextResettingTestCase):
         np.testing.assert_array_equal(returned.copy_to_host(), h_arr + val)
 
     def test_gufunc_arg(self):
-        @guvectorize(['(f8, f8, f8[:])'], '(),()->()', target='cuda')
+        @guvectorize(["(f8, f8, f8[:])"], "(),()->()", target="cuda")
         def vadd(inp, val, out):
             out[0] = inp + val
 
@@ -118,8 +119,8 @@ class TestCudaArrayInterface(ContextResettingTestCase):
 
     def test_array_views(self):
         """Views created via array interface support:
-            - Strided slices
-            - Strided slices
+        - Strided slices
+        - Strided slices
         """
         h_arr = np.random.random(10)
         c_arr = cuda.to_device(h_arr)
@@ -148,23 +149,22 @@ class TestCudaArrayInterface(ContextResettingTestCase):
         self.assertEqual(arr[::2].strides, arr_strided.strides)
         self.assertEqual(arr[::2].dtype.itemsize, arr_strided.dtype.itemsize)
         self.assertEqual(arr[::2].alloc_size, arr_strided.alloc_size)
-        self.assertEqual(arr[::2].nbytes,
-                         arr_strided.size * arr_strided.dtype.itemsize)
+        self.assertEqual(
+            arr[::2].nbytes, arr_strided.size * arr_strided.dtype.itemsize
+        )
 
         # __setitem__ interface propagates into external array
 
         # Writes to a slice
         arr[:5] = np.pi
         np.testing.assert_array_equal(
-            c_arr.copy_to_host(),
-            np.concatenate((np.full(5, np.pi), h_arr[5:]))
+            c_arr.copy_to_host(), np.concatenate((np.full(5, np.pi), h_arr[5:]))
         )
 
         # Writes to a slice from a view
         arr[:5] = arr[5:]
         np.testing.assert_array_equal(
-            c_arr.copy_to_host(),
-            np.concatenate((h_arr[5:], h_arr[5:]))
+            c_arr.copy_to_host(), np.concatenate((h_arr[5:], h_arr[5:]))
         )
 
         # Writes through a view
@@ -177,10 +177,7 @@ class TestCudaArrayInterface(ContextResettingTestCase):
             c_arr.copy_to_host()[::2],
             np.full(5, np.pi),
         )
-        np.testing.assert_array_equal(
-            c_arr.copy_to_host()[1::2],
-            h_arr[1::2]
-        )
+        np.testing.assert_array_equal(c_arr.copy_to_host()[1::2], h_arr[1::2])
 
     def test_negative_strided_issue(self):
         # issue #3705
@@ -188,7 +185,7 @@ class TestCudaArrayInterface(ContextResettingTestCase):
         c_arr = cuda.to_device(h_arr)
 
         def base_offset(orig, sliced):
-            return sliced['data'][0] - orig['data'][0]
+            return sliced["data"][0] - orig["data"][0]
 
         h_ai = h_arr.__array_interface__
         c_ai = c_arr.__cuda_array_interface__
@@ -202,8 +199,8 @@ class TestCudaArrayInterface(ContextResettingTestCase):
             base_offset(c_ai, c_ai_sliced),
         )
         # Check shape and strides are correct
-        self.assertEqual(h_ai_sliced['shape'], c_ai_sliced['shape'])
-        self.assertEqual(h_ai_sliced['strides'], c_ai_sliced['strides'])
+        self.assertEqual(h_ai_sliced["shape"], c_ai_sliced["shape"])
+        self.assertEqual(h_ai_sliced["strides"], c_ai_sliced["strides"])
 
     def test_negative_strided_copy_to_host(self):
         # issue #3705
@@ -212,28 +209,28 @@ class TestCudaArrayInterface(ContextResettingTestCase):
         sliced = c_arr[::-1]
         with self.assertRaises(NotImplementedError) as raises:
             sliced.copy_to_host()
-        expected_msg = 'D->H copy not implemented for negative strides'
+        expected_msg = "D->H copy not implemented for negative strides"
         self.assertIn(expected_msg, str(raises.exception))
 
     def test_masked_array(self):
         h_arr = np.random.random(10)
-        h_mask = np.random.randint(2, size=10, dtype='bool')
+        h_mask = np.random.randint(2, size=10, dtype="bool")
         c_arr = cuda.to_device(h_arr)
         c_mask = cuda.to_device(h_mask)
 
         # Manually create a masked CUDA Array Interface dictionary
         masked_cuda_array_interface = c_arr.__cuda_array_interface__.copy()
-        masked_cuda_array_interface['mask'] = c_mask
+        masked_cuda_array_interface["mask"] = c_mask
 
         with self.assertRaises(NotImplementedError) as raises:
             cuda.from_cuda_array_interface(masked_cuda_array_interface)
-        expected_msg = 'Masked arrays are not supported'
+        expected_msg = "Masked arrays are not supported"
         self.assertIn(expected_msg, str(raises.exception))
 
     def test_zero_size_array(self):
         # for #4175
         c_arr = cuda.device_array(0)
-        self.assertEqual(c_arr.__cuda_array_interface__['data'][0], 0)
+        self.assertEqual(c_arr.__cuda_array_interface__["data"][0], 0)
 
         @cuda.jit
         def add_one(arr):
@@ -249,49 +246,49 @@ class TestCudaArrayInterface(ContextResettingTestCase):
         # for #4175
         # First, test C-contiguous array
         c_arr = cuda.device_array((2, 3, 4))
-        self.assertEqual(c_arr.__cuda_array_interface__['strides'], None)
+        self.assertEqual(c_arr.__cuda_array_interface__["strides"], None)
 
         # Second, test non C-contiguous array
         c_arr = c_arr[:, 1, :]
-        self.assertNotEqual(c_arr.__cuda_array_interface__['strides'], None)
+        self.assertNotEqual(c_arr.__cuda_array_interface__["strides"], None)
 
     def test_consuming_strides(self):
         hostarray = np.arange(10).reshape(2, 5)
         devarray = cuda.to_device(hostarray)
         face = devarray.__cuda_array_interface__
-        self.assertIsNone(face['strides'])
+        self.assertIsNone(face["strides"])
         got = cuda.from_cuda_array_interface(face).copy_to_host()
         np.testing.assert_array_equal(got, hostarray)
-        self.assertTrue(got.flags['C_CONTIGUOUS'])
+        self.assertTrue(got.flags["C_CONTIGUOUS"])
         # Try non-NULL strides
-        face['strides'] = hostarray.strides
-        self.assertIsNotNone(face['strides'])
+        face["strides"] = hostarray.strides
+        self.assertIsNotNone(face["strides"])
         got = cuda.from_cuda_array_interface(face).copy_to_host()
         np.testing.assert_array_equal(got, hostarray)
-        self.assertTrue(got.flags['C_CONTIGUOUS'])
+        self.assertTrue(got.flags["C_CONTIGUOUS"])
 
     def test_produce_no_stream(self):
         c_arr = cuda.device_array(10)
-        self.assertIsNone(c_arr.__cuda_array_interface__['stream'])
+        self.assertIsNone(c_arr.__cuda_array_interface__["stream"])
 
         mapped_arr = cuda.mapped_array(10)
-        self.assertIsNone(mapped_arr.__cuda_array_interface__['stream'])
+        self.assertIsNone(mapped_arr.__cuda_array_interface__["stream"])
 
     @linux_only
     def test_produce_managed_no_stream(self):
         managed_arr = cuda.managed_array(10)
-        self.assertIsNone(managed_arr.__cuda_array_interface__['stream'])
+        self.assertIsNone(managed_arr.__cuda_array_interface__["stream"])
 
     def test_produce_stream(self):
         s = cuda.stream()
         c_arr = cuda.device_array(10, stream=s)
-        cai_stream = c_arr.__cuda_array_interface__['stream']
+        cai_stream = c_arr.__cuda_array_interface__["stream"]
         stream_value = self.get_stream_value(s)
         self.assertEqual(stream_value, cai_stream)
 
         s = cuda.stream()
         mapped_arr = cuda.mapped_array(10, stream=s)
-        cai_stream = mapped_arr.__cuda_array_interface__['stream']
+        cai_stream = mapped_arr.__cuda_array_interface__["stream"]
         stream_value = self.get_stream_value(s)
         self.assertEqual(stream_value, cai_stream)
 
@@ -299,7 +296,7 @@ class TestCudaArrayInterface(ContextResettingTestCase):
     def test_produce_managed_stream(self):
         s = cuda.stream()
         managed_arr = cuda.managed_array(10, stream=s)
-        cai_stream = managed_arr.__cuda_array_interface__['stream']
+        cai_stream = managed_arr.__cuda_array_interface__["stream"]
         stream_value = self.get_stream_value(s)
         self.assertEqual(stream_value, cai_stream)
 
@@ -327,8 +324,9 @@ class TestCudaArrayInterface(ContextResettingTestCase):
         # Create a foreign array with no stream
         f_arr = ForeignArray(cuda.device_array(10))
 
-        with patch.object(cuda.cudadrv.driver.Stream, 'synchronize',
-                          return_value=None) as mock_sync:
+        with patch.object(
+            cuda.cudadrv.driver.Stream, "synchronize", return_value=None
+        ) as mock_sync:
             cuda.as_cuda_array(f_arr)
 
         # Ensure the synchronize method of a stream was not called
@@ -339,8 +337,9 @@ class TestCudaArrayInterface(ContextResettingTestCase):
         s = cuda.stream()
         f_arr = ForeignArray(cuda.device_array(10, stream=s))
 
-        with patch.object(cuda.cudadrv.driver.Stream, 'synchronize',
-                          return_value=None) as mock_sync:
+        with patch.object(
+            cuda.cudadrv.driver.Stream, "synchronize", return_value=None
+        ) as mock_sync:
             cuda.as_cuda_array(f_arr)
 
         # Ensure the synchronize method of a stream was called
@@ -354,9 +353,10 @@ class TestCudaArrayInterface(ContextResettingTestCase):
         # Set sync to false before testing. The test suite should generally be
         # run with sync enabled, but stash the old value just in case it is
         # not.
-        with override_config('CUDA_ARRAY_INTERFACE_SYNC', False):
-            with patch.object(cuda.cudadrv.driver.Stream, 'synchronize',
-                              return_value=None) as mock_sync:
+        with override_config("CUDA_ARRAY_INTERFACE_SYNC", False):
+            with patch.object(
+                cuda.cudadrv.driver.Stream, "synchronize", return_value=None
+            ) as mock_sync:
                 cuda.as_cuda_array(f_arr)
 
             # Ensure the synchronize method of a stream was not called
@@ -370,8 +370,9 @@ class TestCudaArrayInterface(ContextResettingTestCase):
         def f(x):
             pass
 
-        with patch.object(cuda.cudadrv.driver.Stream, 'synchronize',
-                          return_value=None) as mock_sync:
+        with patch.object(
+            cuda.cudadrv.driver.Stream, "synchronize", return_value=None
+        ) as mock_sync:
             f[1, 1](f_arr)
 
         # Ensure the synchronize method of a stream was not called
@@ -386,8 +387,9 @@ class TestCudaArrayInterface(ContextResettingTestCase):
         def f(x):
             pass
 
-        with patch.object(cuda.cudadrv.driver.Stream, 'synchronize',
-                          return_value=None) as mock_sync:
+        with patch.object(
+            cuda.cudadrv.driver.Stream, "synchronize", return_value=None
+        ) as mock_sync:
             f[1, 1](f_arr)
 
         # Ensure the synchronize method of a stream was called
@@ -404,8 +406,9 @@ class TestCudaArrayInterface(ContextResettingTestCase):
         def f(x, y):
             pass
 
-        with patch.object(cuda.cudadrv.driver.Stream, 'synchronize',
-                          return_value=None) as mock_sync:
+        with patch.object(
+            cuda.cudadrv.driver.Stream, "synchronize", return_value=None
+        ) as mock_sync:
             f[1, 1](f_arr1, f_arr2)
 
         # Ensure that synchronize was called twice
@@ -418,13 +421,15 @@ class TestCudaArrayInterface(ContextResettingTestCase):
         f_arr1 = ForeignArray(cuda.device_array(10, stream=s1))
         f_arr2 = ForeignArray(cuda.device_array(10, stream=s2))
 
-        with override_config('CUDA_ARRAY_INTERFACE_SYNC', False):
+        with override_config("CUDA_ARRAY_INTERFACE_SYNC", False):
+
             @cuda.jit
             def f(x, y):
                 pass
 
-            with patch.object(cuda.cudadrv.driver.Stream, 'synchronize',
-                              return_value=None) as mock_sync:
+            with patch.object(
+                cuda.cudadrv.driver.Stream, "synchronize", return_value=None
+            ) as mock_sync:
                 f[1, 1](f_arr1, f_arr2)
 
             # Ensure that synchronize was not called

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

@@ -80,11 +80,12 @@ class TestCudaJitNoTypes(CUDATestCase):
     def test_jit_debug_simulator(self):
         # Ensure that the jit decorator accepts the debug kwarg when the
         # simulator is in use - see Issue #6615.
-        with override_config('ENABLE_CUDASIM', 1):
+        with override_config("ENABLE_CUDASIM", 1):
+
             @cuda.jit(debug=True, opt=False)
             def f(x):
                 pass
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -13,9 +13,9 @@ class TestCudaDateTime(CUDATestCase):
             for i in range(cuda.grid(1), delta.size, cuda.gridsize(1)):
                 delta[i] = end[i] - start[i]
 
-        arr1 = np.arange('2005-02', '2006-02', dtype='datetime64[D]')
+        arr1 = np.arange("2005-02", "2006-02", dtype="datetime64[D]")
         arr2 = arr1 + np.random.randint(0, 10000, arr1.size)
-        delta = np.zeros_like(arr1, dtype='timedelta64[D]')
+        delta = np.zeros_like(arr1, dtype="timedelta64[D]")
 
         foo[1, 32](arr1, arr2, delta)
 
@@ -27,11 +27,12 @@ class TestCudaDateTime(CUDATestCase):
             for i in range(cuda.grid(1), matches.size, cuda.gridsize(1)):
                 matches[i] = dates[i] == target
                 outdelta[i] = dates[i] - delta
-        arr1 = np.arange('2005-02', '2006-02', dtype='datetime64[D]')
-        target = arr1[5]           # datetime
+
+        arr1 = np.arange("2005-02", "2006-02", dtype="datetime64[D]")
+        target = arr1[5]  # datetime
         delta = arr1[6] - arr1[5]  # timedelta
         matches = np.zeros_like(arr1, dtype=np.bool_)
-        outdelta = np.zeros_like(arr1, dtype='datetime64[D]')
+        outdelta = np.zeros_like(arr1, dtype="datetime64[D]")
 
         foo[1, 32](arr1, target, delta, matches, outdelta)
         where = matches.nonzero()
@@ -39,56 +40,59 @@ class TestCudaDateTime(CUDATestCase):
         self.assertEqual(list(where), [5])
         self.assertPreciseEqual(outdelta, arr1 - delta)
 
-    @skip_on_cudasim('ufunc API unsupported in the simulator')
+    @skip_on_cudasim("ufunc API unsupported in the simulator")
     def test_ufunc(self):
-        datetime_t = from_dtype(np.dtype('datetime64[D]'))
+        datetime_t = from_dtype(np.dtype("datetime64[D]"))
 
-        @vectorize([(datetime_t, datetime_t)], target='cuda')
+        @vectorize([(datetime_t, datetime_t)], target="cuda")
         def timediff(start, end):
             return end - start
 
-        arr1 = np.arange('2005-02', '2006-02', dtype='datetime64[D]')
+        arr1 = np.arange("2005-02", "2006-02", dtype="datetime64[D]")
         arr2 = arr1 + np.random.randint(0, 10000, arr1.size)
 
         delta = timediff(arr1, arr2)
 
         self.assertPreciseEqual(delta, arr2 - arr1)
 
-    @skip_on_cudasim('ufunc API unsupported in the simulator')
+    @skip_on_cudasim("ufunc API unsupported in the simulator")
     def test_gufunc(self):
-        datetime_t = from_dtype(np.dtype('datetime64[D]'))
-        timedelta_t = from_dtype(np.dtype('timedelta64[D]'))
-
-        @guvectorize([(datetime_t, datetime_t, timedelta_t[:])], '(),()->()',
-                     target='cuda')
+        datetime_t = from_dtype(np.dtype("datetime64[D]"))
+        timedelta_t = from_dtype(np.dtype("timedelta64[D]"))
+
+        @guvectorize(
+            [(datetime_t, datetime_t, timedelta_t[:])],
+            "(),()->()",
+            target="cuda",
+        )
         def timediff(start, end, out):
             out[0] = end - start
 
-        arr1 = np.arange('2005-02', '2006-02', dtype='datetime64[D]')
+        arr1 = np.arange("2005-02", "2006-02", dtype="datetime64[D]")
         arr2 = arr1 + np.random.randint(0, 10000, arr1.size)
 
         delta = timediff(arr1, arr2)
 
         self.assertPreciseEqual(delta, arr2 - arr1)
 
-    @skip_on_cudasim('no .copy_to_host() in the simulator')
+    @skip_on_cudasim("no .copy_to_host() in the simulator")
     def test_datetime_view_as_int64(self):
-        arr = np.arange('2005-02', '2006-02', dtype='datetime64[D]')
+        arr = np.arange("2005-02", "2006-02", dtype="datetime64[D]")
         darr = cuda.to_device(arr)
         viewed = darr.view(np.int64)
         self.assertPreciseEqual(arr.view(np.int64), viewed.copy_to_host())
         self.assertEqual(viewed.gpu_data, darr.gpu_data)
 
-    @skip_on_cudasim('no .copy_to_host() in the simulator')
+    @skip_on_cudasim("no .copy_to_host() in the simulator")
     def test_timedelta_view_as_int64(self):
-        arr = np.arange('2005-02', '2006-02', dtype='datetime64[D]')
+        arr = np.arange("2005-02", "2006-02", dtype="datetime64[D]")
         arr = arr - (arr - 1)
-        self.assertEqual(arr.dtype, np.dtype('timedelta64[D]'))
+        self.assertEqual(arr.dtype, np.dtype("timedelta64[D]"))
         darr = cuda.to_device(arr)
         viewed = darr.view(np.int64)
         self.assertPreciseEqual(arr.view(np.int64), viewed.copy_to_host())
         self.assertEqual(viewed.gpu_data, darr.gpu_data)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -2,8 +2,11 @@ import numpy as np
 
 from numba.core.utils import PYVERSION
 from numba.cuda.testing import skip_on_cudasim, CUDATestCase
-from numba.tests.support import (override_config, captured_stderr,
-                                 captured_stdout)
+from numba.tests.support import (
+    override_config,
+    captured_stderr,
+    captured_stdout,
+)
 from numba import cuda, float64
 import unittest
 
@@ -13,9 +16,8 @@ def simple_cuda(A, B):
     B[i] = A[i] + 1.5
 
 
-@skip_on_cudasim('Simulator does not produce debug dumps')
+@skip_on_cudasim("Simulator does not produce debug dumps")
 class TestDebugOutput(CUDATestCase):
-
     def compile_simple_cuda(self):
         with captured_stderr() as err:
             with captured_stdout() as out:
@@ -34,14 +36,14 @@ class TestDebugOutput(CUDATestCase):
         self.assertRaises(AssertionError, *args, **kwargs)
 
     def check_debug_output(self, out, enabled_dumps):
-        all_dumps = dict.fromkeys(['bytecode', 'cfg', 'ir', 'llvm',
-                                   'assembly'],
-                                  False)
+        all_dumps = dict.fromkeys(
+            ["bytecode", "cfg", "ir", "llvm", "assembly"], False
+        )
         for name in enabled_dumps:
             assert name in all_dumps
             all_dumps[name] = True
         for name, enabled in sorted(all_dumps.items()):
-            check_meth = getattr(self, '_check_dump_%s' % name)
+            check_meth = getattr(self, "_check_dump_%s" % name)
             if enabled:
                 check_meth(out)
             else:
@@ -50,50 +52,50 @@ class TestDebugOutput(CUDATestCase):
     def _check_dump_bytecode(self, out):
         if PYVERSION > (3, 10):
             # binop with arg=0 is binary add, see CPython dis.py and opcode.py
-            self.assertIn('BINARY_OP(arg=0', out)
+            self.assertIn("BINARY_OP(arg=0", out)
         else:
-            self.assertIn('BINARY_ADD', out)
+            self.assertIn("BINARY_ADD", out)
 
     def _check_dump_cfg(self, out):
-        self.assertIn('CFG dominators', out)
+        self.assertIn("CFG dominators", out)
 
     def _check_dump_ir(self, out):
-        self.assertIn('--IR DUMP: simple_cuda--', out)
-        self.assertIn('const(float, 1.5)', out)
+        self.assertIn("--IR DUMP: simple_cuda--", out)
+        self.assertIn("const(float, 1.5)", out)
 
     def _check_dump_llvm(self, out):
-        self.assertIn('--LLVM DUMP', out)
+        self.assertIn("--LLVM DUMP", out)
         self.assertIn('!"kernel", i32 1', out)
 
     def _check_dump_assembly(self, out):
-        self.assertIn('--ASSEMBLY simple_cuda', out)
-        self.assertIn('Generated by NVIDIA NVVM Compiler', out)
+        self.assertIn("--ASSEMBLY simple_cuda", out)
+        self.assertIn("Generated by NVIDIA NVVM Compiler", out)
 
     def test_dump_bytecode(self):
-        with override_config('DUMP_BYTECODE', True):
+        with override_config("DUMP_BYTECODE", True):
             out = self.compile_simple_cuda()
-        self.check_debug_output(out, ['bytecode'])
+        self.check_debug_output(out, ["bytecode"])
 
     def test_dump_ir(self):
-        with override_config('DUMP_IR', True):
+        with override_config("DUMP_IR", True):
             out = self.compile_simple_cuda()
-        self.check_debug_output(out, ['ir'])
+        self.check_debug_output(out, ["ir"])
 
     def test_dump_cfg(self):
-        with override_config('DUMP_CFG', True):
+        with override_config("DUMP_CFG", True):
             out = self.compile_simple_cuda()
-        self.check_debug_output(out, ['cfg'])
+        self.check_debug_output(out, ["cfg"])
 
     def test_dump_llvm(self):
-        with override_config('DUMP_LLVM', True):
+        with override_config("DUMP_LLVM", True):
             out = self.compile_simple_cuda()
-        self.check_debug_output(out, ['llvm'])
+        self.check_debug_output(out, ["llvm"])
 
     def test_dump_assembly(self):
-        with override_config('DUMP_ASSEMBLY', True):
+        with override_config("DUMP_ASSEMBLY", True):
             out = self.compile_simple_cuda()
-        self.check_debug_output(out, ['assembly'])
+        self.check_debug_output(out, ["assembly"])
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()