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

pyopencl/bitonic_sort.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 __copyright__ = """
 Copyright (c) 2011, Eric Bainville
 Copyright (c) 2015, Ilya Efimoff
@@ -35,7 +38,7 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 from functools import reduce
 from operator import mul
-from typing import ClassVar, Dict
+from typing import ClassVar
 
 from mako.template import Template
 
@@ -64,7 +67,7 @@ class BitonicSort:
     .. automethod:: __call__
     """
 
-    kernels_srcs: ClassVar[Dict[str, str]] = {
+    kernels_srcs: ClassVar[dict[str, str]] = {
             "B2": _tmpl.ParallelBitonic_B2,
             "B4": _tmpl.ParallelBitonic_B4,
             "B8": _tmpl.ParallelBitonic_B8,

pyopencl/bitonic_sort_templates.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 __copyright__ = """
 Copyright (c) 2011, Eric Bainville
 Copyright (c) 2015, Ilya Efimoff

pyopencl/cache.py

@@ -1,4 +1,5 @@
 """PyOpenCL compiler cache."""
+from __future__ import annotations
 
 
 __copyright__ = "Copyright (C) 2011 Andreas Kloeckner"
@@ -28,7 +29,6 @@ import os
 import re
 import sys
 from dataclasses import dataclass
-from typing import List, Optional, Tuple
 
 import pyopencl._cl as _cl
 
@@ -339,8 +339,8 @@ def retrieve_from_cache(cache_dir, cache_key):
 
 @dataclass(frozen=True)
 class _SourceInfo:
-    dependencies: List[Tuple[str, ...]]
-    log: Optional[str]
+    dependencies: list[tuple[str, ...]]
+    log: str | None
 
 
 def _create_built_program_from_source_cached(ctx, src, options_bytes,
@@ -373,7 +373,7 @@ def _create_built_program_from_source_cached(ctx, src, options_bytes,
     binaries = []
     to_be_built_indices = []
     logs = []
-    for i, (_device, cache_key) in enumerate(zip(devices, cache_keys)):
+    for i, (_device, cache_key) in enumerate(zip(devices, cache_keys, strict=True)):
         cache_result = retrieve_from_cache(cache_dir, cache_key)
 
         if cache_result is None:
@@ -391,7 +391,7 @@ def _create_built_program_from_source_cached(ctx, src, options_bytes,
 
     message = (75*"="+"\n").join(
             f"Build on {dev} succeeded, but said:\n\n{log}"
-            for dev, log in zip(devices, logs)
+            for dev, log in zip(devices, logs, strict=True)
             if log is not None and log.strip())
 
     if message:

pyopencl/capture_call.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 __copyright__ = "Copyright (C) 2013 Andreas Kloeckner"
 
 __license__ = """
@@ -21,6 +24,8 @@ THE SOFTWARE.
 """
 
 
+from typing import TYPE_CHECKING, TextIO, cast
+
 import numpy as np
 
 from pytools.py_codegen import Indentation, PythonCodeGenerator
@@ -28,9 +33,26 @@ from pytools.py_codegen import Indentation, PythonCodeGenerator
 import pyopencl as cl
 
 
-def capture_kernel_call(kernel, output_file, queue, g_size, l_size, *args, **kwargs):
+if TYPE_CHECKING:
+    from numpy.typing import DTypeLike
+
+    from pyopencl.typing import KernelArg, WaitList
+
+
+def capture_kernel_call(
+            kernel: cl.Kernel,
+            output_file: str | TextIO,
+            queue: cl.CommandQueue,
+            g_size: tuple[int, ...],
+            l_size: tuple[int, ...] | None,
+            *args: KernelArg,
+            wait_for: WaitList = None,  # pyright: ignore[reportUnusedParameter]
+            g_times_l: bool = False,
+            allow_empty_ndrange: bool = False,
+            global_offset: tuple[int, ...] | None = None,
+        ) -> None:
     try:
-        source = kernel._source
+        source = cast("str | None", kernel._source)  # pyright: ignore[reportAttributeAccessIssue]
     except AttributeError as err:
         raise RuntimeError("cannot capture call, kernel source not available") from err
 
@@ -55,7 +77,7 @@ def capture_kernel_call(kernel, output_file, queue, g_size, l_size, *args, **kwa
 
     # {{{ invocation
 
-    arg_data = []
+    arg_data: list[tuple[str, memoryview | bytearray]] = []
 
     cg("")
     cg("")
@@ -65,7 +87,7 @@ def capture_kernel_call(kernel, output_file, queue, g_size, l_size, *args, **kwa
         cg("queue = cl.CommandQueue(ctx)")
         cg("")
 
-        kernel_args = []
+        kernel_args: list[str] = []
 
         for i, arg in enumerate(args):
             if isinstance(arg, cl.Buffer):
@@ -101,22 +123,23 @@ def capture_kernel_call(kernel, output_file, queue, g_size, l_size, *args, **kwa
 
         cg("")
 
-        g_times_l = kwargs.get("g_times_l", False)
         if g_times_l:
+            assert l_size is not None
             dim = max(len(g_size), len(l_size))
             l_size = l_size + (1,) * (dim-len(l_size))
             g_size = g_size + (1,) * (dim-len(g_size))
             g_size = tuple(
-                    gs*ls for gs, ls in zip(g_size, l_size))
+                    gs*ls for gs, ls in zip(g_size, l_size, strict=True))
 
-        global_offset = kwargs.get("global_offset", None)
         if global_offset is not None:
             kernel_args.append("global_offset=%s" % repr(global_offset))
+        if allow_empty_ndrange:
+            kernel_args.append("allow_empty_ndrange=%s" % repr(allow_empty_ndrange))
 
         cg("prg = cl.Program(ctx, CODE).build()")
         cg("knl = prg.%s" % kernel.function_name)
         if hasattr(kernel, "_scalar_arg_dtypes"):
-            def strify_dtype(d):
+            def strify_dtype(d: DTypeLike):
                 if d is None:
                     return "None"
 

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
 
@@ -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