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

pyopencl/_mymako.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 try:
     import mako.template  # noqa: F401
 except ImportError as err:

pyopencl/algorithm.py

@@ -1,4 +1,5 @@
 """Algorithms built on scans."""
+from __future__ import annotations
 
 
 __copyright__ = """
@@ -30,7 +31,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 """
 
 from dataclasses import dataclass
-from typing import Optional
+from typing import TYPE_CHECKING
 
 import numpy as np
 from mako.template import Template
@@ -38,12 +39,15 @@ from mako.template import Template
 from pytools import memoize, memoize_method
 
 import pyopencl as cl
-import pyopencl.array
-from pyopencl.elementwise import ElementwiseKernel
+import pyopencl.array as cl_array
 from pyopencl.scan import GenericScanKernel, ScanTemplate
 from pyopencl.tools import dtype_to_ctype, get_arg_offset_adjuster_code
 
 
+if TYPE_CHECKING:
+    from pyopencl.elementwise import ElementwiseKernel
+
+
 # {{{ "extra args" handling utility
 
 def _extract_extra_args_types_values(extra_args):
@@ -55,7 +59,7 @@ def _extract_extra_args_types_values(extra_args):
     extra_args_values = []
     extra_wait_for = []
     for name, val in extra_args:
-        if isinstance(val, cl.array.Array):
+        if isinstance(val, cl_array.Array):
             extra_args_types.append(VectorArg(val.dtype, name, with_offset=False))
             extra_args_values.append(val)
             extra_wait_for.extend(val.events)
@@ -117,7 +121,7 @@ def copy_if(ary, predicate, extra_args=None, preamble="", queue=None, wait_for=N
             type_aliases=(("scan_t", scan_dtype), ("item_t", ary.dtype)),
             var_values=(("predicate", predicate),),
             more_preamble=preamble, more_arguments=extra_args_types)
-    out = cl.array.empty_like(ary)
+    out = cl_array.empty_like(ary)
     count = ary._new_with_changes(data=None, offset=0,
             shape=(), strides=(), dtype=scan_dtype)
 
@@ -207,8 +211,8 @@ def partition(ary, predicate, extra_args=None, preamble="",
             var_values=(("predicate", predicate),),
             more_preamble=preamble, more_arguments=extra_args_types)
 
-    out_true = cl.array.empty_like(ary)
-    out_false = cl.array.empty_like(ary)
+    out_true = cl_array.empty_like(ary)
+    out_false = cl_array.empty_like(ary)
     count = ary._new_with_changes(data=None, offset=0,
             shape=(), strides=(), dtype=scan_dtype)
 
@@ -279,7 +283,7 @@ def unique(ary, is_equal_expr="a == b", extra_args=None, preamble="",
             var_values=(("macro_is_equal_expr", is_equal_expr),),
             more_preamble=preamble, more_arguments=extra_args_types)
 
-    out = cl.array.empty_like(ary)
+    out = cl_array.empty_like(ary)
     count = ary._new_with_changes(data=None, offset=0,
             shape=(), strides=(), dtype=scan_dtype)
 
@@ -556,7 +560,7 @@ class RadixSort:
         base_bit = 0
         while base_bit < key_bits:
             sorted_args = [
-                    cl.array.empty(queue, n, arg_descr.dtype, allocator=allocator)
+                    cl_array.empty(queue, n, arg_descr.dtype, allocator=allocator)
                     for arg_descr in self.arguments
                     if arg_descr.name in self.sort_arg_names]
 
@@ -574,7 +578,7 @@ class RadixSort:
             base_bit += self.bits
 
         return [arg_val
-                for arg_descr, arg_val in zip(self.arguments, args)
+                for arg_descr, arg_val in zip(self.arguments, args, strict=True)
                 if arg_descr.name in self.sort_arg_names], last_evt
 
         # }}}
@@ -725,12 +729,12 @@ def _get_arg_list(arg_list, prefix=""):
 
 @dataclass
 class BuiltList:
-    count: Optional[int]
-    starts: Optional[pyopencl.array.Array]
-    lists: Optional[pyopencl.array.Array] = None
-    num_nonempty_lists: Optional[int] = None
-    nonempty_indices: Optional[pyopencl.array.Array] = None
-    compressed_indices: Optional[pyopencl.array.Array] = None
+    count: int | None
+    starts: cl_array.Array | None
+    lists: cl_array.Array | None = None
+    num_nonempty_lists: int | None = None
+    nonempty_indices: cl_array.Array | None = None
+    compressed_indices: cl_array.Array | None = None
 
 
 class ListOfListsBuilder:
@@ -1139,7 +1143,8 @@ class ListOfListsBuilder:
             compress_kernel = self.get_compress_kernel(index_dtype)
 
         data_args = []
-        for i, (arg_descr, arg_val) in enumerate(zip(self.arg_decls, args)):
+        for i, (arg_descr, arg_val) in enumerate(
+                zip(self.arg_decls, args, strict=True)):
             from pyopencl.tools import VectorArg
             if isinstance(arg_descr, VectorArg):
                 from pyopencl import MemoryObject
@@ -1179,7 +1184,7 @@ class ListOfListsBuilder:
                 count_list_args.append(None)
                 continue
 
-            counts = cl.array.empty(queue,
+            counts = cl_array.empty(queue,
                     (n_objects + 1), index_dtype, allocator=allocator)
             counts[-1] = 0
             wait_for = wait_for + counts.events
@@ -1219,14 +1224,14 @@ class ListOfListsBuilder:
             if name not in self.eliminate_empty_output_lists:
                 continue
 
-            compressed_counts = cl.array.empty(
+            compressed_counts = cl_array.empty(
                 queue, (n_objects + 1,), index_dtype, allocator=allocator)
             info_record = result[name]
-            info_record.nonempty_indices = cl.array.empty(
+            info_record.nonempty_indices = cl_array.empty(
                 queue, (n_objects + 1,), index_dtype, allocator=allocator)
-            info_record.num_nonempty_lists = cl.array.empty(
+            info_record.num_nonempty_lists = cl_array.empty(
                 queue, (1,), index_dtype, allocator=allocator)
-            info_record.compressed_indices = cl.array.empty(
+            info_record.compressed_indices = cl_array.empty(
                 queue, (n_objects + 1,), index_dtype, allocator=allocator)
             info_record.compressed_indices[0] = 0
 
@@ -1301,7 +1306,7 @@ class ListOfListsBuilder:
             else:
                 info_record = result[name]
 
-            info_record.lists = cl.array.empty(queue,
+            info_record.lists = cl_array.empty(queue,
                     info_record.count, dtype, allocator=allocator)
             write_list_args.append(info_record.lists.data)
 
@@ -1431,7 +1436,7 @@ class KeyValueSorter:
         (values_sorted_by_key, keys_sorted_by_key), evt = knl_info.by_target_sorter(
                 values, keys, queue=queue, wait_for=wait_for)
 
-        starts = (cl.array.empty(queue, (nkeys+1), starts_dtype, allocator=allocator)
+        starts = (cl_array.empty(queue, (nkeys+1), starts_dtype, allocator=allocator)
                 .fill(len(values_sorted_by_key), wait_for=[evt]))
         evt, = starts.events
 

pyopencl/array.py

@@ -2,6 +2,8 @@
 
 # NOTE: for elwise_kernel_runner which adds keyword arguments
 # pylint:disable=unexpected-keyword-arg
+from __future__ import annotations
+
 
 __copyright__ = "Copyright (C) 2009 Andreas Kloeckner"
 
@@ -32,13 +34,14 @@ import builtins
 from dataclasses import dataclass
 from functools import reduce
 from numbers import Number
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any
 from warnings import warn
 
 import numpy as np
 
 import pyopencl as cl
 import pyopencl.elementwise as elementwise
+import pyopencl.tools as cl_tools
 from pyopencl import cltypes
 from pyopencl.characterize import has_double_support
 from pyopencl.compyte.array import (
@@ -230,13 +233,13 @@ def elwise_kernel_runner(kernel_getter):
     return kernel_runner
 
 
-class DefaultAllocator(cl.tools.DeferredAllocator):
+class DefaultAllocator(cl_tools.DeferredAllocator):
     def __init__(self, *args, **kwargs):
         warn("pyopencl.array.DefaultAllocator is deprecated. "
                 "It will be continue to exist throughout the 2013.x "
                 "versions of PyOpenCL.",
                 DeprecationWarning, stacklevel=2)
-        cl.tools.DeferredAllocator.__init__(self, *args, **kwargs)
+        cl_tools.DeferredAllocator.__init__(self, *args, **kwargs)
 
 # }}}
 
@@ -262,7 +265,7 @@ class _copy_queue:  # noqa: N801
     pass
 
 
-_ARRAY_GET_SIZES_CACHE: Dict[Tuple[int, int, int], Tuple[int, int]] = {}
+_ARRAY_GET_SIZES_CACHE: dict[tuple[int, int, int], tuple[int, int]] = {}
 _BOOL_DTYPE = np.dtype(np.int8)
 _NOT_PRESENT = object()
 
@@ -457,22 +460,22 @@ class Array:
 
     def __init__(
             self,
-            cq: Optional[Union[cl.Context, cl.CommandQueue]],
-            shape: Union[Tuple[int, ...], int],
+            cq: cl.Context | cl.CommandQueue | None,
+            shape: tuple[int, ...] | int,
             dtype: Any,
             order: str = "C",
-            allocator: Optional[cl.tools.AllocatorBase] = None,
+            allocator: cl_tools.AllocatorBase | None = None,
             data: Any = None,
             offset: int = 0,
-            strides: Optional[Tuple[int, ...]] = None,
-            events: Optional[List[cl.Event]] = None,
+            strides: tuple[int, ...] | None = None,
+            events: list[cl.Event] | None = None,
 
             # NOTE: following args are used for the fast constructor
             _flags: Any = None,
             _fast: bool = False,
-            _size: Optional[int] = None,
-            _context: Optional[cl.Context] = None,
-            _queue: Optional[cl.CommandQueue] = None) -> None:
+            _size: int | None = None,
+            _context: cl.Context | None = None,
+            _queue: cl.CommandQueue | None = None) -> None:
         if _fast:
             # Assumptions, should be disabled if not testing
             if 0:
@@ -1956,13 +1959,13 @@ class Array:
             raise ValueError("new type not compatible with array")
 
         new_shape = (
-                self.shape[:min_stride_axis]
-                + (self.shape[min_stride_axis] * old_itemsize // itemsize,)
-                + self.shape[min_stride_axis+1:])
+                *self.shape[:min_stride_axis],
+                self.shape[min_stride_axis] * old_itemsize // itemsize,
+                *self.shape[min_stride_axis+1:])
         new_strides = (
-                self.strides[:min_stride_axis]
-                + (self.strides[min_stride_axis] * itemsize // old_itemsize,)
-                + self.strides[min_stride_axis+1:])
+                *self.strides[:min_stride_axis],
+                self.strides[min_stride_axis] * itemsize // old_itemsize,
+                *self.strides[min_stride_axis+1:])
 
         return self._new_with_changes(
                 self.base_data, self.offset,
@@ -2352,11 +2355,11 @@ def zeros_like(ary):
 
 @dataclass
 class _ArangeInfo:
-    start: Optional[int] = None
-    stop: Optional[int] = None
-    step: Optional[int] = None
-    dtype: Optional["np.dtype"] = None
-    allocator: Optional[Any] = None
+    start: int | None = None
+    stop: int | None = None
+    step: int | None = None
+    dtype: np.dtype | None = None
+    allocator: Any | None = None
 
 
 @elwise_kernel_runner
@@ -2759,9 +2762,9 @@ def concatenate(arrays, axis=0, queue=None, allocator=None):
     for ary in arrays:
         my_len = ary.shape[axis]
         result.setitem(
-                full_slice[:axis]
-                + (slice(base_idx, base_idx+my_len),)
-                + full_slice[axis+1:],
+                (*full_slice[:axis],
+                    slice(base_idx, base_idx+my_len),
+                    *full_slice[axis+1:]),
                 ary)
 
         base_idx += my_len
@@ -2867,7 +2870,7 @@ def stack(arrays, axis=0, queue=None):
         # pyopencl.Array.__setitem__ does not support non-contiguous assignments
         raise NotImplementedError
 
-    result_shape = input_shape[:axis] + (len(arrays),) + input_shape[axis:]
+    result_shape = (*input_shape[:axis], len(arrays), *input_shape[axis:])
 
     if __debug__:
         if builtins.any(type(ary) != type(arrays[0])  # noqa: E721

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__ = """