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

pyopencl/cltypes.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 __copyright__ = "Copyright (C) 2016 Jonathan Mackenzie"
 
 __license__ = """
@@ -19,6 +22,7 @@ THE SOFTWARE.
 """
 
 import warnings
+from typing import Any
 
 import numpy as np
 
@@ -89,10 +93,11 @@ def _create_vector_types():
             except NotImplementedError:
                 try:
                     dtype = np.dtype([((n, title), base_type)
-                                      for (n, title) in zip(names, titles)])
+                                      for (n, title)
+                                      in zip(names, titles, strict=True)])
                 except TypeError:
                     dtype = np.dtype([(n, base_type) for (n, title)
-                                      in zip(names, titles)])
+                                      in zip(names, titles, strict=True)])
 
             get_or_register_dtype(name, dtype)
 
@@ -134,4 +139,64 @@ vec_types, vec_type_to_scalar_and_count = _create_vector_types()
 
 # }}}
 
+char2: np.dtype[Any]
+char3: np.dtype[Any]
+char4: np.dtype[Any]
+char8: np.dtype[Any]
+char16: np.dtype[Any]
+
+uchar2: np.dtype[Any]
+uchar3: np.dtype[Any]
+uchar4: np.dtype[Any]
+uchar8: np.dtype[Any]
+uchar16: np.dtype[Any]
+
+short2: np.dtype[Any]
+short3: np.dtype[Any]
+short4: np.dtype[Any]
+short8: np.dtype[Any]
+short16: np.dtype[Any]
+
+ushort2: np.dtype[Any]
+ushort3: np.dtype[Any]
+ushort4: np.dtype[Any]
+ushort8: np.dtype[Any]
+ushort16: np.dtype[Any]
+
+int2: np.dtype[Any]
+int3: np.dtype[Any]
+int4: np.dtype[Any]
+int8: np.dtype[Any]
+int16: np.dtype[Any]
+
+uint2: np.dtype[Any]
+uint3: np.dtype[Any]
+uint4: np.dtype[Any]
+uint8: np.dtype[Any]
+uint16: np.dtype[Any]
+
+long2: np.dtype[Any]
+long3: np.dtype[Any]
+long4: np.dtype[Any]
+long8: np.dtype[Any]
+long16: np.dtype[Any]
+
+ulong2: np.dtype[Any]
+ulong3: np.dtype[Any]
+ulong4: np.dtype[Any]
+ulong8: np.dtype[Any]
+ulong16: np.dtype[Any]
+
+float2: np.dtype[Any]
+float3: np.dtype[Any]
+float4: np.dtype[Any]
+float8: np.dtype[Any]
+float16: np.dtype[Any]
+
+double2: np.dtype[Any]
+double3: np.dtype[Any]
+double4: np.dtype[Any]
+double8: np.dtype[Any]
+double16: np.dtype[Any]
+
 # vim: foldmethod=marker

pyopencl/compyte/array.py

@@ -67,13 +67,13 @@ def is_f_contiguous_strides(strides, itemsize, shape):
     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):
     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 ArrayFlags:
@@ -177,7 +177,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

@@ -84,8 +84,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]
@@ -103,7 +103,7 @@ 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
 
 # }}}
 
@@ -135,18 +135,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)
 
@@ -245,7 +248,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)
 
@@ -260,7 +263,7 @@ def parse_c_arg_backend(c_arg, scalar_arg_factory, vec_arg_factory,
     try:
         dtype = name_to_dtype(tp)
     except KeyError:
-        raise ValueError("unknown type '%s'" % tp) from None
+        raise ValueError(f"unknown type '{tp}'") from None
 
     return arg_class(dtype, name)
 
@@ -280,9 +283,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,5 @@ multiline-quotes = "double"
 combine-as-imports = true
 known-first-party = [
     "pytools",
-    "pymbolic",
-]
-known-local-folder = [
-    "modepy",
 ]
 lines-after-imports = 2

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

pyopencl/reduction.py

@@ -1,4 +1,6 @@
 """Computation of reductions on vectors."""
+from __future__ import annotations
+
 
 __copyright__ = "Copyright (C) 2010 Andreas Kloeckner"
 
@@ -29,7 +31,7 @@ None of the original source code remains.
 """
 
 from dataclasses import dataclass
-from typing import Any, List, Optional, Tuple, Union
+from typing import Any
 
 import numpy as np
 
@@ -133,7 +135,7 @@ class _ReductionInfo:
 
     program: cl.Program
     kernel: cl.Kernel
-    arg_types: List[DtypedArgument]
+    arg_types: list[DtypedArgument]
 
 
 def _get_reduction_source(
@@ -143,12 +145,12 @@ def _get_reduction_source(
         neutral: str,
         reduce_expr: str,
         map_expr: str,
-        parsed_args: List[DtypedArgument],
+        parsed_args: list[DtypedArgument],
         name: str = "reduce_kernel",
         preamble: str = "",
         arg_prep: str = "",
-        device: Optional[cl.Device] = None,
-        max_group_size: Optional[int] = None) -> Tuple[str, int]:
+        device: cl.Device | None = None,
+        max_group_size: int | None = None) -> tuple[str, int]:
 
     if device is not None:
         devices = [device]
@@ -209,13 +211,13 @@ def get_reduction_kernel(
         dtype_out: Any,
         neutral: str,
         reduce_expr: str,
-        map_expr: Optional[str] = None,
-        arguments: Optional[List[DtypedArgument]] = None,
+        map_expr: str | None = None,
+        arguments: list[DtypedArgument] | None = None,
         name: str = "reduce_kernel",
         preamble: str = "",
-        device: Optional[cl.Device] = None,
+        device: cl.Device | None = None,
         options: Any = None,
-        max_group_size: Optional[int] = None) -> _ReductionInfo:
+        max_group_size: int | None = None) -> _ReductionInfo:
     if stage not in (1, 2):
         raise ValueError(f"unknown stage index: '{stage}'")
 
@@ -308,8 +310,8 @@ class ReductionKernel:
             dtype_out: Any,
             neutral: str,
             reduce_expr: str,
-            map_expr: Optional[str] = None,
-            arguments: Optional[Union[str, List[DtypedArgument]]] = None,
+            map_expr: str | None = None,
+            arguments: str | list[DtypedArgument] | None = None,
             name: str = "reduce_kernel",
             options: Any = None,
             preamble: str = "") -> None:
@@ -418,7 +420,7 @@ class ReductionKernel:
             array_empty = empty
 
             from pyopencl.tools import VectorArg
-            for arg, arg_tp in zip(args, stage_inf.arg_types):
+            for arg, arg_tp in zip(args, stage_inf.arg_types, strict=True):
                 if isinstance(arg_tp, VectorArg):
                     array_empty = arg.__class__
                     if not arg.flags.forc:
@@ -544,12 +546,12 @@ class ReductionKernel:
 class ReductionTemplate(KernelTemplateBase):
     def __init__(
             self,
-            arguments: Union[str, List[DtypedArgument]],
+            arguments: str | list[DtypedArgument],
             neutral: str,
             reduce_expr: str,
-            map_expr: Optional[str] = None,
-            is_segment_start_expr: Optional[str] = None,
-            input_fetch_exprs: Optional[List[Tuple[str, str, int]]] = None,
+            map_expr: str | None = None,
+            is_segment_start_expr: str | None = None,
+            input_fetch_exprs: list[tuple[str, str, int]] | None = None,
             name_prefix: str = "reduce",
             preamble: str = "",
             template_processor: Any = None) -> None: