pyopencl 2025.1__cp310-cp310-win_amd64.whl → 2025.2.2__cp310-cp310-win_amd64.whl

pyopencl/compyte/array.py

@@ -20,10 +20,13 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 """
 
+from typing import Any, Protocol
+
 import numpy as np
+from typing_extensions import override
 
 
-def f_contiguous_strides(itemsize, shape):
+def f_contiguous_strides(itemsize: int, shape: tuple[int, ...]) -> tuple[int, ...]:
     if shape:
         strides = [itemsize]
         for s in shape[:-1]:
@@ -36,7 +39,7 @@ def f_contiguous_strides(itemsize, shape):
         return ()
 
 
-def c_contiguous_strides(itemsize, shape):
+def c_contiguous_strides(itemsize: int, shape: tuple[int, ...]) -> tuple[int, ...]:
     if shape:
         strides = [itemsize]
         for s in shape[:0:-1]:
@@ -49,7 +52,11 @@ def c_contiguous_strides(itemsize, shape):
         return ()
 
 
-def equal_strides(strides1, strides2, shape):
+def equal_strides(
+            strides1: tuple[int, ...],
+            strides2: tuple[int, ...],
+            shape: tuple[int, ...]
+        ) -> bool:
     if strides1 == strides2:
         return True
 
@@ -63,33 +70,53 @@ def equal_strides(strides1, strides2, shape):
     return True
 
 
-def is_f_contiguous_strides(strides, itemsize, shape):
+def is_f_contiguous_strides(
+            strides: tuple[int, ...],
+            itemsize: int,
+            shape: tuple[int, ...]
+        ) -> bool:
     from pytools import product
     return (
             equal_strides(strides, f_contiguous_strides(itemsize, shape), shape)
-            or product(shape) == 0)  # noqa: W503
+            or product(shape) == 0)
 
 
-def is_c_contiguous_strides(strides, itemsize, shape):
+def is_c_contiguous_strides(
+            strides: tuple[int, ...],
+            itemsize: int,
+            shape: tuple[int, ...]
+        ) -> bool:
     from pytools import product
     return (equal_strides(strides, c_contiguous_strides(itemsize, shape), shape)
-            or product(shape) == 0)  # noqa: W503
+            or product(shape) == 0)
+
+
+class ArrayIsh(Protocol):
+    shape: tuple[int, ...]
+    strides: tuple[int, ...]
+    dtype: np.dtype[Any]
 
 
 class ArrayFlags:
-    def __init__(self, ary):
+    f_contiguous: bool
+    c_contiguous: bool
+    forc: bool
+
+    def __init__(self, ary: ArrayIsh):
         self.f_contiguous = is_f_contiguous_strides(
             ary.strides, ary.dtype.itemsize, ary.shape)
         self.c_contiguous = is_c_contiguous_strides(
             ary.strides, ary.dtype.itemsize, ary.shape)
         self.forc = self.f_contiguous or self.c_contiguous
 
+    @override
     def __repr__(self):
         return (
                 f"  C_CONTIGUOUS : {self.c_contiguous}\n"
                 f"  F_CONTIGUOUS : {self.f_contiguous}"
                 )
 
+    @override
     def __str__(self):
         return repr(self)
 
@@ -177,7 +204,7 @@ except Exception:
         # currently (2014/May/17) on pypy.
 
         if ((shape is None or x.shape == shape)
-                and (strides is None or x.strides == strides)):  # noqa: W503
+                and (strides is None or x.strides == strides)):
             return x
         if not x.dtype.isbuiltin:
             if shape is None:

pyopencl/compyte/dtypes.py

@@ -26,7 +26,11 @@ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
 """
 
+from collections.abc import Sequence
+from typing import Any, Callable, TypeVar
+
 import numpy as np
+from numpy.typing import DTypeLike
 
 
 class TypeNameNotKnown(RuntimeError):  # noqa: N818
@@ -36,11 +40,16 @@ class TypeNameNotKnown(RuntimeError):  # noqa: N818
 # {{{ registry
 
 class DTypeRegistry:
+    dtype_to_name: dict[np.dtype[Any] | str, str]
+    name_to_dtype: dict[str, np.dtype[Any]]
+
     def __init__(self):
         self.dtype_to_name = {}
         self.name_to_dtype = {}
 
-    def get_or_register_dtype(self, c_names, dtype=None):
+    def get_or_register_dtype(self,
+                c_names: str | Sequence[str],
+                dtype: DTypeLike | None = None):
         """Get or register a :class:`numpy.dtype` associated with the C type names
         in the string list *c_names*. If *dtype* is `None`, no registration is
         performed, and the :class:`numpy.dtype` must already have been registered.
@@ -84,8 +93,8 @@ class DTypeRegistry:
                 self.name_to_dtype[nm] = dtype
             else:
                 if name_dtype != dtype:
-                    raise RuntimeError("name '%s' already registered to "
-                            "different dtype" % nm)
+                    raise RuntimeError(
+                        f"name '{nm}' already registered to different dtype")
 
         if not existed:
             self.dtype_to_name[dtype] = c_names[0]
@@ -94,8 +103,8 @@ class DTypeRegistry:
 
         return dtype
 
-    def dtype_to_ctype(self, dtype):
-        if dtype is None:
+    def dtype_to_ctype(self, dtype: np.dtype[Any]) -> str:
+        if dtype is None:  # pyright: ignore[reportUnnecessaryComparison]
             raise ValueError("dtype may not be None")
 
         dtype = np.dtype(dtype)
@@ -103,14 +112,18 @@ class DTypeRegistry:
         try:
             return self.dtype_to_name[dtype]
         except KeyError:
-            raise ValueError("unable to map dtype '%s'" % dtype) from None
+            raise ValueError(f"unable to map dtype '{dtype}'") from None
 
 # }}}
 
 
 # {{{ C types
 
-def fill_registry_with_c_types(reg, respect_windows, include_bool=True):
+def fill_registry_with_c_types(
+            reg: DTypeRegistry,
+            respect_windows: bool,
+            include_bool: bool = True
+        ) -> None:
     import struct
     from sys import platform
 
@@ -135,18 +148,21 @@ def fill_registry_with_c_types(reg, respect_windows, include_bool=True):
         else:
             i64_name = "long"
 
-        reg.get_or_register_dtype(
-                [i64_name, "%s int" % i64_name, "signed %s int" % i64_name,
-                    "%s signed int" % i64_name],
+        reg.get_or_register_dtype([
+                i64_name,
+                f"{i64_name} int",
+                f"signed {i64_name} int",
+                f"{i64_name} signed int"],
                 np.int64)
-        reg.get_or_register_dtype(
-                ["unsigned %s" % i64_name, "unsigned %s int" % i64_name,
-                    "%s unsigned int" % i64_name],
+        reg.get_or_register_dtype([
+                f"unsigned {i64_name}",
+                f"unsigned {i64_name} int",
+                f"{i64_name} unsigned int"],
                 np.uint64)
 
-    # http://projects.scipy.org/numpy/ticket/2017
+    # https://github.com/numpy/numpy/issues/2610
     if is_64_bit:
-        reg.get_or_register_dtype(["unsigned %s" % i64_name], np.uintp)
+        reg.get_or_register_dtype([f"unsigned {i64_name}"], np.uintp)
     else:
         reg.get_or_register_dtype(["unsigned"], np.uintp)
 
@@ -154,7 +170,7 @@ def fill_registry_with_c_types(reg, respect_windows, include_bool=True):
     reg.get_or_register_dtype("double", np.float64)
 
 
-def fill_registry_with_opencl_c_types(reg):
+def fill_registry_with_opencl_c_types(reg: DTypeRegistry) -> None:
     reg.get_or_register_dtype(["char", "signed char"], np.int8)
     reg.get_or_register_dtype(["uchar", "unsigned char"], np.uint8)
     reg.get_or_register_dtype(["short", "signed short",
@@ -180,7 +196,7 @@ def fill_registry_with_opencl_c_types(reg):
     reg.get_or_register_dtype("double", np.float64)
 
 
-def fill_registry_with_c99_stdint_types(reg):
+def fill_registry_with_c99_stdint_types(reg: DTypeRegistry) -> None:
     reg.get_or_register_dtype("bool", np.bool_)
 
     reg.get_or_register_dtype("int8_t", np.int8)
@@ -197,7 +213,7 @@ def fill_registry_with_c99_stdint_types(reg):
     reg.get_or_register_dtype("double", np.float64)
 
 
-def fill_registry_with_c99_complex_types(reg):
+def fill_registry_with_c99_complex_types(reg: DTypeRegistry) -> None:
     reg.get_or_register_dtype("float complex", np.complex64)
     reg.get_or_register_dtype("double complex", np.complex128)
     reg.get_or_register_dtype("long double complex", np.clongdouble)
@@ -226,12 +242,21 @@ def _fill_dtype_registry(respect_windows, include_bool=True):
 
 # {{{ c declarator parsing
 
-def parse_c_arg_backend(c_arg, scalar_arg_factory, vec_arg_factory,
-        name_to_dtype=None):
+ArgTypeT = TypeVar("ArgTypeT")
+
+
+def parse_c_arg_backend(
+            c_arg: str,
+            scalar_arg_factory: Callable[[np.dtype[Any], str], ArgTypeT],
+            vec_arg_factory: Callable[[np.dtype[Any], str], ArgTypeT],
+            name_to_dtype: Callable[[str], np.dtype[Any]] | DTypeRegistry | None = None,
+        ):
     if isinstance(name_to_dtype, DTypeRegistry):
-        name_to_dtype = name_to_dtype.name_to_dtype__getitem__
+        name_to_dtype_clbl = name_to_dtype.name_to_dtype.__getitem__
     elif name_to_dtype is None:
-        name_to_dtype = NAME_TO_DTYPE.__getitem__
+        name_to_dtype_clbl = NAME_TO_DTYPE.__getitem__
+    else:
+        name_to_dtype_clbl = name_to_dtype
 
     c_arg = (c_arg
             .replace("const", "")
@@ -245,7 +270,7 @@ def parse_c_arg_backend(c_arg, scalar_arg_factory, vec_arg_factory,
     decl_match = decl_re.search(c_arg)
 
     if decl_match is None:
-        raise ValueError("couldn't parse C declarator '%s'" % c_arg)
+        raise ValueError(f"couldn't parse C declarator '{c_arg}'")
 
     name = decl_match.group(2)
 
@@ -258,16 +283,20 @@ def parse_c_arg_backend(c_arg, scalar_arg_factory, vec_arg_factory,
     tp = " ".join(tp.split())
 
     try:
-        dtype = name_to_dtype(tp)
+        dtype = name_to_dtype_clbl(tp)
     except KeyError:
-        raise ValueError("unknown type '%s'" % tp) from None
+        raise ValueError(f"unknown type '{tp}'") from None
 
     return arg_class(dtype, name)
 
 # }}}
 
 
-def register_dtype(dtype, c_names, alias_ok=False):
+def register_dtype(
+            dtype: DTypeLike,
+            c_names: Sequence[str] | str,
+            alias_ok: bool = False
+        ) -> None:
     from warnings import warn
     warn("register_dtype is deprecated. Use get_or_register_dtype instead.",
             DeprecationWarning, stacklevel=2)
@@ -280,9 +309,12 @@ def register_dtype(dtype, c_names, alias_ok=False):
     # check if we've seen this dtype before and error out if a) it was seen before
     # and b) alias_ok is False.
 
-    if not alias_ok and dtype in TYPE_REGISTRY.dtype_to_name:
-        raise RuntimeError("dtype '%s' already registered (as '%s', new names '%s')"
-                % (dtype, TYPE_REGISTRY.dtype_to_name[dtype], ", ".join(c_names)))
+    name = TYPE_REGISTRY.dtype_to_name.get(dtype)
+    if not alias_ok and name is not None:
+        c_names_join = "', '".join(c_names)
+        raise RuntimeError(
+                f"dtype '{dtype}' already registered "
+                f"(as '{name}', new names '{c_names_join}')")
 
     TYPE_REGISTRY.get_or_register_dtype(c_names, dtype)
 

pyopencl/compyte/pyproject.toml

@@ -7,36 +7,20 @@ extend-select = [
     "C",   # flake8-comprehensions
     "E",   # pycodestyle
     "F",   # pyflakes
-
     "I",   # flake8-isort
-
     "N",   # pep8-naming
     "NPY", # numpy
     "Q",   # flake8-quotes
+    "RUF", # ruff
+    "UP",  # pyupgrade
     "W",   # pycodestyle
-
-    # TODO
-    # "UP",  # pyupgrade
-    # "RUF", # ruff
 ]
 extend-ignore = [
     "C90",  # McCabe complexity
-    "E221", # multiple spaces before operator
-    "E241", # multiple spaces after comma
     "E402", # module level import not at the top of file
     "E226", # missing whitespace around operator
-    "N817", # CamelCase `SubstitutionRuleMappingContext` imported as acronym `SRMC`
-
-    # FIXME
-    "NPY002", # numpy rng
-    "C408", # unnecssary dict() -> literal
-    "E265", # block comment should start with
-    "F841", # local variable unused
 ]
 
-[tool.ruff.lint.per-file-ignores]
-"ndarray/**/*.py" = ["Q", "B", "E", "F", "N", "C4"]
-
 [tool.ruff.lint.flake8-quotes]
 docstring-quotes = "double"
 inline-quotes = "double"
@@ -46,9 +30,20 @@ multiline-quotes = "double"
 combine-as-imports = true
 known-first-party = [
     "pytools",
-    "pymbolic",
-]
-known-local-folder = [
-    "modepy",
 ]
 lines-after-imports = 2
+
+
+[tool.basedpyright]
+reportImplicitStringConcatenation = "none"
+reportUnnecessaryIsInstance = "none"
+reportUnusedCallResult = "none"
+reportExplicitAny = "none"
+reportUnreachable = "hint"
+
+# This reports even cycles that are qualified by 'if TYPE_CHECKING'. Not what
+# we care about at this moment.
+# https://github.com/microsoft/pyright/issues/746
+reportImportCycles = "none"
+pythonVersion = "3.10"
+pythonPlatform = "All"

pyopencl/elementwise.py

@@ -1,4 +1,5 @@
 """Elementwise functionality."""
+from __future__ import annotations
 
 
 __copyright__ = "Copyright (C) 2009 Andreas Kloeckner"
@@ -28,7 +29,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 
 import enum
-from typing import Any, List, Optional, Tuple, Union
+from typing import Any
 
 import numpy as np
 
@@ -50,7 +51,7 @@ from pyopencl.tools import (
 
 def get_elwise_program(
         context: cl.Context,
-        arguments: List[DtypedArgument],
+        arguments: list[DtypedArgument],
         operation: str, *,
         name: str = "elwise_kernel",
         options: Any = None,
@@ -118,13 +119,13 @@ def get_elwise_program(
 
 def get_elwise_kernel_and_types(
         context: cl.Context,
-        arguments: Union[str, List[DtypedArgument]],
+        arguments: str | list[DtypedArgument],
         operation: str, *,
         name: str = "elwise_kernel",
         options: Any = None,
         preamble: str = "",
         use_range: bool = False,
-        **kwargs: Any) -> Tuple[cl.Kernel, List[DtypedArgument]]:
+        **kwargs: Any) -> tuple[cl.Kernel, list[DtypedArgument]]:
 
     from pyopencl.tools import get_arg_offset_adjuster_code, parse_arg_list
     parsed_args = parse_arg_list(arguments, with_offset=True)
@@ -181,7 +182,7 @@ def get_elwise_kernel_and_types(
 
 def get_elwise_kernel(
         context: cl.Context,
-        arguments: Union[str, List[DtypedArgument]],
+        arguments: str | list[DtypedArgument],
         operation: str, *,
         name: str = "elwise_kernel",
         options: Any = None, **kwargs: Any) -> cl.Kernel:
@@ -228,7 +229,7 @@ class ElementwiseKernel:
     def __init__(
             self,
             context: cl.Context,
-            arguments: Union[str, List[DtypedArgument]],
+            arguments: str | list[DtypedArgument],
             operation: str,
             name: str = "elwise_kernel",
             options: Any = None, **kwargs: Any) -> None:
@@ -294,7 +295,9 @@ class ElementwiseKernel:
 
         repr_vec = None
         invocation_args = []
-        for arg, arg_descr in zip(args, arg_descrs):
+
+        # non-strict because length arg gets appended below
+        for arg, arg_descr in zip(args, arg_descrs, strict=False):
             if isinstance(arg_descr, VectorArg):
                 if repr_vec is None:
                     repr_vec = arg
@@ -358,11 +361,11 @@ class ElementwiseKernel:
 class ElementwiseTemplate(KernelTemplateBase):
     def __init__(
             self,
-            arguments: Union[str, List[DtypedArgument]],
+            arguments: str | list[DtypedArgument],
             operation: str,
             name: str = "elwise",
             preamble: str = "",
-            template_processor: Optional[str] = None) -> None:
+            template_processor: str | None = None) -> None:
         super().__init__(template_processor=template_processor)
         self.arguments = arguments
         self.operation = operation
@@ -411,7 +414,7 @@ def get_argument_kind(v: Any) -> ArgumentKind:
         return ArgumentKind.SCALAR
 
 
-def get_decl_and_access_for_kind(name: str, kind: ArgumentKind) -> Tuple[str, str]:
+def get_decl_and_access_for_kind(name: str, kind: ArgumentKind) -> tuple[str, str]:
     if kind == ArgumentKind.ARRAY:
         return f"*{name}", f"{name}[i]"
     elif kind == ArgumentKind.SCALAR:

pyopencl/invoker.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 __copyright__ = """
 Copyright (C) 2017 Andreas Kloeckner
 """
@@ -22,7 +25,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 """
 
-from typing import Any, Tuple
+from typing import Any
 from warnings import warn
 
 import numpy as np
@@ -306,7 +309,7 @@ def _generate_enqueue_and_set_args_module(function_name,
 
     return (
             gen.get_picklable_module(
-                name=f"<pyopencl invoker for '{function_name}'>"),
+                name_prefix=f"pyopencl invoker for '{function_name}'"),
             enqueue_name)
 
 
@@ -319,7 +322,7 @@ def _get_max_parameter_size(dev):
     dev_limit = dev.max_parameter_size
     pocl_version = get_pocl_version(dev.platform, fallback_value=(1, 8))
     if pocl_version is not None and pocl_version < (3, 0):
-        # Current PoCL versions (as of 04/2022) have an incorrect parameter
+        # Older PoCL versions (<3.0) have an incorrect parameter
         # size limit of 1024; see e.g. https://github.com/pocl/pocl/pull/1046
         if dev_limit == 1024:
             if dev.type & cl.device_type.CPU:
@@ -336,17 +339,20 @@ def _check_arg_size(function_name, num_cl_args, arg_types, devs):
     """Check whether argument sizes exceed the OpenCL device limit."""
 
     for dev in devs:
+        from pyopencl.characterize import nv_compute_capability
+        if nv_compute_capability(dev) is None:
+            # Only warn on Nvidia GPUs, because actual failures related to
+            # the device limit have been observed only on such devices.
+            continue
+
         dev_ptr_size = int(dev.address_bits / 8)
         dev_limit = _get_max_parameter_size(dev)
 
         total_arg_size = 0
 
-        is_estimate = False
-
         if arg_types:
             for arg_type in arg_types:
                 if arg_type is None:
-                    is_estimate = True
                     total_arg_size += dev_ptr_size
                 elif isinstance(arg_type, VectorArg):
                     total_arg_size += dev_ptr_size
@@ -354,7 +360,6 @@ def _check_arg_size(function_name, num_cl_args, arg_types, devs):
                     total_arg_size += np.dtype(arg_type).itemsize
         else:
             # Estimate that each argument has the size of a pointer on average
-            is_estimate = True
             total_arg_size = dev_ptr_size * num_cl_args
 
         if total_arg_size > dev_limit:
@@ -364,22 +369,13 @@ def _check_arg_size(function_name, num_cl_args, arg_types, devs):
                 f"the limit of {dev_limit} bytes on {dev}. This might "
                 "lead to compilation errors, especially on GPU devices.",
                 stacklevel=3)
-        elif is_estimate and total_arg_size >= dev_limit * 0.75:
-            # Since total_arg_size is just an estimate, also warn in case we are
-            # just below the actual limit.
-            from warnings import warn
-            warn(f"Kernel '{function_name}' has {num_cl_args} arguments with "
-                f"a total size of {total_arg_size} bytes, which approaches "
-                f"the limit of {dev_limit} bytes on {dev}. This might "
-                "lead to compilation errors, especially on GPU devices.",
-                stacklevel=3)
 
 # }}}
 
 
 if not cl._PYOPENCL_NO_CACHE:
     from pytools.py_codegen import PicklableModule
-    invoker_cache: WriteOncePersistentDict[Any, Tuple[PicklableModule, str]] \
+    invoker_cache: WriteOncePersistentDict[Any, tuple[PicklableModule, str]] \
         = WriteOncePersistentDict(
             "pyopencl-invoker-cache-v42-nano",
             key_builder=_NumpyTypesKeyBuilder(),

pyopencl/ipython_ext.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from IPython.core.magic import Magics, cell_magic, line_magic, magics_class
 
 import pyopencl as cl