pyopencl 2025.2.5__cp311-cp311-macosx_11_0_arm64.whl → 2025.2.6__cp311-cp311-macosx_11_0_arm64.whl

pyopencl/array.py

@@ -1,7 +1,5 @@
 """CL device arrays."""
 
-# NOTE: for elwise_kernel_runner which adds keyword arguments
-# pylint:disable=unexpected-keyword-arg
 from __future__ import annotations
 
 
@@ -41,12 +39,13 @@ from typing import (
     Concatenate,
     Literal,
     ParamSpec,
+    TypeAlias,
     cast,
 )
 from warnings import warn
 
 import numpy as np
-from typing_extensions import Self, override
+from typing_extensions import Self, TypeIs, override
 
 import pyopencl as cl
 import pyopencl.elementwise as elementwise
@@ -213,7 +212,7 @@ def _splay(
         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(f"n:{n} gc:{group_count} wipg:{work_items_per_group}")
     return (group_count*work_items_per_group,), (work_items_per_group,)
 
 
@@ -246,14 +245,13 @@ def elwise_kernel_runner(
         assert queue is not None
 
         knl = kernel_getter(out, *args, **kwargs)
-        work_group_info = cast("int", knl.get_work_group_info(
+        gs, ls = out._get_sizes(queue, knl.get_work_group_info(
             cl.kernel_work_group_info.WORK_GROUP_SIZE,
             queue.device))
-        gs, ls = out._get_sizes(queue, work_group_info)
 
         knl_args = (out, *args, out.size)
         if ARRAY_KERNEL_EXEC_HOOK is not None:
-            return ARRAY_KERNEL_EXEC_HOOK(  # pylint: disable=not-callable
+            return ARRAY_KERNEL_EXEC_HOOK(
                     knl, queue, gs, ls, *knl_args, wait_for=wait_for)
         else:
             return knl(queue, gs, ls, *knl_args, wait_for=wait_for)
@@ -289,6 +287,12 @@ _ARRAY_GET_SIZES_CACHE: \
 _BOOL_DTYPE = np.dtype(np.int8)
 _NOT_PRESENT = object()
 
+ScalarLike: TypeAlias = int | float | complex | np.number[Any]
+
+
+def _is_scalar(s: object) -> TypeIs[ScalarLike]:
+    return isinstance(s, SCALAR_CLASSES)
+
 
 class Array:
     """A :class:`numpy.ndarray` work-alike that stores its data and performs
@@ -478,16 +482,6 @@ class Array:
 
     __array_priority__: ClassVar[int] = 100
 
-    queue: cl.CommandQueue | None
-    shape: tuple[int, ...]
-    dtype: np.dtype[Any]
-    strides: tuple[int, ...]
-    events: list[cl.Event]
-    nbytes: int
-    size: int
-    allocator: Allocator | None
-    base_data: cl.MemoryObjectHolder | cl.SVMPointer | None
-
     def __init__(
             self,
             cq: cl.Context | cl.CommandQueue | None,
@@ -568,7 +562,7 @@ class Array:
             dtype = np.dtype(dtype)
 
             try:
-                shape = tuple(shape)        # type: ignore[arg-type]
+                shape = tuple(shape)
             except TypeError as err:
                 if not isinstance(shape, (int, np.integer)):
                     raise TypeError(
@@ -587,7 +581,7 @@ class Array:
                 raise ValueError(f"negative dimensions are not allowed: {shape}")
             if np.any([np.array([s]).dtype.kind not in ["u", "i"] for s in shape]):
                 raise ValueError(
-                    "Invalid shape %s ; dimensions, must be integer" % (str(shape)))
+                    f"invalid shape {shape} (all dimensions must be integers)")
             size = np.prod(shape_array, dtype=np.uint64).item()
 
             if strides is None:
@@ -624,34 +618,37 @@ class Array:
             if alloc_nbytes < 0:
                 raise ValueError("cannot allocate CL buffer with negative size")
 
-        self.queue = queue
-        self.shape = shape
-        self.dtype = dtype
-        self.strides = strides
-        self.events = [] if events is None else events
-        self.nbytes = alloc_nbytes
-        self.size = size
-        self.allocator = allocator
-
+        base_data = None
         if data is None:
             if alloc_nbytes == 0:
-                self.base_data = None
+                base_data = None
 
             else:
-                if self.allocator is None:
+                if allocator is None:
                     if context is None and queue is not None:
                         context = queue.context
 
-                    self.base_data = cl.Buffer(
-                            context, cl.mem_flags.READ_WRITE, alloc_nbytes)
+                    assert context is not None
+                    base_data = cl.Buffer(
+                        context, cl.mem_flags.READ_WRITE, alloc_nbytes)
                 else:
-                    self.base_data = self.allocator(alloc_nbytes)
+                    base_data = allocator(alloc_nbytes)
         else:
-            self.base_data = data
-
-        self.offset = offset
-        self.context = context
-        self._flags = _flags
+            base_data = data
+
+        self.queue: cl.CommandQueue | None = queue
+        self.context: cl.Context | None = context
+        self.shape: tuple[int, ...] = shape
+        self.dtype: np.dtype[Any] = dtype
+        self.strides: tuple[int, ...] = strides
+        self.events: list[cl.Event] = [] if events is None else events
+        self.nbytes: int = alloc_nbytes
+        self.size: int = size
+        self.allocator: Allocator | None = allocator
+        self.base_data: cl.MemoryObjectHolder | cl.SVMPointer | None = base_data
+        self.offset: int = offset
+
+        self._flags: _ArrayFlags | None = _flags
 
         if __debug__:
             if queue is not None and isinstance(
@@ -664,11 +661,11 @@ class Array:
                          InconsistentOpenCLQueueWarning, stacklevel=2)
 
     @property
-    def ndim(self):
+    def ndim(self) -> int:
         return len(self.shape)
 
     @property
-    def data(self):
+    def data(self) -> cl.MemoryObjectHolder | cl.SVMPointer | None:
         if self.offset:
             raise ArrayHasOffsetError()
         else:
@@ -679,6 +676,7 @@ class Array:
         f = self._flags
         if f is None:
             self._flags = f = _ArrayFlags(self)
+
         return f
 
     def _new_with_changes(self,
@@ -899,14 +897,16 @@ class Array:
 
         return result
 
-    def __str__(self):
+    @override
+    def __str__(self) -> str:
         if self.queue is None:
             return (f"<cl.{type(self).__name__} {self.shape} of {self.dtype} "
                     "without queue, call with_queue()>")
 
         return str(self.get())
 
-    def __repr__(self):
+    @override
+    def __repr__(self) -> str:
         if self.queue is None:
             return (f"<cl.{type(self).__name__} {self.shape} of {self.dtype} "
                     f"at {id(self):x} without queue, call with_queue()>")
@@ -922,49 +922,69 @@ class Array:
 
         return result
 
-    def safely_stringify_for_pudb(self):
+    def safely_stringify_for_pudb(self) -> str:
         return f"cl.{type(self).__name__} {self.dtype} {self.shape}"
 
-    def __hash__(self):
+    @override
+    def __hash__(self) -> int:
         raise TypeError("pyopencl arrays are not hashable.")
 
     # {{{ kernel invocation wrappers
 
     @staticmethod
     @elwise_kernel_runner
-    def _axpbyz(out, afac, a, bfac, b, queue: cl.CommandQueue | None = None):
-        """Compute ``out = selffac * self + otherfac*other``,
+    def _axpbyz(out: Array,
+                a: ScalarLike,
+                x: Array,
+                b: ScalarLike,
+                y: Array,
+                queue: cl.CommandQueue | None = None) -> cl.Kernel:
+        """Compute ``out = a*x + b*y``,
         where *other* is an array."""
-        a_shape = a.shape
-        b_shape = b.shape
+        x_shape = x.shape
+        y_shape = y.shape
         out_shape = out.shape
-        assert (a_shape == b_shape == out_shape
-                or (a_shape == () and b_shape == out_shape)
-                or (b_shape == () and a_shape == out_shape))
+
+        assert out.context is not None
+        assert (x_shape == y_shape == out_shape
+                or (x_shape == () and y_shape == out_shape)
+                or (y_shape == () and x_shape == out_shape))
+
         return elementwise.get_axpbyz_kernel(
-                out.context, a.dtype, b.dtype, out.dtype,
-                x_is_scalar=(a_shape == ()),
-                y_is_scalar=(b_shape == ()))
+                out.context, x.dtype, y.dtype, out.dtype,
+                x_is_scalar=(x_shape == ()),
+                y_is_scalar=(y_shape == ()))
 
     @staticmethod
     @elwise_kernel_runner
-    def _axpbz(out, a, x, b, queue: cl.CommandQueue | None = None):
+    def _axpbz(out: Array,
+               a: ScalarLike,
+               x: Array,
+               b: ScalarLike,
+               queue: cl.CommandQueue | None = None) -> cl.Kernel:
         """Compute ``z = a * x + b``, where *b* is a scalar."""
-        a = np.array(a)
-        b = np.array(b)
         assert out.shape == x.shape
-        return elementwise.get_axpbz_kernel(out.context,
-                a.dtype, x.dtype, b.dtype, out.dtype)
+        assert out.context is not None
+
+        return elementwise.get_axpbz_kernel(
+                out.context,
+                np.array(a).dtype, x.dtype, np.array(b).dtype, out.dtype)
 
     @staticmethod
     @elwise_kernel_runner
-    def _elwise_multiply(out, a, b, queue: cl.CommandQueue | None = None):
+    def _elwise_multiply(out: Array,
+                         a: Array,
+                         b: Array,
+                         queue: cl.CommandQueue | None = None) -> cl.Kernel:
         a_shape = a.shape
         b_shape = b.shape
         out_shape = out.shape
+
         assert (a_shape == b_shape == out_shape
                 or (a_shape == () and b_shape == out_shape)
                 or (b_shape == () and a_shape == out_shape))
+        assert a.context is not None
+
         return elementwise.get_multiply_kernel(
                 a.context, a.dtype, b.dtype, out.dtype,
                 x_is_scalar=(a_shape == ()),
@@ -973,19 +993,27 @@ class Array:
 
     @staticmethod
     @elwise_kernel_runner
-    def _rdiv_scalar(out, ary, other, queue: cl.CommandQueue | None = None):
-        other = np.array(other)
+    def _rdiv_scalar(out: Array,
+                     ary: Array,
+                     other: ScalarLike,
+                     queue: cl.CommandQueue | None = None) -> cl.Kernel:
+        assert out.context is not None
         assert out.shape == ary.shape
+
         return elementwise.get_rdivide_elwise_kernel(
-                out.context, ary.dtype, other.dtype, out.dtype)
+                out.context, ary.dtype, np.array(other).dtype, out.dtype)
 
     @staticmethod
     @elwise_kernel_runner
-    def _div(out, self, other, queue: cl.CommandQueue | None = None):
+    def _div(out: Array,
+             self: Array,
+             other: Array,
+             queue: cl.CommandQueue | None = None) -> cl.Kernel:
         """Divides an array by another array."""
         assert (self.shape == other.shape == out.shape
                 or (self.shape == () and other.shape == out.shape)
                 or (other.shape == () and self.shape == out.shape))
+        assert self.context is not None
 
         return elementwise.get_divide_kernel(self.context,
                 self.dtype, other.dtype, out.dtype,
@@ -994,15 +1022,18 @@ class Array:
 
     @staticmethod
     @elwise_kernel_runner
-    def _fill(result, scalar):
+    def _fill(result: Array, scalar: ScalarLike) -> cl.Kernel:
+        assert result.context is not None
         return elementwise.get_fill_kernel(result.context, result.dtype)
 
     @staticmethod
     @elwise_kernel_runner
-    def _abs(result, arg):
+    def _abs(result: Array, arg: Array) -> cl.Kernel:
+        assert arg.context is not None
+
         if arg.dtype.kind == "c":
             from pyopencl.elementwise import complex_dtype_to_name
-            fname = "%s_abs" % complex_dtype_to_name(arg.dtype)
+            fname = f"{complex_dtype_to_name(arg.dtype)}_abs"
         elif arg.dtype.kind == "f":
             fname = "fabs"
         elif arg.dtype.kind in ["u", "i"]:
@@ -1015,63 +1046,83 @@ class Array:
 
     @staticmethod
     @elwise_kernel_runner
-    def _real(result, arg):
+    def _real(result: Array, arg: Array) -> cl.Kernel:
         from pyopencl.elementwise import complex_dtype_to_name
-        fname = "%s_real" % complex_dtype_to_name(arg.dtype)
+
+        assert arg.context is not None
+        fname = f"{complex_dtype_to_name(arg.dtype)}_real"
+
         return elementwise.get_unary_func_kernel(
                 arg.context, fname, arg.dtype, out_dtype=result.dtype)
 
     @staticmethod
     @elwise_kernel_runner
-    def _imag(result, arg):
+    def _imag(result: Array, arg: Array) -> cl.Kernel:
         from pyopencl.elementwise import complex_dtype_to_name
-        fname = "%s_imag" % complex_dtype_to_name(arg.dtype)
+
+        assert arg.context is not None
+        fname = f"{complex_dtype_to_name(arg.dtype)}_imag"
+
         return elementwise.get_unary_func_kernel(
                 arg.context, fname, arg.dtype, out_dtype=result.dtype)
 
     @staticmethod
     @elwise_kernel_runner
-    def _conj(result, arg):
+    def _conj(result: Array, arg: Array) -> cl.Kernel:
         from pyopencl.elementwise import complex_dtype_to_name
-        fname = "%s_conj" % complex_dtype_to_name(arg.dtype)
+
+        assert arg.context is not None
+        fname = f"{complex_dtype_to_name(arg.dtype)}_conj"
+
         return elementwise.get_unary_func_kernel(
                 arg.context, fname, arg.dtype, out_dtype=result.dtype)
 
     @staticmethod
     @elwise_kernel_runner
-    def _pow_scalar(result, ary, exponent):
-        exponent = np.array(exponent)
+    def _pow_scalar(result: Array,
+                    ary: Array,
+                    exponent: ScalarLike) -> cl.Kernel:
+        assert result.context is not None
         return elementwise.get_pow_kernel(result.context,
-                ary.dtype, exponent.dtype, result.dtype,
+                ary.dtype, np.array(exponent).dtype, result.dtype,
                 is_base_array=True, is_exp_array=False)
 
     @staticmethod
     @elwise_kernel_runner
-    def _rpow_scalar(result, base, exponent):
-        base = np.array(base)
+    def _rpow_scalar(result: Array,
+                     base: ScalarLike,
+                     exponent: Array) -> cl.Kernel:
+        assert result.context is not None
         return elementwise.get_pow_kernel(result.context,
-                base.dtype, exponent.dtype, result.dtype,
+                np.array(base).dtype, exponent.dtype, result.dtype,
                 is_base_array=False, is_exp_array=True)
 
     @staticmethod
     @elwise_kernel_runner
-    def _pow_array(result, base, exponent):
+    def _pow_array(result: Array,
+                   base: Array,
+                   exponent: Array) -> cl.Kernel:
+        assert result.context is not None
         return elementwise.get_pow_kernel(
                 result.context, base.dtype, exponent.dtype, result.dtype,
                 is_base_array=True, is_exp_array=True)
 
     @staticmethod
     @elwise_kernel_runner
-    def _reverse(result, ary):
+    def _reverse(result: Array, ary: Array) -> cl.Kernel:
+        assert result.context is not None
         return elementwise.get_reverse_kernel(result.context, ary.dtype)
 
     @staticmethod
     @elwise_kernel_runner
-    def _copy(dest, src):
+    def _copy(dest: Array, src: Array) -> cl.Kernel:
+        assert dest.context is not None
         return elementwise.get_copy_kernel(
                 dest.context, dest.dtype, src.dtype)
 
-    def _new_like_me(self, dtype=None, queue: cl.CommandQueue | None = None):
+    def _new_like_me(self,
+                     dtype: DTypeLike = None,
+                     queue: cl.CommandQueue | None = None) -> Self:
         if dtype is None:
             dtype = self.dtype
             strides = self.strides
@@ -1095,20 +1146,26 @@ class Array:
 
     @staticmethod
     @elwise_kernel_runner
-    def _scalar_binop(out, a, b, queue: cl.CommandQueue | None = None, op=None):
+    def _scalar_binop(out: Array, a: Array, b: ScalarLike, op: str,
+                      queue: cl.CommandQueue | None = None) -> cl.Kernel:
+        assert out.context is not None
         return elementwise.get_array_scalar_binop_kernel(
                 out.context, op, out.dtype, a.dtype,
                 np.array(b).dtype)
 
     @staticmethod
     @elwise_kernel_runner
-    def _array_binop(out, a, b, queue: cl.CommandQueue | None = None, op=None):
+    def _array_binop(out: Array, a: Array, b: Array, op: str,
+                     queue: cl.CommandQueue | None = None) -> cl.Kernel:
         a_shape = a.shape
         b_shape = b.shape
         out_shape = out.shape
+
         assert (a_shape == b_shape == out_shape
                 or (a_shape == () and b_shape == out_shape)
                 or (b_shape == () and a_shape == out_shape))
+        assert out.context is not None
+
         return elementwise.get_array_binop_kernel(
                 out.context, op, out.dtype, a.dtype, b.dtype,
                 a_is_scalar=(a_shape == ()),
@@ -1116,9 +1173,12 @@ class Array:
 
     @staticmethod
     @elwise_kernel_runner
-    def _unop(out, a, queue: cl.CommandQueue | None = None, op=None):
+    def _unop(out: Array, a: Array, op: str,
+              queue: cl.CommandQueue | None = None) -> cl.Kernel:
+        assert out.context is not None
         if out.shape != a.shape:
             raise ValueError("shapes of arguments do not match")
+
         return elementwise.get_unop_kernel(
                 out.context, op, a.dtype, out.dtype)
 
@@ -1590,7 +1650,7 @@ class Array:
         result.add_event(self._reverse(result, self))
         return result
 
-    def astype(self, dtype, queue: cl.CommandQueue | None = None):
+    def astype(self, dtype: DTypeLike, queue: cl.CommandQueue | None = None):
         """Return a copy of *self*, cast to *dtype*."""
         if dtype == self.dtype:
             return self.copy()
@@ -1636,15 +1696,26 @@ class Array:
 
     @staticmethod
     @elwise_kernel_runner
-    def _scalar_comparison(out, a, b, queue: cl.CommandQueue | None = None, op=None):
+    def _scalar_comparison(out: Array,
+                           a: Array,
+                           b: ScalarLike,
+                           op: str,
+                           queue: cl.CommandQueue | None = None) -> cl.Kernel:
+        assert out.context is not None
         return elementwise.get_array_scalar_comparison_kernel(
                 out.context, op, a.dtype)
 
     @staticmethod
     @elwise_kernel_runner
-    def _array_comparison(out, a, b, queue: cl.CommandQueue | None = None, op=None):
+    def _array_comparison(out: Array,
+                          a: Array,
+                          b: Array,
+                          op: str,
+                          queue: cl.CommandQueue | None = None) -> cl.Kernel:
+        assert out.context is not None
         if a.shape != b.shape:
             raise ValueError("shapes of comparison arguments do not match")
+
         return elementwise.get_array_comparison_kernel(
                 out.context, op, a.dtype, b.dtype)
 
@@ -1810,8 +1881,7 @@ class Array:
 
         order = kwargs.pop("order", "C")
         if kwargs:
-            raise TypeError("unexpected keyword arguments: %s"
-                    % list(kwargs.keys()))
+            raise TypeError(f"unexpected keyword arguments: {list(kwargs)}")
 
         if order not in "CF":
             raise ValueError("order must be either 'C' or 'F'")
@@ -2123,8 +2193,7 @@ class Array:
                     index_entry += array_shape
 
                 if not (0 <= index_entry < array_shape):
-                    raise IndexError(
-                            "subindex in axis %d out of range" % index_axis)
+                    raise IndexError(f"subindex in axis {index_axis} out of range")
 
                 new_offset += self.strides[array_axis]*index_entry
 
@@ -2154,7 +2223,7 @@ class Array:
                 index_axis += 1
 
             else:
-                raise IndexError("invalid subindex in axis %d" % index_axis)
+                raise IndexError(f"invalid subindex in axis {index_axis}")
 
         while array_axis < len(self.shape):
             new_shape.append(self.shape[array_axis])
@@ -2656,11 +2725,15 @@ def multi_put(
         return []
 
     from pytools import single_valued
+
     a_dtype = single_valued(a.dtype for a in arrays)
     a_allocator = arrays[0].allocator
+
     context = dest_indices.context
     queue = queue or dest_indices.queue
     assert queue is not None
+    assert context is not None
+
     if wait_for is None:
         wait_for = []
     wait_for = [*wait_for, *dest_indices.events]
@@ -2764,7 +2837,6 @@ def concatenate(arrays, axis=0, queue: cl.CommandQueue | None = None, allocator=
                 raise ValueError(
                     f"{i_ary}-th array has residual not matching other arrays")
 
-            # pylint: disable=unsupported-assignment-operation
             shape[axis] += ary.shape[axis]
 
     # }}}
@@ -2960,18 +3032,18 @@ def _if_positive(result, criterion, then_, else_):
 
 
 def if_positive(
-            criterion,
-            then_,
-            else_,
-            out=None,
+            criterion: Array | ScalarLike,
+            then_: Array | ScalarLike,
+            else_: Array | ScalarLike,
+            out: Array | None = None,
             queue: cl.CommandQueue | None = None):
     """Return an array like *then_*, which, for the element at index *i*,
     contains *then_[i]* if *criterion[i]>0*, else *else_[i]*.
     """
 
-    is_then_scalar = isinstance(then_, SCALAR_CLASSES)
-    is_else_scalar = isinstance(else_, SCALAR_CLASSES)
-    if isinstance(criterion, SCALAR_CLASSES) and is_then_scalar and is_else_scalar:
+    is_then_scalar = _is_scalar(then_)
+    is_else_scalar = _is_scalar(else_)
+    if _is_scalar(criterion) and is_then_scalar and is_else_scalar:
         result = np.where(criterion, then_, else_)
 
         if out is not None:
@@ -2981,53 +3053,60 @@ def if_positive(
         return result
 
     if is_then_scalar:
-        then_ = np.array(then_)
+        then_ary = np.array(then_)
+    else:
+        then_ary = then_
+
+    assert not _is_scalar(criterion)
 
     if is_else_scalar:
-        else_ = np.array(else_)
+        else_ary = np.array(else_)
+    else:
+        else_ary = else_
 
-    if then_.dtype != else_.dtype:
+    if then_ary.dtype != else_ary.dtype:
         raise ValueError(
-                f"dtypes do not match: then_ is '{then_.dtype}' and "
-                f"else_ is '{else_.dtype}'")
+                f"dtypes do not match: then_ary is '{then_ary.dtype}' and "
+                f"else_ary is '{else_ary.dtype}'")
 
-    if then_.shape == () and else_.shape == ():
+    if then_ary.shape == () and else_ary.shape == ():
         pass
-    elif then_.shape != () and else_.shape != ():
-        if not (criterion.shape == then_.shape == else_.shape):
+    elif then_ary.shape != () and else_ary.shape != ():
+        if not (criterion.shape == then_ary.shape == else_ary.shape):
             raise ValueError(
                     f"shapes do not match: 'criterion' has shape {criterion.shape}"
-                    f", 'then_' has shape {then_.shape} and 'else_' has shape "
-                    f"{else_.shape}")
-    elif then_.shape == ():
-        if criterion.shape != else_.shape:
+                    f", 'then_ary' has shape {then_ary.shape} and 'else_ary' has shape "
+                    f"{else_ary.shape}")
+    elif then_ary.shape == ():
+        if criterion.shape != else_ary.shape:
             raise ValueError(
                     f"shapes do not match: 'criterion' has shape {criterion.shape}"
-                    f" and 'else_' has shape {else_.shape}")
-    elif else_.shape == ():
-        if criterion.shape != then_.shape:
+                    f" and 'else_ary' has shape {else_ary.shape}")
+    elif else_ary.shape == ():
+        if criterion.shape != then_ary.shape:
             raise ValueError(
                     f"shapes do not match: 'criterion' has shape {criterion.shape}"
-                    f" and 'then_' has shape {then_.shape}")
+                    f" and 'then_ary' has shape {then_ary.shape}")
     else:
         raise AssertionError()
 
     if out is None:
-        if then_.shape != ():
+        if then_ary.shape != ():
+            assert isinstance(then_ary, Array)
             out = empty_like(
-                then_, criterion.queue, allocator=criterion.allocator)
+                then_ary, criterion.queue, allocator=criterion.allocator)
         else:
             # Use same strides as criterion
             cr_byte_strides = np.array(criterion.strides, dtype=np.int64)
             cr_item_strides = cr_byte_strides // criterion.dtype.itemsize
-            out_strides = tuple(cr_item_strides*then_.dtype.itemsize)
+            out_strides = tuple(cr_item_strides*then_ary.dtype.itemsize)
 
             out = type(criterion)(
-                        criterion.queue, criterion.shape, then_.dtype,
+                        criterion.queue, criterion.shape, then_ary.dtype,
                         allocator=criterion.allocator,
                         strides=out_strides)
 
-    event1 = _if_positive(out, criterion, then_, else_, queue=queue)
+    event1 = _if_positive(out, criterion, then_ary, else_ary, queue=queue)
     out.add_event(event1)
 
     return out
@@ -3105,7 +3184,11 @@ def minimum(a, b, out=None, queue: cl.CommandQueue | None = None):
 
 # {{{ logical ops
 
-def _logical_op(x1, x2, out, operator, queue: cl.CommandQueue | None = None):
+def _logical_op(x1: Array | ScalarLike,
+                x2: Array | ScalarLike,
+                out: Array | None,
+                operator: str,
+                queue: cl.CommandQueue | None = None) -> Array:
     # NOTE: Copied from pycuda.gpuarray
     assert operator in ["&&", "||"]
 
@@ -3129,6 +3212,7 @@ def _logical_op(x1, x2, out, operator, queue: cl.CommandQueue | None = None):
 
         out = out or ary_arg._new_like_me(dtype=np.int8)
 
+        assert queue is not None
         assert out.shape == ary_arg.shape and out.dtype == np.int8
 
         knl = elementwise.get_array_scalar_binop_kernel(
@@ -3153,6 +3237,7 @@ def _logical_op(x1, x2, out, operator, queue: cl.CommandQueue | None = None):
             out = empty(queue, allocator=allocator,
                         shape=x1.shape, dtype=np.int8)
 
+        assert queue is not None
         assert out.shape == x1.shape and out.dtype == np.int8
 
         knl = elementwise.get_array_binop_kernel(