pyopencl 2025.1__cp311-cp311-win_amd64.whl → 2025.2.1__cp311-cp311-win_amd64.whl

pyopencl/scan.py

@@ -1,4 +1,5 @@
 """Scan primitive."""
+from __future__ import annotations
 
 
 __copyright__ = """
@@ -25,7 +26,7 @@ Derived from code within the Thrust project, https://github.com/NVIDIA/thrust
 import logging
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Set, Tuple, Union
+from typing import Any
 
 import numpy as np
 
@@ -33,7 +34,7 @@ from pytools.persistent_dict import WriteOncePersistentDict
 
 import pyopencl as cl
 import pyopencl._mymako as mako
-import pyopencl.array
+import pyopencl.array as cl_array
 from pyopencl._cluda import CLUDA_PREAMBLE
 from pyopencl.tools import (
     DtypedArgument,
@@ -848,7 +849,7 @@ def _make_template(s: str):
     import re
     leftovers = set()
 
-    def replace_id(match: "re.Match") -> str:
+    def replace_id(match: re.Match) -> str:
         # avoid name clashes with user code by adding 'psc_' prefix to
         # identifiers.
 
@@ -874,11 +875,11 @@ def _make_template(s: str):
 class _GeneratedScanKernelInfo:
     scan_src: str
     kernel_name: str
-    scalar_arg_dtypes: List[Optional[np.dtype]]
+    scalar_arg_dtypes: list[np.dtype | None]
     wg_size: int
     k_group_size: int
 
-    def build(self, context: cl.Context, options: Any) -> "_BuiltScanKernelInfo":
+    def build(self, context: cl.Context, options: Any) -> _BuiltScanKernelInfo:
         program = cl.Program(context, self.scan_src).build(options)
         kernel = getattr(program, self.kernel_name)
         kernel.set_scalar_arg_dtypes(self.scalar_arg_dtypes)
@@ -899,12 +900,12 @@ class _BuiltScanKernelInfo:
 class _GeneratedFinalUpdateKernelInfo:
     source: str
     kernel_name: str
-    scalar_arg_dtypes: List[Optional[np.dtype]]
+    scalar_arg_dtypes: list[np.dtype | None]
     update_wg_size: int
 
     def build(self,
               context: cl.Context,
-              options: Any) -> "_BuiltFinalUpdateKernelInfo":
+              options: Any) -> _BuiltFinalUpdateKernelInfo:
         program = cl.Program(context, self.source).build(options)
         kernel = getattr(program, self.kernel_name)
         kernel.set_scalar_arg_dtypes(self.scalar_arg_dtypes)
@@ -930,18 +931,18 @@ class GenericScanKernelBase(ABC):
             self,
             ctx: cl.Context,
             dtype: Any,
-            arguments: Union[str, List[DtypedArgument]],
+            arguments: str | list[DtypedArgument],
             input_expr: str,
             scan_expr: str,
-            neutral: Optional[str],
+            neutral: str | None,
             output_statement: str,
-            is_segment_start_expr: Optional[str] = None,
-            input_fetch_exprs: Optional[List[Tuple[str, str, int]]] = None,
+            is_segment_start_expr: str | None = None,
+            input_fetch_exprs: list[tuple[str, str, int]] | None = None,
             index_dtype: Any = None,
             name_prefix: str = "scan",
             options: Any = None,
             preamble: str = "",
-            devices: Optional[cl.Device] = None) -> None:
+            devices: cl.Device | None = None) -> None:
         """
         :arg ctx: a :class:`pyopencl.Context` within which the code
             for this scan kernel will be generated.
@@ -1142,7 +1143,7 @@ class GenericScanKernelBase(ABC):
 
 if not cl._PYOPENCL_NO_CACHE:
     generic_scan_kernel_cache: WriteOncePersistentDict[Any,
-                    Tuple[_GeneratedScanKernelInfo, _GeneratedScanKernelInfo,
+                    tuple[_GeneratedScanKernelInfo, _GeneratedScanKernelInfo,
                     _GeneratedFinalUpdateKernelInfo]] = \
         WriteOncePersistentDict(
             "pyopencl-generated-scan-kernel-cache-v1",
@@ -1329,7 +1330,7 @@ class GenericScanKernel(GenericScanKernelBase):
             VectorArg(self.dtype, "interval_sums"),
             ]
 
-        second_level_build_kwargs: Dict[str, Optional[str]] = {}
+        second_level_build_kwargs: dict[str, str | None] = {}
         if self.is_segmented:
             second_level_arguments.append(
                     VectorArg(self.index_dtype,
@@ -1401,7 +1402,7 @@ class GenericScanKernel(GenericScanKernelBase):
         for arg in self.parsed_args:
             arg_dtypes[arg.name] = arg.dtype
 
-        fetch_expr_offsets: Dict[str, Set] = {}
+        fetch_expr_offsets: dict[str, set] = {}
         for _name, arg_name, ife_offset in self.input_fetch_exprs:
             fetch_expr_offsets.setdefault(arg_name, set()).add(ife_offset)
 
@@ -1427,10 +1428,10 @@ class GenericScanKernel(GenericScanKernelBase):
     def generate_scan_kernel(
             self,
             max_wg_size: int,
-            arguments: List[DtypedArgument],
+            arguments: list[DtypedArgument],
             input_expr: str,
-            is_segment_start_expr: Optional[str],
-            input_fetch_exprs: List[Tuple[str, str, int]],
+            is_segment_start_expr: str | None,
+            input_fetch_exprs: list[tuple[str, str, int]],
             is_first_level: bool,
             store_segment_start_flags: bool,
             k_group_size: int,
@@ -1527,7 +1528,7 @@ class GenericScanKernel(GenericScanKernelBase):
             return cl.enqueue_marker(queue, wait_for=wait_for)
 
         data_args = []
-        for arg_descr, arg_val in zip(self.parsed_args, args):
+        for arg_descr, arg_val in zip(self.parsed_args, args, strict=True):
             from pyopencl.tools import VectorArg
             if isinstance(arg_descr, VectorArg):
                 data_args.append(arg_val.base_data)
@@ -1552,16 +1553,16 @@ class GenericScanKernel(GenericScanKernelBase):
 
         # {{{ allocate some buffers
 
-        interval_results = cl.array.empty(queue,
+        interval_results = cl_array.empty(queue,
                 num_intervals, dtype=self.dtype,
                 allocator=allocator)
 
-        partial_scan_buffer = cl.array.empty(
+        partial_scan_buffer = cl_array.empty(
                 queue, n, dtype=self.dtype,
                 allocator=allocator)
 
         if self.store_segment_start_flags:
-            segment_start_flags = cl.array.empty(
+            segment_start_flags = cl_array.empty(
                     queue, n, dtype=np.bool_,
                     allocator=allocator)
 
@@ -1575,7 +1576,7 @@ class GenericScanKernel(GenericScanKernelBase):
                 ]
 
         if self.is_segmented:
-            first_segment_start_in_interval = cl.array.empty(queue,
+            first_segment_start_in_interval = cl_array.empty(queue,
                     num_intervals, dtype=self.index_dtype,
                     allocator=allocator)
             scan1_args.append(first_segment_start_in_interval.data)
@@ -1755,13 +1756,13 @@ class GenericDebugScanKernel(GenericScanKernelBase):
         if n is None:
             n, = first_array.shape
 
-        scan_tmp = cl.array.empty(queue,
+        scan_tmp = cl_array.empty(queue,
                 n, dtype=self.dtype,
                 allocator=allocator)
 
         data_args = [scan_tmp.data]
         from pyopencl.tools import VectorArg
-        for arg_descr, arg_val in zip(self.parsed_args, args):
+        for arg_descr, arg_val in zip(self.parsed_args, args, strict=True):
             if isinstance(arg_descr, VectorArg):
                 data_args.append(arg_val.base_data)
                 if arg_descr.with_offset:
@@ -1806,7 +1807,7 @@ class _LegacyScanKernelBase(GenericScanKernel):
             output_ary = input_ary
 
         if isinstance(output_ary, (str, str)) and output_ary == "new":
-            output_ary = cl.array.empty_like(input_ary, allocator=allocator)
+            output_ary = cl_array.empty_like(input_ary, allocator=allocator)
 
         if input_ary.shape != output_ary.shape:
             raise ValueError("input and output must have the same shape")
@@ -1841,13 +1842,13 @@ class ExclusiveScanKernel(_LegacyScanKernelBase):
 class ScanTemplate(KernelTemplateBase):
     def __init__(
             self,
-            arguments: Union[str, List[DtypedArgument]],
+            arguments: str | list[DtypedArgument],
             input_expr: str,
             scan_expr: str,
-            neutral: Optional[str],
+            neutral: str | None,
             output_statement: str,
-            is_segment_start_expr: Optional[str] = None,
-            input_fetch_exprs: Optional[List[Tuple[str, str, int]]] = None,
+            is_segment_start_expr: str | None = None,
+            input_fetch_exprs: list[tuple[str, str, int]] | None = None,
             name_prefix: str = "scan",
             preamble: str = "",
             template_processor: Any = None) -> None:

pyopencl/tools.py

@@ -100,6 +100,8 @@ Type aliases
    See :class:`pyopencl.tools.AllocatorBase`.
 """
 
+from __future__ import annotations
+
 
 __copyright__ = "Copyright (C) 2010 Andreas Kloeckner"
 
@@ -126,18 +128,27 @@ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
 """
 
+
 import re
 from abc import ABC, abstractmethod
+from dataclasses import dataclass
 from sys import intern
-from typing import Any, List, Optional, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Concatenate,
+    ParamSpec,
+    TypeVar,
+)
 
 import numpy as np
+from typing_extensions import TypeIs, override
 
 from pytools import memoize, memoize_method
 from pytools.persistent_dict import KeyBuilder as KeyBuilderBase
 
-from pyopencl._cl import bitlog2, get_cl_header_version  # noqa: F401
-from pyopencl.compyte.dtypes import (  # noqa: F401
+from pyopencl._cl import bitlog2, get_cl_header_version
+from pyopencl.compyte.dtypes import (
     TypeNameNotKnown,
     dtype_to_ctype,
     get_or_register_dtype,
@@ -145,6 +156,12 @@ from pyopencl.compyte.dtypes import (  # noqa: F401
 )
 
 
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable, Sequence
+
+    from numpy.typing import DTypeLike
+
+
 # Do not add a pyopencl import here: This will add an import cycle.
 
 
@@ -460,11 +477,17 @@ if get_cl_header_version() >= (2, 0):
 
 # {{{ first-arg caches
 
-_first_arg_dependent_caches = []
+_first_arg_dependent_caches: list[dict[Hashable, object]] = []
+
+
+RetT = TypeVar("RetT")
+P = ParamSpec("P")
 
 
-def first_arg_dependent_memoize(func):
-    def wrapper(cl_object, *args, **kwargs):
+def first_arg_dependent_memoize(
+            func: Callable[Concatenate[object, P], RetT]
+        ) -> Callable[Concatenate[object, P], RetT]:
+    def wrapper(cl_object: Hashable, *args: P.args, **kwargs: P.kwargs) -> RetT:
         """Provides memoization for a function. Typically used to cache
         things that get created inside a :class:`pyopencl.Context`, e.g. programs
         and kernels. Assumes that the first argument of the decorated function is
@@ -479,12 +502,13 @@ def first_arg_dependent_memoize(func):
         else:
             cache_key = (args,)
 
+        ctx_dict: dict[Hashable, dict[Hashable, RetT]]
         try:
-            ctx_dict = func._pyopencl_first_arg_dep_memoize_dic
+            ctx_dict = func._pyopencl_first_arg_dep_memoize_dic  # pyright: ignore[reportFunctionMemberAccess]
         except AttributeError:
             # FIXME: This may keep contexts alive longer than desired.
             # But I guess since the memory in them is freed, who cares.
-            ctx_dict = func._pyopencl_first_arg_dep_memoize_dic = {}
+            ctx_dict = func._pyopencl_first_arg_dep_memoize_dic = {}  # pyright: ignore[reportFunctionMemberAccess]
             _first_arg_dependent_caches.append(ctx_dict)
 
         try:
@@ -512,8 +536,6 @@ def first_arg_dependent_memoize_nested(nested_func):
     :func:`clear_first_arg_caches`.
 
     .. versionadded:: 2013.1
-
-    Requires Python 2.5 or newer.
     """
 
     from functools import wraps
@@ -567,6 +589,10 @@ def clear_first_arg_caches():
 import atexit
 
 
+if TYPE_CHECKING:
+    import pyopencl as cl
+
+
 atexit.register(clear_first_arg_caches)
 
 # }}}
@@ -575,7 +601,9 @@ atexit.register(clear_first_arg_caches)
 # {{{ pytest fixtures
 
 class _ContextFactory:
-    def __init__(self, device):
+    device: cl.Device
+
+    def __init__(self, device: cl.Device):
         self.device = device
 
     def __call__(self):
@@ -590,14 +618,37 @@ class _ContextFactory:
         import pyopencl as cl
         return cl.Context([self.device])
 
-    def __str__(self):
+    @override
+    def __str__(self) -> str:
         # Don't show address, so that parallel test collection works
         return ("<context factory for <pyopencl.Device '%s' on '%s'>>" %
                 (self.device.name.strip(),
                  self.device.platform.name.strip()))
 
 
-def get_test_platforms_and_devices(plat_dev_string=None):
+DeviceOrPlatformT = TypeVar("DeviceOrPlatformT", "cl.Device", "cl.Platform")
+
+
+def _find_cl_obj(
+            objs: Sequence[DeviceOrPlatformT],
+            identifier: str
+        ) -> DeviceOrPlatformT:
+    try:
+        num = int(identifier)
+    except Exception:
+        pass
+    else:
+        return objs[num]
+
+    for obj in objs:
+        if identifier.lower() in (obj.name + " " + obj.vendor).lower():
+            return obj
+    raise RuntimeError("object '%s' not found" % identifier)
+
+
+def get_test_platforms_and_devices(
+            plat_dev_string: str | None = None
+        ):
     """Parse a string of the form 'PYOPENCL_TEST=0:0,1;intel:i5'.
 
     :return: list of tuples (platform, [device, device, ...])
@@ -609,29 +660,14 @@ def get_test_platforms_and_devices(plat_dev_string=None):
         import os
         plat_dev_string = os.environ.get("PYOPENCL_TEST", None)
 
-    def find_cl_obj(objs, identifier):
-        try:
-            num = int(identifier)
-        except Exception:
-            pass
-        else:
-            return objs[num]
-
-        found = False
-        for obj in objs:
-            if identifier.lower() in (obj.name + " " + obj.vendor).lower():
-                return obj
-        if not found:
-            raise RuntimeError("object '%s' not found" % identifier)
-
     if plat_dev_string:
-        result = []
+        result: list[tuple[cl.Platform, list[cl.Device]]] = []
 
         for entry in plat_dev_string.split(";"):
             lhsrhs = entry.split(":")
 
             if len(lhsrhs) == 1:
-                platform = find_cl_obj(cl.get_platforms(), lhsrhs[0])
+                platform = _find_cl_obj(cl.get_platforms(), lhsrhs[0])
                 result.append((platform, platform.get_devices()))
 
             elif len(lhsrhs) != 2:
@@ -639,11 +675,11 @@ def get_test_platforms_and_devices(plat_dev_string=None):
             else:
                 plat_str, dev_strs = lhsrhs
 
-                platform = find_cl_obj(cl.get_platforms(), plat_str)
+                platform = _find_cl_obj(cl.get_platforms(), plat_str)
                 devs = platform.get_devices()
                 result.append(
                         (platform,
-                            [find_cl_obj(devs, dev_id)
+                            [_find_cl_obj(devs, dev_id)
                                 for dev_id in dev_strs.split(",")]))
 
         return result
@@ -748,44 +784,33 @@ class Argument(ABC):
         pass
 
 
-class DtypedArgument(Argument):
+@dataclass(frozen=True, init=False)
+class DtypedArgument(Argument, ABC):
     """
-    .. attribute:: name
-    .. attribute:: dtype
+    .. autoattribute:: name
+    .. autoattribute:: dtype
     """
+    dtype: np.dtype[Any]
+    name: str
 
-    def __init__(self, dtype: Any, name: str) -> None:
-        self.dtype = np.dtype(dtype)
-        self.name = name
-
-    def __repr__(self) -> str:
-        return "{}({!r}, {})".format(
-                self.__class__.__name__,
-                self.name,
-                self.dtype)
-
-    def __eq__(self, other: Any) -> bool:
-        return (type(self) is type(other)
-                and self.dtype == other.dtype
-                and self.name == other.name)
-
-    def __hash__(self) -> int:
-        return (
-                hash(type(self))
-                ^ hash(self.dtype)
-                ^ hash(self.name))
+    def __init__(self, dtype: DTypeLike, name: str) -> None:
+        object.__setattr__(self, "name", name)
+        object.__setattr__(self, "dtype", np.dtype(dtype))
 
 
+@dataclass(frozen=True)
 class VectorArg(DtypedArgument):
     """Inherits from :class:`DtypedArgument`.
 
     .. automethod:: __init__
     """
+    with_offset: bool
 
-    def __init__(self, dtype: Any, name: str, with_offset: bool = False) -> None:
-        super().__init__(dtype, name)
-        self.with_offset = with_offset
+    def __init__(self, name: str, dtype: DTypeLike, with_offset: bool = False):
+        super().__init__(name, dtype)
+        object.__setattr__(self, "with_offset", with_offset)
 
+    @override
     def declarator(self) -> str:
         if self.with_offset:
             # Two underscores -> less likelihood of a name clash.
@@ -796,40 +821,25 @@ class VectorArg(DtypedArgument):
 
         return result
 
-    def __eq__(self, other) -> bool:
-        return (super().__eq__(other)
-                and self.with_offset == other.with_offset)
-
-    def __hash__(self) -> int:
-        return super().__hash__() ^ hash(self.with_offset)
-
 
+@dataclass(frozen=True, init=False)
 class ScalarArg(DtypedArgument):
     """Inherits from :class:`DtypedArgument`."""
 
-    def declarator(self):
+    @override
+    def declarator(self) -> str:
         return "{} {}".format(dtype_to_ctype(self.dtype), self.name)
 
 
+@dataclass(frozen=True)
 class OtherArg(Argument):
-    def __init__(self, declarator: str, name: str) -> None:
-        self.decl = declarator
-        self.name = name
+    decl: str
+    name: str
 
+    @override
     def declarator(self) -> str:
         return self.decl
 
-    def __eq__(self, other) -> bool:
-        return (type(self) is type(other)
-                and self.decl == other.decl
-                and self.name == other.name)
-
-    def __hash__(self) -> int:
-        return (
-                hash(type(self))
-                ^ hash(self.decl)
-                ^ hash(self.name))
-
 
 def parse_c_arg(c_arg: str, with_offset: bool = False) -> DtypedArgument:
     for aspace in ["__local", "__constant"]:
@@ -850,8 +860,8 @@ def parse_c_arg(c_arg: str, with_offset: bool = False) -> DtypedArgument:
 
 
 def parse_arg_list(
-        arguments: Union[str, List[str], List[DtypedArgument]],
-        with_offset: bool = False) -> List[DtypedArgument]:
+        arguments: str | list[str] | list[DtypedArgument],
+        with_offset: bool = False) -> list[DtypedArgument]:
     """Parse a list of kernel arguments. *arguments* may be a comma-separate
     list of C declarators in a string, a list of strings representing C
     declarators, or :class:`Argument` objects.
@@ -860,7 +870,7 @@ def parse_arg_list(
     if isinstance(arguments, str):
         arguments = arguments.split(",")
 
-    def parse_single_arg(obj: Union[str, DtypedArgument]) -> DtypedArgument:
+    def parse_single_arg(obj: str | DtypedArgument) -> DtypedArgument:
         if isinstance(obj, str):
             from pyopencl.tools import parse_c_arg
             return parse_c_arg(obj, with_offset=with_offset)
@@ -886,9 +896,9 @@ def get_arg_list_arg_types(arg_types):
 
 
 def get_arg_list_scalar_arg_dtypes(
-        arg_types: List[DtypedArgument]
-        ) -> List[Optional[np.dtype]]:
-    result: List[Optional[np.dtype]] = []
+        arg_types: Sequence[DtypedArgument]
+        ) -> list[np.dtype | None]:
+    result: list[np.dtype | None] = []
 
     for arg_type in arg_types:
         if isinstance(arg_type, ScalarArg):
@@ -903,8 +913,8 @@ def get_arg_list_scalar_arg_dtypes(
     return result
 
 
-def get_arg_offset_adjuster_code(arg_types):
-    result = []
+def get_arg_offset_adjuster_code(arg_types: Sequence[Argument]) -> str:
+    result: list[str] = []
 
     for arg_type in arg_types:
         if isinstance(arg_type, VectorArg) and arg_type.with_offset:
@@ -1181,7 +1191,8 @@ def match_dtype_to_c_struct(device, name, dtype, context=None):
         def calc_field_type():
             total_size = 0
             padding_count = 0
-            for offset, (field_name, (field_dtype, _)) in zip(offsets, fields):
+            for offset, (field_name, (field_dtype, _)) in zip(
+                        offsets, fields, strict=True):
                 if offset > total_size:
                     padding_count += 1
                     yield ("__pycl_padding%d" % padding_count,
@@ -1497,7 +1508,7 @@ def array_module(a):
 # }}}
 
 
-def is_spirv(s):
+def is_spirv(s: str | bytes) -> TypeIs[bytes]:
     spirv_magic = b"\x07\x23\x02\x03"
     return (
             isinstance(s, bytes)
@@ -1524,4 +1535,31 @@ class _NumpyTypesKeyBuilder(KeyBuilderBase):
 
 # }}}
 
+
+__all__ = [
+    "AllocatorBase",
+    "AllocatorBase",
+    "Argument",
+    "DeferredAllocator",
+    "DtypedArgument",
+    "ImmediateAllocator",
+    "MemoryPool",
+    "OtherArg",
+    "PooledBuffer",
+    "PooledSVM",
+    "SVMAllocator",
+    "SVMPool",
+    "ScalarArg",
+    "TypeNameNotKnown",
+    "VectorArg",
+    "bitlog2",
+    "clear_first_arg_caches",
+    "dtype_to_ctype",
+    "first_arg_dependent_memoize",
+    "get_or_register_dtype",
+    "parse_arg_list",
+    "pytest_generate_tests_for_pyopencl",
+    "register_dtype",
+]
+
 # vim: foldmethod=marker

pyopencl/typing.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+
+__copyright__ = "Copyright (C) 2025 University of Illinois Board of Trustees"
+
+__license__ = """
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 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 TYPE_CHECKING, Any, TypeAlias, TypeVar
+
+import numpy as np
+from numpy.typing import NDArray
+from typing_extensions import Buffer as abc_Buffer
+
+
+if TYPE_CHECKING:
+    import pyopencl as _cl
+
+
+DTypeT = TypeVar("DTypeT", bound=np.dtype[Any])
+
+HasBufferInterface: TypeAlias = abc_Buffer | NDArray[Any]
+SVMInnerT = TypeVar("SVMInnerT", bound=HasBufferInterface)
+WaitList: TypeAlias = Sequence["_cl.Event"] | None
+KernelArg: TypeAlias = """
+    int
+    | float
+    | complex
+    | HasBufferInterface
+    | np.generic
+    | _cl.Buffer
+    | _cl.Image
+    | _cl.Sampler
+    | _cl.SVMPointer"""

pyopencl/version.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import re
 from importlib import metadata