pyopencl 2025.2.5__cp311-cp311-win_amd64.whl → 2025.2.7__cp311-cp311-win_amd64.whl

pyopencl/cache.py

@@ -505,7 +505,7 @@ def create_built_program_from_source_cached(ctx, src, options_bytes, devices=Non
     except Exception as e:
         from pyopencl import Error
         build_program_failure = (isinstance(e, Error)
-                and e.code == _cl.status_code.BUILD_PROGRAM_FAILURE)  # pylint:disable=no-member
+                and e.code == _cl.status_code.BUILD_PROGRAM_FAILURE)
 
         # Mac error on intel CPU driver: can't build from cached version.
         # If we get a build_program_failure from the cached version then

pyopencl/characterize/__init__.py

@@ -24,8 +24,6 @@ THE SOFTWARE.
 """
 
 
-from typing import cast
-
 from pytools import memoize
 
 import pyopencl as cl
@@ -70,9 +68,9 @@ def reasonable_work_group_size_multiple(
         }
         """)
     prg.build()
-    return cast("int", prg.knl.get_work_group_info(
+    return prg.knl.get_work_group_info(
             cl.kernel_work_group_info.PREFERRED_WORK_GROUP_SIZE_MULTIPLE,
-            dev))
+            dev)
 
 
 def nv_compute_capability(dev: cl.Device):

pyopencl/clmath.py

@@ -1,4 +1,3 @@
-# pylint:disable=unexpected-keyword-arg  # for @elwise_kernel_runner
 from __future__ import annotations
 
 

pyopencl/cltypes.py

@@ -22,13 +22,17 @@ THE SOFTWARE.
 """
 
 import warnings
-from typing import Any
+from typing import TYPE_CHECKING, Any, cast
 
 import numpy as np
 
 from pyopencl.tools import get_or_register_dtype
 
 
+if TYPE_CHECKING:
+    import builtins
+    from collections.abc import MutableSequence
+
 if __file__.endswith("array.py"):
     warnings.warn(
         "pyopencl.array.vec is deprecated. Please use pyopencl.cltypes.",
@@ -53,16 +57,19 @@ double = np.float64
 
 # {{{ vector types
 
-def _create_vector_types():
+def _create_vector_types() -> tuple[
+        dict[tuple[np.dtype[Any], builtins.int], np.dtype[Any]],
+        dict[np.dtype[Any], tuple[np.dtype[Any], builtins.int]]]:
     mapping = [(k, globals()[k]) for k in
                 ["char", "uchar", "short", "ushort", "int",
                  "uint", "long", "ulong", "float", "double"]]
 
-    def set_global(key, val):
+    def set_global(key: str, val: np.dtype[Any]) -> None:
         globals()[key] = val
 
-    vec_types = {}
-    vec_type_to_scalar_and_count = {}
+    vec_types: dict[tuple[np.dtype[Any], builtins.int], np.dtype[Any]] = {}
+    vec_type_to_scalar_and_count: dict[np.dtype[Any],
+                                       tuple[np.dtype[Any], builtins.int]] = {}
 
     field_names = ["x", "y", "z", "w"]
 
@@ -70,20 +77,21 @@ def _create_vector_types():
 
     for base_name, base_type in mapping:
         for count in counts:
-            name = "%s%d" % (base_name, count)
-
-            titles = field_names[:count]
+            name = f"{base_name}{count}"
+            titles = cast("MutableSequence[str | None]", field_names[:count])
 
             padded_count = count
             if count == 3:
                 padded_count = 4
 
-            names = ["s%d" % i for i in range(count)]
+            names = [f"s{i}" for i in range(count)]
             while len(names) < padded_count:
-                names.append("padding%d" % (len(names) - count))
+                pad = len(names) - count
+                names.append(f"padding{pad}")
 
             if len(titles) < len(names):
-                titles.extend((len(names) - len(titles)) * [None])
+                pad = len(names) - len(titles)
+                titles.extend([None] * pad)
 
             try:
                 dtype = np.dtype({
@@ -96,14 +104,16 @@ def _create_vector_types():
                                       for (n, title)
                                       in zip(names, titles, strict=True)])
                 except TypeError:
-                    dtype = np.dtype([(n, base_type) for (n, title)
-                                      in zip(names, titles, strict=True)])
+                    dtype = np.dtype([(n, base_type) for n in names])
 
+            assert isinstance(dtype, np.dtype)
             get_or_register_dtype(name, dtype)
-
             set_global(name, dtype)
 
-            def create_array(dtype, count, padded_count, *args, **kwargs):
+            def create_array(dtype: np.dtype[Any],
+                             count: int,
+                             padded_count: int,
+                             *args: Any, **kwargs: Any) -> dict[str, Any]:
                 if len(args) < count:
                     from warnings import warn
                     warn("default values for make_xxx are deprecated;"
@@ -116,21 +126,26 @@ def _create_vector_types():
                              {"array": np.array,
                               "padded_args": padded_args,
                               "dtype": dtype})
-                for key, val in list(kwargs.items()):
+
+                for key, val in kwargs.items():
                     array[key] = val
+
                 return array
 
-            set_global("make_" + name, eval(
-                "lambda *args, **kwargs: create_array(dtype, %i, %i, "
-                "*args, **kwargs)" % (count, padded_count),
-                {"create_array": create_array, "dtype": dtype}))
-            set_global("filled_" + name, eval(
-                "lambda val: make_%s(*[val]*%i)" % (name, count)))
-            set_global("zeros_" + name, eval("lambda: filled_%s(0)" % (name)))
-            set_global("ones_" + name, eval("lambda: filled_%s(1)" % (name)))
-
-            vec_types[np.dtype(base_type), count] = dtype
-            vec_type_to_scalar_and_count[dtype] = np.dtype(base_type), count
+            set_global(
+                f"make_{name}",
+                eval("lambda *args, **kwargs: "
+                     f"create_array(dtype, {count}, {padded_count}, *args, **kwargs)",
+                     {"create_array": create_array, "dtype": dtype}))
+            set_global(
+                f"filled_{name}",
+                eval(f"lambda val: make_{name}(*[val]*{count})"))
+            set_global(f"zeros_{name}", eval(f"lambda: filled_{name}(0)"))
+            set_global(f"ones_{name}", eval(f"lambda: filled_{name}(1)"))
+
+            base_dtype = np.dtype(base_type)
+            vec_types[base_dtype, count] = dtype
+            vec_type_to_scalar_and_count[dtype] = base_dtype, count
 
     return vec_types, vec_type_to_scalar_and_count
 

pyopencl/compyte/array.py

@@ -63,7 +63,7 @@ def equal_strides(
     if len(strides1) != len(strides2) or len(strides2) != len(shape):
         return False
 
-    for s, st1, st2 in zip(shape, strides1, strides2):
+    for s, st1, st2 in zip(shape, strides1, strides2, strict=True):
         if s != 1 and st1 != st2:
             return False
 
@@ -98,30 +98,27 @@ class ArrayIsh(Protocol):
 
 
 class ArrayFlags:
-    f_contiguous: bool
-    c_contiguous: bool
-    forc: bool
-
-    def __init__(self, ary: ArrayIsh):
-        self.f_contiguous = is_f_contiguous_strides(
+    def __init__(self, ary: ArrayIsh) -> None:
+        self.f_contiguous: bool = is_f_contiguous_strides(
             ary.strides, ary.dtype.itemsize, ary.shape)
-        self.c_contiguous = is_c_contiguous_strides(
+        self.c_contiguous: bool = is_c_contiguous_strides(
             ary.strides, ary.dtype.itemsize, ary.shape)
-        self.forc = self.f_contiguous or self.c_contiguous
+        self.forc: bool = self.f_contiguous or self.c_contiguous
 
     @override
-    def __repr__(self):
+    def __repr__(self) -> str:
         return (
                 f"  C_CONTIGUOUS : {self.c_contiguous}\n"
                 f"  F_CONTIGUOUS : {self.f_contiguous}"
                 )
 
     @override
-    def __str__(self):
+    def __str__(self) -> str:
         return repr(self)
 
 
-def get_common_dtype(obj1, obj2, allow_double):
+def get_common_dtype(obj1: ArrayIsh, obj2: ArrayIsh,
+                     allow_double: bool) -> np.dtype[Any]:
     # Yes, numpy behaves differently depending on whether
     # we're dealing with arrays or scalars.
 
@@ -143,33 +140,6 @@ def get_common_dtype(obj1, obj2, allow_double):
     return result
 
 
-def bound(a):
-    high = a.bytes
-    low = a.bytes
-
-    for stri, shp in zip(a.strides, a.shape):
-        if stri < 0:
-            low += (stri)*(shp-1)
-        else:
-            high += (stri)*(shp-1)
-    return low, high
-
-
-def may_share_memory(a, b):
-    # When this is called with a an ndarray and b
-    # a sparse matrix, numpy.may_share_memory fails.
-    if a is b:
-        return True
-    if a.__class__ is b.__class__:
-        a_l, a_h = bound(a)
-        b_l, b_h = bound(b)
-        if b_l >= a_h or a_l >= b_h:
-            return False
-        return True
-    else:
-        return False
-
-
 # {{{ as_strided implementation
 
 try:

pyopencl/compyte/dtypes.py

@@ -26,8 +26,8 @@ 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
+from collections.abc import Callable, Sequence
+from typing import Any, TypeVar
 
 import numpy as np
 from numpy.typing import DTypeLike
@@ -40,14 +40,12 @@ 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) -> None:
+        self.dtype_to_name: dict[np.dtype[Any] | str, str] = {}
+        self.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,
+    def get_or_register_dtype(
+                self,
                 names: str | Sequence[str],
                 dtype: DTypeLike | None = None) -> np.dtype[Any]:
         """Get or register a :class:`numpy.dtype` associated with the C type names
@@ -227,7 +225,7 @@ dtype_to_ctype = TYPE_REGISTRY.dtype_to_ctype
 get_or_register_dtype = TYPE_REGISTRY.get_or_register_dtype
 
 
-def _fill_dtype_registry(respect_windows, include_bool=True):
+def _fill_dtype_registry(respect_windows: bool, include_bool: bool = True) -> None:
     fill_registry_with_c_types(
             TYPE_REGISTRY, respect_windows, include_bool)
 
@@ -244,7 +242,7 @@ def parse_c_arg_backend(
             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,
-        ):
+        ) -> ArgTypeT:
     if isinstance(name_to_dtype, DTypeRegistry):
         name_to_dtype_clbl = name_to_dtype.name_to_dtype.__getitem__
     elif name_to_dtype is None:

pyopencl/compyte/pyproject.toml

@@ -40,9 +40,6 @@ reportUnnecessaryIsInstance = "none"
 reportUnusedCallResult = "none"
 reportExplicitAny = "none"
 reportUnreachable = "hint"
-# array.py looks like stdlib array, but pyright doesn't know this
-# won't ever be a top-level anything.
-reportShadowedImports = "none"
 
 # This reports even cycles that are qualified by 'if TYPE_CHECKING'. Not what
 # we care about at this moment.