numba-cuda 0.23.0__cp313-cp313-win_amd64.whl → 0.24.0__cp313-cp313-win_amd64.whl

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

@@ -187,41 +187,43 @@ def make_fancy_creation_kernel(vtype):
 
         f4_34 = v4(f4_1)  # 1 2 3 4
 
-        for v in (
-            f4_1,
-            f4_2,
-            f4_3,
-            f4_4,
-            f4_5,
-            f4_6,
-            f4_7,
-            f4_8,
-            f4_9,
-            f4_10,
-            f4_11,
-            f4_12,
-            f4_13,
-            f4_14,
-            f4_15,
-            f4_16,
-            f4_17,
-            f4_18,
-            f4_19,
-            f4_20,
-            f4_21,
-            f4_22,
-            f4_23,
-            f4_24,
-            f4_25,
-            f4_26,
-            f4_27,
-            f4_28,
-            f4_29,
-            f4_30,
-            f4_31,
-            f4_32,
-            f4_33,
-            f4_34,
+        for v in tuple(
+            (
+                f4_1,
+                f4_2,
+                f4_3,
+                f4_4,
+                f4_5,
+                f4_6,
+                f4_7,
+                f4_8,
+                f4_9,
+                f4_10,
+                f4_11,
+                f4_12,
+                f4_13,
+                f4_14,
+                f4_15,
+                f4_16,
+                f4_17,
+                f4_18,
+                f4_19,
+                f4_20,
+                f4_21,
+                f4_22,
+                f4_23,
+                f4_24,
+                f4_25,
+                f4_26,
+                f4_27,
+                f4_28,
+                f4_29,
+                f4_30,
+                f4_31,
+                f4_32,
+                f4_33,
+                f4_34,
+            )
         ):
             res[j] = v.x
             res[j + 1] = v.y

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

@@ -287,16 +287,17 @@ class TestCudaWarpOperations(CUDATestCase):
         valid_cases = [
             # mask: unsigned/signed integer
             # predicate: unsigned/signed integer, boolean
-            ("void(uint32[:], uint32[:], int32[:])", np.uint32, np.uint32, 1),
-            ("void(int64[:], int64[:], int32[:])", np.int64, np.int64, 1),
-            ("void(uint64[:], uint64[:], int32[:])", np.uint64, np.uint64, 1),
-            ("void(int32[:], int32[:], int32[:])", np.int32, np.int32, 1),
-            ("void(uint32[:], boolean[:], int32[:])", np.uint32, np.bool_, 1),
-            ("void(uint64[:], boolean[:], int32[:])", np.uint64, np.bool_, 1),
+            ("void(uint32[:], uint32[:], int32[:])", np.uint32, np.uint32),
+            ("void(int64[:], int64[:], int32[:])", np.int64, np.int64),
+            ("void(uint64[:], uint64[:], int32[:])", np.uint64, np.uint64),
+            ("void(int32[:], int32[:], int32[:])", np.int32, np.int32),
+            ("void(uint32[:], boolean[:], int32[:])", np.uint32, np.bool_),
+            ("void(uint64[:], boolean[:], int32[:])", np.uint64, np.bool_),
         ]
 
-        for sig, mask_dtype, pred_dtype, mask_val in valid_cases:
+        for sig, mask_dtype, pred_dtype in valid_cases:
             with self.subTest(sig=sig):
+                mask_val = (~np.array(0, dtype=mask_dtype)).item()
                 compiled = cuda.jit(sig)(use_vote_sync_all_with_mask)
                 ary_mask = np.full(nelem, mask_val, dtype=mask_dtype)
                 ary_pred = np.ones(nelem, dtype=pred_dtype)

numba_cuda/numba/cuda/tests/support.py

@@ -38,6 +38,7 @@ from numba.cuda.datamodel.models import OpaqueModel
 from numba.cuda.np import numpy_support
 
 from numba.cuda import HAS_NUMBA
+from numba.cuda.utils import PYVERSION
 
 if HAS_NUMBA:
     from numba.core.extending import (
@@ -56,6 +57,16 @@ class EnableNRTStatsMixin(object):
         rtsys.memsys_disable_stats()
 
 
+skip_if_py314 = unittest.skipIf(PYVERSION == (3, 14), "Test unstable on 3.14")
+
+
+def expected_failure_py314(fn):
+    if PYVERSION == (3, 14):
+        return unittest.expectedFailure(fn)
+    else:
+        return fn
+
+
 skip_unless_cffi = unittest.skipUnless(cffi_utils.SUPPORTED, "requires cffi")
 
 _lnx_reason = "linux only test"

numba_cuda/numba/cuda/types/cuda_functions.py

@@ -334,7 +334,7 @@ class BaseFunction(Callable):
                             k: _unlit_non_poison(v) for k, v in kws.items()
                         }
                         sig = temp.apply(nolitargs, nolitkws)
-                except Exception as e:
+                except Exception as e:  # noqa: PERF203
                     if not isinstance(e, errors.NumbaError):
                         raise e
                     sig = None

numba_cuda/numba/cuda/typing/asnumbatype.py

@@ -7,6 +7,7 @@ import typing as py_typing
 from numba.cuda.typing.typeof import typeof
 from numba.cuda.core import errors
 from numba.cuda import types
+from numba.cuda.utils import PYVERSION
 
 
 class AsNumbaTypeRegistry:
@@ -40,8 +41,42 @@ class AsNumbaTypeRegistry:
             return py_type
 
     def _builtin_infer(self, py_type):
-        if not isinstance(py_type, py_typing._GenericAlias):
-            return
+        if PYVERSION in ((3, 14),):
+            # As of 3.14 the typing module has been updated to return a
+            # different type when calling: `typing.Optional[X]`.
+            #
+            # On 3.14:
+            #
+            # >>> type(typing.Optional[float])
+            # <class 'typing.Union'>
+            #
+            #
+            # On 3.13 (and presumably below):
+            #
+            # >>> type(typing._UnionGenericAlias)
+            # <class 'typing._UnionGenericAlias'>
+            #
+            #
+            # The previous implementation of this predicate used
+            # `_GenericAlias`, which was possible because `_UnionGenericAlias`
+            # is a subclass of `_GenericAlias`...
+            #
+            # >>> issubclass(typing._UnionGenericAlias, typing._GenericAlias)
+            # True
+            #
+            # However, other types, such as `typing.List[float]` remain as
+            # `typing._GenericAlias`, so that must be keept.
+            #
+            if not isinstance(
+                py_type, (py_typing.Union, py_typing._GenericAlias)
+            ):
+                return
+        elif PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
+            # Use of underscore type `_GenericAlias`.
+            if not isinstance(py_type, py_typing._GenericAlias):
+                return
+        else:
+            raise NotImplementedError(PYVERSION)
 
         if getattr(py_type, "__origin__", None) is py_typing.Union:
             if len(py_type.__args__) != 2:

numba_cuda/numba/cuda/typing/typeof.py

@@ -5,6 +5,7 @@ from collections import namedtuple
 from functools import singledispatch
 import ctypes
 import enum
+import operator
 
 import numpy as np
 from numpy.random.bit_generator import BitGenerator
@@ -47,10 +48,6 @@ def typeof_impl(val, c):
     """
     Generic typeof() implementation.
     """
-    tp = _typeof_buffer(val, c)
-    if tp is not None:
-        return tp
-
     tp = getattr(val, "_numba_type_", None)
     if tp is not None:
         return tp
@@ -64,6 +61,10 @@ def typeof_impl(val, c):
         if tp is not None:
             return tp
 
+    tp = _typeof_buffer(val, c)
+    if tp is not None:
+        return tp
+
     # cffi is handled here as it does not expose a public base class
     # for exported functions or CompiledFFI instances.
     from numba.cuda.typing import cffi_utils
@@ -318,17 +319,13 @@ def _typeof_cuda_array_interface(val, c):
     Array Interface. These are typed as regular Array types, with lowering
     handled in numba.cuda.np.arrayobj.
     """
-    # Only handle constants, not arguments (arguments use regular array typing)
-    if c.purpose == Purpose.argument:
-        return None
-
     dtype = numpy_support.from_dtype(np.dtype(val["typestr"]))
     shape = val["shape"]
     ndim = len(shape)
     strides = val.get("strides")
 
     # Determine layout
-    if ndim == 0:
+    if not ndim:
         layout = "C"
     elif strides is None:
         layout = "C"
@@ -340,18 +337,14 @@ def _typeof_cuda_array_interface(val, c):
             c_strides = numpy_support.strides_from_shape(
                 shape, itemsize, order="C"
             )
-            layout = (
-                "C" if all(x == y for x, y in zip(strides, c_strides)) else "A"
-            )
+            layout = "C" if all(map(operator.eq, strides, c_strides)) else "A"
         elif strides[0] == itemsize:
             f_strides = numpy_support.strides_from_shape(
                 shape, itemsize, order="F"
             )
-            layout = (
-                "F" if all(x == y for x, y in zip(strides, f_strides)) else "A"
-            )
+            layout = "F" if all(map(operator.eq, strides, f_strides)) else "A"
         else:
             layout = "A"
 
-    readonly = val["data"][1]
+    _, readonly = val["data"]
     return types.Array(dtype, ndim, layout, readonly=readonly)

{numba_cuda-0.23.0.dist-info → numba_cuda-0.24.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numba-cuda
-Version: 0.23.0
+Version: 0.24.0
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License-Expression: BSD-2-Clause
@@ -16,24 +16,15 @@ License-File: LICENSE.numba
 Requires-Dist: numba>=0.60.0
 Requires-Dist: cuda-bindings<14.0.0,>=12.9.1
 Requires-Dist: cuda-core<1.0.0,>=0.3.2
+Requires-Dist: packaging
 Provides-Extra: cu12
 Requires-Dist: cuda-bindings<13.0.0,>=12.9.1; extra == "cu12"
 Requires-Dist: cuda-core<1.0.0,>=0.3.0; extra == "cu12"
-Requires-Dist: cuda-python==12.9.*; extra == "cu12"
-Requires-Dist: nvidia-cuda-nvcc-cu12; extra == "cu12"
-Requires-Dist: nvidia-cuda-runtime-cu12; extra == "cu12"
-Requires-Dist: nvidia-cuda-nvrtc-cu12; extra == "cu12"
-Requires-Dist: nvidia-nvjitlink-cu12; extra == "cu12"
-Requires-Dist: nvidia-cuda-cccl-cu12; extra == "cu12"
+Requires-Dist: cuda-toolkit[cccl,cudart,nvcc,nvjitlink,nvrtc]==12.*; extra == "cu12"
 Provides-Extra: cu13
 Requires-Dist: cuda-bindings==13.*; extra == "cu13"
 Requires-Dist: cuda-core<1.0.0,>=0.3.2; extra == "cu13"
-Requires-Dist: cuda-python==13.*; extra == "cu13"
-Requires-Dist: nvidia-nvvm==13.*; extra == "cu13"
-Requires-Dist: nvidia-cuda-runtime==13.*; extra == "cu13"
-Requires-Dist: nvidia-cuda-nvrtc==13.*; extra == "cu13"
-Requires-Dist: nvidia-nvjitlink==13.*; extra == "cu13"
-Requires-Dist: nvidia-cuda-cccl==13.*; extra == "cu13"
+Requires-Dist: cuda-toolkit[cccl,cudart,nvjitlink,nvrtc,nvvm]==13.*; extra == "cu13"
 Dynamic: license-file
 
 <div align="center"><img src="docs/source/_static/numba-green-icon-rgb.svg" width="200"/></div>