array-api-strict 2.5__py3-none-any.whl → 2.6__py3-none-any.whl

array_api_strict/_array_object.py

@@ -20,7 +20,7 @@ import sys
 from collections.abc import Iterator
 from enum import IntEnum
 from types import EllipsisType, ModuleType
-from typing import Any, Final, Literal, SupportsIndex, Callable
+from typing import Any, Literal, SupportsIndex, Callable
 
 import numpy as np
 import numpy.typing as npt
@@ -40,35 +40,14 @@ from ._dtypes import (
     _real_to_complex_map,
     _result_type,
 )
+from ._devices import (
+    CPU_DEVICE, Device, device_supports_dtype, _normalize_dl_device, _DLPACK_DEVICE_FOR,
+    DLDeviceType
+)
 from ._flags import get_array_api_strict_flags, set_array_api_strict_flags
 from ._typing import PyCapsule
 
 
-class Device:
-    _device: Final[str]
-    __slots__ = ("_device", "__weakref__")
-
-    def __init__(self, device: str = "CPU_DEVICE"):
-        if device not in ("CPU_DEVICE", "device1", "device2"):
-            raise ValueError(f"The device '{device}' is not a valid choice.")
-        self._device = device
-
-    def __repr__(self) -> str:
-        return f"array_api_strict.Device('{self._device}')"
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Device):
-            return False
-        return self._device == other._device
-
-    def __hash__(self) -> int:
-        return hash(("Device", self._device))
-
-
-CPU_DEVICE = Device()
-ALL_DEVICES = (CPU_DEVICE, Device("device1"), Device("device2"))
-
-
 class Array:
     """
     n-d array object for the array API namespace.
@@ -113,10 +92,15 @@ class Array:
             raise TypeError(
                 f"The array_api_strict namespace does not support the dtype '{x.dtype}'"
             )
-        obj._array = x
-        obj._dtype = _dtype
+
         if device is None:
             device = CPU_DEVICE
+        if not device_supports_dtype(device, _dtype):
+            raise ValueError(f"Device {device!r} does not support dtype={_dtype!r}.")
+
+        obj._array = x
+        obj._dtype = _dtype
+
         obj._device = device
         return obj
 
@@ -400,7 +384,7 @@ class Array:
                 isinstance(i, SupportsIndex)  # i.e. ints
                 or isinstance(i, slice)
                 or i == Ellipsis
-                or i is None
+                or (op == "getitem" and i is None) # `None` disallowed in setitem
                 or isinstance(i, Array)
                 or isinstance(i, np.ndarray)
             ):
@@ -630,22 +614,40 @@ class Array:
                 raise NotImplementedError("The copy argument to __dlpack__ is not yet implemented")
 
             return self._array.__dlpack__(stream=stream)
-        else:
-            kwargs = {'stream': stream}
-            if max_version is not _undef:
-                kwargs['max_version'] = max_version
-            if dl_device is not _undef:
-                kwargs['dl_device'] = dl_device
-            if copy is not _undef:
-                kwargs['copy'] = copy
-            return self._array.__dlpack__(**kwargs)
+
+        kwargs: dict[str, Any] = {'stream': stream}
+        self_dl_device = _normalize_dl_device(*_DLPACK_DEVICE_FOR[self._device])
+        cpu_dl_device = _normalize_dl_device(DLDeviceType.kDLCPU, 0)
+        numpy_dl_device: tuple[IntEnum, int] | None = None
+
+        if dl_device not in [_undef, None]:
+            requested = _normalize_dl_device(dl_device[0], dl_device[1])
+            if requested == self_dl_device:
+                pass
+            elif requested == cpu_dl_device and self_dl_device != cpu_dl_device:
+                if copy is False:
+                    raise BufferError(
+                        "Cannot export array to CPU without copying when copy=False"
+                    )
+                if copy is _undef:
+                    copy = True
+                numpy_dl_device = (DLDeviceType.kDLCPU, 0)
+            else:
+                raise BufferError("unsupported device requested")
+
+        if max_version is not _undef:
+            kwargs['max_version'] = max_version
+        if numpy_dl_device is not None:
+            kwargs['dl_device'] = numpy_dl_device
+        if copy is not _undef:
+            kwargs['copy'] = copy
+        return self._array.__dlpack__(**kwargs)
 
     def __dlpack_device__(self) -> tuple[IntEnum, int]:
         """
         Performs the operation __dlpack_device__.
         """
-        # Note: device support is required for this
-        return self._array.__dlpack_device__()
+        return _DLPACK_DEVICE_FOR[self._device]
 
     def __eq__(self, other: Array | complex, /) -> Array:  # type: ignore[override]
         """
@@ -960,6 +962,10 @@ class Array:
         other = value
         if isinstance(value, (bool, int, float, complex)):
             other = self._promote_scalar(value)
+        else:
+            if value.device != self.device:
+                raise ValueError(f"mismatched devices: {self.device = } != {value.device =}.")
+
         dt = _result_type(self.dtype, other.dtype)
         if dt != self.dtype:
             raise TypeError(f"mismatched dtypes: {self.dtype = } and {other.dtype = }")

array_api_strict/_creation_functions.py

@@ -5,7 +5,11 @@ from typing import TYPE_CHECKING, Literal
 
 import numpy as np
 
-from ._dtypes import DType, _all_dtypes, _np_dtype
+from ._dtypes import DType, _all_dtypes, _np_dtype, bool as xp_bool
+from ._devices import (
+    Device, device_supports_dtype, get_default_dtypes,
+    check_device as _check_device
+)
 from ._flags import get_array_api_strict_flags
 from ._typing import NestedSequence, SupportsBufferProtocol, SupportsDLPack
 
@@ -14,7 +18,7 @@ if TYPE_CHECKING:
     from typing_extensions import TypeIs
 
     # Circular import
-    from ._array_object import Array, Device
+    from ._array_object import Array
 
 
 class Undef(Enum):
@@ -24,10 +28,15 @@ class Undef(Enum):
 _undef = Undef.UNDEF
 
 
-def _check_valid_dtype(dtype: DType | None) -> None:
+def _check_valid_dtype(dtype: DType | None, device: Device | None = None) -> None:
     # Note: Only spelling dtypes as the dtype objects is supported.
-    if dtype not in (None,) + _all_dtypes:
-        raise ValueError(f"dtype must be one of the supported dtypes, got {dtype!r}")
+    if dtype is not None:
+        if dtype not in _all_dtypes:
+            raise ValueError(f"dtype must be one of the supported dtypes, got {dtype!r}")
+
+        if device is not None:
+            if not device_supports_dtype(device, dtype):
+                raise ValueError(f"Device {device!r} does not support dtype={dtype!r}.")
 
 
 def _supports_buffer_protocol(obj: object) -> TypeIs[SupportsBufferProtocol]:
@@ -38,18 +47,6 @@ def _supports_buffer_protocol(obj: object) -> TypeIs[SupportsBufferProtocol]:
     return True
 
 
-def _check_device(device: Device | None) -> None:
-    # _array_object imports in this file are inside the functions to avoid
-    # circular imports
-    from ._array_object import ALL_DEVICES, Device
-
-    if device is not None and not isinstance(device, Device):
-        raise ValueError(f"Unsupported device {device!r}")
-
-    if device is not None and device not in ALL_DEVICES:
-        raise ValueError(f"Unsupported device {device!r}")
-
-
 def asarray(
     obj: Array | complex | NestedSequence[complex] | SupportsBufferProtocol,
     /,
@@ -65,11 +62,12 @@ def asarray(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
+    _check_device(device)
+    _check_valid_dtype(dtype, device)
     _np_dtype = None
     if dtype is not None:
         _np_dtype = dtype._np_dtype
-    _check_device(device)
+
     if isinstance(obj, Array) and device is None:
         device = obj.device
 
@@ -108,6 +106,27 @@ def asarray(
         raise OverflowError("Integer out of bounds for array dtypes")
 
     res = np.array(obj, dtype=_np_dtype, copy=copy)
+
+    # numpy default dtype may differ; if so, adjust the dtype
+    if dtype is None and device is not None:
+        res_dtype = DType(res.dtype)
+        # The dtype selected by Numpy might not be the default dtype
+        # on this device. We thus find the default dtype for the dtype "kind", and
+        # cast to the device-appropriate default.
+        from ._data_type_functions import isdtype
+        if isdtype(res_dtype, "bool"):
+            target_dtype = DType("bool")
+        elif isdtype(res_dtype, "integral"):
+            target_dtype = get_default_dtypes(device)["integral"]
+        elif isdtype(res_dtype, "real floating"):
+            target_dtype = get_default_dtypes(device)["real floating"]
+        elif isdtype(res_dtype, "complex floating"):
+            target_dtype = get_default_dtypes(device)["complex floating"]
+        else:
+            raise ValueError(f"{res_dtype = } not understood.")
+
+        res = res.astype(target_dtype._np_dtype)
+
     return Array._new(res, device=device)
 
 
@@ -127,8 +146,13 @@ def arange(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
+    _check_valid_dtype(dtype, device)
+    if dtype is None:
+        if any(isinstance(x, float) for x in (start, stop, step)):
+            dtype = get_default_dtypes(device)["real floating"]
+        else:
+            dtype = get_default_dtypes(device)["integral"]
 
     return Array._new(
         np.arange(start, stop, step, dtype=_np_dtype(dtype)),
@@ -149,8 +173,10 @@ def empty(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
+    _check_valid_dtype(dtype, device)
+    if dtype is None:
+        dtype = get_default_dtypes(device)["real floating"]
 
     return Array._new(np.empty(shape, dtype=_np_dtype(dtype)), device=device)
 
@@ -165,10 +191,12 @@ def empty_like(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
     if device is None:
         device = x.device
+    if dtype is None:
+        dtype = x.dtype
+    _check_valid_dtype(dtype, device)
 
     return Array._new(np.empty_like(x._array, dtype=_np_dtype(dtype)), device=device)
 
@@ -189,8 +217,10 @@ def eye(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
+    _check_valid_dtype(dtype, device)
+    if dtype is None:
+        dtype = get_default_dtypes(device)["real floating"]
 
     return Array._new(
         np.eye(n_rows, M=n_cols, k=k, dtype=_np_dtype(dtype)), device=device
@@ -212,15 +242,20 @@ def from_dlpack(
         if copy is not _undef:
             raise ValueError("The copy argument to from_dlpack requires at least version 2023.12 of the array API")
 
-    # Going to wait for upstream numpy support
     if device is not _undef:
         _check_device(device)
     else:
         device = None
-    if copy not in [_undef, None]:
-        raise NotImplementedError("The copy argument to from_dlpack is not yet implemented")
+        if hasattr(x, "__dlpack_device__"):
+            from ._devices import _device_from_dlpack_device
 
-    return Array._new(np.from_dlpack(x), device=device)
+            dl_type, dl_id = x.__dlpack_device__()
+            device = _device_from_dlpack_device(dl_type, dl_id)
+    if copy in [_undef, None]:
+        # numpy 1.26 does not have the copy= arg
+        return Array._new(np.from_dlpack(x), device=device)
+
+    return Array._new(np.from_dlpack(x, copy=copy), device=device)
 
 
 def full(
@@ -237,12 +272,22 @@ def full(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
+    _check_valid_dtype(dtype, device)
 
     if not isinstance(fill_value, bool | int | float | complex):
         msg = f"Expected Python scalar fill_value, got type {type(fill_value)}"
         raise TypeError(msg)
+
+    if dtype is None:
+        if type(fill_value) == bool:
+            dtype = xp_bool
+        else:
+            kind = {
+                int: "integral", float: "real floating", complex: "complex floating"
+            }[type(fill_value)]
+            dtype = get_default_dtypes(device)[kind]
+
     res = np.full(shape, fill_value, dtype=_np_dtype(dtype))
     if DType(res.dtype) not in _all_dtypes:
         # This will happen if the fill value is not something that NumPy
@@ -266,10 +311,12 @@ def full_like(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
     if device is None:
         device = x.device
+    if dtype is None:
+        dtype = x.dtype
+    _check_valid_dtype(dtype, device)
 
     if not isinstance(fill_value, bool | int | float | complex):
         msg = f"Expected Python scalar fill_value, got type {type(fill_value)}"
@@ -300,8 +347,13 @@ def linspace(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
+    _check_valid_dtype(dtype, device)
+    if dtype is None:
+        if isinstance(start, complex) or isinstance(stop, complex):
+            dtype = get_default_dtypes(device)["complex floating"]
+        else:
+            dtype = get_default_dtypes(device)["real floating"]
 
     return Array._new(
         np.linspace(start, stop, num, dtype=_np_dtype(dtype), endpoint=endpoint),
@@ -353,8 +405,10 @@ def ones(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
+    _check_valid_dtype(dtype, device)
+    if dtype is None:
+        dtype = get_default_dtypes(device)["real floating"]
 
     return Array._new(np.ones(shape, dtype=_np_dtype(dtype)), device=device)
 
@@ -369,10 +423,12 @@ def ones_like(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
     if device is None:
         device = x.device
+    if dtype is None:
+        dtype = x.dtype
+    _check_valid_dtype(dtype, device)
 
     return Array._new(np.ones_like(x._array, dtype=_np_dtype(dtype)), device=device)
 
@@ -418,8 +474,10 @@ def zeros(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
+    _check_valid_dtype(dtype, device)
+    if dtype is None:
+        dtype = get_default_dtypes(device)["real floating"]
 
     return Array._new(np.zeros(shape, dtype=_np_dtype(dtype)), device=device)
 
@@ -434,9 +492,11 @@ def zeros_like(
     """
     from ._array_object import Array
 
-    _check_valid_dtype(dtype)
     _check_device(device)
     if device is None:
         device = x.device
+    if dtype is None:
+        dtype = x.dtype
+    _check_valid_dtype(dtype, device)
 
     return Array._new(np.zeros_like(x._array, dtype=_np_dtype(dtype)), device=device)

array_api_strict/_devices.py

@@ -0,0 +1,136 @@
+from typing import Final
+from enum import IntEnum
+
+from ._dtypes import (
+    DType, float32, float64, complex64, complex128, int64,
+    _all_dtypes, _boolean_dtypes, _signed_integer_dtypes,
+    _unsigned_integer_dtypes, _integer_dtypes, _real_floating_dtypes,
+    _complex_floating_dtypes, _numeric_dtypes
+)
+
+_ALL_DEVICE_NAMES = ("CPU_DEVICE", "device1", "device2", "no_float64")
+
+class Device:
+    _device: Final[str]
+    __slots__ = ("_device", "__weakref__")
+
+    def __init__(self, device: str = "CPU_DEVICE"):
+        if device not in _ALL_DEVICE_NAMES:
+            raise ValueError(f"The device '{device}' is not a valid choice.")
+        self._device = device
+
+    def __repr__(self) -> str:
+        return f"array_api_strict.Device('{self._device}')"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Device):
+            return False
+        return self._device == other._device
+
+    def __hash__(self) -> int:
+        return hash(("Device", self._device))
+
+
+CPU_DEVICE = Device()
+NO_FLOAT64_DEVICE = Device("no_float64")
+
+ALL_DEVICES = (CPU_DEVICE, Device("device1"), Device("device2"), NO_FLOAT64_DEVICE)
+
+class DLDeviceType(IntEnum):
+    kDLCPU = 1
+    kDLCUDA = 2
+    kDLMETAL = 8
+
+
+_DLPACK_DEVICE_FOR: Final[dict[Device, tuple[DLDeviceType, int]]] = {
+    CPU_DEVICE: (DLDeviceType.kDLCPU, 0),
+    Device("device1"): (DLDeviceType.kDLCUDA, 0),
+    Device("device2"): (DLDeviceType.kDLCUDA, 1),
+    NO_FLOAT64_DEVICE: (DLDeviceType.kDLMETAL, 0),
+}
+
+_DLPACK_DEVICE_TO_LOGICAL: Final[dict[tuple[int, int], Device]] = {
+    (int(device_type), device_id): logical_device
+    for logical_device, (device_type, device_id) in _DLPACK_DEVICE_FOR.items()
+}
+
+
+def _normalize_dl_device(device_type: IntEnum | int, device_id: int) -> tuple[int, int]:
+    return (int(device_type), device_id)
+
+
+def _device_from_dlpack_device(
+    device_type: IntEnum | int, device_id: int
+) -> Device:
+    # NB: if the (device_type, device_id) pair not known, raise
+    return _DLPACK_DEVICE_TO_LOGICAL[_normalize_dl_device(device_type, device_id)]
+
+
+def check_device(device: Device | None) -> None:
+    if device is not None and not isinstance(device, Device):
+        raise ValueError(f"Unsupported device {device!r}")
+
+    if device is not None and device not in ALL_DEVICES:
+        raise ValueError(f"Unsupported device {device!r}")
+
+
+# Helpers for device-specific dtype support
+
+def get_default_dtypes(device: Device | None = None) -> dict[str, DType]:
+    if device == NO_FLOAT64_DEVICE:
+        # mimic an MPS device which does not have float64 at all
+        return {
+            "real floating": float32,
+            "complex floating": complex64,
+            "integral": int64,
+            "indexing": int64,
+        }
+    elif device == Device('device2'):
+        # mimic a torch CPU device: support float64 but default to float32
+        return {
+            "real floating": float32,
+            "complex floating": complex64,
+            "integral": int64,
+            "indexing": int64,
+        }
+    else:
+        return {
+            "real floating": float64,
+            "complex floating": complex128,
+            "integral": int64,
+            "indexing": int64,
+        }
+
+
+def device_supports_dtype(device: Device | None, dtype: DType |None) -> bool:
+    """True if `device` supports `dtype`, False otherwise."""
+    # Device("no_float64") supports all dtypes except float64 and complex128
+    if device == NO_FLOAT64_DEVICE:
+        return dtype not in (float64, complex128)
+
+    # All other devices support all dtypes
+    return True
+
+
+def _map_supported(dtypes: list[DType], device: Device) -> dict[str, DType]:
+    return {
+        dt._canonical_name: dt
+        for dt in dtypes
+        if device_supports_dtype(device, dt)
+    }
+
+
+# _info.dtypes() maps "kind" -> dict of {name: dtype}
+# Note that "kinds" differ from "categories" above, per the spec.
+
+_kind_to_dtypes = {
+    None: _all_dtypes,
+    "bool": _boolean_dtypes,
+    "signed integer": _signed_integer_dtypes,
+    "unsigned integer": _unsigned_integer_dtypes,
+    "integral": _integer_dtypes,
+    "real floating": _real_floating_dtypes,
+    "complex floating": _complex_floating_dtypes,
+    "numeric": _numeric_dtypes
+}
+

array_api_strict/_dtypes.py

@@ -11,9 +11,11 @@ import numpy.typing as npt
 
 class DType:
     _np_dtype: Final[np.dtype[Any]]
-    __slots__ = ("_np_dtype", "__weakref__")
+    _canonical_name: Final[Any]
+    __slots__ = ("_np_dtype", "_canonical_name", "__weakref__")
 
     def __init__(self, np_dtype: npt.DTypeLike):
+        self._canonical_name = np_dtype
         self._np_dtype = np.dtype(np_dtype)
 
     def __repr__(self) -> str:

array_api_strict/_fft.py

@@ -3,7 +3,8 @@ from typing import Literal
 
 import numpy as np
 
-from ._array_object import ALL_DEVICES, Array, Device
+from ._array_object import Array
+from ._devices import ALL_DEVICES, Device, device_supports_dtype
 from ._data_type_functions import astype
 from ._dtypes import (
     DType,
@@ -13,6 +14,7 @@ from ._dtypes import (
     complex64,
     float32,
 )
+from ._info import __array_namespace_info__
 from ._flags import requires_extension
 
 
@@ -268,6 +270,15 @@ def fftfreq(
     np_result = np.fft.fftfreq(n, d=d)
     if dtype:
         np_result = np_result.astype(dtype._np_dtype)
+
+    if not device_supports_dtype(device, DType(np_result.dtype)):
+        if dtype:
+            # user input unsupported
+            raise ValueError(f"Device {device!r} does not support dtype={dtype!r}.")
+
+        dt = __array_namespace_info__().default_dtypes(device=device)["real floating"]
+        np_result = np_result.astype(dt._np_dtype)
+
     return Array._new(np_result, device=device)
 
 @requires_extension('fft')
@@ -292,6 +303,15 @@ def rfftfreq(
     np_result = np.fft.rfftfreq(n, d=d)
     if dtype:
         np_result = np_result.astype(dtype._np_dtype)
+
+    if not device_supports_dtype(device, DType(np_result.dtype)):
+        if dtype:
+            # user input unsupported
+            raise ValueError(f"Device {device!r} does not support dtype={dtype!r}.")
+
+        dt = __array_namespace_info__().default_dtypes(device=device)["real floating"]
+        np_result = np_result.astype(dt._np_dtype)
+
     return Array._new(np_result, device=device)
 
 @requires_extension('fft')

array_api_strict/_info.py

@@ -1,7 +1,7 @@
 import numpy as np
 
-from . import _dtypes as dt
-from ._array_object import ALL_DEVICES, CPU_DEVICE, Device
+from . import _devices
+from ._devices import ALL_DEVICES, CPU_DEVICE, Device
 from ._flags import get_array_api_strict_flags, requires_api_version
 from ._typing import Capabilities, DataTypes, DefaultDataTypes
 
@@ -40,12 +40,7 @@ class __array_namespace_info__:
         *,
         device: Device | None = None,
     ) -> DefaultDataTypes:
-        return {
-            "real floating": dt.float64,
-            "complex floating": dt.complex128,
-            "integral": dt.int64,
-            "indexing": dt.int64,
-        }
+        return _devices.get_default_dtypes(device)
 
     @requires_api_version('2023.12')
     def dtypes(
@@ -54,78 +49,21 @@ class __array_namespace_info__:
         device: Device | None = None,
         kind: str | tuple[str, ...] | None = None,
     ) -> DataTypes:
-        if kind is None:
-            return {
-                "bool": dt.bool,
-                "int8": dt.int8,
-                "int16": dt.int16,
-                "int32": dt.int32,
-                "int64": dt.int64,
-                "uint8": dt.uint8,
-                "uint16": dt.uint16,
-                "uint32": dt.uint32,
-                "uint64": dt.uint64,
-                "float32": dt.float32,
-                "float64": dt.float64,
-                "complex64": dt.complex64,
-                "complex128": dt.complex128,
-            }
-        if kind == "bool":
-            return {"bool": dt.bool}
-        if kind == "signed integer":
-            return {
-                "int8": dt.int8,
-                "int16": dt.int16,
-                "int32": dt.int32,
-                "int64": dt.int64,
-            }
-        if kind == "unsigned integer":
-            return {
-                "uint8": dt.uint8,
-                "uint16": dt.uint16,
-                "uint32": dt.uint32,
-                "uint64": dt.uint64,
-            }
-        if kind == "integral":
-            return {
-                "int8": dt.int8,
-                "int16": dt.int16,
-                "int32": dt.int32,
-                "int64": dt.int64,
-                "uint8": dt.uint8,
-                "uint16": dt.uint16,
-                "uint32": dt.uint32,
-                "uint64": dt.uint64,
-            }
-        if kind == "real floating":
-            return {
-                "float32": dt.float32,
-                "float64": dt.float64,
-            }
-        if kind == "complex floating":
-            return {
-                "complex64": dt.complex64,
-                "complex128": dt.complex128,
-            }
-        if kind == "numeric":
-            return {
-                "int8": dt.int8,
-                "int16": dt.int16,
-                "int32": dt.int32,
-                "int64": dt.int64,
-                "uint8": dt.uint8,
-                "uint16": dt.uint16,
-                "uint32": dt.uint32,
-                "uint64": dt.uint64,
-                "float32": dt.float32,
-                "float64": dt.float64,
-                "complex64": dt.complex64,
-                "complex128": dt.complex128,
-            }
-        if isinstance(kind, tuple):
+        if device is None:
+            device = CPU_DEVICE
+        if isinstance(kind, type(None) | str):
+
+            try:
+                dtypes = _devices._kind_to_dtypes[kind]
+            except KeyError:
+                raise ValueError(f"unsupported kind: {kind!r}")  
+            res = _devices._map_supported(dtypes, device)
+            return res
+
+        elif isinstance(kind, tuple):
             res: DataTypes = {}
             for k in kind:
-                res.update(self.dtypes(kind=k))
+                res.update(self.dtypes(kind=k, device=device))
             return res
         raise ValueError(f"unsupported kind: {kind!r}")
 

array_api_strict/_statistical_functions.py

@@ -39,7 +39,10 @@ def cumulative_sum(
     if include_initial:
         if axis < 0:
             axis += x.ndim
-        x = concat([zeros(x.shape[:axis] + (1,) + x.shape[axis + 1:], dtype=x.dtype), x], axis=axis)
+        x = concat(
+            [zeros(x.shape[:axis] + (1,) + x.shape[axis + 1:], dtype=x.dtype, device=x.device), x],
+            axis=axis
+        )
     return Array._new(np.cumsum(x._array, axis=axis, dtype=_np_dtype(dtype)), device=x.device)
 
 
@@ -66,7 +69,10 @@ def cumulative_prod(
     if include_initial:
         if axis < 0:
             axis += x.ndim
-        x = concat([ones(x.shape[:axis] + (1,) + x.shape[axis + 1:], dtype=x.dtype), x], axis=axis)
+        x = concat(
+            [ones(x.shape[:axis] + (1,) + x.shape[axis + 1:], dtype=x.dtype, device=x.device), x],
+            axis=axis
+        )
     return Array._new(np.cumprod(x._array, axis=axis, dtype=_np_dtype(dtype)), device=x.device)
 
 

array_api_strict/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.5'
-__version_tuple__ = version_tuple = (2, 5)
+__version__ = version = '2.6'
+__version_tuple__ = version_tuple = (2, 6)
 
 __commit_id__ = commit_id = None

array_api_strict/tests/test_array_object.py

@@ -9,7 +9,8 @@ import numpy as np
 import pytest
 
 from .. import ones, arange, reshape, asarray, result_type, all, equal, stack
-from .._array_object import Array, CPU_DEVICE, Device
+from .._array_object import Array
+from .._devices import CPU_DEVICE, Device, DLDeviceType
 from .._dtypes import (
     _all_dtypes,
     _boolean_dtypes,
@@ -220,6 +221,14 @@ def test_setitem_invalid_promotions():
         a[0] = asarray(3.5j, dtype=complex128)
 
 
+def test_setitem_device_transfer():
+    a = arange(3)
+    b = arange(4, 1, -1, device=Device('device1'))
+
+    with pytest.raises(ValueError):
+        a[:] = b[:]
+
+
 def test_promoted_scalar_inherits_device():
     device1 = Device("device1")
     x = asarray([1., 2, 3], device=device1)
@@ -749,6 +758,40 @@ def test_dlpack_2023_12(api_version):
         a.__dlpack__(copy=True)
         a.__dlpack__(copy=None)
 
+@pytest.mark.parametrize(
+    ("device", "expected"),
+    [
+        (CPU_DEVICE, (DLDeviceType.kDLCPU, 0)),
+        (Device("device1"), (DLDeviceType.kDLCUDA, 0)),
+        (Device("device2"), (DLDeviceType.kDLCUDA, 1)),
+    ],
+)
+def test_dlpack_device_numbers(device, expected):
+    a = asarray([1, 2, 3], device=device)
+    assert a.__dlpack_device__() == expected
+
+
+@pytest.mark.parametrize("device", [CPU_DEVICE, Device("device1"), Device("device2")])
+def test_dlpack_export_with_matching_dl_device(device):
+    if np.lib.NumpyVersion(np.__version__) < "2.1.0":
+        pytest.skip("dl_device argument requires NumPy >= 2.1.0")
+    set_array_api_strict_flags(api_version="2023.12")
+
+    a = asarray([1, 2, 3], device=device)
+    a.__dlpack__(dl_device=a.__dlpack_device__())
+
+
+@pytest.mark.parametrize("device", [Device("device1"), Device("device2")])
+def test_dlpack_cross_device_export_buffer_error(device):
+    if np.lib.NumpyVersion(np.__version__) < "2.1.0":
+        pytest.skip("dl_device argument requires NumPy >= 2.1.0")
+    set_array_api_strict_flags(api_version="2023.12")
+
+    a = asarray([1, 2, 3], device=device)
+    with pytest.raises(BufferError):
+        a.__dlpack__(dl_device=(DLDeviceType.kDLCPU, 0), copy=False)
+
+
 def test_pickle():
     """Check that arrays are pickleable (despite raising on `__new__`)"""
     a = ones(2)

array_api_strict/tests/test_creation_functions.py

@@ -22,8 +22,10 @@ from .._creation_functions import (
     zeros,
     zeros_like,
 )
-from .._dtypes import float32, float64
-from .._array_object import Array, CPU_DEVICE, Device
+from .._dtypes import float32, float64, complex64, bool as xp_bool
+from .._array_object import Array
+from .._devices import CPU_DEVICE, ALL_DEVICES, Device
+from .._info import __array_namespace_info__
 from .._flags import set_array_api_strict_flags
 
 def test_asarray_errors():
@@ -212,6 +214,7 @@ def test_zeros_like_errors():
     assert_raises(ValueError, lambda: zeros_like(asarray(1), dtype=int))
     assert_raises(ValueError, lambda: zeros_like(asarray(1), dtype="i"))
 
+
 def test_meshgrid_dtype_errors():
     # Doesn't raise
     meshgrid()
@@ -221,6 +224,150 @@ def test_meshgrid_dtype_errors():
     assert_raises(ValueError, lambda: meshgrid(asarray([1.], dtype=float32), asarray([1.], dtype=float64)))
 
 
+
+def _full(a, *args, **kwds):
+    return full(a, fill_value=42.0, *args, **kwds)
+
+
+def _full_like(a, *args, **kwds):
+    return full_like(a, fill_value=42.0, *args, **kwds)
+
+
+class TestDefaultDType:
+
+    info = __array_namespace_info__()
+
+    @pytest.mark.parametrize("device", ALL_DEVICES)
+    @pytest.mark.parametrize("func", [empty, zeros, ones, _full])
+    def test_ones_etc(self, func, device):
+        a = func(1, device=device)
+        assert a.dtype == self.info.default_dtypes(device=device)["real floating"]
+
+    @pytest.mark.parametrize("func", [empty_like, zeros_like, ones_like, _full_like])
+    def test_ones_like_etc_correct(self, func):
+        # float32 is preserved
+        a = ones(2, dtype=float32)
+        device = Device('no_float64')
+        b = func(a, device=device)
+        assert b.dtype == self.info.default_dtypes(device=device)["real floating"]
+        assert b.device == device
+
+    @pytest.mark.parametrize("func", [empty_like, zeros_like, ones_like, _full_like])
+    def test_ones_like_etc_incorrect(self, func):
+        a = ones(2)
+        assert a.dtype == float64
+        assert a.device == Device()
+
+        # XXX: a.dtype not supported by the device: ValueError or TypeError?
+
+        # >>> a = torch.ones(3, dtype=torch.float64, device='cpu')
+        # >>> torch.ones_like(a, device='mps')
+        # TypeError: Cannot convert a MPS Tensor to float64 dtype as the MPS framework
+        # doesn't support float64.
+
+        # incompatible dtype inferred from `a.dtype`
+        with pytest.raises((TypeError, ValueError)):
+            func(a, device=Device('no_float64'))
+
+        # `a.dtype` is compatible but the explicit dtype= argument is incompatible
+        a = ones(2, dtype=float32)
+        with pytest.raises((TypeError, ValueError)):
+            func(a, device=Device('no_float64'), dtype=float64)
+
+    def test_eye(self):
+        device = Device('no_float64')
+        a = eye(3, device=device)
+        assert a.dtype == self.info.default_dtypes(device=device)["real floating"]
+        assert a.device == device
+
+        with pytest.raises((TypeError, ValueError)):
+            eye(3, device=device, dtype=float64)
+
+    def test_linspace(self):
+        device = Device('no_float64')
+
+        a = linspace(1, 10, 11, device=device)
+        assert a.dtype == self.info.default_dtypes(device=device)["real floating"]
+        assert a.device == device
+
+        a = linspace(1+0j, 10, 11, device=device)
+        assert a.dtype == self.info.default_dtypes(device=device)["complex floating"]
+
+        with pytest.raises((TypeError, ValueError)):
+            linspace(1, 10, 11, device=device, dtype=float64)
+
+    def test_arange(self):
+        device = Device('no_float64')
+
+        a = arange(0, 10, 1, device=device)
+        assert a.dtype == self.info.default_dtypes(device=device)["integral"]
+        assert a.device == device
+
+        a = arange(0.0, 10, 1, device=device)
+        assert a.dtype == self.info.default_dtypes(device=device)["real floating"]
+        assert a.device == device
+
+        with pytest.raises((TypeError, ValueError)):
+            arange(0, 10, 1, device=device, dtype=float64)
+
+        with pytest.raises((TypeError, ValueError)):
+            arange(0.0, 10, 1, device=device, dtype=float64)
+
+    def test_asarray(self):
+        device = Device('no_float64')
+
+        ### asarray(python_object)
+        for x in (True, [False,]):
+            arr = asarray(x, device=device)
+            assert arr.dtype == xp_bool
+            assert arr.device == device
+
+        for x in [1, [1,]]:
+            arr = asarray(x, device=device)
+            assert arr.dtype == self.info.default_dtypes(device=device)['integral']
+            assert arr.device == device
+
+        for x in [1.0, [1.0,]]:
+            arr = asarray(x, device=device)
+            assert arr.dtype == self.info.default_dtypes(device=device)['real floating']
+            assert arr.device == device
+
+        for x in [1j, [1j,]]:
+            arr = asarray(x, device=device)
+            assert arr.dtype == self.info.default_dtypes(device=device)['complex floating']
+            assert arr.device == device
+
+        # asarray(python_object, dtype=unsupported_by_device)
+        with pytest.raises(ValueError, match="Device"):
+            asarray(1, dtype=float64, device=device)
+
+        ### asarray(array)
+
+        # compatible dtypes, device transfer
+        src = asarray(1, dtype=float32, device=Device('device1'))
+        dst = asarray(src, device=device)
+        assert dst.device == device
+        assert dst.dtype == float32
+
+        # incompatible dtypes, device transfer
+        src = asarray(1, dtype=float64, device=Device('device1'))
+
+        with pytest.raises(ValueError, match="Device"):
+            asarray(src, device=device)
+
+
+def test_asarray_device_2():
+    # device2 allows float64 but defaults to float32
+    x = asarray([1.0], device=Device('device2'))
+    assert x.dtype == float32
+
+    x = asarray([1j], device=Device('device2'))
+    assert x.dtype == complex64
+
+    y = asarray([1.0], device=Device('device2'), dtype=float64)
+    assert y.dtype == float64
+
+
 @pytest.mark.parametrize("api_version", ['2021.12', '2022.12', '2023.12'])
 def from_dlpack_2023_12(api_version):
     if api_version != '2022.12':
@@ -247,3 +394,13 @@ def test_from_dlpack_default_device():
     y = from_dlpack(x)
     z = from_dlpack(np.asarray([1, 2, 3]))
     assert x.device == y.device == z.device == CPU_DEVICE
+
+
+@pytest.mark.parametrize(
+    "device",
+    [Device("device1"), Device("device2")],
+)
+def test_from_dlpack_preserves_device(device):
+    x = asarray([1, 2, 3], device=device)
+    y = from_dlpack(x)
+    assert y.device == device

array_api_strict/tests/test_device_support.py

@@ -1,6 +1,6 @@
 import pytest
 
-import array_api_strict
+import array_api_strict as xp
 
 
 @pytest.mark.parametrize(
@@ -18,11 +18,11 @@ import array_api_strict
     ),
 )
 def test_fft_device_support_complex(func_name):
-    func = getattr(array_api_strict.fft, func_name)
-    x = array_api_strict.asarray(
+    func = getattr(xp.fft, func_name)
+    x = xp.asarray(
         [1, 2.0],
-        dtype=array_api_strict.complex64,
-        device=array_api_strict.Device("device1"),
+        dtype=xp.complex64,
+        device=xp.Device("device1"),
     )
     y = func(x)
 
@@ -31,8 +31,50 @@ def test_fft_device_support_complex(func_name):
 
 @pytest.mark.parametrize("func_name", ("rfft", "rfftn", "ihfft"))
 def test_fft_device_support_real(func_name):
-    func = getattr(array_api_strict.fft, func_name)
-    x = array_api_strict.asarray([1, 2.0], device=array_api_strict.Device("device1"))
+    func = getattr(xp.fft, func_name)
+    x = xp.asarray([1, 2.0], device=xp.Device("device1"))
     y = func(x)
 
     assert x.device == y.device
+
+
+@pytest.mark.parametrize("func_name", ("fftfreq", "rfftfreq"))
+def test_fft_default_dtype(func_name):
+    func = getattr(xp.fft, func_name)
+    device = xp.Device("no_float64")
+    res = func(3, device=device)
+    assert res.device == device
+    assert res.dtype == xp.__array_namespace_info__().default_dtypes(device=device)["real floating"]
+
+    with pytest.raises(ValueError):
+        func(3, device=device, dtype=xp.float64)
+
+
+class TestF32Device:
+    @pytest.mark.parametrize("dtype_str", ["float64", "complex128"])
+    def test_f64_raises(self, dtype_str):
+        f32_only_device = xp.Device("no_float64")
+        dtype = getattr(xp, dtype_str)
+        with pytest.raises(ValueError):
+            xp.arange(3, device=f32_only_device, dtype=dtype)
+
+    def test_info_no_f64(self):
+        f32_only_device = xp.Device("no_float64")
+
+        info = xp.__array_namespace_info__()
+        all_dtypes = info.dtypes(device=f32_only_device)
+        assert "float64" not in all_dtypes
+        assert "complex128" not in all_dtypes
+
+    def test_info_default_dtypes(self):
+        f32_only_device = xp.Device("no_float64")
+        info = xp.__array_namespace_info__()
+        defaults = info.default_dtypes(device=f32_only_device)
+        assert defaults["real floating"] == xp.float32
+        assert defaults["complex floating"] == xp.complex64
+
+        cpu_device = xp.Device()
+        info = xp.__array_namespace_info__()
+        defaults = info.default_dtypes(device=cpu_device)
+        assert defaults["real floating"] == xp.float64
+        assert defaults["complex floating"] == xp.complex128

array_api_strict/tests/test_elementwise_functions.py

@@ -6,7 +6,7 @@ import pytest
 
 
 from .. import asarray, _elementwise_functions
-from .._array_object import ALL_DEVICES, CPU_DEVICE, Device
+from .._devices import ALL_DEVICES, CPU_DEVICE, Device
 from .._elementwise_functions import bitwise_left_shift, bitwise_right_shift
 from .._dtypes import (
     _dtype_categories,
@@ -21,6 +21,7 @@ from .._dtypes import (
     int64,
     uint64,
 )
+from .._info import __array_namespace_info__
 from .test_array_object import _check_op_array_scalar, BIG_INT
 
 import array_api_strict
@@ -144,6 +145,10 @@ def test_elementwise_function_device_persists(func_name, types, device):
             yield asarray(1., dtype=dtype, device=device)
 
     dtypes = _dtype_categories[types]
+
+    supported_dtypes = __array_namespace_info__().dtypes(device=device)
+    dtypes = [dt for dt in dtypes if dt in supported_dtypes]
+
     func = getattr(_elementwise_functions, func_name)
 
     for x in _array_vals(dtypes):

array_api_strict/tests/test_searching_functions.py

@@ -3,7 +3,7 @@ import pytest
 import array_api_strict as xp
 
 from array_api_strict import ArrayAPIStrictFlags
-from .._array_object import ALL_DEVICES, CPU_DEVICE, Device
+from .._devices import ALL_DEVICES, CPU_DEVICE, Device
 from .._dtypes import _all_dtypes
 
 

array_api_strict/tests/test_statistical_functions.py

@@ -55,3 +55,19 @@ def test_mean_complex():
     with pytest.raises(TypeError):
         xp.mean(xp.arange(3))
 
+
+def test_cumsum_device():
+    x = xp.arange(3, device=xp.Device('device1'))
+    y = xp.cumulative_sum(x, include_initial=True)
+    expected = xp.asarray([0, 0, 1, 3], device=x.device)
+    assert y.device == expected.device
+    assert xp.all(y == expected)
+
+
+def test_cumprod_device():
+    x = xp.arange(1, 4, device=xp.Device('device1'))
+    y = xp.cumulative_prod(x, include_initial=True)
+    expected = xp.asarray([1, 1, 2, 6], device=x.device)
+    assert y.device == expected.device
+    assert xp.all(y == expected)
+

{array_api_strict-2.5.dist-info → array_api_strict-2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: array_api_strict
-Version: 2.5
+Version: 2.6
 Summary: A strict, minimal implementation of the Python array API standard.
 Author: Consortium for Python Data API Standards
 License: Copyright (c) 2021-2024, NumPy Developers, Consortium for Python Data API Standards

{array_api_strict-2.5.dist-info → array_api_strict-2.6.dist-info}/RECORD

@@ -1,44 +1,45 @@
 array_api_strict/__init__.py,sha256=kexXRJ7WHgMTeMi80H6XiObC3ePtUEr5gf92dnwyPGE,7173
-array_api_strict/_array_object.py,sha256=m5197OW2aW778dGDMjQI4Zxaw5BfIqXWQ6sJK_DpgaA,54393
+array_api_strict/_array_object.py,sha256=wOCTJl6JaeOqbS1aoH0wbFlfx1vqR6Jzu0U-5w9-Ncw,54938
 array_api_strict/_constants.py,sha256=ilkAGjIceZxT4zPywIoWbl3Xv8k19UOI4SSF6EPegpg,93
-array_api_strict/_creation_functions.py,sha256=TXookrcG1zeUBMvgFdbiwXxZJ1aMvViSef24tqVo53s,12658
+array_api_strict/_creation_functions.py,sha256=1M6WYyTbVHfiFaTYkCZPG-j-dmt6LdifnM9Y4GD_TSo,15100
 array_api_strict/_data_type_functions.py,sha256=5OPnsIj4QafrSlnizUZcO4DHO5u0ap9OyDNovV4qrns,8765
-array_api_strict/_dtypes.py,sha256=PNSd4LpGdnRiEGoB2uqxi93d0dmtiyFp_awUzUcdHJE,6597
+array_api_strict/_devices.py,sha256=k3QdhG2NKGw5DfHAZOvkJ-d_ft1Jn7083D4dXoeETwU,4225
+array_api_strict/_dtypes.py,sha256=ejImxjVLg7-jSKrdKqGDCXZ8oHYKGhdl68WiP9uaIho,6688
 array_api_strict/_elementwise_functions.py,sha256=D3jOalyR5-kDSzeGTZLKnGPVwjKBuPihkwn23YSxcUc,13198
-array_api_strict/_fft.py,sha256=DVw7KK4Xvyf3_0rJuWdskggGRCSxS4OrguYNVBf9fH0,10189
+array_api_strict/_fft.py,sha256=Ut1IgT6lIbpC2g_j2eFejLvW9NpctKuDwdOOJ5luNFE,10971
 array_api_strict/_flags.py,sha256=JaaGahMa-yQjz9fq2E_cFQvhh5B5rVJKms9pMcwdKAg,14758
 array_api_strict/_helpers.py,sha256=St8M41s5pdhdPdn1-BcdZCrNtRID4X9z5F28fBD3GNg,1915
 array_api_strict/_indexing_functions.py,sha256=BHPtoyRUIoEMe28MkwUrHRSz5X71i8w_WkTuWQljrpI,1398
-array_api_strict/_info.py,sha256=nGLPkobKqDuLlLD4yOxG4y3JVO98o9UNEImXu6YeKH8,4532
+array_api_strict/_info.py,sha256=U0EgZiPbksc0mcZTALlDx5AnKKUTChc9aR1CQOqFXAg,2551
 array_api_strict/_linalg.py,sha256=HQjpkVPB0R59mOQBR4cqlZTUKOQTEjGEXbkwk3KNa2Y,21495
 array_api_strict/_linear_algebra_functions.py,sha256=j8fSBharI31ugZHsUvm74Nv3SHxRrxqtmouK3AOH038,3800
 array_api_strict/_manipulation_functions.py,sha256=KR0O7bMulglaX0DoqEWpiNK3V25D12mFdsqeq-vm8mg,6935
 array_api_strict/_searching_functions.py,sha256=X7pT_kuGBpJltpo4MvVYiZdnKr7jgnH1DNtHiHTKdgw,4263
 array_api_strict/_set_functions.py,sha256=yTKA2OqueeKwk8tp_XcpcsWliL02kgzT3NBzot5zuQ8,4196
 array_api_strict/_sorting_functions.py,sha256=kw_ns3NajcA8ekpHikNhZxvVePXa3gjdZ7oTwFnBOmk,2074
-array_api_strict/_statistical_functions.py,sha256=XR9PoZmxJWTsAbzYj05ytDn2D2YDf2YTzWNApdmJBIM,5642
+array_api_strict/_statistical_functions.py,sha256=MVjoxIvy3eWfWtNXFq6VFMg-Ygmnn9_eixEa8z_EUrc,5744
 array_api_strict/_typing.py,sha256=FVM2m6ZTZYDnznCo0SlMRpcXxGR49y6k4ejNEiuGUtc,1486
 array_api_strict/_utility_functions.py,sha256=L7FJM-RT90gqkAqvMEfQ6FkzurTziHByROk_5R8a5fY,1938
-array_api_strict/_version.py,sha256=hJiFMfUPM_IAKDdGwMOVrwsdi46DfhTA5ZGiPklON8o,699
+array_api_strict/_version.py,sha256=3bHZCrpqHyLVEDhNiGUyfzQKJwposHttYzrlwruXOpM,699
 array_api_strict/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 array_api_strict/tests/__init__.py,sha256=t_2GZ3lKcsu4ec4GMKPUDYaeMUJyDquBlQAcPgj7kFE,282
 array_api_strict/tests/conftest.py,sha256=-wIDryl2MdRLdSonU1G1xWssNq2TFKiWuHquNasXYA8,468
-array_api_strict/tests/test_array_object.py,sha256=PZj2Ekw6sY1pbNBrjs2Ll3COkGRVXNsROxirpHfXHJ4,29186
-array_api_strict/tests/test_creation_functions.py,sha256=KeBxgG65ZnKBwclNFZBjyoSwov3j-E3f9iMnXfUsmA8,8638
+array_api_strict/tests/test_array_object.py,sha256=65VpWqlYnEgfiNJRM2v2grYwK-iEK6rAAju3pPmQGUY,30624
+array_api_strict/tests/test_creation_functions.py,sha256=g4WXz-L5zYKGTG658oqpWtINW9UoSyaeD5IZLuq3vWk,14088
 array_api_strict/tests/test_data_type_functions.py,sha256=6V7YeJavgsBmKtR1gvY1GTTlKzGyzPAHki1WtKFeVdU,4098
-array_api_strict/tests/test_device_support.py,sha256=zpfhHxeRREoXfp0qZTlilm2ZceBc71uCKea1GMVe-ZU,855
-array_api_strict/tests/test_elementwise_functions.py,sha256=ZZOfPaCNIug026zv9IdhV2164jZZkRSwmteAnefFBGw,11396
+array_api_strict/tests/test_device_support.py,sha256=f3_OyYRMX9PPVQOOPsti9q5qgBGNyG86QxvgWdF_KPg,2361
+array_api_strict/tests/test_elementwise_functions.py,sha256=4zzXA7b5NmZnWV4aKxsVjJWdLEZV8X9Zw1UFaKMeEII,11571
 array_api_strict/tests/test_flags.py,sha256=g7Tajftvmc2ih0a6U57FxcpmleEiDoMgCvzUt2S7MF4,18982
 array_api_strict/tests/test_indexing_functions.py,sha256=C23FnuowVDC1OBuDH06pvsd61qM2dTpTwzw6UgC4BoY,1281
 array_api_strict/tests/test_linalg.py,sha256=CJ4JnCkWyysMUAih3PI-ZZeOH-X39H0p-RKBoEwk6Jw,5675
 array_api_strict/tests/test_manipulation_functions.py,sha256=Yc92IvA3FaTZueqAUOFMkx3MH4PXCHDof7ckrJxudQs,1078
-array_api_strict/tests/test_searching_functions.py,sha256=wT2VsKwBhyy233pZ2NcXMl_A8vnU1TuevbOwI4eHLF8,3441
+array_api_strict/tests/test_searching_functions.py,sha256=sTOvPUrmzOKbJZDTm_fMecvPpkVJObwZOg-454-j7Cw,3436
 array_api_strict/tests/test_set_functions.py,sha256=ikzab1j3SXxGf0OqwHrOAM13HwQetdhtB60Zc_gc1DE,542
 array_api_strict/tests/test_sorting_functions.py,sha256=1xvQBKts5KTKYc-puMITX9iR_KTbzzVB8fY-SObad_Y,899
-array_api_strict/tests/test_statistical_functions.py,sha256=0ihnw4W9vOqU6RMBOUw29Fg-xumXpfz0h05v0E0RsMQ,1814
+array_api_strict/tests/test_statistical_functions.py,sha256=c542tcGuxUQvjd8ML1U8I07UFuOhba19804-_-IC2Jc,2335
 array_api_strict/tests/test_validation.py,sha256=VDci4SgcAhxzSFVnFYBvJWXEsWRxHARnq9TwTfH02xg,635
-array_api_strict-2.5.dist-info/LICENSE,sha256=djDm4UfHAJmycwFUNyUmrTdRkrFF9Ac8uqIlbxH7j5Y,1585
-array_api_strict-2.5.dist-info/METADATA,sha256=0sP5kLahxH406PSNEXzGLED-PAWJEWZ9QV1EUg6asr4,3613
-array_api_strict-2.5.dist-info/WHEEL,sha256=5Mi1sN9lKoFv_gxcPtisEVrJZihrm_beibeg5R6xb4I,91
-array_api_strict-2.5.dist-info/top_level.txt,sha256=M4cE8VLgRHp_d9TPkbk7_I4JriELFdEJz-NKJJqAkAE,17
-array_api_strict-2.5.dist-info/RECORD,,
+array_api_strict-2.6.dist-info/LICENSE,sha256=djDm4UfHAJmycwFUNyUmrTdRkrFF9Ac8uqIlbxH7j5Y,1585
+array_api_strict-2.6.dist-info/METADATA,sha256=pwiqnybdKy12HJOL3jhV4oH_lbO66EvsekvSaeCCW8E,3613
+array_api_strict-2.6.dist-info/WHEEL,sha256=5Mi1sN9lKoFv_gxcPtisEVrJZihrm_beibeg5R6xb4I,91
+array_api_strict-2.6.dist-info/top_level.txt,sha256=M4cE8VLgRHp_d9TPkbk7_I4JriELFdEJz-NKJJqAkAE,17
+array_api_strict-2.6.dist-info/RECORD,,