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

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

@@ -1,4 +1,4 @@
-from numba.tests.support import (override_config, captured_stdout)
+from numba.tests.support import override_config, captured_stdout
 from numba.cuda.testing import skip_on_cudasim
 from numba import cuda
 from numba.core import types
@@ -8,7 +8,7 @@ import re
 import unittest
 
 
-@skip_on_cudasim('Simulator does not produce debug dumps')
+@skip_on_cudasim("Simulator does not produce debug dumps")
 class TestCudaDebugInfo(CUDATestCase):
     """
     These tests only checks the compiled PTX for debuginfo section
@@ -49,7 +49,7 @@ class TestCudaDebugInfo(CUDATestCase):
         self._check(foo, sig=(types.int32[:],), expect=True)
 
     def test_environment_override(self):
-        with override_config('CUDA_DEBUGINFO_DEFAULT', 1):
+        with override_config("CUDA_DEBUGINFO_DEFAULT", 1):
             # Using default value
             @cuda.jit(opt=False)
             def foo(x):
@@ -86,7 +86,7 @@ class TestCudaDebugInfo(CUDATestCase):
 
         llvm_ir = f.inspect_llvm(sig)
         # A varible name starting with "bool" in the debug metadata
-        pat = r'!DILocalVariable\(.*name:\s+\"bool'
+        pat = r"!DILocalVariable\(.*name:\s+\"bool"
         match = re.compile(pat).search(llvm_ir)
         self.assertIsNone(match, msg=llvm_ir)
 
@@ -106,7 +106,7 @@ class TestCudaDebugInfo(CUDATestCase):
         mdnode_id = match.group(1)
 
         # verify the DIBasicType has correct encoding attribute DW_ATE_boolean
-        pat = rf'!{mdnode_id}\s+=\s+!DIBasicType\(.*DW_ATE_boolean'
+        pat = rf"!{mdnode_id}\s+=\s+!DIBasicType\(.*DW_ATE_boolean"
         match = re.compile(pat).search(llvm_ir)
         self.assertIsNotNone(match, msg=llvm_ir)
 
@@ -133,14 +133,17 @@ class TestCudaDebugInfo(CUDATestCase):
 
         llvm_ir = f.inspect_llvm(sig)
 
-        defines = [line for line in llvm_ir.splitlines()
-                   if 'define void @"_ZN6cudapy' in line]
+        defines = [
+            line
+            for line in llvm_ir.splitlines()
+            if 'define void @"_ZN6cudapy' in line
+        ]
 
         # Make sure we only found one definition
         self.assertEqual(len(defines), 1)
 
         wrapper_define = defines[0]
-        self.assertIn('!dbg', wrapper_define)
+        self.assertIn("!dbg", wrapper_define)
 
     def test_debug_function_calls_internal_impl(self):
         # Calling a function in a module generated from an implementation
@@ -198,16 +201,16 @@ class TestCudaDebugInfo(CUDATestCase):
         debug_opts = itertools.product(*[(True, False)] * 3)
 
         for kernel_debug, f1_debug, f2_debug in debug_opts:
-            with self.subTest(kernel_debug=kernel_debug,
-                              f1_debug=f1_debug,
-                              f2_debug=f2_debug):
-                self._test_chained_device_function(kernel_debug,
-                                                   f1_debug,
-                                                   f2_debug)
-
-    def _test_chained_device_function_two_calls(self, kernel_debug, f1_debug,
-                                                f2_debug):
-
+            with self.subTest(
+                kernel_debug=kernel_debug, f1_debug=f1_debug, f2_debug=f2_debug
+            ):
+                self._test_chained_device_function(
+                    kernel_debug, f1_debug, f2_debug
+                )
+
+    def _test_chained_device_function_two_calls(
+        self, kernel_debug, f1_debug, f2_debug
+    ):
         @cuda.jit(device=True, debug=f2_debug, opt=False)
         def f2(x):
             return x + 1
@@ -232,12 +235,12 @@ class TestCudaDebugInfo(CUDATestCase):
         debug_opts = itertools.product(*[(True, False)] * 3)
 
         for kernel_debug, f1_debug, f2_debug in debug_opts:
-            with self.subTest(kernel_debug=kernel_debug,
-                              f1_debug=f1_debug,
-                              f2_debug=f2_debug):
-                self._test_chained_device_function_two_calls(kernel_debug,
-                                                             f1_debug,
-                                                             f2_debug)
+            with self.subTest(
+                kernel_debug=kernel_debug, f1_debug=f1_debug, f2_debug=f2_debug
+            ):
+                self._test_chained_device_function_two_calls(
+                    kernel_debug, f1_debug, f2_debug
+                )
 
     def test_chained_device_three_functions(self):
         # Like test_chained_device_function, but with enough functions (three)
@@ -278,13 +281,13 @@ class TestCudaDebugInfo(CUDATestCase):
         llvm_ir = f.inspect_llvm(sig)
 
         # extract the metadata node id from `types` field of DISubroutineType
-        pat = r'!DISubroutineType\(types:\s+!(\d+)\)'
+        pat = r"!DISubroutineType\(types:\s+!(\d+)\)"
         match = re.compile(pat).search(llvm_ir)
         self.assertIsNotNone(match, msg=llvm_ir)
         mdnode_id = match.group(1)
 
         # extract the metadata node ids from the flexible node of types
-        pat = rf'!{mdnode_id}\s+=\s+!{{\s+!(\d+),\s+!(\d+)\s+}}'
+        pat = rf"!{mdnode_id}\s+=\s+!{{\s+!(\d+),\s+!(\d+)\s+}}"
         match = re.compile(pat).search(llvm_ir)
         self.assertIsNotNone(match, msg=llvm_ir)
         mdnode_id1 = match.group(1)
@@ -303,10 +306,10 @@ class TestCudaDebugInfo(CUDATestCase):
 
     def test_kernel_args_types_dump(self):
         # see issue#135
-        with override_config('DUMP_LLVM', 1):
+        with override_config("DUMP_LLVM", 1):
             with captured_stdout():
                 self._test_kernel_args_types()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -3,8 +3,13 @@ import cffi
 
 import numpy as np
 
-from numba.cuda.testing import (skip_if_curand_kernel_missing, skip_on_cudasim,
-                                test_data_dir, unittest, CUDATestCase)
+from numba.cuda.testing import (
+    skip_if_curand_kernel_missing,
+    skip_on_cudasim,
+    test_data_dir,
+    unittest,
+    CUDATestCase,
+)
 from numba import cuda, jit, float32, int32, types
 from numba.core.errors import TypingError
 from numba.tests.support import skip_unless_cffi
@@ -12,9 +17,7 @@ from types import ModuleType
 
 
 class TestDeviceFunc(CUDATestCase):
-
     def test_use_add2f(self):
-
         @cuda.jit("float32(float32, float32)", device=True)
         def add2f(a, b):
             return a + b
@@ -33,7 +36,6 @@ class TestDeviceFunc(CUDATestCase):
         self.assertTrue(np.all(ary == exp), (ary, exp))
 
     def test_indirect_add2f(self):
-
         @cuda.jit("float32(float32, float32)", device=True)
         def add2f(a, b):
             return a + b
@@ -74,12 +76,12 @@ class TestDeviceFunc(CUDATestCase):
 
         self._check_cpu_dispatcher(add)
 
-    @skip_on_cudasim('not supported in cudasim')
+    @skip_on_cudasim("not supported in cudasim")
     def test_cpu_dispatcher_invalid(self):
         # Test invalid usage
         # Explicit signature disables compilation, which also disable
         # compiling on CUDA.
-        @jit('(i4, i4)')
+        @jit("(i4, i4)")
         def add(a, b):
             return a + b
 
@@ -95,7 +97,7 @@ class TestDeviceFunc(CUDATestCase):
         def add(a, b):
             return a + b
 
-        mymod = ModuleType(name='mymod')
+        mymod = ModuleType(name="mymod")
         mymod.add = add
         del add
 
@@ -109,7 +111,7 @@ class TestDeviceFunc(CUDATestCase):
         add_kernel[1, ary.size](ary)
         np.testing.assert_equal(expect, ary)
 
-    @skip_on_cudasim('not supported in cudasim')
+    @skip_on_cudasim("not supported in cudasim")
     def test_inspect_llvm(self):
         @cuda.jit(device=True)
         def foo(x, y):
@@ -120,13 +122,13 @@ class TestDeviceFunc(CUDATestCase):
 
         fname = cres.fndesc.mangled_name
         # Verify that the function name has "foo" in it as in the python name
-        self.assertIn('foo', fname)
+        self.assertIn("foo", fname)
 
         llvm = foo.inspect_llvm(args)
         # Check that the compiled function name is in the LLVM.
         self.assertIn(fname, llvm)
 
-    @skip_on_cudasim('not supported in cudasim')
+    @skip_on_cudasim("not supported in cudasim")
     def test_inspect_asm(self):
         @cuda.jit(device=True)
         def foo(x, y):
@@ -137,13 +139,13 @@ class TestDeviceFunc(CUDATestCase):
 
         fname = cres.fndesc.mangled_name
         # Verify that the function name has "foo" in it as in the python name
-        self.assertIn('foo', fname)
+        self.assertIn("foo", fname)
 
         ptx = foo.inspect_asm(args)
         # Check that the compiled function name is in the PTX
         self.assertIn(fname, ptx)
 
-    @skip_on_cudasim('not supported in cudasim')
+    @skip_on_cudasim("not supported in cudasim")
     def test_inspect_sass_disallowed(self):
         @cuda.jit(device=True)
         def foo(x, y):
@@ -152,10 +154,11 @@ class TestDeviceFunc(CUDATestCase):
         with self.assertRaises(RuntimeError) as raises:
             foo.inspect_sass((int32, int32))
 
-        self.assertIn('Cannot inspect SASS of a device function',
-                      str(raises.exception))
+        self.assertIn(
+            "Cannot inspect SASS of a device function", str(raises.exception)
+        )
 
-    @skip_on_cudasim('cudasim will allow calling any function')
+    @skip_on_cudasim("cudasim will allow calling any function")
     def test_device_func_as_kernel_disallowed(self):
         @cuda.jit(device=True)
         def f():
@@ -164,10 +167,12 @@ class TestDeviceFunc(CUDATestCase):
         with self.assertRaises(RuntimeError) as raises:
             f[1, 1]()
 
-        self.assertIn('Cannot compile a device function as a kernel',
-                      str(raises.exception))
+        self.assertIn(
+            "Cannot compile a device function as a kernel",
+            str(raises.exception),
+        )
 
-    @skip_on_cudasim('cudasim ignores casting by jit decorator signature')
+    @skip_on_cudasim("cudasim ignores casting by jit decorator signature")
     def test_device_casting(self):
         # Ensure that casts to the correct type are forced when calling a
         # device function with a signature. This test ensures that:
@@ -176,20 +181,23 @@ class TestDeviceFunc(CUDATestCase):
         #   shouldn't
         # - We insert a cast when calling rgba, as opposed to failing to type.
 
-        @cuda.jit('int32(int32, int32, int32, int32)', device=True)
+        @cuda.jit("int32(int32, int32, int32, int32)", device=True)
         def rgba(r, g, b, a):
-            return (((r & 0xFF) << 16) |
-                    ((g & 0xFF) << 8) |
-                    ((b & 0xFF) << 0) |
-                    ((a & 0xFF) << 24))
+            return (
+                ((r & 0xFF) << 16)
+                | ((g & 0xFF) << 8)
+                | ((b & 0xFF) << 0)
+                | ((a & 0xFF) << 24)
+            )
 
         @cuda.jit
         def rgba_caller(x, channels):
             x[0] = rgba(channels[0], channels[1], channels[2], channels[3])
 
         x = cuda.device_array(1, dtype=np.int32)
-        channels = cuda.to_device(np.asarray([1.0, 2.0, 3.0, 4.0],
-                                             dtype=np.float32))
+        channels = cuda.to_device(
+            np.asarray([1.0, 2.0, 3.0, 4.0], dtype=np.float32)
+        )
 
         rgba_caller[1, 1](x, channels)
 
@@ -259,32 +267,31 @@ int random_number(unsigned int *out, unsigned long long seed)
 }""")
 
 
-@skip_on_cudasim('External functions unsupported in the simulator')
+@skip_on_cudasim("External functions unsupported in the simulator")
 class TestDeclareDevice(CUDATestCase):
-
     def check_api(self, decl):
-        self.assertEqual(decl.name, 'f1')
+        self.assertEqual(decl.name, "f1")
         self.assertEqual(decl.sig.args, (float32[:],))
         self.assertEqual(decl.sig.return_type, int32)
 
     def test_declare_device_signature(self):
-        f1 = cuda.declare_device('f1', int32(float32[:]))
+        f1 = cuda.declare_device("f1", int32(float32[:]))
         self.check_api(f1)
 
     def test_declare_device_string(self):
-        f1 = cuda.declare_device('f1', 'int32(float32[:])')
+        f1 = cuda.declare_device("f1", "int32(float32[:])")
         self.check_api(f1)
 
     def test_bad_declare_device_tuple(self):
-        with self.assertRaisesRegex(TypeError, 'Return type'):
-            cuda.declare_device('f1', (float32[:],))
+        with self.assertRaisesRegex(TypeError, "Return type"):
+            cuda.declare_device("f1", (float32[:],))
 
     def test_bad_declare_device_string(self):
-        with self.assertRaisesRegex(TypeError, 'Return type'):
-            cuda.declare_device('f1', '(float32[:],)')
+        with self.assertRaisesRegex(TypeError, "Return type"):
+            cuda.declare_device("f1", "(float32[:],)")
 
     def test_link_cu_source(self):
-        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+        times2 = cuda.declare_device("times2", "int32(int32)", link=times2_cu)
 
         @cuda.jit
         def kernel(r, x):
@@ -301,7 +308,7 @@ class TestDeclareDevice(CUDATestCase):
 
     def _test_link_multiple_sources(self, link_type):
         link = link_type([times2_cu, times4_cu])
-        times4 = cuda.declare_device('times4', 'int32(int32)', link=link)
+        times4 = cuda.declare_device("times4", "int32(int32)", link=link)
 
         @cuda.jit
         def kernel(r, x):
@@ -360,7 +367,7 @@ class TestDeclareDevice(CUDATestCase):
         np.testing.assert_equal(x[0], 323845807)
 
     def test_declared_in_called_function(self):
-        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+        times2 = cuda.declare_device("times2", "int32(int32)", link=times2_cu)
 
         @cuda.jit
         def device_func(x):
@@ -380,7 +387,7 @@ class TestDeclareDevice(CUDATestCase):
         np.testing.assert_equal(r, x * 2)
 
     def test_declared_in_called_function_twice(self):
-        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+        times2 = cuda.declare_device("times2", "int32(int32)", link=times2_cu)
 
         @cuda.jit
         def device_func_1(x):
@@ -404,7 +411,7 @@ class TestDeclareDevice(CUDATestCase):
         np.testing.assert_equal(r, x * 2)
 
     def test_declared_in_called_function_two_calls(self):
-        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+        times2 = cuda.declare_device("times2", "int32(int32)", link=times2_cu)
 
         @cuda.jit
         def device_func(x):
@@ -424,7 +431,7 @@ class TestDeclareDevice(CUDATestCase):
         np.testing.assert_equal(r, x * 6)
 
     def test_call_declared_function_twice(self):
-        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+        times2 = cuda.declare_device("times2", "int32(int32)", link=times2_cu)
 
         @cuda.jit
         def kernel(r, x):
@@ -440,7 +447,7 @@ class TestDeclareDevice(CUDATestCase):
         np.testing.assert_equal(r, x * 6)
 
     def test_declared_in_called_function_and_parent(self):
-        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+        times2 = cuda.declare_device("times2", "int32(int32)", link=times2_cu)
 
         @cuda.jit
         def device_func(x):
@@ -460,8 +467,8 @@ class TestDeclareDevice(CUDATestCase):
         np.testing.assert_equal(r, x * 4)
 
     def test_call_two_different_declared_functions(self):
-        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
-        times3 = cuda.declare_device('times3', 'int32(int32)', link=times3_cu)
+        times2 = cuda.declare_device("times2", "int32(int32)", link=times2_cu)
+        times3 = cuda.declare_device("times3", "int32(int32)", link=times3_cu)
 
         @cuda.jit
         def kernel(r, x):
@@ -477,5 +484,5 @@ class TestDeclareDevice(CUDATestCase):
         np.testing.assert_equal(r, x * 5)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -15,19 +15,18 @@ def add_kernel(r, x, y):
     r[0] = x + y
 
 
-@skip_on_cudasim('Specialization not implemented in the simulator')
+@skip_on_cudasim("Specialization not implemented in the simulator")
 class TestDispatcherSpecialization(CUDATestCase):
     def _test_no_double_specialize(self, dispatcher, ty):
-
         with self.assertRaises(RuntimeError) as e:
             dispatcher.specialize(ty)
 
-        self.assertIn('Dispatcher already specialized', str(e.exception))
+        self.assertIn("Dispatcher already specialized", str(e.exception))
 
     def test_no_double_specialize_sig_same_types(self):
         # Attempting to specialize a kernel jitted with a signature is illegal,
         # even for the same types the kernel is already specialized for.
-        @cuda.jit('void(float32[::1])')
+        @cuda.jit("void(float32[::1])")
         def f(x):
             pass
 
@@ -45,7 +44,7 @@ class TestDispatcherSpecialization(CUDATestCase):
 
     def test_no_double_specialize_sig_diff_types(self):
         # Attempting to specialize a kernel jitted with a signature is illegal.
-        @cuda.jit('void(int32[::1])')
+        @cuda.jit("void(int32[::1])")
         def f(x):
             pass
 
@@ -132,13 +131,13 @@ class TestDispatcher(CUDATestCase):
         self.assertEqual(r[0], add(12300000000, 456))
 
         # Now force compilation of only a single specialization
-        c_add = cuda.jit('(i4[::1], i4, i4)')(add_kernel)
+        c_add = cuda.jit("(i4[::1], i4, i4)")(add_kernel)
         r = np.zeros(1, dtype=np.int32)
 
         c_add[1, 1](r, 123, 456)
         self.assertPreciseEqual(r[0], add(123, 456))
 
-    @skip_on_cudasim('Simulator ignores signature')
+    @skip_on_cudasim("Simulator ignores signature")
     @unittest.expectedFailure
     def test_coerce_input_types_unsafe(self):
         # Implicit (unsafe) conversion of float to int, originally from
@@ -149,25 +148,24 @@ class TestDispatcher(CUDATestCase):
         #
         # This test is marked as xfail until future changes enable this
         # behavior.
-        c_add = cuda.jit('(i4[::1], i4, i4)')(add_kernel)
+        c_add = cuda.jit("(i4[::1], i4, i4)")(add_kernel)
         r = np.zeros(1, dtype=np.int32)
 
         c_add[1, 1](r, 12.3, 45.6)
         self.assertPreciseEqual(r[0], add(12, 45))
 
-    @skip_on_cudasim('Simulator ignores signature')
+    @skip_on_cudasim("Simulator ignores signature")
     def test_coerce_input_types_unsafe_complex(self):
         # Implicit conversion of complex to int disallowed
-        c_add = cuda.jit('(i4[::1], i4, i4)')(add_kernel)
+        c_add = cuda.jit("(i4[::1], i4, i4)")(add_kernel)
         r = np.zeros(1, dtype=np.int32)
 
         with self.assertRaises(TypeError):
             c_add[1, 1](r, 12.3, 45.6j)
 
-    @skip_on_cudasim('Simulator does not track overloads')
+    @skip_on_cudasim("Simulator does not track overloads")
     def test_ambiguous_new_version(self):
-        """Test compiling new version in an ambiguous case
-        """
+        """Test compiling new version in an ambiguous case"""
         c_add = cuda.jit(add_kernel)
 
         r = np.zeros(1, dtype=np.float64)
@@ -190,8 +188,9 @@ class TestDispatcher(CUDATestCase):
         # to (float, int) or (int, float) with equal weight.
         c_add[1, 1](r, 1, 1)
         self.assertAlmostEqual(r[0], INT + INT)
-        self.assertEqual(len(c_add.overloads), 4, "didn't compile a new "
-                                                  "version")
+        self.assertEqual(
+            len(c_add.overloads), 4, "didn't compile a new version"
+        )
 
     @skip_on_cudasim("Simulator doesn't support concurrent kernels")
     def test_lock(self):
@@ -245,8 +244,10 @@ class TestDispatcher(CUDATestCase):
 
     def test_explicit_signatures_strings(self):
         # Check with a list of strings for signatures
-        sigs = ["(int64[::1], int64, int64)",
-                "(float64[::1], float64, float64)"]
+        sigs = [
+            "(int64[::1], int64, int64)",
+            "(float64[::1], float64, float64)",
+        ]
         self._test_explicit_signatures(sigs)
 
     def test_explicit_signatures_tuples(self):
@@ -256,26 +257,31 @@ class TestDispatcher(CUDATestCase):
 
     def test_explicit_signatures_signatures(self):
         # Check with a list of Signature objects for signatures
-        sigs = [void(int64[::1], int64, int64),
-                void(float64[::1], float64, float64)]
+        sigs = [
+            void(int64[::1], int64, int64),
+            void(float64[::1], float64, float64),
+        ]
         self._test_explicit_signatures(sigs)
 
     def test_explicit_signatures_mixed(self):
         # Check when we mix types of signature objects in a list of signatures
 
         # Tuple and string
-        sigs = [(int64[::1], int64, int64),
-                "(float64[::1], float64, float64)"]
+        sigs = [(int64[::1], int64, int64), "(float64[::1], float64, float64)"]
         self._test_explicit_signatures(sigs)
 
         # Tuple and Signature object
-        sigs = [(int64[::1], int64, int64),
-                void(float64[::1], float64, float64)]
+        sigs = [
+            (int64[::1], int64, int64),
+            void(float64[::1], float64, float64),
+        ]
         self._test_explicit_signatures(sigs)
 
         # Signature object and string
-        sigs = [void(int64[::1], int64, int64),
-                "(float64[::1], float64, float64)"]
+        sigs = [
+            void(int64[::1], int64, int64),
+            "(float64[::1], float64, float64)",
+        ]
         self._test_explicit_signatures(sigs)
 
     def test_explicit_signatures_same_type_class(self):
@@ -284,8 +290,10 @@ class TestDispatcher(CUDATestCase):
         # that dispatch is differentiated on the types of x and y only, to
         # closely preserve the intent of the original test from
         # numba.tests.test_dispatcher)
-        sigs = ["(float64[::1], float32, float32)",
-                "(float64[::1], float64, float64)"]
+        sigs = [
+            "(float64[::1], float32, float32)",
+            "(float64[::1], float64, float64)",
+        ]
         f = cuda.jit(sigs)(add_kernel)
 
         r = np.zeros(1, dtype=np.float64)
@@ -296,13 +304,17 @@ class TestDispatcher(CUDATestCase):
         f[1, 1](r, 1, 2**-25)
         self.assertPreciseEqual(r[0], 1.0000000298023224)
 
-    @skip_on_cudasim('No overload resolution in the simulator')
+    @skip_on_cudasim("No overload resolution in the simulator")
     def test_explicit_signatures_ambiguous_resolution(self):
         # Fail to resolve ambiguity between the two best overloads
         # (Also deliberate float64[::1] for the first argument in all cases)
-        f = cuda.jit(["(float64[::1], float32, float64)",
-                      "(float64[::1], float64, float32)",
-                      "(float64[::1], int64, int64)"])(add_kernel)
+        f = cuda.jit(
+            [
+                "(float64[::1], float32, float64)",
+                "(float64[::1], float64, float32)",
+                "(float64[::1], int64, int64)",
+            ]
+        )(add_kernel)
         with self.assertRaises(TypeError) as cm:
             r = np.zeros(1, dtype=np.float64)
             f[1, 1](r, 1.0, 2.0)
@@ -317,12 +329,12 @@ class TestDispatcher(CUDATestCase):
             r"\(Array\(float64, 1, 'C', False, aligned=True\), float32,"
             r" float64\) -> none\n"
             r"\(Array\(float64, 1, 'C', False, aligned=True\), float64,"
-            r" float32\) -> none"
+            r" float32\) -> none",
         )
         # The integer signature is not part of the best matches
         self.assertNotIn("int64", str(cm.exception))
 
-    @skip_on_cudasim('Simulator does not use _prepare_args')
+    @skip_on_cudasim("Simulator does not use _prepare_args")
     @unittest.expectedFailure
     def test_explicit_signatures_unsafe(self):
         # These tests are from test_explicit_signatures, but have to be xfail
@@ -336,8 +348,10 @@ class TestDispatcher(CUDATestCase):
         self.assertPreciseEqual(r[0], 3)
         self.assertEqual(len(f.overloads), 1, f.overloads)
 
-        sigs = ["(int64[::1], int64, int64)",
-                "(float64[::1], float64, float64)"]
+        sigs = [
+            "(int64[::1], int64, int64)",
+            "(float64[::1], float64, float64)",
+        ]
         f = cuda.jit(sigs)(add_kernel)
         r = np.zeros(1, dtype=np.float64)
         # Approximate match (int32 -> float64 is a safe conversion)
@@ -414,7 +428,7 @@ class TestDispatcher(CUDATestCase):
         f[1, 1](r, 1.5, 2.5)
         self.assertPreciseEqual(r[0], 4.0)
 
-    @skip_on_cudasim('CUDA Simulator does not force casting')
+    @skip_on_cudasim("CUDA Simulator does not force casting")
     def test_explicit_signatures_device_unsafe(self):
         # These tests are from test_explicit_signatures. The device function
         # variant of these tests can succeed on CUDA because the compilation
@@ -489,17 +503,15 @@ class TestDispatcherKernelProperties(CUDATestCase):
         # provides the same values as getting the registers per thread for
         # individual signatures.
         regs_per_thread_all = pi_sin_array.get_regs_per_thread()
-        self.assertEqual(regs_per_thread_all[sig_f32.args],
-                         regs_per_thread_f32)
-        self.assertEqual(regs_per_thread_all[sig_f64.args],
-                         regs_per_thread_f64)
+        self.assertEqual(regs_per_thread_all[sig_f32.args], regs_per_thread_f32)
+        self.assertEqual(regs_per_thread_all[sig_f64.args], regs_per_thread_f64)
 
         if regs_per_thread_f32 == regs_per_thread_f64:
             # If the register usage is the same for both variants, there may be
             # a bug, but this may also be an artifact of the compiler / driver
             # / device combination, so produce an informational message only.
-            print('f32 and f64 variant thread usages are equal.')
-            print('This may warrant some investigation. Devices:')
+            print("f32 and f64 variant thread usages are equal.")
+            print("This may warrant some investigation. Devices:")
             cuda.detect()
 
     def test_get_regs_per_thread_specialized(self):
@@ -696,5 +708,5 @@ class TestDispatcherKernelProperties(CUDATestCase):
         self.assertGreaterEqual(local_mem_per_thread, N * 4)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()