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

pyopencl/characterize/__init__.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 __copyright__ = "Copyright (C) 2009 Andreas Kloeckner"
 
 __license__ = """
@@ -20,7 +23,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 """
 
-from typing import Dict, Optional, Tuple
+
+from typing import cast
 
 from pytools import memoize
 
@@ -32,14 +36,14 @@ class CLCharacterizationWarning(UserWarning):
 
 
 @memoize
-def has_double_support(dev):
+def has_double_support(dev: cl.Device):
     for ext in dev.extensions.split(" "):
         if ext == "cl_khr_fp64":
             return True
     return False
 
 
-def has_amd_double_support(dev):
+def has_amd_double_support(dev: cl.Device):
     """"Fix to allow incomplete amd double support in low end boards"""
 
     for ext in dev.extensions.split(" "):
@@ -48,7 +52,10 @@ def has_amd_double_support(dev):
     return False
 
 
-def reasonable_work_group_size_multiple(dev, ctx=None):
+def reasonable_work_group_size_multiple(
+            dev: cl.Device,
+            ctx: cl.Context | None = None
+        ):
     try:
         return dev.warp_size_nv
     except Exception:
@@ -63,12 +70,12 @@ def reasonable_work_group_size_multiple(dev, ctx=None):
         }
         """)
     prg.build()
-    return prg.knl.get_work_group_info(
+    return cast("int", prg.knl.get_work_group_info(
             cl.kernel_work_group_info.PREFERRED_WORK_GROUP_SIZE_MULTIPLE,
-            dev)
+            dev))
 
 
-def nv_compute_capability(dev):
+def nv_compute_capability(dev: cl.Device):
     """If *dev* is an Nvidia GPU :class:`pyopencl.Device`, return a tuple
     *(major, minor)* indicating the device's compute capability.
     """
@@ -80,7 +87,7 @@ def nv_compute_capability(dev):
         return None
 
 
-def usable_local_mem_size(dev, nargs=None):
+def usable_local_mem_size(dev: cl.Device, nargs: int | None = None):
     """Return an estimate of the usable local memory size.
     :arg nargs: Number of 32-bit arguments passed.
     """
@@ -101,7 +108,7 @@ def usable_local_mem_size(dev, nargs=None):
     return usable_local_mem_size
 
 
-def simultaneous_work_items_on_local_access(dev):
+def simultaneous_work_items_on_local_access(dev: cl.Device):
     """Return the number of work items that access local
     memory simultaneously and thereby may conflict with
     each other.
@@ -136,12 +143,12 @@ def simultaneous_work_items_on_local_access(dev):
         return 16
 
 
-def local_memory_access_granularity(dev):
+def local_memory_access_granularity(dev: cl.Device):
     """Return the number of bytes per bank in local memory."""
     return 4
 
 
-def local_memory_bank_count(dev):
+def local_memory_bank_count(dev: cl.Device):
     """Return the number of banks present in local memory.
     """
     nv_compute_cap = nv_compute_capability(dev)
@@ -219,7 +226,7 @@ def why_not_local_access_conflict_free(dev, itemsize,
             idx = []
             left_over_idx = work_item_id
             for axis, (ax_size, ax_stor_size) in enumerate(
-                    zip(array_shape, array_stored_shape)):
+                    zip(array_shape, array_stored_shape, strict=True)):
 
                 if axis >= work_item_axis:
                     left_over_idx, ax_idx = divmod(left_over_idx, ax_size)
@@ -258,7 +265,7 @@ def why_not_local_access_conflict_free(dev, itemsize,
         return 1, None
 
 
-def get_fast_inaccurate_build_options(dev):
+def get_fast_inaccurate_build_options(dev: cl.Device):
     """Return a list of flags valid on device *dev* that enable fast, but
     potentially inaccurate floating point math.
     """
@@ -269,7 +276,7 @@ def get_fast_inaccurate_build_options(dev):
     return result
 
 
-def get_simd_group_size(dev, type_size):
+def get_simd_group_size(dev: cl.Device, type_size: int):
     """Return an estimate of how many work items will be executed across SIMD
     lanes. This returns the size of what Nvidia calls a warp and what AMD calls
     a wavefront.
@@ -323,8 +330,8 @@ def get_simd_group_size(dev, type_size):
 
 def get_pocl_version(
         platform: cl.Platform,
-        fallback_value: Optional[Tuple[int, int]] = None
-        ) -> Optional[Tuple[int, int]]:
+        fallback_value: tuple[int, int] | None = None
+        ) -> tuple[int, int] | None:
     if platform.name != "Portable Computing Language":
         return None
 
@@ -342,12 +349,12 @@ def get_pocl_version(
         return (int(ver_match.group(1)), int(ver_match.group(2)))
 
 
-_CHECK_FOR_POCL_ARG_COUNT_BUG_CACHE: Dict[cl.Device, bool] = {}
+_CHECK_FOR_POCL_ARG_COUNT_BUG_CACHE: dict[cl.Device, bool] = {}
 
 
 def _check_for_pocl_arg_count_bug(
         dev: cl.Device,
-        ctx: Optional[cl.Context] = None) -> bool:
+        ctx: cl.Context | None = None) -> bool:
     try:
         return _CHECK_FOR_POCL_ARG_COUNT_BUG_CACHE[dev]
     except KeyError:
@@ -437,7 +444,7 @@ def has_fine_grain_system_svm_atomics(dev):
 # }}}
 
 
-def has_src_build_cache(dev: cl.Device) -> Optional[bool]:
+def has_src_build_cache(dev: cl.Device) -> bool | None:
     """
     Return *True* if *dev* has internal support for caching builds from source,
     *False* if it doesn't, and *None* if unknown.

pyopencl/characterize/performance.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 __copyright__ = "Copyright (C) 2009 Andreas Kloeckner"
 
 __license__ = """

pyopencl/clmath.py

@@ -1,4 +1,6 @@
 # pylint:disable=unexpected-keyword-arg  # for @elwise_kernel_runner
+from __future__ import annotations
+
 
 __copyright__ = "Copyright (C) 2009 Andreas Kloeckner"
 

pyopencl/clrandom.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 __copyright__ = "Copyright (C) 2009-16 Andreas Kloeckner"
 
 __license__ = """

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
 
@@ -50,7 +54,7 @@ double = np.float64
 # {{{ vector types
 
 def _create_vector_types():
-    _mapping = [(k, globals()[k]) for k in
+    mapping = [(k, globals()[k]) for k in
                 ["char", "uchar", "short", "ushort", "int",
                  "uint", "long", "ulong", "float", "double"]]
 
@@ -64,7 +68,7 @@ def _create_vector_types():
 
     counts = [2, 3, 4, 8, 16]
 
-    for base_name, base_type in _mapping:
+    for base_name, base_type in mapping:
         for count in counts:
             name = "%s%d" % (base_name, count)
 
@@ -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