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

numba_cuda/numba/cuda/tests/doc_examples/test_sessionize.py

@@ -1,14 +1,18 @@
 import unittest
 
-from numba.cuda.testing import (CUDATestCase, skip_if_cudadevrt_missing,
-                                skip_on_cudasim, skip_unless_cc_60,
-                                skip_if_mvc_enabled)
+from numba.cuda.testing import (
+    CUDATestCase,
+    skip_if_cudadevrt_missing,
+    skip_on_cudasim,
+    skip_unless_cc_60,
+    skip_if_mvc_enabled,
+)
 from numba.tests.support import captured_stdout
 
 
 @skip_if_cudadevrt_missing
 @skip_unless_cc_60
-@skip_if_mvc_enabled('CG not supported with MVC')
+@skip_if_mvc_enabled("CG not supported with MVC")
 @skip_on_cudasim("cudasim doesn't support cuda import at non-top-level")
 class TestSessionization(CUDATestCase):
     """
@@ -40,26 +44,71 @@ class TestSessionization(CUDATestCase):
         ids = cuda.to_device(
             np.array(
                 [
-                    1, 1, 1, 1, 1, 1,
-                    2, 2, 2,
-                    3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-                    4, 4, 4, 4, 4, 4, 4, 4, 4,
+                    1,
+                    1,
+                    1,
+                    1,
+                    1,
+                    1,
+                    2,
+                    2,
+                    2,
+                    3,
+                    3,
+                    3,
+                    3,
+                    3,
+                    3,
+                    3,
+                    3,
+                    3,
+                    3,
+                    4,
+                    4,
+                    4,
+                    4,
+                    4,
+                    4,
+                    4,
+                    4,
+                    4,
                 ]
             )
         )
         sec = cuda.to_device(
             np.array(
                 [
-                    1, 2, 3, 5000, 5001, 5002, 1,
-                    2, 3, 1, 2, 5000, 5001, 10000,
-                    10001, 10002, 10003, 15000, 150001,
-                    1, 5000, 50001, 15000, 20000,
-                    25000, 25001, 25002, 25003,
+                    1,
+                    2,
+                    3,
+                    5000,
+                    5001,
+                    5002,
+                    1,
+                    2,
+                    3,
+                    1,
+                    2,
+                    5000,
+                    5001,
+                    10000,
+                    10001,
+                    10002,
+                    10003,
+                    15000,
+                    150001,
+                    1,
+                    5000,
+                    50001,
+                    15000,
+                    20000,
+                    25000,
+                    25001,
+                    25002,
+                    25003,
                 ],
                 dtype="datetime64[ns]",
-            ).astype(
-                "int64"
-            )  # Cast to int64 for compatibility
+            ).astype("int64")  # Cast to int64 for compatibility
         )
         # Create a vector to hold the results
         results = cuda.to_device(np.zeros(len(ids)))
@@ -105,6 +154,7 @@ class TestSessionization(CUDATestCase):
                     if gid + look_ahead == size - 1:
                         results[gid + look_ahead] = gid
                         break
+
         # ex_sessionize.kernel.end
 
         # ex_sessionize.launch.begin
@@ -119,9 +169,34 @@ class TestSessionization(CUDATestCase):
         # ex_sessionize.launch.end
 
         expect = [
-            0, 0, 0, 3, 3, 3, 6, 6, 6, 9, 9,
-            11, 11, 13, 13, 13, 13, 17, 18, 19, 20, 21,
-            21, 23, 24, 24, 24, 24
+            0,
+            0,
+            0,
+            3,
+            3,
+            3,
+            6,
+            6,
+            6,
+            9,
+            9,
+            11,
+            11,
+            13,
+            13,
+            13,
+            13,
+            17,
+            18,
+            19,
+            20,
+            21,
+            21,
+            23,
+            24,
+            24,
+            24,
+            24,
         ]
         np.testing.assert_equal(expect, results.copy_to_host())
 

numba_cuda/numba/cuda/tests/doc_examples/test_vecadd.py

@@ -37,6 +37,7 @@ class TestVecAdd(CUDATestCase):
 
             if tid < size:
                 c[tid] = a[tid] + b[tid]
+
         # ex_vecadd.kernel.end
 
         # Seed RNG for test repeatability
@@ -64,8 +65,7 @@ class TestVecAdd(CUDATestCase):
         # ex_vecadd.launch.end
 
         np.testing.assert_equal(
-            c.copy_to_host(),
-            a.copy_to_host() + b.copy_to_host()
+            c.copy_to_host(), a.copy_to_host() + b.copy_to_host()
         )
 
 

numba_cuda/numba/cuda/tests/nocuda/test_dummyarray.py

@@ -7,9 +7,8 @@ from numba.cuda.testing import skip_on_cudasim
 
 @skip_on_cudasim("Tests internals of the CUDA driver device array")
 class TestSlicing(unittest.TestCase):
-
     def assertSameContig(self, arr, nparr):
-        attrs = 'C_CONTIGUOUS', 'F_CONTIGUOUS'
+        attrs = "C_CONTIGUOUS", "F_CONTIGUOUS"
         for attr in attrs:
             if arr.flags[attr] != nparr.flags[attr]:
                 if arr.size == 0 and nparr.size == 0:
@@ -17,15 +16,18 @@ class TestSlicing(unittest.TestCase):
                     # some are not
                     pass
                 else:
-                    self.fail("contiguous flag mismatch:\ngot=%s\nexpect=%s" %
-                              (arr.flags, nparr.flags))
+                    self.fail(
+                        "contiguous flag mismatch:\ngot=%s\nexpect=%s"
+                        % (arr.flags, nparr.flags)
+                    )
 
     #### 1D
 
     def test_slice0_1d(self):
         nparr = np.empty(4)
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         self.assertSameContig(arr, nparr)
         xx = -2, -1, 0, 1, 2
         for x in xx:
@@ -37,8 +39,9 @@ class TestSlicing(unittest.TestCase):
 
     def test_slice1_1d(self):
         nparr = np.empty(4)
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         xx = -2, -1, 0, 1, 2
         for x in xx:
             expect = nparr[:x]
@@ -49,8 +52,9 @@ class TestSlicing(unittest.TestCase):
 
     def test_slice2_1d(self):
         nparr = np.empty(4)
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         xx = -2, -1, 0, 1, 2
         for x, y in itertools.product(xx, xx):
             expect = nparr[x:y]
@@ -63,8 +67,9 @@ class TestSlicing(unittest.TestCase):
 
     def test_slice0_2d(self):
         nparr = np.empty((4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         xx = -2, 0, 1, 2
         for x in xx:
             expect = nparr[x:]
@@ -82,8 +87,9 @@ class TestSlicing(unittest.TestCase):
 
     def test_slice1_2d(self):
         nparr = np.empty((4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         xx = -2, 0, 2
         for x in xx:
             expect = nparr[:x]
@@ -101,8 +107,9 @@ class TestSlicing(unittest.TestCase):
 
     def test_slice2_2d(self):
         nparr = np.empty((4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         xx = -2, 0, 2
         for s, t, u, v in itertools.product(xx, xx, xx, xx):
             expect = nparr[s:t, u:v]
@@ -122,8 +129,9 @@ class TestSlicing(unittest.TestCase):
 
     def test_strided_1d(self):
         nparr = np.empty(4)
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         xx = -2, -1, 1, 2
         for x in xx:
             expect = nparr[::x]
@@ -134,8 +142,9 @@ class TestSlicing(unittest.TestCase):
 
     def test_strided_2d(self):
         nparr = np.empty((4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         xx = -2, -1, 1, 2
         for a, b in itertools.product(xx, xx):
             expect = nparr[::a, ::b]
@@ -146,8 +155,9 @@ class TestSlicing(unittest.TestCase):
 
     def test_strided_3d(self):
         nparr = np.empty((4, 5, 6))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         xx = -2, -1, 1, 2
         for a, b, c in itertools.product(xx, xx, xx):
             expect = nparr[::a, ::b, ::c]
@@ -160,16 +170,17 @@ class TestSlicing(unittest.TestCase):
         z = np.empty((1, 2, 3))
         z = np.transpose(z, axes=(2, 0, 1))
         arr = Array.from_desc(0, z.shape, z.strides, z.itemsize)
-        self.assertEqual(z.flags['C_CONTIGUOUS'], arr.flags['C_CONTIGUOUS'])
-        self.assertEqual(z.flags['F_CONTIGUOUS'], arr.flags['F_CONTIGUOUS'])
+        self.assertEqual(z.flags["C_CONTIGUOUS"], arr.flags["C_CONTIGUOUS"])
+        self.assertEqual(z.flags["F_CONTIGUOUS"], arr.flags["F_CONTIGUOUS"])
 
 
 @skip_on_cudasim("Tests internals of the CUDA driver device array")
 class TestReshape(unittest.TestCase):
     def test_reshape_2d2d(self):
         nparr = np.empty((4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         expect = nparr.reshape(5, 4)
         got = arr.reshape(5, 4)[0]
         self.assertEqual(got.shape, expect.shape)
@@ -177,8 +188,9 @@ class TestReshape(unittest.TestCase):
 
     def test_reshape_2d1d(self):
         nparr = np.empty((4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         expect = nparr.reshape(5 * 4)
         got = arr.reshape(5 * 4)[0]
         self.assertEqual(got.shape, expect.shape)
@@ -186,8 +198,9 @@ class TestReshape(unittest.TestCase):
 
     def test_reshape_3d3d(self):
         nparr = np.empty((3, 4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         expect = nparr.reshape(5, 3, 4)
         got = arr.reshape(5, 3, 4)[0]
         self.assertEqual(got.shape, expect.shape)
@@ -195,8 +208,9 @@ class TestReshape(unittest.TestCase):
 
     def test_reshape_3d2d(self):
         nparr = np.empty((3, 4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         expect = nparr.reshape(3 * 4, 5)
         got = arr.reshape(3 * 4, 5)[0]
         self.assertEqual(got.shape, expect.shape)
@@ -204,8 +218,9 @@ class TestReshape(unittest.TestCase):
 
     def test_reshape_3d1d(self):
         nparr = np.empty((3, 4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         expect = nparr.reshape(3 * 4 * 5)
         got = arr.reshape(3 * 4 * 5)[0]
         self.assertEqual(got.shape, expect.shape)
@@ -213,8 +228,9 @@ class TestReshape(unittest.TestCase):
 
     def test_reshape_infer2d2d(self):
         nparr = np.empty((4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         expect = nparr.reshape(-1, 4)
         got = arr.reshape(-1, 4)[0]
         self.assertEqual(got.shape, expect.shape)
@@ -222,8 +238,9 @@ class TestReshape(unittest.TestCase):
 
     def test_reshape_infer2d1d(self):
         nparr = np.empty((4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         expect = nparr.reshape(-1)
         got = arr.reshape(-1)[0]
         self.assertEqual(got.shape, expect.shape)
@@ -231,8 +248,9 @@ class TestReshape(unittest.TestCase):
 
     def test_reshape_infer3d3d(self):
         nparr = np.empty((3, 4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         expect = nparr.reshape(5, -1, 4)
         got = arr.reshape(5, -1, 4)[0]
         self.assertEqual(got.shape, expect.shape)
@@ -240,8 +258,9 @@ class TestReshape(unittest.TestCase):
 
     def test_reshape_infer3d2d(self):
         nparr = np.empty((3, 4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         expect = nparr.reshape(3, -1)
         got = arr.reshape(3, -1)[0]
         self.assertEqual(got.shape, expect.shape)
@@ -249,8 +268,9 @@ class TestReshape(unittest.TestCase):
 
     def test_reshape_infer3d1d(self):
         nparr = np.empty((3, 4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         expect = nparr.reshape(-1)
         got = arr.reshape(-1)[0]
         self.assertEqual(got.shape, expect.shape)
@@ -258,23 +278,26 @@ class TestReshape(unittest.TestCase):
 
     def test_reshape_infer_two_unknowns(self):
         nparr = np.empty((3, 4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
 
         with self.assertRaises(ValueError) as raises:
             arr.reshape(-1, -1, 3)
-        self.assertIn('can only specify one unknown dimension',
-                      str(raises.exception))
+        self.assertIn(
+            "can only specify one unknown dimension", str(raises.exception)
+        )
 
     def test_reshape_infer_invalid_shape(self):
         nparr = np.empty((3, 4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
 
         with self.assertRaises(ValueError) as raises:
             arr.reshape(-1, 7)
 
-        expected_message = 'cannot infer valid shape for unknown dimension'
+        expected_message = "cannot infer valid shape for unknown dimension"
         self.assertIn(expected_message, str(raises.exception))
 
 
@@ -289,6 +312,7 @@ class TestSqueeze(unittest.TestCase):
         def _assert_equal_shape_strides(arr1, arr2):
             self.assertEqual(arr1.shape, arr2.shape)
             self.assertEqual(arr1.strides, arr2.strides)
+
         _assert_equal_shape_strides(arr, nparr)
         _assert_equal_shape_strides(arr.squeeze()[0], nparr.squeeze())
         for axis in (0, 2, 4, (0, 2), (0, 4), (2, 4), (0, 2, 4)):
@@ -311,29 +335,33 @@ class TestSqueeze(unittest.TestCase):
 class TestExtent(unittest.TestCase):
     def test_extent_1d(self):
         nparr = np.empty(4)
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         s, e = arr.extent
         self.assertEqual(e - s, nparr.size * nparr.dtype.itemsize)
 
     def test_extent_2d(self):
         nparr = np.empty((4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         s, e = arr.extent
         self.assertEqual(e - s, nparr.size * nparr.dtype.itemsize)
 
     def test_extent_iter_1d(self):
         nparr = np.empty(4)
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         [ext] = list(arr.iter_contiguous_extent())
         self.assertEqual(ext, arr.extent)
 
     def test_extent_iter_2d(self):
         nparr = np.empty((4, 5))
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
         [ext] = list(arr.iter_contiguous_extent())
         self.assertEqual(ext, arr.extent)
 
@@ -346,8 +374,9 @@ class TestIterate(unittest.TestCase):
         # for #4201
         N = 5
         nparr = np.empty(N)
-        arr = Array.from_desc(0, nparr.shape, nparr.strides,
-                              nparr.dtype.itemsize)
+        arr = Array.from_desc(
+            0, nparr.shape, nparr.strides, nparr.dtype.itemsize
+        )
 
         x = 0  # just a placeholder
         # this loop should not raise AssertionError
@@ -355,5 +384,5 @@ class TestIterate(unittest.TestCase):
             x = val  # noqa: F841
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/nocuda/test_function_resolution.py

@@ -9,19 +9,28 @@ from numba.cuda.cudadrv import nvvm
 class TestFunctionResolution(unittest.TestCase):
     def test_fp16_binary_operators(self):
         from numba.cuda.descriptor import cuda_target
-        ops = (operator.add, operator.iadd, operator.sub, operator.isub,
-               operator.mul, operator.imul)
+
+        ops = (
+            operator.add,
+            operator.iadd,
+            operator.sub,
+            operator.isub,
+            operator.mul,
+            operator.imul,
+        )
         for op in ops:
             fp16 = types.float16
             typingctx = cuda_target.typing_context
             typingctx.refresh()
             fnty = typingctx.resolve_value_type(op)
             out = typingctx.resolve_function_type(fnty, (fp16, fp16), {})
-            self.assertEqual(out, typing.signature(fp16, fp16, fp16),
-                             msg=str(out))
+            self.assertEqual(
+                out, typing.signature(fp16, fp16, fp16), msg=str(out)
+            )
 
     def test_fp16_unary_operators(self):
         from numba.cuda.descriptor import cuda_target
+
         ops = (operator.neg, abs)
         for op in ops:
             fp16 = types.float16
@@ -32,5 +41,5 @@ class TestFunctionResolution(unittest.TestCase):
             self.assertEqual(out, typing.signature(fp16, fp16), msg=str(out))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/nocuda/test_import.py

@@ -11,30 +11,30 @@ class TestImport(unittest.TestCase):
         """
 
         banlist = (
-            'numba.cpython.slicing',
-            'numba.cpython.tupleobj',
-            'numba.cpython.enumimpl',
-            'numba.cpython.hashing',
-            'numba.cpython.heapq',
-            'numba.cpython.iterators',
-            'numba.cpython.numbers',
-            'numba.cpython.rangeobj',
-            'numba.cpython.cmathimpl',
-            'numba.cpython.mathimpl',
-            'numba.cpython.printimpl',
-            'numba.cpython.randomimpl',
-            'numba.core.optional',
-            'numba.misc.gdb_hook',
-            'numba.misc.literal',
-            'numba.misc.cffiimpl',
-            'numba.np.linalg',
-            'numba.np.polynomial',
-            'numba.np.arraymath',
-            'numba.np.npdatetime',
-            'numba.np.npyimpl',
-            'numba.typed.typeddict',
-            'numba.typed.typedlist',
-            'numba.experimental.jitclass.base',
+            "numba.cpython.slicing",
+            "numba.cpython.tupleobj",
+            "numba.cpython.enumimpl",
+            "numba.cpython.hashing",
+            "numba.cpython.heapq",
+            "numba.cpython.iterators",
+            "numba.cpython.numbers",
+            "numba.cpython.rangeobj",
+            "numba.cpython.cmathimpl",
+            "numba.cpython.mathimpl",
+            "numba.cpython.printimpl",
+            "numba.cpython.randomimpl",
+            "numba.core.optional",
+            "numba.misc.gdb_hook",
+            "numba.misc.literal",
+            "numba.misc.cffiimpl",
+            "numba.np.linalg",
+            "numba.np.polynomial",
+            "numba.np.arraymath",
+            "numba.np.npdatetime",
+            "numba.np.npyimpl",
+            "numba.typed.typeddict",
+            "numba.typed.typedlist",
+            "numba.experimental.jitclass.base",
         )
 
         code = "import sys; from numba import cuda; print(list(sys.modules))"
@@ -45,5 +45,5 @@ class TestImport(unittest.TestCase):
         self.assertFalse(unexpected, "some modules unexpectedly imported")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()