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

numba_cuda/numba/cuda/target.py

@@ -35,19 +35,21 @@ class CUDATypingContext(typing.BaseContext):
     def resolve_value_type(self, val):
         # treat other dispatcher object as another device function
         from numba.cuda.dispatcher import CUDADispatcher
-        if (isinstance(val, Dispatcher) and not
-                isinstance(val, CUDADispatcher)):
+
+        if isinstance(val, Dispatcher) and not isinstance(val, CUDADispatcher):
             try:
                 # use cached device function
                 val = val.__dispatcher
             except AttributeError:
                 if not val._can_compile:
-                    raise ValueError('using cpu function on device '
-                                     'but its compilation is disabled')
+                    raise ValueError(
+                        "using cpu function on device "
+                        "but its compilation is disabled"
+                    )
                 targetoptions = val.targetoptions.copy()
-                targetoptions['device'] = True
-                targetoptions['debug'] = targetoptions.get('debug', False)
-                targetoptions['opt'] = targetoptions.get('opt', True)
+                targetoptions["device"] = True
+                targetoptions["debug"] = targetoptions.get("debug", False)
+                targetoptions["opt"] = targetoptions.get("opt", True)
                 disp = CUDADispatcher(val.py_func, targetoptions)
                 # cache the device function for future use and to avoid
                 # duplicated copy of the same function.
@@ -57,18 +59,47 @@ class CUDATypingContext(typing.BaseContext):
         # continue with parent logic
         return super(CUDATypingContext, self).resolve_value_type(val)
 
+    def can_convert(self, fromty, toty):
+        """
+        Check whether conversion is possible from *fromty* to *toty*.
+        If successful, return a numba.typeconv.Conversion instance;
+        otherwise None is returned.
+        """
+
+        # This implementation works around the issue addressed in Numba PR
+        # #10047, "Fix IntEnumMember.can_convert_to() when no conversions
+        # found", https://github.com/numba/numba/pull/10047.
+        #
+        # This should be gated on the version of Numba that the fix is
+        # incorporated into, and eventually removed when the minimum supported
+        # Numba version includes the fix.
+
+        try:
+            return super().can_convert(fromty, toty)
+        except TypeError:
+            if isinstance(fromty, types.IntEnumMember):
+                # IntEnumMember fails to correctly handle impossible
+                # conversions - in this scenario the correct thing to do is to
+                # return None to signal that the conversion was not possible
+                return None
+            else:
+                # Any failure involving conversion from a non-IntEnumMember is
+                # almost certainly a real and separate issue
+                raise
+
+
 # -----------------------------------------------------------------------------
 # Implementation
 
 
-VALID_CHARS = re.compile(r'[^a-z0-9]', re.I)
+VALID_CHARS = re.compile(r"[^a-z0-9]", re.I)
 
 
 class CUDATargetContext(BaseContext):
     implement_powi_as_math_call = True
     strict_alignment = True
 
-    def __init__(self, typingctx, target='cuda'):
+    def __init__(self, typingctx, target="cuda"):
         super().__init__(typingctx, target)
         self.data_model_manager = cuda_data_manager.chain(
             datamodel.default_manager
@@ -76,7 +107,7 @@ class CUDATargetContext(BaseContext):
 
     @property
     def enable_nrt(self):
-        return getattr(config, 'CUDA_ENABLE_NRT', False)
+        return getattr(config, "CUDA_ENABLE_NRT", False)
 
     @property
     def DIBuilder(self):
@@ -98,18 +129,17 @@ class CUDATargetContext(BaseContext):
     def load_additional_registries(self):
         # side effect of import needed for numba.cpython.*, the builtins
         # registry is updated at import time.
-        from numba.cpython import numbers, tupleobj, slicing # noqa: F401
-        from numba.cpython import rangeobj, iterators, enumimpl # noqa: F401
-        from numba.cpython import unicode, charseq # noqa: F401
+        from numba.cpython import numbers, tupleobj, slicing  # noqa: F401
+        from numba.cpython import rangeobj, iterators, enumimpl  # noqa: F401
+        from numba.cpython import unicode, charseq  # noqa: F401
         from numba.cpython import cmathimpl
         from numba.misc import cffiimpl
-        from numba.np import arrayobj # noqa: F401
-        from numba.np import npdatetime # noqa: F401
-        from . import (
-            cudaimpl, printimpl, libdeviceimpl, mathimpl, vector_types
-        )
+        from numba.np import arrayobj  # noqa: F401
+        from numba.np import npdatetime  # noqa: F401
+        from . import cudaimpl, printimpl, libdeviceimpl, mathimpl, vector_types
+
         # fix for #8940
-        from numba.np.unsafe import ndarray # noqa F401
+        from numba.np.unsafe import ndarray  # noqa F401
 
         self.install_registry(cudaimpl.registry)
         self.install_registry(cffiimpl.registry)
@@ -136,10 +166,18 @@ class CUDATargetContext(BaseContext):
         These include threadIdx, blockDim, etc.
         """
         from numba import cuda
-        nonconsts = ('threadIdx', 'blockDim', 'blockIdx', 'gridDim', 'laneid',
-                     'warpsize')
-        nonconsts_with_mod = tuple([(types.Module(cuda), nc)
-                                    for nc in nonconsts])
+
+        nonconsts = (
+            "threadIdx",
+            "blockDim",
+            "blockIdx",
+            "gridDim",
+            "laneid",
+            "warpsize",
+        )
+        nonconsts_with_mod = tuple(
+            [(types.Module(cuda), nc) for nc in nonconsts]
+        )
         return nonconsts_with_mod
 
     @cached_property
@@ -147,8 +185,9 @@ class CUDATargetContext(BaseContext):
         return CUDACallConv(self)
 
     def mangler(self, name, argtypes, *, abi_tags=(), uid=None):
-        return itanium_mangler.mangle(name, argtypes, abi_tags=abi_tags,
-                                      uid=uid)
+        return itanium_mangler.mangle(
+            name, argtypes, abi_tags=abi_tags, uid=uid
+        )
 
     def make_constant_array(self, builder, aryty, arr):
         """
@@ -160,15 +199,16 @@ class CUDATargetContext(BaseContext):
 
         constvals = [
             self.get_constant(types.byte, i)
-            for i in iter(arr.tobytes(order='A'))
+            for i in iter(arr.tobytes(order="A"))
         ]
         constaryty = ir.ArrayType(ir.IntType(8), len(constvals))
         constary = ir.Constant(constaryty, constvals)
 
         addrspace = nvvm.ADDRSPACE_CONSTANT
-        gv = cgutils.add_global_variable(lmod, constary.type, "_cudapy_cmem",
-                                         addrspace=addrspace)
-        gv.linkage = 'internal'
+        gv = cgutils.add_global_variable(
+            lmod, constary.type, "_cudapy_cmem", addrspace=addrspace
+        )
+        gv.linkage = "internal"
         gv.global_constant = True
         gv.initializer = constary
 
@@ -179,17 +219,21 @@ class CUDATargetContext(BaseContext):
 
         # Convert to generic address-space
         ptrty = ir.PointerType(ir.IntType(8))
-        genptr = builder.addrspacecast(gv, ptrty, 'generic')
+        genptr = builder.addrspacecast(gv, ptrty, "generic")
 
         # Create array object
         ary = self.make_array(aryty)(self, builder)
         kshape = [self.get_constant(types.intp, s) for s in arr.shape]
         kstrides = [self.get_constant(types.intp, s) for s in arr.strides]
-        self.populate_array(ary, data=builder.bitcast(genptr, ary.data.type),
-                            shape=kshape,
-                            strides=kstrides,
-                            itemsize=ary.itemsize, parent=ary.parent,
-                            meminfo=None)
+        self.populate_array(
+            ary,
+            data=builder.bitcast(genptr, ary.data.type),
+            shape=kshape,
+            strides=kstrides,
+            itemsize=ary.itemsize,
+            parent=ary.parent,
+            meminfo=None,
+        )
 
         return ary._getvalue()
 
@@ -199,15 +243,17 @@ class CUDATargetContext(BaseContext):
         addrspace.
         """
         text = cgutils.make_bytearray(string.encode("utf-8") + b"\x00")
-        name = '$'.join(["__conststring__",
-                         itanium_mangler.mangle_identifier(string)])
+        name = "$".join(
+            ["__conststring__", itanium_mangler.mangle_identifier(string)]
+        )
         # Try to reuse existing global
         gv = mod.globals.get(name)
         if gv is None:
             # Not defined yet
-            gv = cgutils.add_global_variable(mod, text.type, name,
-                                             addrspace=nvvm.ADDRSPACE_CONSTANT)
-            gv.linkage = 'internal'
+            gv = cgutils.add_global_variable(
+                mod, text.type, name, addrspace=nvvm.ADDRSPACE_CONSTANT
+            )
+            gv.linkage = "internal"
             gv.global_constant = True
             gv.initializer = text
 
@@ -225,11 +271,10 @@ class CUDATargetContext(BaseContext):
         lmod = builder.module
         gv = self.insert_const_string(lmod, string)
         charptrty = ir.PointerType(ir.IntType(8))
-        return builder.addrspacecast(gv, charptrty, 'generic')
+        return builder.addrspacecast(gv, charptrty, "generic")
 
     def optimize_function(self, func):
-        """Run O1 function passes
-        """
+        """Run O1 function passes"""
         pass
         ## XXX skipped for now
         # fpm = lp.FunctionPassManager.new(func.module)
@@ -266,8 +311,9 @@ class CUDACABICallConv(BaseCallConv):
     def return_value(self, builder, retval):
         return builder.ret(retval)
 
-    def return_user_exc(self, builder, exc, exc_args=None, loc=None,
-                        func_name=None):
+    def return_user_exc(
+        self, builder, exc, exc_args=None, loc=None, func_name=None
+    ):
         msg = "Python exceptions are unsupported in the CUDA C/C++ ABI"
         raise NotImplementedError(msg)
 
@@ -290,8 +336,7 @@ class CUDACABICallConv(BaseCallConv):
         """
         assert not noalias
         arginfo = self._get_arg_packer(fe_argtypes)
-        arginfo.assign_names(self.get_arguments(fn),
-                             ['arg.' + a for a in args])
+        arginfo.assign_names(self.get_arguments(fn), ["arg." + a for a in args])
 
     def get_arguments(self, func):
         """

numba_cuda/numba/cuda/testing.py

@@ -11,7 +11,7 @@ from pathlib import Path
 import unittest
 
 numba_cuda_dir = Path(__file__).parent
-test_data_dir = numba_cuda_dir / 'tests' / 'data'
+test_data_dir = numba_cuda_dir / "tests" / "data"
 
 
 class CUDATestCase(SerialMixin, TestCase):
@@ -55,6 +55,7 @@ class ContextResettingTestCase(CUDATestCase):
     def tearDown(self):
         super().tearDown()
         from numba.cuda.cudadrv.devices import reset
+
         reset()
 
 
@@ -89,26 +90,26 @@ def skip_unless_conda_cudatoolkit(reason):
 
 def skip_if_external_memmgr(reason):
     """Skip test if an EMM Plugin is in use"""
-    return unittest.skipIf(config.CUDA_MEMORY_MANAGER != 'default', reason)
+    return unittest.skipIf(config.CUDA_MEMORY_MANAGER != "default", reason)
 
 
 def skip_under_cuda_memcheck(reason):
-    return unittest.skipIf(os.environ.get('CUDA_MEMCHECK') is not None, reason)
+    return unittest.skipIf(os.environ.get("CUDA_MEMCHECK") is not None, reason)
 
 
 def skip_without_nvdisasm(reason):
-    nvdisasm_path = shutil.which('nvdisasm')
+    nvdisasm_path = shutil.which("nvdisasm")
     return unittest.skipIf(nvdisasm_path is None, reason)
 
 
 def skip_with_nvdisasm(reason):
-    nvdisasm_path = shutil.which('nvdisasm')
+    nvdisasm_path = shutil.which("nvdisasm")
     return unittest.skipIf(nvdisasm_path is not None, reason)
 
 
 def skip_on_arm(reason):
     cpu = platform.processor()
-    is_arm = cpu.startswith('arm') or cpu.startswith('aarch')
+    is_arm = cpu.startswith("arm") or cpu.startswith("aarch")
     return unittest.skipIf(is_arm, reason)
 
 
@@ -116,25 +117,27 @@ def skip_if_cuda_includes_missing(fn):
     # Skip when cuda.h is not available - generally this should indicate
     # whether the CUDA includes are available or not
     cuda_include_path = libs.get_cuda_include_dir()
-    cuda_h = os.path.join(cuda_include_path, 'cuda.h')
-    cuda_h_file = (os.path.exists(cuda_h) and os.path.isfile(cuda_h))
-    reason = 'CUDA include dir not available on this system'
+    cuda_h = os.path.join(cuda_include_path, "cuda.h")
+    cuda_h_file = os.path.exists(cuda_h) and os.path.isfile(cuda_h)
+    reason = "CUDA include dir not available on this system"
     return unittest.skipUnless(cuda_h_file, reason)(fn)
 
 
 def skip_if_curand_kernel_missing(fn):
     cuda_include_path = libs.get_cuda_include_dir()
-    curand_kernel_h = os.path.join(cuda_include_path, 'curand_kernel.h')
-    curand_kernel_h_file = (os.path.exists(curand_kernel_h) and
-                            os.path.isfile(curand_kernel_h))
-    reason = 'curand_kernel.h not available on this system'
+    curand_kernel_h = os.path.join(cuda_include_path, "curand_kernel.h")
+    curand_kernel_h_file = os.path.exists(curand_kernel_h) and os.path.isfile(
+        curand_kernel_h
+    )
+    reason = "curand_kernel.h not available on this system"
     return unittest.skipUnless(curand_kernel_h_file, reason)(fn)
 
 
 def skip_if_mvc_enabled(reason):
     """Skip a test if Minor Version Compatibility is enabled"""
-    return unittest.skipIf(config.CUDA_ENABLE_MINOR_VERSION_COMPATIBILITY,
-                           reason)
+    return unittest.skipIf(
+        config.CUDA_ENABLE_MINOR_VERSION_COMPATIBILITY, reason
+    )
 
 
 def skip_if_mvc_libraries_unavailable(fn):
@@ -142,12 +145,14 @@ def skip_if_mvc_libraries_unavailable(fn):
     try:
         import cubinlinker  # noqa: F401
         import ptxcompiler  # noqa: F401
+
         libs_available = True
     except ImportError:
         pass
 
-    return unittest.skipUnless(libs_available,
-                               "Requires cubinlinker and ptxcompiler")(fn)
+    return unittest.skipUnless(
+        libs_available, "Requires cubinlinker and ptxcompiler"
+    )(fn)
 
 
 def cc_X_or_above(major, minor):
@@ -189,7 +194,7 @@ def cudadevrt_missing():
     if config.ENABLE_CUDASIM:
         return False
     try:
-        path = libs.get_cudalib('cudadevrt', static=True)
+        path = libs.get_cudalib("cudadevrt", static=True)
         libs.check_static_lib(path)
     except FileNotFoundError:
         return True
@@ -197,7 +202,7 @@ def cudadevrt_missing():
 
 
 def skip_if_cudadevrt_missing(fn):
-    return unittest.skipIf(cudadevrt_missing(), 'cudadevrt missing')(fn)
+    return unittest.skipIf(cudadevrt_missing(), "cudadevrt missing")(fn)
 
 
 class ForeignArray(object):

numba_cuda/numba/cuda/tests/__init__.py

@@ -19,18 +19,19 @@ def load_testsuite(loader, dir):
         files = []
         for f in os.listdir(dir):
             path = join(dir, f)
-            if isfile(path) and fnmatch(f, 'test_*.py'):
+            if isfile(path) and fnmatch(f, "test_*.py"):
                 files.append(f)
-            elif isfile(join(path, '__init__.py')):
-                suite.addTests(loader.discover(path,
-                                               top_level_dir=top_level_dir))
+            elif isfile(join(path, "__init__.py")):
+                suite.addTests(
+                    loader.discover(path, top_level_dir=top_level_dir)
+                )
         for f in files:
             # turn 'f' into a filename relative to the toplevel dir and
             # translate it to a module name. This differs from the
             # implementation in Numba, because the toplevel dir is the
             # numba_cuda module location, not the numba one.
             f = relpath(join(dir, f), top_level_dir)
-            f = splitext(normpath(f.replace(os.path.sep, '.')))[0]
+            f = splitext(normpath(f.replace(os.path.sep, ".")))[0]
             suite.addTests(loader.loadTestsFromName(f))
         return suite
     except Exception:
@@ -42,16 +43,17 @@ def load_tests(loader, tests, pattern):
     suite = unittest.TestSuite()
     this_dir = dirname(__file__)
     ensure_supported_ccs_initialized()
-    suite.addTests(load_testsuite(loader, join(this_dir, 'nocuda')))
+    suite.addTests(load_testsuite(loader, join(this_dir, "nocuda")))
     if cuda.is_available():
-        suite.addTests(load_testsuite(loader, join(this_dir, 'cudasim')))
+        suite.addTests(load_testsuite(loader, join(this_dir, "cudasim")))
         gpus = cuda.list_devices()
         if gpus and gpus[0].compute_capability >= (2, 0):
-            suite.addTests(load_testsuite(loader, join(this_dir, 'cudadrv')))
-            suite.addTests(load_testsuite(loader, join(this_dir, 'cudapy')))
-            suite.addTests(load_testsuite(loader, join(this_dir, 'nrt')))
-            suite.addTests(load_testsuite(loader, join(this_dir,
-                                                       'doc_examples')))
+            suite.addTests(load_testsuite(loader, join(this_dir, "cudadrv")))
+            suite.addTests(load_testsuite(loader, join(this_dir, "cudapy")))
+            suite.addTests(load_testsuite(loader, join(this_dir, "nrt")))
+            suite.addTests(
+                load_testsuite(loader, join(this_dir, "doc_examples"))
+            )
         else:
             print("skipped CUDA tests because GPU CC < 2.0")
     else:

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

@@ -4,7 +4,6 @@ from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
 
 
 class TestArrayAttr(CUDATestCase):
-
     def test_contigous_2d(self):
         ary = np.arange(10)
         cary = ary.reshape(2, 5)
@@ -44,7 +43,7 @@ class TestArrayAttr(CUDATestCase):
     def test_ravel_1d(self):
         ary = np.arange(60)
         dary = cuda.to_device(ary)
-        for order in 'CFA':
+        for order in "CFA":
             expect = ary.ravel(order=order)
             dflat = dary.ravel(order=order)
             flat = dflat.copy_to_host()
@@ -52,14 +51,14 @@ class TestArrayAttr(CUDATestCase):
             self.assertEqual(flat.ndim, 1)
             self.assertPreciseEqual(expect, flat)
 
-    @skip_on_cudasim('CUDA Array Interface is not supported in the simulator')
+    @skip_on_cudasim("CUDA Array Interface is not supported in the simulator")
     def test_ravel_stride_1d(self):
         ary = np.arange(60)
         dary = cuda.to_device(ary)
         # No-copy stride device array
         darystride = dary[::2]
-        dary_data = dary.__cuda_array_interface__['data'][0]
-        ddarystride_data = darystride.__cuda_array_interface__['data'][0]
+        dary_data = dary.__cuda_array_interface__["data"][0]
+        ddarystride_data = darystride.__cuda_array_interface__["data"][0]
         self.assertEqual(dary_data, ddarystride_data)
         # Fail on ravel on non-contiguous array
         with self.assertRaises(NotImplementedError):
@@ -69,7 +68,7 @@ class TestArrayAttr(CUDATestCase):
         ary = np.arange(60)
         reshaped = ary.reshape(2, 5, 2, 3)
 
-        expect = reshaped.ravel(order='C')
+        expect = reshaped.ravel(order="C")
         dary = cuda.to_device(reshaped)
         dflat = dary.ravel()
         flat = dflat.copy_to_host()
@@ -78,7 +77,7 @@ class TestArrayAttr(CUDATestCase):
         self.assertPreciseEqual(expect, flat)
 
         # explicit order kwarg
-        for order in 'CA':
+        for order in "CA":
             expect = reshaped.ravel(order=order)
             dary = cuda.to_device(reshaped)
             dflat = dary.ravel(order=order)
@@ -87,15 +86,15 @@ class TestArrayAttr(CUDATestCase):
             self.assertEqual(flat.ndim, 1)
             self.assertPreciseEqual(expect, flat)
 
-    @skip_on_cudasim('CUDA Array Interface is not supported in the simulator')
+    @skip_on_cudasim("CUDA Array Interface is not supported in the simulator")
     def test_ravel_stride_c(self):
         ary = np.arange(60)
         reshaped = ary.reshape(2, 5, 2, 3)
 
         dary = cuda.to_device(reshaped)
         darystride = dary[::2, ::2, ::2, ::2]
-        dary_data = dary.__cuda_array_interface__['data'][0]
-        ddarystride_data = darystride.__cuda_array_interface__['data'][0]
+        dary_data = dary.__cuda_array_interface__["data"][0]
+        ddarystride_data = darystride.__cuda_array_interface__["data"][0]
         self.assertEqual(dary_data, ddarystride_data)
         with self.assertRaises(NotImplementedError):
             darystride.ravel()
@@ -103,7 +102,7 @@ class TestArrayAttr(CUDATestCase):
     def test_ravel_f(self):
         ary = np.arange(60)
         reshaped = np.asfortranarray(ary.reshape(2, 5, 2, 3))
-        for order in 'FA':
+        for order in "FA":
             expect = reshaped.ravel(order=order)
             dary = cuda.to_device(reshaped)
             dflat = dary.ravel(order=order)
@@ -112,14 +111,14 @@ class TestArrayAttr(CUDATestCase):
             self.assertEqual(flat.ndim, 1)
             self.assertPreciseEqual(expect, flat)
 
-    @skip_on_cudasim('CUDA Array Interface is not supported in the simulator')
+    @skip_on_cudasim("CUDA Array Interface is not supported in the simulator")
     def test_ravel_stride_f(self):
         ary = np.arange(60)
         reshaped = np.asfortranarray(ary.reshape(2, 5, 2, 3))
         dary = cuda.to_device(reshaped)
         darystride = dary[::2, ::2, ::2, ::2]
-        dary_data = dary.__cuda_array_interface__['data'][0]
-        ddarystride_data = darystride.__cuda_array_interface__['data'][0]
+        dary_data = dary.__cuda_array_interface__["data"][0]
+        ddarystride_data = darystride.__cuda_array_interface__["data"][0]
         self.assertEqual(dary_data, ddarystride_data)
         with self.assertRaises(NotImplementedError):
             darystride.ravel()
@@ -134,12 +133,12 @@ class TestArrayAttr(CUDATestCase):
 
     def test_reshape_f(self):
         ary = np.arange(10)
-        expect = ary.reshape(2, 5, order='F')
+        expect = ary.reshape(2, 5, order="F")
         dary = cuda.to_device(ary)
-        dary_reshaped = dary.reshape(2, 5, order='F')
+        dary_reshaped = dary.reshape(2, 5, order="F")
         got = dary_reshaped.copy_to_host()
         self.assertPreciseEqual(expect, got)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -27,7 +27,6 @@ class TestContextStack(CUDATestCase):
 
 
 class TestContextAPI(CUDATestCase):
-
     def tearDown(self):
         super().tearDown()
         cuda.close()
@@ -36,7 +35,7 @@ class TestContextAPI(CUDATestCase):
         try:
             mem = cuda.current_context().get_memory_info()
         except NotImplementedError:
-            self.skipTest('EMM Plugin does not implement get_memory_info()')
+            self.skipTest("EMM Plugin does not implement get_memory_info()")
 
         self.assertIsInstance(mem.free, numbers.Number)
         self.assertEqual(mem.free, mem[0])
@@ -47,7 +46,7 @@ class TestContextAPI(CUDATestCase):
         self.assertLessEqual(mem.free, mem.total)
 
     @unittest.skipIf(len(cuda.gpus) < 2, "need more than 1 gpus")
-    @skip_on_cudasim('CUDA HW required')
+    @skip_on_cudasim("CUDA HW required")
     def test_forbidden_context_switch(self):
         # Cannot switch context inside a `cuda.require_context`
         @cuda.require_context
@@ -72,7 +71,7 @@ class TestContextAPI(CUDATestCase):
         self.assertEqual(int(devid), 1)
 
 
-@skip_on_cudasim('CUDA HW required')
+@skip_on_cudasim("CUDA HW required")
 class Test3rdPartyContext(CUDATestCase):
     def tearDown(self):
         super().tearDown()
@@ -118,8 +117,9 @@ class Test3rdPartyContext(CUDATestCase):
             cuda.current_context()
         except RuntimeError as e:
             # Expecting an error about non-primary CUDA context
-            self.assertIn("Numba cannot operate on non-primary CUDA context ",
-                          str(e))
+            self.assertIn(
+                "Numba cannot operate on non-primary CUDA context ", str(e)
+            )
         else:
             self.fail("No RuntimeError raised")
         finally:
@@ -141,5 +141,5 @@ class Test3rdPartyContext(CUDATestCase):
         self.test_attached_primary(do)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()