pyopencl 2024.2.7__cp39-cp39-macosx_11_0_arm64.whl → 2025.1__cp39-cp39-macosx_11_0_arm64.whl

pyopencl/array.py

@@ -32,7 +32,7 @@ import builtins
 from dataclasses import dataclass
 from functools import reduce
 from numbers import Number
-from typing import Any, Dict, Hashable, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 from warnings import warn
 
 import numpy as np
@@ -42,9 +42,12 @@ import pyopencl.elementwise as elementwise
 from pyopencl import cltypes
 from pyopencl.characterize import has_double_support
 from pyopencl.compyte.array import (
-    ArrayFlags as _ArrayFlags, as_strided as _as_strided,
-    c_contiguous_strides as _c_contiguous_strides, equal_strides as _equal_strides,
-    f_contiguous_strides as _f_contiguous_strides)
+    ArrayFlags as _ArrayFlags,
+    as_strided as _as_strided,
+    c_contiguous_strides as _c_contiguous_strides,
+    equal_strides as _equal_strides,
+    f_contiguous_strides as _f_contiguous_strides,
+)
 
 
 SCALAR_CLASSES = (Number, np.bool_, bool)
@@ -55,20 +58,14 @@ else:
     _SVMPointer_or_nothing = ()
 
 
-_NUMPY_PRE_2 = np.__version__.startswith("1.")
-
-
 # {{{ _get_common_dtype
 
-_COMMON_DTYPE_CACHE: Dict[Tuple[Hashable, ...], np.dtype] = {}
-
-
 class DoubleDowncastWarning(UserWarning):
     pass
 
 
 _DOUBLE_DOWNCAST_WARNING = (
-        "The operation you requested would result in a double-precisision "
+        "The operation you requested would result in a double-precision "
         "quantity according to numpy semantics. Since your device does not "
         "support double precision, a single-precision quantity is being returned.")
 
@@ -78,78 +75,12 @@ def _get_common_dtype(obj1, obj2, queue):
         raise ValueError("PyOpenCL array has no queue; call .with_queue() to "
                 "add one in order to be able to perform operations")
 
-    allow_double = has_double_support(queue.device)
-    cache_key = None
-    o1_is_array = isinstance(obj1, Array)
-    o2_is_array = isinstance(obj2, Array)
-
-    if o1_is_array and o2_is_array:
-        o1_dtype = obj1.dtype
-        o2_dtype = obj2.dtype
-        cache_key = (obj1.dtype, obj2.dtype, allow_double)
-    else:
-        o1_dtype = getattr(obj1, "dtype", type(obj1))
-        o2_dtype = getattr(obj2, "dtype", type(obj2))
-
-        o1_is_integral = np.issubdtype(o1_dtype, np.integer)
-        o2_is_integral = np.issubdtype(o1_dtype, np.integer)
-
-        o1_key = obj1 if o1_is_integral and not o1_is_array else o1_dtype
-        o2_key = obj2 if o2_is_integral and not o2_is_array else o2_dtype
-
-        cache_key = (o1_key, o2_key, o1_is_array, o2_is_array, allow_double)
-
-    try:
-        return _COMMON_DTYPE_CACHE[cache_key]
-    except KeyError:
-        pass
+    # Note: We are calling np.result_type with pyopencl arrays here.
+    # Luckily, np.result_type only looks at the dtype of input arrays up until
+    # at least numpy v2.1.
+    result = np.result_type(obj1, obj2)
 
-    # Numpy's behavior around integers is a bit bizarre, and definitely value-
-    # and not just type-sensitive when it comes to scalars.  We'll just do our
-    # best to emulate it.
-    #
-    # Some samples that are true as of numpy 1.23.1.
-    #
-    # >>> a = np.zeros(1, dtype=np.int16)
-    # >>> (a + 123123123312).dtype
-    # dtype('int64')
-    # >>> (a + 12312).dtype
-    # dtype('int16')
-    # >>> (a + 12312444).dtype
-    # dtype('int32')
-    # >>> (a + np.int32(12312444)).dtype
-    # dtype('int32')
-    # >>> (a + np.int32(1234)).dtype
-    # dtype('int16')
-    #
-    # Note that np.find_common_type, while appealing, won't be able to tell
-    # the full story.
-
-    if (_NUMPY_PRE_2
-            and not (o1_is_array and o2_is_array)
-            and o1_is_integral and o2_is_integral):
-        if o1_is_array:
-            obj1 = np.zeros(1, dtype=o1_dtype)
-        if o2_is_array:
-            obj2 = np.zeros(1, dtype=o2_dtype)
-
-        result = (obj1 + obj2).dtype
-    else:
-        array_types = []
-        scalars = []
-
-        if o1_is_array:
-            array_types.append(o1_dtype)
-        else:
-            scalars.append(obj1)
-        if o2_is_array:
-            array_types.append(o2_dtype)
-        else:
-            scalars.append(obj2)
-
-        result = np.result_type(*array_types, *scalars)
-
-    if not allow_double:
+    if not has_double_support(queue.device):
         if result == np.float64:
             result = np.dtype(np.float32)
             warn(_DOUBLE_DOWNCAST_WARNING, DoubleDowncastWarning, stacklevel=3)
@@ -157,9 +88,6 @@ def _get_common_dtype(obj1, obj2, queue):
             result = np.dtype(np.complex64)
             warn(_DOUBLE_DOWNCAST_WARNING, DoubleDowncastWarning, stacklevel=3)
 
-    if cache_key is not None:
-        _COMMON_DTYPE_CACHE[cache_key] = result
-
     return result
 
 # }}}
@@ -259,7 +187,7 @@ def _splay(device, n, kernel_specific_max_wg_size=None):
         group_count = max_groups
         work_items_per_group = max_work_items
 
-    #print "n:%d gc:%d wipg:%d" % (n, group_count, work_items_per_group)
+    # print("n:%d gc:%d wipg:%d" % (n, group_count, work_items_per_group))
     return (group_count*work_items_per_group,), (work_items_per_group,)
 
 
@@ -292,7 +220,7 @@ def elwise_kernel_runner(kernel_getter):
             queue.device)
         gs, ls = out._get_sizes(queue, work_group_info)
 
-        args = (out,) + args + (out.size,)
+        args = (out, *args, out.size)
         if ARRAY_KERNEL_EXEC_HOOK is not None:
             return ARRAY_KERNEL_EXEC_HOOK(  # pylint: disable=not-callable
                     knl, queue, gs, ls, *args, wait_for=wait_for)
@@ -587,7 +515,7 @@ class Array:
                 # FIXME It would be nice to check this. But it would require
                 # changing the allocator interface. Trust the user for now.
 
-                #assert allocator.context == context
+                # assert allocator.context == context
                 pass
 
             # Queue-less arrays do have a purpose in life.
@@ -608,11 +536,11 @@ class Array:
 
             try:
                 shape = tuple(shape)        # type: ignore[arg-type]
-            except TypeError:
+            except TypeError as err:
                 if not isinstance(shape, (int, np.integer)):
                     raise TypeError(
                         "shape must either be iterable or castable to an integer: "
-                        f"got a '{type(shape).__name__}'")
+                        f"got a '{type(shape).__name__}'") from err
 
                 shape = (shape,)
 
@@ -654,7 +582,7 @@ class Array:
             # }}}
 
             assert dtype != object, \
-                    "object arrays on the compute device are not allowed"
+                    "object arrays on the compute device are not allowed"  # noqa: E721
             assert isinstance(shape, tuple)
             assert isinstance(strides, tuple)
 
@@ -922,7 +850,7 @@ class Array:
                     "device-to-host transfers",
                     DeprecationWarning, stacklevel=2)
 
-        ary, event1 = self._get(queue=queue, ary=ary, async_=async_, **kwargs)
+        ary, _event1 = self._get(queue=queue, ary=ary, async_=async_, **kwargs)
 
         return ary
 
@@ -2047,9 +1975,10 @@ class Array:
 
         .. versionadded:: 2015.2
         """
-        new_shape = tuple([dim for dim in self.shape if dim > 1])
-        new_strides = tuple([self.strides[i]
-            for i, dim in enumerate(self.shape) if dim > 1])
+        new_shape = tuple(dim for dim in self.shape if dim > 1)
+        new_strides = tuple(
+            self.strides[i] for i, dim in enumerate(self.shape)
+            if dim > 1)
 
         return self._new_with_changes(
                 self.base_data, self.offset,
@@ -2514,7 +2443,7 @@ def arange(queue, *args, **kwargs):
         raise TypeError("arange requires a dtype argument")
 
     from math import ceil
-    size = int(ceil((stop-start)/step))
+    size = ceil((stop-start)/step)
 
     result = Array(queue, (size,), dtype, allocator=inf.allocator)
     result.add_event(_arange_knl(result, start, step, queue=queue))
@@ -2595,14 +2524,16 @@ def multi_take(arrays, indices, out=None, queue=None):
                     cl.kernel_work_group_info.WORK_GROUP_SIZE,
                     queue.device))
 
-        wait_for_this = (indices.events
-            + builtins.sum((i.events for i in arrays[chunk_slice]), [])
-            + builtins.sum((o.events for o in out[chunk_slice]), []))
+        wait_for_this = (
+            *indices.events,
+            *[evt for i in arrays[chunk_slice] for evt in i.events],
+            *[evt for o in out[chunk_slice] for evt in o.events])
         evt = knl(queue, gs, ls,
                 indices.data,
-                *([o.data for o in out[chunk_slice]]
-                    + [i.data for i in arrays[chunk_slice]]
-                    + [indices.size]), wait_for=wait_for_this)
+                *[o.data for o in out[chunk_slice]],
+                *[i.data for i in arrays[chunk_slice]],
+                *[indices.size],
+                wait_for=wait_for_this)
         for o in out[chunk_slice]:
             o.add_event(evt)
 
@@ -2673,15 +2604,19 @@ def multi_take_put(arrays, dest_indices, src_indices, dest_shape=None,
                     cl.kernel_work_group_info.WORK_GROUP_SIZE,
                     queue.device))
 
-        wait_for_this = (dest_indices.events + src_indices.events
-            + builtins.sum((i.events for i in arrays[chunk_slice]), [])
-            + builtins.sum((o.events for o in out[chunk_slice]), []))
+        wait_for_this = (
+            *dest_indices.events,
+            *src_indices.events,
+            *[evt for i in arrays[chunk_slice] for evt in i.events],
+            *[evt for o in out[chunk_slice] for evt in o.events])
         evt = knl(queue, gs, ls,
-                *(list(out[chunk_slice])
-                    + [dest_indices, src_indices]
-                    + list(arrays[chunk_slice])
-                    + src_offsets_list[chunk_slice]
-                    + [src_indices.size]), wait_for=wait_for_this)
+                  *out[chunk_slice],
+                  dest_indices,
+                  src_indices,
+                  *arrays[chunk_slice],
+                  *src_offsets_list[chunk_slice],
+                  src_indices.size,
+                  wait_for=wait_for_this)
         for o in out[chunk_slice]:
             o.add_event(evt)
 
@@ -2750,16 +2685,16 @@ def multi_put(arrays, dest_indices, dest_shape=None, out=None, queue=None,
                     cl.kernel_work_group_info.WORK_GROUP_SIZE,
                     queue.device))
 
-        wait_for_this = (wait_for
-            + builtins.sum([i.events for i in arrays[chunk_slice]], [])
-            + builtins.sum([o.events for o in out[chunk_slice]], []))
+        wait_for_this = (
+            *wait_for,
+            *[evt for i in arrays[chunk_slice] for evt in i.events],
+            *[evt for o in out[chunk_slice] for evt in o.events])
         evt = knl(queue, gs, ls,
-                *(
-                    list(out[chunk_slice])
-                    + [dest_indices]
-                    + list(arrays[chunk_slice])
-                    + [use_fill_cla, array_lengths_cla, dest_indices.size]),
-                wait_for=wait_for_this)
+                  *out[chunk_slice],
+                  dest_indices,
+                  *arrays[chunk_slice],
+                  use_fill_cla, array_lengths_cla, dest_indices.size,
+                  wait_for=wait_for_this)
 
         for o in out[chunk_slice]:
             o.add_event(evt)
@@ -2874,7 +2809,7 @@ def hstack(arrays, queue=None):
 
     lead_shape = single_valued(ary.shape[:-1] for ary in arrays)
 
-    w = builtins.sum([ary.shape[-1] for ary in arrays])
+    w = builtins.sum(ary.shape[-1] for ary in arrays)
 
     if __debug__:
         if builtins.any(type(ary) != type(arrays[0])  # noqa: E721
@@ -2883,7 +2818,7 @@ def hstack(arrays, queue=None):
                  "an instance of the type of arrays[0]",
                  stacklevel=2)
 
-    result = arrays[0].__class__(queue, lead_shape+(w,), arrays[0].dtype,
+    result = arrays[0].__class__(queue, (*lead_shape, w), arrays[0].dtype,
                                  allocator=arrays[0].allocator)
     index = 0
     for ary in arrays:
@@ -3150,8 +3085,8 @@ def _logical_op(x1, x2, out, operator, queue=None):
         else:
             out[:] = np.logical_or(x1, x2)
     elif np.isscalar(x1) or np.isscalar(x2):
-        scalar_arg, = [x for x in (x1, x2) if np.isscalar(x)]
-        ary_arg, = [x for x in (x1, x2) if not np.isscalar(x)]
+        scalar_arg, = (x for x in (x1, x2) if np.isscalar(x))
+        ary_arg, = (x for x in (x1, x2) if not np.isscalar(x))
         queue = queue or ary_arg.queue
         allocator = ary_arg.allocator
 

pyopencl/bitonic_sort.py

@@ -35,8 +35,10 @@ 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 mako.template import Template
+
 from pytools import memoize_method
 
 import pyopencl as cl
@@ -62,7 +64,7 @@ class BitonicSort:
     .. automethod:: __call__
     """
 
-    kernels_srcs = {
+    kernels_srcs: ClassVar[Dict[str, str]] = {
             "B2": _tmpl.ParallelBitonic_B2,
             "B4": _tmpl.ParallelBitonic_B4,
             "B8": _tmpl.ParallelBitonic_B8,

pyopencl/bitonic_sort_templates.py

@@ -488,7 +488,7 @@ __kernel void run(__global const data_t * in,__global data_t * out,__local data_
   // Write output
   out[i] = aux[i];
 }
-"""         # noqa: E501
+"""
 
 # }}}
 

pyopencl/cache.py

@@ -42,12 +42,14 @@ import hashlib
 new_hash = hashlib.md5
 
 
-def _erase_dir(dir):
+def _erase_dir(directory):
     from os import listdir, rmdir, unlink
     from os.path import join
-    for name in listdir(dir):
-        unlink(join(dir, name))
-    rmdir(dir)
+
+    for name in listdir(directory):
+        unlink(join(directory, name))
+
+    rmdir(directory)
 
 
 def update_checksum(checksum, obj):
@@ -213,7 +215,7 @@ def get_dependencies(src, include_path):
 
     _inner(src)
 
-    result = [(name,) + vals for name, vals in result.items()]
+    result = [(name, *vals) for name, vals in result.items()]
     result.sort()
 
     return result
@@ -266,7 +268,7 @@ def get_cache_key(device, options_bytes, src):
 
 
 def retrieve_from_cache(cache_dir, cache_key):
-    class _InvalidInfoFile(RuntimeError):
+    class _InvalidInfoFileError(RuntimeError):
         pass
 
     from os.path import isdir, join
@@ -290,18 +292,18 @@ def retrieve_from_cache(cache_dir, cache_key):
 
                 try:
                     info_file = open(info_path, "rb")
-                except OSError:
-                    raise _InvalidInfoFile()
+                except OSError as err:
+                    raise _InvalidInfoFileError() from err
 
                 try:
                     try:
                         info = load(info_file)
-                    except EOFError:
-                        raise _InvalidInfoFile()
+                    except EOFError as err:
+                        raise _InvalidInfoFileError() from err
                 finally:
                     info_file.close()
 
-            except _InvalidInfoFile:
+            except _InvalidInfoFileError:
                 mod_cache_dir_m.reset()
                 from warnings import warn
                 warn(
@@ -375,13 +377,13 @@ def _create_built_program_from_source_cached(ctx, src, options_bytes,
         cache_result = retrieve_from_cache(cache_dir, cache_key)
 
         if cache_result is None:
-            logger.debug("build program: binary cache miss (key: %s)" % cache_key)
+            logger.debug("build program: binary cache miss (key: %s)", cache_key)
 
             to_be_built_indices.append(i)
             binaries.append(None)
             logs.append(None)
         else:
-            logger.debug("build program: binary cache hit (key: %s)" % cache_key)
+            logger.debug("build program: binary cache hit (key: %s)", cache_key)
 
             binary, log = cache_result
             binaries.append(binary)
@@ -410,8 +412,9 @@ def _create_built_program_from_source_cached(ctx, src, options_bytes,
         src = src + "\n\n__constant int pyopencl_defeat_cache_%s = 0;" % (
                 uuid4().hex)
 
-        logger.debug("build program: start building program from source on %s"
-                % ", ".join(str(devices[i]) for i in to_be_built_indices))
+        logger.debug(
+                "build program: start building program from source on %s",
+                ", ".join(str(devices[i]) for i in to_be_built_indices))
 
         prg = _cl._Program(ctx, src)
         prg.build(options_bytes, [devices[i] for i in to_be_built_indices])
@@ -459,13 +462,11 @@ def _create_built_program_from_source_cached(ctx, src, options_bytes,
                     binary_path = mod_cache_dir_m.sub("binary")
                     source_path = mod_cache_dir_m.sub("source.cl")
 
-                    outf = open(source_path, "wt")
-                    outf.write(src)
-                    outf.close()
+                    with open(source_path, "w") as outf:
+                        outf.write(src)
 
-                    outf = open(binary_path, "wb")
-                    outf.write(binary)
-                    outf.close()
+                    with open(binary_path, "wb") as outf:
+                        outf.write(binary)
 
                     from pickle import dump
                     info_file = open(info_path, "wb")
@@ -504,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)  # noqa pylint:disable=no-member
+                and e.code == _cl.status_code.BUILD_PROGRAM_FAILURE)  # pylint:disable=no-member
 
         # 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/capture_call.py

@@ -22,6 +22,7 @@ THE SOFTWARE.
 
 
 import numpy as np
+
 from pytools.py_codegen import Indentation, PythonCodeGenerator
 
 import pyopencl as cl
@@ -30,8 +31,8 @@ import pyopencl as cl
 def capture_kernel_call(kernel, output_file, queue, g_size, l_size, *args, **kwargs):
     try:
         source = kernel._source
-    except AttributeError:
-        raise RuntimeError("cannot capture call, kernel source not available")
+    except AttributeError as err:
+        raise RuntimeError("cannot capture call, kernel source not available") from err
 
     if source is None:
         raise RuntimeError("cannot capture call, kernel source not available")
@@ -91,9 +92,9 @@ def capture_kernel_call(kernel, output_file, queue, g_size, l_size, *args, **kwa
             else:
                 try:
                     arg_buf = memoryview(arg)
-                except Exception:
+                except Exception as err:
                     raise RuntimeError("cannot capture: "
-                            "unsupported arg nr %d (0-based)" % i)
+                            "unsupported arg nr %d (0-based)" % i) from err
 
                 arg_data.append(("arg%d_data" % i, arg_buf))
                 kernel_args.append("decompress(b64decode(arg%d_data))" % i)

pyopencl/clrandom.py

@@ -50,6 +50,7 @@ for some documentation if you're planning on using Random123 directly.
 # }}}
 
 import numpy as np
+
 from pytools import memoize_method
 
 import pyopencl as cl

pyopencl/cltypes.py

@@ -50,7 +50,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 +64,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)
 

pyopencl/compyte/dtypes.py

@@ -29,7 +29,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 import numpy as np
 
 
-class TypeNameNotKnown(RuntimeError):
+class TypeNameNotKnown(RuntimeError):  # noqa: N818
     pass
 
 
@@ -89,7 +89,7 @@ class DTypeRegistry:
 
         if not existed:
             self.dtype_to_name[dtype] = c_names[0]
-        if not str(dtype) in self.dtype_to_name:
+        if str(dtype) not in self.dtype_to_name:
             self.dtype_to_name[str(dtype)] = c_names[0]
 
         return dtype
@@ -103,7 +103,7 @@ class DTypeRegistry:
         try:
             return self.dtype_to_name[dtype]
         except KeyError:
-            raise ValueError("unable to map dtype '%s'" % dtype)
+            raise ValueError("unable to map dtype '%s'" % dtype) from None
 
 # }}}
 
@@ -260,7 +260,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)
+        raise ValueError("unknown type '%s'" % tp) from None
 
     return arg_class(dtype, name)
 

pyopencl/compyte/pyproject.toml

@@ -0,0 +1,54 @@
+[tool.ruff]
+preview = true
+
+[tool.ruff.lint]
+extend-select = [
+    "B",   # flake8-bugbear
+    "C",   # flake8-comprehensions
+    "E",   # pycodestyle
+    "F",   # pyflakes
+
+    "I",   # flake8-isort
+
+    "N",   # pep8-naming
+    "NPY", # numpy
+    "Q",   # flake8-quotes
+    "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"
+multiline-quotes = "double"
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+known-first-party = [
+    "pytools",
+    "pymbolic",
+]
+known-local-folder = [
+    "modepy",
+]
+lines-after-imports = 2

pyopencl/elementwise.py

@@ -31,12 +31,19 @@ import enum
 from typing import Any, List, Optional, Tuple, Union
 
 import numpy as np
+
 from pytools import memoize_method
 
 import pyopencl as cl
 from pyopencl.tools import (
-    DtypedArgument, KernelTemplateBase, ScalarArg, VectorArg,
-    context_dependent_memoize, dtype_to_c_struct, dtype_to_ctype)
+    DtypedArgument,
+    KernelTemplateBase,
+    ScalarArg,
+    VectorArg,
+    context_dependent_memoize,
+    dtype_to_c_struct,
+    dtype_to_ctype,
+)
 
 
 # {{{ elementwise kernel code generator