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

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()

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

@@ -6,24 +6,24 @@ import numpy as np
 
 from numba import int16, int32
 from numba import cuda, vectorize, njit
+from numba.core import types
 from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
 from numba.tests.enum_usecases import (
     Color,
     Shape,
     Planet,
     RequestError,
-    IntEnumWithNegatives
+    IntEnumWithNegatives,
 )
 
 
 class EnumTest(CUDATestCase):
-
     pairs = [
         (Color.red, Color.red),
         (Color.red, Color.green),
         (Planet.EARTH, Planet.EARTH),
         (Planet.VENUS, Planet.MARS),
-        (Shape.circle, IntEnumWithNegatives.two) # IntEnum, same value
+        (Shape.circle, IntEnumWithNegatives.two),  # IntEnum, same value
     ]
 
     def test_compare(self):
@@ -45,7 +45,7 @@ class EnumTest(CUDATestCase):
         def f(out):
             # Lookup of an enum member on its class
             out[0] = Color.red == Color.green
-            out[1] = Color['red'] == Color['green']
+            out[1] = Color["red"] == Color["green"]
 
         cuda_f = cuda.jit(f)
         got = np.zeros((2,), dtype=np.bool_)
@@ -106,16 +106,33 @@ class EnumTest(CUDATestCase):
     def test_vectorize(self):
         def f(x):
             if x != RequestError.not_found:
-                return RequestError['internal_error']
+                return RequestError["internal_error"]
             else:
                 return RequestError.dummy
 
-        cuda_func = vectorize("int64(int64)", target='cuda')(f)
+        cuda_func = vectorize("int64(int64)", target="cuda")(f)
         arr = np.array([2, 404, 500, 404], dtype=np.int64)
         expected = np.array([f(x) for x in arr], dtype=np.int64)
         got = cuda_func(arr)
         self.assertPreciseEqual(expected, got)
 
+    def test_int_enum_no_conversion(self):
+        # Ported from Numba PR #10047: "Fix IntEnumMember.can_convert_to() when
+        # no conversions found", https://github.com/numba/numba/pull/10047.
+
+        # The original test is intended to ensures that
+        # IntEnumMember.can_convert_to() handles the case when the typing
+        # context's can_convert() method returns None to signal no possible
+        # conversion. In Numba-CUDA, we had to patch the CUDA target context to
+        # work around this issue, because we cannot guarantee that the
+        # IntEnumMember method can be patched before instances are created.
+        ctx = cuda.descriptor.cuda_target.typing_context
+
+        int_enum_type = types.IntEnumMember(Shape, types.int64)
+        # Conversion of an int enum member to a 1D array would be invalid
+        invalid_toty = types.int64[::1]
+        self.assertIsNone(ctx.can_convert(int_enum_type, invalid_toty))
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -17,34 +17,49 @@ class TestJitErrors(CUDATestCase):
 
         with self.assertRaises(ValueError) as raises:
             kernfunc[(1, 2, 3, 4), (5, 6)]
-        self.assertIn("griddim must be a sequence of 1, 2 or 3 integers, "
-                      "got [1, 2, 3, 4]",
-                      str(raises.exception))
+        self.assertIn(
+            "griddim must be a sequence of 1, 2 or 3 integers, "
+            "got [1, 2, 3, 4]",
+            str(raises.exception),
+        )
 
         with self.assertRaises(ValueError) as raises:
-            kernfunc[(1, 2,), (3, 4, 5, 6)]
-        self.assertIn("blockdim must be a sequence of 1, 2 or 3 integers, "
-                      "got [3, 4, 5, 6]",
-                      str(raises.exception))
+            kernfunc[
+                (
+                    1,
+                    2,
+                ),
+                (3, 4, 5, 6),
+            ]
+        self.assertIn(
+            "blockdim must be a sequence of 1, 2 or 3 integers, "
+            "got [3, 4, 5, 6]",
+            str(raises.exception),
+        )
 
     def test_non_integral_dims(self):
         kernfunc = cuda.jit(noop)
 
         with self.assertRaises(TypeError) as raises:
             kernfunc[2.0, 3]
-        self.assertIn("griddim must be a sequence of integers, got [2.0]",
-                      str(raises.exception))
+        self.assertIn(
+            "griddim must be a sequence of integers, got [2.0]",
+            str(raises.exception),
+        )
 
         with self.assertRaises(TypeError) as raises:
             kernfunc[2, 3.0]
-        self.assertIn("blockdim must be a sequence of integers, got [3.0]",
-                      str(raises.exception))
+        self.assertIn(
+            "blockdim must be a sequence of integers, got [3.0]",
+            str(raises.exception),
+        )
 
     def _test_unconfigured(self, kernfunc):
         with self.assertRaises(ValueError) as raises:
             kernfunc(0)
-        self.assertIn("launch configuration was not specified",
-                      str(raises.exception))
+        self.assertIn(
+            "launch configuration was not specified", str(raises.exception)
+        )
 
     def test_unconfigured_typed_cudakernel(self):
         kernfunc = cuda.jit("void(int32)")(noop)
@@ -54,7 +69,7 @@ class TestJitErrors(CUDATestCase):
         kernfunc = cuda.jit(noop)
         self._test_unconfigured(kernfunc)
 
-    @skip_on_cudasim('TypingError does not occur on simulator')
+    @skip_on_cudasim("TypingError does not occur on simulator")
     def test_typing_error(self):
         # see #5860, this is present to catch changes to error reporting
         # accidentally breaking the CUDA target
@@ -75,5 +90,5 @@ class TestJitErrors(CUDATestCase):
         self.assertIn("NameError: name 'floor' is not defined", excstr)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -83,20 +83,19 @@ class TestException(CUDATestCase):
                         x[i] += x[i] // y[i]
 
         n = 32
-        got_x = 1. / (np.arange(n) + 0.01)
-        got_y = 1. / (np.arange(n) + 0.01)
+        got_x = 1.0 / (np.arange(n) + 0.01)
+        got_y = 1.0 / (np.arange(n) + 0.01)
         problematic[1, n](got_x, got_y)
 
-        expect_x = 1. / (np.arange(n) + 0.01)
-        expect_y = 1. / (np.arange(n) + 0.01)
+        expect_x = 1.0 / (np.arange(n) + 0.01)
+        expect_y = 1.0 / (np.arange(n) + 0.01)
         oracle[1, n](expect_x, expect_y)
 
         np.testing.assert_almost_equal(expect_x, got_x)
         np.testing.assert_almost_equal(expect_y, got_y)
 
     def test_raise_causing_warp_diverge(self):
-        """Test case for issue #2655.
-        """
+        """Test case for issue #2655."""
         self.case_raise_causing_warp_diverge(with_debug_mode=False)
 
     # The following two cases relate to Issue #7806: Division by zero stops the
@@ -117,8 +116,8 @@ class TestException(CUDATestCase):
 
         f[1, 1](r, x, y)
 
-        self.assertTrue(np.isinf(r[0]), 'Expected inf from div by zero')
-        self.assertEqual(r[1], y[0], 'Expected execution to continue')
+        self.assertTrue(np.isinf(r[0]), "Expected inf from div by zero")
+        self.assertEqual(r[1], y[0], "Expected execution to continue")
 
     def test_zero_division_error_in_debug(self):
         # When debug is True:
@@ -146,15 +145,15 @@ class TestException(CUDATestCase):
         with self.assertRaises(exc):
             f[1, 1](r, x, y)
 
-        self.assertEqual(r[0], 0, 'Expected result to be left unset')
-        self.assertEqual(r[1], 0, 'Expected execution to stop')
+        self.assertEqual(r[0], 0, "Expected result to be left unset")
+        self.assertEqual(r[1], 0, "Expected execution to stop")
 
     @xfail_unless_cudasim
     def test_raise_in_device_function(self):
         # This is an expected failure because reporting of exceptions raised in
         # device functions does not work correctly - see Issue #8036:
         # https://github.com/numba/numba/issues/8036
-        msg = 'Device Function Error'
+        msg = "Device Function Error"
 
         @cuda.jit(device=True)
         def f():
@@ -170,5 +169,5 @@ class TestException(CUDATestCase):
         self.assertIn(msg, str(raises.exception))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -8,12 +8,13 @@ class Interval:
     """
     A half-open interval on the real number line.
     """
+
     def __init__(self, lo, hi):
         self.lo = lo
         self.hi = hi
 
     def __repr__(self):
-        return 'Interval(%f, %f)' % (self.lo, self.hi)
+        return "Interval(%f, %f)" % (self.lo, self.hi)
 
     @property
     def width(self):
@@ -32,16 +33,23 @@ def sum_intervals(i, j):
 
 if not config.ENABLE_CUDASIM:
     from numba.core import cgutils
-    from numba.core.extending import (lower_builtin, make_attribute_wrapper,
-                                      models, register_model, type_callable,
-                                      typeof_impl)
+    from numba.core.extending import (
+        lower_builtin,
+        models,
+        type_callable,
+        typeof_impl,
+    )
     from numba.core.typing.templates import AttributeTemplate
     from numba.cuda.cudadecl import registry as cuda_registry
     from numba.cuda.cudaimpl import lower_attr as cuda_lower_attr
+    from numba.cuda.extending import (
+        register_model,
+        make_attribute_wrapper,
+    )
 
     class IntervalType(types.Type):
         def __init__(self):
-            super().__init__(name='Interval')
+            super().__init__(name="Interval")
 
     interval_type = IntervalType()
 
@@ -54,19 +62,20 @@ if not config.ENABLE_CUDASIM:
         def typer(lo, hi):
             if isinstance(lo, types.Float) and isinstance(hi, types.Float):
                 return interval_type
+
         return typer
 
     @register_model(IntervalType)
     class IntervalModel(models.StructModel):
         def __init__(self, dmm, fe_type):
             members = [
-                ('lo', types.float64),
-                ('hi', types.float64),
+                ("lo", types.float64),
+                ("hi", types.float64),
             ]
             models.StructModel.__init__(self, dmm, fe_type, members)
 
-    make_attribute_wrapper(IntervalType, 'lo', 'lo')
-    make_attribute_wrapper(IntervalType, 'hi', 'hi')
+    make_attribute_wrapper(IntervalType, "lo", "lo")
+    make_attribute_wrapper(IntervalType, "hi", "hi")
 
     @lower_builtin(Interval, types.Float, types.Float)
     def impl_interval(context, builder, sig, args):
@@ -84,14 +93,14 @@ if not config.ENABLE_CUDASIM:
         def resolve_width(self, mod):
             return types.float64
 
-    @cuda_lower_attr(IntervalType, 'width')
+    @cuda_lower_attr(IntervalType, "width")
     def cuda_Interval_width(context, builder, sig, arg):
         lo = builder.extract_value(arg, 0)
         hi = builder.extract_value(arg, 1)
         return builder.fsub(hi, lo)
 
 
-@skip_on_cudasim('Extensions not supported in the simulator')
+@skip_on_cudasim("Extensions not supported in the simulator")
 class TestExtending(CUDATestCase):
     def test_attributes(self):
         @cuda.jit
@@ -151,5 +160,5 @@ class TestExtending(CUDATestCase):
         np.testing.assert_allclose(r, expected)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()