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

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

@@ -2,8 +2,11 @@ import multiprocessing as mp
 import logging
 import traceback
 from numba.cuda.testing import unittest, CUDATestCase
-from numba.cuda.testing import (skip_on_cudasim, skip_with_cuda_python,
-                                skip_under_cuda_memcheck)
+from numba.cuda.testing import (
+    skip_on_cudasim,
+    skip_with_cuda_python,
+    skip_under_cuda_memcheck,
+)
 from numba.tests.support import linux_only
 
 
@@ -23,12 +26,12 @@ def child_test():
     # used.
     logbuf = io.StringIO()
     handler = logging.StreamHandler(logbuf)
-    cudadrv_logger = logging.getLogger('numba.cuda.cudadrv.driver')
+    cudadrv_logger = logging.getLogger("numba.cuda.cudadrv.driver")
     cudadrv_logger.addHandler(handler)
     cudadrv_logger.setLevel(logging.DEBUG)
 
     # Set up data for our test, and copy over to the device
-    N = 2 ** 16
+    N = 2**16
     N_THREADS = 10
     N_ADDITIONS = 4096
 
@@ -65,8 +68,10 @@ def child_test():
         f[n_blocks, n_threads, stream](rs[n], xs[n])
 
     # Create threads
-    threads = [threading.Thread(target=kernel_thread, args=(i,))
-               for i in range(N_THREADS)]
+    threads = [
+        threading.Thread(target=kernel_thread, args=(i,))
+        for i in range(N_THREADS)
+    ]
 
     # Start all threads
     for thread in threads:
@@ -95,7 +100,7 @@ def child_test_wrapper(result_queue):
         output = child_test()
         success = True
     # Catch anything raised so it can be propagated
-    except: # noqa: E722
+    except:  # noqa: E722
         output = traceback.format_exc()
         success = False
 
@@ -105,13 +110,13 @@ def child_test_wrapper(result_queue):
 # Run on Linux only until the reason for test hangs on Windows (Issue #8635,
 # https://github.com/numba/numba/issues/8635) is diagnosed
 @linux_only
-@skip_under_cuda_memcheck('Hangs cuda-memcheck')
-@skip_on_cudasim('Streams not supported on the simulator')
+@skip_under_cuda_memcheck("Hangs cuda-memcheck")
+@skip_on_cudasim("Streams not supported on the simulator")
 class TestPTDS(CUDATestCase):
-    @skip_with_cuda_python('Function names unchanged for PTDS with NV Binding')
+    @skip_with_cuda_python("Function names unchanged for PTDS with NV Binding")
     def test_ptds(self):
         # Run a test with PTDS enabled in a child process
-        ctx = mp.get_context('spawn')
+        ctx = mp.get_context("spawn")
         result_queue = ctx.Queue()
         proc = ctx.Process(target=child_test_wrapper, args=(result_queue,))
         proc.start()
@@ -124,8 +129,11 @@ class TestPTDS(CUDATestCase):
 
         # Functions with a per-thread default stream variant that we expect to
         # see in the output
-        ptds_functions = ('cuMemcpyHtoD_v2_ptds', 'cuLaunchKernel_ptsz',
-                          'cuMemcpyDtoH_v2_ptds')
+        ptds_functions = (
+            "cuMemcpyHtoD_v2_ptds",
+            "cuLaunchKernel_ptsz",
+            "cuMemcpyDtoH_v2_ptds",
+        )
 
         for fn in ptds_functions:
             with self.subTest(fn=fn, expected=True):
@@ -133,17 +141,20 @@ class TestPTDS(CUDATestCase):
 
         # Non-PTDS versions of the functions that we should not see in the
         # output:
-        legacy_functions = ('cuMemcpyHtoD_v2', 'cuLaunchKernel',
-                            'cuMemcpyDtoH_v2')
+        legacy_functions = (
+            "cuMemcpyHtoD_v2",
+            "cuLaunchKernel",
+            "cuMemcpyDtoH_v2",
+        )
 
         for fn in legacy_functions:
             with self.subTest(fn=fn, expected=False):
                 # Ensure we only spot these function names appearing without a
                 # _ptds or _ptsz suffix by checking including the end of the
                 # line in the log
-                fn_at_end = f'{fn}\n'
+                fn_at_end = f"{fn}\n"
                 self.assertNotIn(fn_at_end, output)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -7,7 +7,6 @@ from queue import Queue
 
 class TestResetDevice(ContextResettingTestCase):
     def test_reset_device(self):
-
         def newthread(exception_queue):
             try:
                 devices = range(driver.get_device_count())
@@ -32,5 +31,5 @@ class TestResetDevice(ContextResettingTestCase):
         self.assertEqual(exceptions, [])
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -11,32 +11,40 @@ def set_visible_devices_and_check(q):
         from numba import cuda
         import os
 
-        os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+        os.environ["CUDA_VISIBLE_DEVICES"] = "0"
         q.put(len(cuda.gpus.lst))
-    except: # noqa: E722
+    except:  # noqa: E722
         # Sentinel value for error executing test code
         q.put(-1)
 
 
 if config.ENABLE_CUDASIM:
-    SUPPORTED_VERSIONS = (-1, -1),
+    SUPPORTED_VERSIONS = ((-1, -1),)
 else:
-    SUPPORTED_VERSIONS = ((11, 0), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5),
-                          (11, 6), (11, 7))
+    SUPPORTED_VERSIONS = (
+        (11, 0),
+        (11, 1),
+        (11, 2),
+        (11, 3),
+        (11, 4),
+        (11, 5),
+        (11, 6),
+        (11, 7),
+    )
 
 
 class TestRuntime(unittest.TestCase):
     def test_is_supported_version_true(self):
         for v in SUPPORTED_VERSIONS:
-            with patch.object(runtime, 'get_version', return_value=v):
+            with patch.object(runtime, "get_version", return_value=v):
                 self.assertTrue(runtime.is_supported_version())
 
-    @skip_on_cudasim('The simulator always simulates a supported runtime')
+    @skip_on_cudasim("The simulator always simulates a supported runtime")
     def test_is_supported_version_false(self):
         # Check with an old unsupported version and some potential future
         # versions
         for v in ((10, 2), (11, 8), (12, 0)):
-            with patch.object(runtime, 'get_version', return_value=v):
+            with patch.object(runtime, "get_version", return_value=v):
                 self.assertFalse(runtime.is_supported_version())
 
     def test_supported_versions(self):
@@ -57,13 +65,13 @@ class TestVisibleDevices(unittest.TestCase, SerialMixin):
         from numba import cuda
 
         if len(cuda.gpus.lst) in (0, 1):
-            self.skipTest('This test requires multiple GPUs')
+            self.skipTest("This test requires multiple GPUs")
 
-        if os.environ.get('CUDA_VISIBLE_DEVICES'):
-            msg = 'Cannot test when CUDA_VISIBLE_DEVICES already set'
+        if os.environ.get("CUDA_VISIBLE_DEVICES"):
+            msg = "Cannot test when CUDA_VISIBLE_DEVICES already set"
             self.skipTest(msg)
 
-        ctx = multiprocessing.get_context('spawn')
+        ctx = multiprocessing.get_context("spawn")
         q = ctx.Queue()
         p = ctx.Process(target=set_visible_devices_and_check, args=(q,))
         p.start()
@@ -74,12 +82,12 @@ class TestVisibleDevices(unittest.TestCase, SerialMixin):
 
         # Make an obvious distinction between an error running the test code
         # and an incorrect number of GPUs in the list
-        msg = 'Error running set_visible_devices_and_check'
+        msg = "Error running set_visible_devices_and_check"
         self.assertNotEqual(visible_gpu_count, -1, msg=msg)
 
         # The actual check that we see only one GPU
         self.assertEqual(visible_gpu_count, 1)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -37,5 +37,5 @@ class TestSelectDevice(ContextResettingTestCase):
         self.assertEqual(exceptions, [])
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -15,10 +15,11 @@ def with_asyncio_loop(f):
             return loop.run_until_complete(f(*args, **kwds))
         finally:
             loop.close()
+
     return runner
 
 
-@skip_on_cudasim('CUDA Driver API unsupported in the simulator')
+@skip_on_cudasim("CUDA Driver API unsupported in the simulator")
 class TestCudaStream(CUDATestCase):
     def test_add_callback(self):
         def callback(stream, status, event):
@@ -89,7 +90,7 @@ class TestCudaStream(CUDATestCase):
         self.assertTrue(done2.done())
 
 
-@skip_on_cudasim('CUDA Driver API unsupported in the simulator')
+@skip_on_cudasim("CUDA Driver API unsupported in the simulator")
 class TestFailingStream(CUDATestCase):
     # This test can only be run in isolation because it corrupts the CUDA
     # context, which cannot be recovered from within the same process. It is
@@ -118,5 +119,5 @@ class TestFailingStream(CUDATestCase):
         self.assertIsNotNone(done.exception())
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -17,6 +17,7 @@ class UseCase:
     The return type is inferred from the type of the first argument, unless it
     is explicitly overridden by the ``retty`` kwarg.
     """
+
     def __init__(self, func, retty=None):
         self._func = func
         self._retty = retty
@@ -59,6 +60,7 @@ Z = 1
 
 # Inner / outer cached / uncached cases
 
+
 @cuda.jit(cache=True)
 def inner(x, y):
     return x + y + Z
@@ -81,13 +83,13 @@ outer_uncached = CUDAUseCase(outer_uncached_kernel)
 # Exercise returning a record instance.  This used to hardcode the dtype
 # pointer's value in the bitcode.
 
-packed_record_type = np.dtype([('a', np.int8), ('b', np.float64)])
-aligned_record_type = np.dtype([('a', np.int8), ('b', np.float64)], align=True)
+packed_record_type = np.dtype([("a", np.int8), ("b", np.float64)])
+aligned_record_type = np.dtype([("a", np.int8), ("b", np.float64)], align=True)
 
 packed_arr = np.empty(2, dtype=packed_record_type)
 for i in range(packed_arr.size):
-    packed_arr[i]['a'] = i + 1
-    packed_arr[i]['b'] = i + 42.5
+    packed_arr[i]["a"] = i + 1
+    packed_arr[i]["b"] = i + 42.5
 
 aligned_arr = np.array(packed_arr, dtype=aligned_record_type)
 
@@ -103,6 +105,7 @@ record_return_aligned = CUDAUseCase(record_return, retty=aligned_record_type)
 
 # Closure test cases
 
+
 def make_closure(x):
     @cuda.jit(cache=True)
     def closure(r, y):
@@ -119,6 +122,7 @@ closure4 = make_closure(9)
 
 # Ambiguous / renamed functions
 
+
 @cuda.jit(cache=True)
 def ambiguous_function(r, x):
     r[()] = x[()] + 2
@@ -190,6 +194,7 @@ def many_locals():
 
 # Simple use case for multiprocessing test
 
+
 @cuda.jit(cache=True)
 def simple_usecase_kernel(r, x):
     r[()] = x[()]
@@ -200,6 +205,7 @@ simple_usecase_caller = CUDAUseCase(simple_usecase_kernel)
 
 # Usecase with cooperative groups
 
+
 @cuda.jit(cache=True)
 def cg_usecase_kernel(r, x):
     grid = cuda.cg.this_grid()

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

@@ -12,6 +12,7 @@ class CPUUseCase(UseCase):
 
 # Using the same function as a cached CPU and CUDA-jitted function
 
+
 def target_shared_assign(r, x):
     r[()] = x[()]
 

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

@@ -23,7 +23,7 @@ if not config.ENABLE_CUDASIM:
         register_model,
         make_attribute_wrapper,
         typeof_impl,
-        type_callable
+        type_callable,
     )
     from numba.cuda.cudaimpl import lower
     from numba.core import cgutils
@@ -38,21 +38,22 @@ if not config.ENABLE_CUDASIM:
             members = [("x", int32), ("y", int32)]
             super().__init__(dmm, fe_type, members)
 
-    make_attribute_wrapper(TestStructModelType, 'x', 'x')
-    make_attribute_wrapper(TestStructModelType, 'y', 'y')
+    make_attribute_wrapper(TestStructModelType, "x", "x")
+    make_attribute_wrapper(TestStructModelType, "y", "y")
 
     @type_callable(TestStruct)
     def type_test_struct(context):
         def typer(x, y):
             if isinstance(x, types.Integer) and isinstance(y, types.Integer):
                 return test_struct_model_type
+
         return typer
 
     @lower(TestStruct, types.Integer, types.Integer)
     def lower_test_type_ctor(context, builder, sig, args):
-        obj = cgutils.create_struct_proxy(
-            test_struct_model_type
-        )(context, builder)
+        obj = cgutils.create_struct_proxy(test_struct_model_type)(
+            context, builder
+        )
         obj.x = args[0]
         obj.y = args[1]
         return obj._getvalue()

numba_cuda/numba/cuda/tests/cudapy/jitlink.ptx

@@ -26,5 +26,3 @@
 	st.param.b32	[func_retval0+0], %r3;
 	ret;
 }
-
-

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

@@ -97,4 +97,5 @@ def make_growing_tuple_case(jit=lambda x: x):
             return None
 
         return (n, make_list(n - 1))
+
     return make_list

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

@@ -6,7 +6,7 @@ import unittest
 
 class TestAlignment(CUDATestCase):
     def test_record_alignment(self):
-        rec_dtype = np.dtype([('a', 'int32'), ('b', 'float64')], align=True)
+        rec_dtype = np.dtype([("a", "int32"), ("b", "float64")], align=True)
         rec = from_dtype(rec_dtype)
 
         @cuda.jit((rec[:],))
@@ -24,19 +24,20 @@ class TestAlignment(CUDATestCase):
 
         self.assertTrue(np.all(a_recarray.a == a_recarray.b))
 
-    @skip_on_cudasim('Simulator does not check alignment')
+    @skip_on_cudasim("Simulator does not check alignment")
     def test_record_alignment_error(self):
-        rec_dtype = np.dtype([('a', 'int32'), ('b', 'float64')])
+        rec_dtype = np.dtype([("a", "int32"), ("b", "float64")])
         rec = from_dtype(rec_dtype)
 
         with self.assertRaises(Exception) as raises:
+
             @cuda.jit((rec[:],))
             def foo(a):
                 i = cuda.grid(1)
                 a[i].a = a[i].b
 
-        self.assertTrue('type float64 is not aligned' in str(raises.exception))
+        self.assertTrue("type float64 is not aligned" in str(raises.exception))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -8,8 +8,11 @@ from numba import config, cuda
 if config.ENABLE_CUDASIM:
     ARRAY_LIKE_FUNCTIONS = (cuda.device_array_like, cuda.pinned_array_like)
 else:
-    ARRAY_LIKE_FUNCTIONS = (cuda.device_array_like, cuda.mapped_array_like,
-                            cuda.pinned_array_like)
+    ARRAY_LIKE_FUNCTIONS = (
+        cuda.device_array_like,
+        cuda.mapped_array_like,
+        cuda.pinned_array_like,
+    )
 
 
 def array_reshape1d(arr, newshape, got):
@@ -55,8 +58,7 @@ class TestCudaArray(CUDATestCase):
         self.assertEqual(shape2, null_shape)
 
     def test_gpu_array_strided(self):
-
-        @cuda.jit('void(double[:])')
+        @cuda.jit("void(double[:])")
         def kernel(x):
             i = cuda.grid(1)
             if i < x.shape[0]:
@@ -69,8 +71,7 @@ class TestCudaArray(CUDATestCase):
         self.assertTrue(np.allclose(z, list(range(9))))
 
     def test_gpu_array_interleaved(self):
-
-        @cuda.jit('void(double[:], double[:])')
+        @cuda.jit("void(double[:], double[:])")
         def copykernel(x, y):
             i = cuda.grid(1)
             if i < x.shape[0]:
@@ -86,8 +87,10 @@ class TestCudaArray(CUDATestCase):
         except ValueError:
             pass
         else:
-            raise AssertionError("Should raise exception complaining the "
-                                 "contiguous-ness of the array.")
+            raise AssertionError(
+                "Should raise exception complaining the "
+                "contiguous-ness of the array."
+            )
             # Should we handle this use case?
             # assert z.size == y.size
             # copykernel[1, n](y, x)
@@ -108,55 +111,57 @@ class TestCudaArray(CUDATestCase):
         self.assertEqual(array.shape, array_like.shape)
         self.assertEqual(array.strides, array_like.strides)
         self.assertEqual(array.dtype, array_like.dtype)
-        self.assertEqual(array.flags['C_CONTIGUOUS'],
-                         array_like.flags['C_CONTIGUOUS'])
-        self.assertEqual(array.flags['F_CONTIGUOUS'],
-                         array_like.flags['F_CONTIGUOUS'])
+        self.assertEqual(
+            array.flags["C_CONTIGUOUS"], array_like.flags["C_CONTIGUOUS"]
+        )
+        self.assertEqual(
+            array.flags["F_CONTIGUOUS"], array_like.flags["F_CONTIGUOUS"]
+        )
 
     def test_array_like_1d(self):
-        d_a = cuda.device_array(10, order='C')
+        d_a = cuda.device_array(10, order="C")
         for like_func in ARRAY_LIKE_FUNCTIONS:
             with self.subTest(like_func=like_func):
                 self._test_array_like_same(like_func, d_a)
 
     def test_array_like_2d(self):
-        d_a = cuda.device_array((10, 12), order='C')
+        d_a = cuda.device_array((10, 12), order="C")
         for like_func in ARRAY_LIKE_FUNCTIONS:
             with self.subTest(like_func=like_func):
                 self._test_array_like_same(like_func, d_a)
 
     def test_array_like_2d_transpose(self):
-        d_a = cuda.device_array((10, 12), order='C')
+        d_a = cuda.device_array((10, 12), order="C")
         for like_func in ARRAY_LIKE_FUNCTIONS:
             with self.subTest(like_func=like_func):
                 self._test_array_like_same(like_func, d_a)
 
     def test_array_like_3d(self):
-        d_a = cuda.device_array((10, 12, 14), order='C')
+        d_a = cuda.device_array((10, 12, 14), order="C")
         for like_func in ARRAY_LIKE_FUNCTIONS:
             with self.subTest(like_func=like_func):
                 self._test_array_like_same(like_func, d_a)
 
     def test_array_like_1d_f(self):
-        d_a = cuda.device_array(10, order='F')
+        d_a = cuda.device_array(10, order="F")
         for like_func in ARRAY_LIKE_FUNCTIONS:
             with self.subTest(like_func=like_func):
                 self._test_array_like_same(like_func, d_a)
 
     def test_array_like_2d_f(self):
-        d_a = cuda.device_array((10, 12), order='F')
+        d_a = cuda.device_array((10, 12), order="F")
         for like_func in ARRAY_LIKE_FUNCTIONS:
             with self.subTest(like_func=like_func):
                 self._test_array_like_same(like_func, d_a)
 
     def test_array_like_2d_f_transpose(self):
-        d_a = cuda.device_array((10, 12), order='F')
+        d_a = cuda.device_array((10, 12), order="F")
         for like_func in ARRAY_LIKE_FUNCTIONS:
             with self.subTest(like_func=like_func):
                 self._test_array_like_same(like_func, d_a)
 
     def test_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")
         for like_func in ARRAY_LIKE_FUNCTIONS:
             with self.subTest(like_func=like_func):
                 self._test_array_like_same(like_func, d_a)
@@ -173,10 +178,12 @@ class TestCudaArray(CUDATestCase):
         # Use NumPy as a reference for the expected strides
         np_like = np.zeros_like(view)
         self.assertEqual(nb_like.strides, np_like.strides)
-        self.assertEqual(nb_like.flags['C_CONTIGUOUS'],
-                         np_like.flags['C_CONTIGUOUS'])
-        self.assertEqual(nb_like.flags['F_CONTIGUOUS'],
-                         np_like.flags['F_CONTIGUOUS'])
+        self.assertEqual(
+            nb_like.flags["C_CONTIGUOUS"], np_like.flags["C_CONTIGUOUS"]
+        )
+        self.assertEqual(
+            nb_like.flags["F_CONTIGUOUS"], np_like.flags["F_CONTIGUOUS"]
+        )
 
     def test_array_like_1d_view(self):
         shape = 10
@@ -188,8 +195,8 @@ class TestCudaArray(CUDATestCase):
 
     def test_array_like_1d_view_f(self):
         shape = 10
-        view = np.zeros(shape, order='F')[::2]
-        d_view = cuda.device_array(shape, order='F')[::2]
+        view = np.zeros(shape, order="F")[::2]
+        d_view = cuda.device_array(shape, order="F")[::2]
         for like_func in ARRAY_LIKE_FUNCTIONS:
             with self.subTest(like_func=like_func):
                 self._test_array_like_view(like_func, view, d_view)
@@ -204,13 +211,13 @@ class TestCudaArray(CUDATestCase):
 
     def test_array_like_2d_view_f(self):
         shape = (10, 12)
-        view = np.zeros(shape, order='F')[::2, ::2]
-        d_view = cuda.device_array(shape, order='F')[::2, ::2]
+        view = np.zeros(shape, order="F")[::2, ::2]
+        d_view = cuda.device_array(shape, order="F")[::2, ::2]
         for like_func in ARRAY_LIKE_FUNCTIONS:
             with self.subTest(like_func=like_func):
                 self._test_array_like_view(like_func, view, d_view)
 
-    @skip_on_cudasim('Numba and NumPy stride semantics differ for transpose')
+    @skip_on_cudasim("Numba and NumPy stride semantics differ for transpose")
     def test_array_like_2d_view_transpose_device(self):
         shape = (10, 12)
         d_view = cuda.device_array(shape)[::2, ::2].T
@@ -224,11 +231,12 @@ class TestCudaArray(CUDATestCase):
                 self.assertEqual(d_view.shape, like.shape)
                 self.assertEqual(d_view.dtype, like.dtype)
                 self.assertEqual((40, 8), like.strides)
-                self.assertTrue(like.flags['C_CONTIGUOUS'])
-                self.assertFalse(like.flags['F_CONTIGUOUS'])
+                self.assertTrue(like.flags["C_CONTIGUOUS"])
+                self.assertFalse(like.flags["F_CONTIGUOUS"])
 
-    @skip_unless_cudasim('Numba and NumPy stride semantics differ for '
-                         'transpose')
+    @skip_unless_cudasim(
+        "Numba and NumPy stride semantics differ for transpose"
+    )
     def test_array_like_2d_view_transpose_simulator(self):
         shape = (10, 12)
         view = np.zeros(shape)[::2, ::2].T
@@ -243,20 +251,22 @@ class TestCudaArray(CUDATestCase):
                 self.assertEqual(d_view.shape, nb_like.shape)
                 self.assertEqual(d_view.dtype, nb_like.dtype)
                 self.assertEqual(np_like.strides, nb_like.strides)
-                self.assertEqual(np_like.flags['C_CONTIGUOUS'],
-                                 nb_like.flags['C_CONTIGUOUS'])
-                self.assertEqual(np_like.flags['F_CONTIGUOUS'],
-                                 nb_like.flags['F_CONTIGUOUS'])
+                self.assertEqual(
+                    np_like.flags["C_CONTIGUOUS"], nb_like.flags["C_CONTIGUOUS"]
+                )
+                self.assertEqual(
+                    np_like.flags["F_CONTIGUOUS"], nb_like.flags["F_CONTIGUOUS"]
+                )
 
     def test_array_like_2d_view_f_transpose(self):
         shape = (10, 12)
-        view = np.zeros(shape, order='F')[::2, ::2].T
-        d_view = cuda.device_array(shape, order='F')[::2, ::2].T
+        view = np.zeros(shape, order="F")[::2, ::2].T
+        d_view = cuda.device_array(shape, order="F")[::2, ::2].T
         for like_func in ARRAY_LIKE_FUNCTIONS:
             with self.subTest(like_func=like_func):
                 self._test_array_like_view(like_func, view, d_view)
 
-    @skip_on_cudasim('Kernel overloads not created in the simulator')
+    @skip_on_cudasim("Kernel overloads not created in the simulator")
     def test_issue_4628(self):
         # CUDA Device arrays were reported as always being typed with 'A' order
         # so launching the kernel with a host array and then a device array
@@ -318,7 +328,7 @@ class TestCudaArray(CUDATestCase):
         check(array_reshape, array_reshape3d, arr, (8, 1, 3))
 
         # Test negative shape value
-        arr = np.arange(25).reshape(5,5)
+        arr = np.arange(25).reshape(5, 5)
         check(array_reshape, array_reshape1d, arr, -1)
         check(array_reshape, array_reshape1d, arr, (-1,))
         check(array_reshape, array_reshape2d, arr, (-1, 5))
@@ -329,5 +339,5 @@ class TestCudaArray(CUDATestCase):
         check_empty(arr)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -7,12 +7,11 @@ from numba.cuda.testing import unittest, CUDATestCase
 
 class TestCudaArrayArg(CUDATestCase):
     def test_array_ary(self):
-
-        @cuda.jit('double(double[:],int64)', device=True, inline=True)
+        @cuda.jit("double(double[:],int64)", device=True, inline=True)
         def device_function(a, c):
             return a[c]
 
-        @cuda.jit('void(double[:],double[:])')
+        @cuda.jit("void(double[:],double[:])")
         def kernel(x, y):
             i = cuda.grid(1)
             y[i] = device_function(x, i)
@@ -63,7 +62,7 @@ class TestCudaArrayArg(CUDATestCase):
             r[0] = x.x
             r[1] = x.y
 
-        Point = namedtuple('Point', ('x', 'y'))
+        Point = namedtuple("Point", ("x", "y"))
         x = Point(1, 2)
         r = np.zeros(len(x), dtype=np.int64)
         f[1, 1](r, x)
@@ -78,7 +77,7 @@ class TestCudaArrayArg(CUDATestCase):
             r1[1] = x.y
             r2[0] = x.r
 
-        Point = namedtuple('Point', ('x', 'y', 'r'))
+        Point = namedtuple("Point", ("x", "y", "r"))
         x = Point(1, 2, 2.236)
         r1 = np.zeros(2, dtype=np.int64)
         r2 = np.zeros(1, dtype=np.float64)
@@ -197,5 +196,5 @@ class TestCudaArrayArg(CUDATestCase):
         self.assertEqual(r[4], 3)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()