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

array_api_strict/__init__.py

@@ -73,6 +73,7 @@ __all__ += [
 from ._data_type_functions import (
     astype,
     broadcast_arrays,
+    broadcast_shapes,
     broadcast_to,
     can_cast,
     finfo,
@@ -84,6 +85,7 @@ from ._data_type_functions import (
 __all__ += [
     "astype",
     "broadcast_arrays",
+    "broadcast_shapes",
     "broadcast_to",
     "can_cast",
     "finfo",
@@ -299,9 +301,9 @@ from ._searching_functions import argmax, argmin, nonzero, count_nonzero, search
 
 __all__ += ["argmax", "argmin", "nonzero", "count_nonzero", "searchsorted", "where"]
 
-from ._set_functions import unique_all, unique_counts, unique_inverse, unique_values
+from ._set_functions import unique_all, unique_counts, unique_inverse, unique_values, isin
 
-__all__ += ["unique_all", "unique_counts", "unique_inverse", "unique_values"]
+__all__ += ["unique_all", "unique_counts", "unique_inverse", "unique_values", "isin"]
 
 from ._sorting_functions import argsort, sort
 

array_api_strict/_array_object.py

@@ -16,10 +16,11 @@ of ndarray.
 from __future__ import annotations
 
 import operator
+import sys
 from collections.abc import Iterator
 from enum import IntEnum
 from types import EllipsisType, ModuleType
-from typing import Any, Final, Literal, SupportsIndex
+from typing import Any, Final, Literal, SupportsIndex, Callable
 
 import numpy as np
 import numpy.typing as npt
@@ -67,8 +68,6 @@ class Device:
 CPU_DEVICE = Device()
 ALL_DEVICES = (CPU_DEVICE, Device("device1"), Device("device2"))
 
-_default = object()
-
 
 class Array:
     """
@@ -126,6 +125,9 @@ class Array:
         raise TypeError(
             "The array_api_strict Array object should not be instantiated directly. Use an array creation function, such as asarray(), instead."
         )
+    
+    def __reduce__(self) -> tuple[Callable, tuple[npt.NDArray[Any], Device]]:
+        return (self._new, (self._array, self._device))
 
     # These functions are not required by the spec, but are implemented for
     # the sake of usability.
@@ -149,29 +151,40 @@ class Array:
 
     __str__ = __repr__
 
-    # `__array__` was implemented historically for compatibility, and removing it has
-    # caused issues for some libraries (see
-    # https://github.com/data-apis/array-api-strict/issues/67).
-
-    # Instead of `__array__` we now implement the buffer protocol.
-    # Note that it makes array-apis-strict requiring python>=3.12
     def __buffer__(self, flags):
         if self._device != CPU_DEVICE:
-            raise RuntimeError(f"Can not convert array on the '{self._device}' device to a Numpy array.")
+            raise RuntimeError(
+                # NumPy swallows this exception and falls back to __array__.
+                f"Can't extract host buffer from array on the '{self._device}' device."
+            )
         return self._array.__buffer__(flags)
 
-    # We do not define __release_buffer__, per the discussion at
-    # https://github.com/data-apis/array-api-strict/pull/115#pullrequestreview-2917178729
-
-    def __array__(self, *args, **kwds):
-        # a stub for python < 3.12; otherwise numpy silently produces object arrays
-        import sys
-        minor, major = sys.version_info.minor, sys.version_info.major
-        if major < 3 or minor < 12:
+    # `__array__` is not part of the Array API. Ideally we want to support
+    # `xp.asarray(Array)` exclusively through the __buffer__ protocol; however this is
+    # only possible on Python >=3.12. Additionally, when __buffer__ raises (e.g. because
+    # the array is not on the CPU device, NumPy will try to fall back on __array__ but,
+    # if that doesn't exist, create a scalar numpy array of objects which contains the
+    # array_api_strict.Array. So we can't get rid of __array__ entirely.
+    def __array__(
+        self, dtype: None | np.dtype[Any] = None, copy: None | bool = None
+    ) -> npt.NDArray[Any]:
+        if self._device != CPU_DEVICE:
+            # We arrive here from np.asarray() on Python >=3.12 when __buffer__ raises.
+            raise RuntimeError(
+                f"Can't convert array on the '{self._device}' device to a "
+                "NumPy array."
+            )
+        if sys.version_info >= (3, 12):
             raise TypeError(
-                "Interoperation with NumPy requires python >= 3.12. Please upgrade."
+                "The __array__ method is not supported by the Array API. "
+                "Please use the __buffer__ interface instead."
             )
 
+        # copy keyword is new in 2.0
+        if np.__version__[0] < '2':
+            return np.asarray(self._array, dtype=dtype)
+        return np.asarray(self._array, dtype=dtype, copy=copy)
+
     # These are various helper functions to make the array behavior match the
     # spec in places where it either deviates from or is more strict than
     # NumPy behavior
@@ -942,6 +955,15 @@ class Array:
         self._validate_index(key, op="setitem")
         # Indexing self._array with array_api_strict arrays can be erroneous
         np_key = key._array if isinstance(key, Array) else key
+
+        # sanitize the value
+        other = value
+        if isinstance(value, (bool, int, float, complex)):
+            other = self._promote_scalar(value)
+        dt = _result_type(self.dtype, other.dtype)
+        if dt != self.dtype:
+            raise TypeError(f"mismatched dtypes: {self.dtype = } and {other.dtype = }")
+
         self._array.__setitem__(np_key, asarray(value)._array)
 
     def __sub__(self, other: Array | complex, /) -> Array:
@@ -1104,6 +1126,7 @@ class Array:
         """
         Performs the operation __imod__.
         """
+        self._check_type_device(other)
         other = self._check_allowed_dtypes(other, "real numeric", "__imod__")
         if other is NotImplemented:
             return other
@@ -1126,6 +1149,7 @@ class Array:
         """
         Performs the operation __imul__.
         """
+        self._check_type_device(other)
         other = self._check_allowed_dtypes(other, "numeric", "__imul__")
         if other is NotImplemented:
             return other
@@ -1148,6 +1172,7 @@ class Array:
         """
         Performs the operation __ior__.
         """
+        self._check_type_device(other)
         other = self._check_allowed_dtypes(other, "integer or boolean", "__ior__")
         if other is NotImplemented:
             return other
@@ -1170,6 +1195,7 @@ class Array:
         """
         Performs the operation __ipow__.
         """
+        self._check_type_device(other)
         other = self._check_allowed_dtypes(other, "numeric", "__ipow__")
         if other is NotImplemented:
             return other
@@ -1182,6 +1208,7 @@ class Array:
         """
         from ._elementwise_functions import pow  # type: ignore[attr-defined]
 
+        self._check_type_device(other)
         other = self._check_allowed_dtypes(other, "numeric", "__rpow__")
         if other is NotImplemented:
             return other
@@ -1193,6 +1220,7 @@ class Array:
         """
         Performs the operation __irshift__.
         """
+        self._check_type_device(other)
         other = self._check_allowed_dtypes(other, "integer", "__irshift__")
         if other is NotImplemented:
             return other
@@ -1215,6 +1243,7 @@ class Array:
         """
         Performs the operation __isub__.
         """
+        self._check_type_device(other)
         other = self._check_allowed_dtypes(other, "numeric", "__isub__")
         if other is NotImplemented:
             return other
@@ -1237,6 +1266,7 @@ class Array:
         """
         Performs the operation __itruediv__.
         """
+        self._check_type_device(other)
         other = self._check_allowed_dtypes(other, "floating-point", "__itruediv__")
         if other is NotImplemented:
             return other
@@ -1259,6 +1289,7 @@ class Array:
         """
         Performs the operation __ixor__.
         """
+        self._check_type_device(other)
         other = self._check_allowed_dtypes(other, "integer or boolean", "__ixor__")
         if other is NotImplemented:
             return other

array_api_strict/_creation_functions.py

@@ -240,8 +240,9 @@ def full(
     _check_valid_dtype(dtype)
     _check_device(device)
 
-    if isinstance(fill_value, Array) and fill_value.ndim == 0:
-        fill_value = fill_value._array
+    if not isinstance(fill_value, bool | int | float | complex):
+        msg = f"Expected Python scalar fill_value, got type {type(fill_value)}"
+        raise TypeError(msg)
     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
@@ -270,6 +271,10 @@ def full_like(
     if device is None:
         device = x.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)
+
     res = np.full_like(x._array, 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
@@ -304,7 +309,7 @@ def linspace(
     )
 
 
-def meshgrid(*arrays: Array, indexing: Literal["xy", "ij"] = "xy") -> list[Array]:
+def meshgrid(*arrays: Array, indexing: Literal["xy", "ij"] = "xy") -> tuple[Array, ...]:
     """
     Array API compatible wrapper for :py:func:`np.meshgrid <numpy.meshgrid>`.
 
@@ -327,10 +332,12 @@ def meshgrid(*arrays: Array, indexing: Literal["xy", "ij"] = "xy") -> list[Array
     else:
         device = None
 
-    return [
+    typ = list if get_array_api_strict_flags()['api_version'] < '2025.12' else tuple
+
+    return typ(
         Array._new(array, device=device)
         for array in np.meshgrid(*[a._array for a in arrays], indexing=indexing)
-    ]
+    )
 
 
 def ones(

array_api_strict/_data_type_functions.py

@@ -16,7 +16,7 @@ from ._dtypes import (
     _signed_integer_dtypes,
     _unsigned_integer_dtypes,
 )
-from ._flags import get_array_api_strict_flags
+from ._flags import get_array_api_strict_flags, requires_api_version
 
 
 # Note: astype is a function, not an array method as in NumPy.
@@ -49,7 +49,7 @@ def astype(
     return Array._new(x._array.astype(dtype=dtype._np_dtype, copy=copy), device=device)
 
 
-def broadcast_arrays(*arrays: Array) -> list[Array]:
+def broadcast_arrays(*arrays: Array) -> tuple[Array, ...]:
     """
     Array API compatible wrapper for :py:func:`np.broadcast_arrays <numpy.broadcast_arrays>`.
 
@@ -57,9 +57,21 @@ def broadcast_arrays(*arrays: Array) -> list[Array]:
     """
     from ._array_object import Array
 
-    return [
+    typ = list if get_array_api_strict_flags()['api_version'] < '2025.12' else tuple
+
+    return typ(
         Array._new(array, device=arrays[0].device) for array in np.broadcast_arrays(*[a._array for a in arrays])
-    ]
+    )
+
+
+@requires_api_version("2025.12")
+def broadcast_shapes(*shapes: tuple[int, ...]) -> tuple[int, ...]:
+    """
+    Array API compatible wrapper for :py:func:`np.broadcast_shapes <numpy.broadcast_shapes>`.
+
+    See its docstring for more information.
+    """
+    return np.broadcast_shapes(*shapes)
 
 
 def broadcast_to(x: Array, /, shape: tuple[int, ...]) -> Array:

array_api_strict/_elementwise_functions.py

@@ -257,7 +257,7 @@ def clip(
         raise TypeError("Only real numeric dtypes are allowed in clip")
 
     if min is max is None:
-        return x
+        return Array._new(x._array.copy(), device=x.device)
 
     for argname, arg in ("min", min), ("max", max):
         if isinstance(arg, Array):
@@ -278,8 +278,8 @@ def clip(
                 isinstance(arg, Array) and arg.dtype in _real_floating_dtypes)):
             raise TypeError(f"{argname} must be integral when x is integral")
         if (x.dtype in _real_floating_dtypes
-            and (isinstance(arg, int) or
-                isinstance(arg, Array) and arg.dtype in _integer_dtypes)):
+            and (isinstance(arg, Array) and arg.dtype in _integer_dtypes)
+        ):
             raise TypeError(f"{arg} must be floating-point when x is floating-point")
 
     # Normalize to make the below logic simpler
@@ -352,5 +352,7 @@ def sign(x: Array, /) -> Array:
         raise TypeError("Only numeric dtypes are allowed in sign")
     # Special treatment to work around non-compliant NumPy 1.x behaviour
     if x.dtype in _complex_floating_dtypes:
-        return x/abs(x)
+        _x = x._array
+        _result = _x / np.abs(np.where(_x != 0, _x, np.asarray(1.0, dtype=_x.dtype)))
+        return Array._new(_result, device=x.device)
     return Array._new(np.sign(x._array), device=x.device)

array_api_strict/_flags.py

@@ -30,11 +30,12 @@ supported_versions = (
     "2022.12",
     "2023.12",
     "2024.12",
+    "2025.12",
 )
 
-draft_version = "2025.12"
+draft_version = "2026.12"
 
-API_VERSION = default_version = "2024.12"
+API_VERSION = default_version = "2025.12"
 
 BOOLEAN_INDEXING = True
 

array_api_strict/_info.py

@@ -130,5 +130,8 @@ class __array_namespace_info__:
         raise ValueError(f"unsupported kind: {kind!r}")
 
     @requires_api_version('2023.12')
-    def devices(self) -> list[Device]:
-        return list(ALL_DEVICES)
+    def devices(self) -> tuple[Device]:
+        if get_array_api_strict_flags()['api_version'] < '2025.12':
+            return list(ALL_DEVICES)
+        else:
+            return tuple(ALL_DEVICES)

array_api_strict/_linalg.py

@@ -9,7 +9,7 @@ from ._array_object import Array
 from ._data_type_functions import finfo
 from ._dtypes import DType, _floating_dtypes, _numeric_dtypes, complex64, complex128
 from ._elementwise_functions import conj
-from ._flags import get_array_api_strict_flags, requires_extension
+from ._flags import get_array_api_strict_flags, requires_extension, requires_api_version
 from ._manipulation_functions import reshape
 from ._statistical_functions import _np_dtype_sumprod
 
@@ -23,6 +23,10 @@ class EighResult(NamedTuple):
     eigenvalues: Array
     eigenvectors: Array
 
+class EigResult(NamedTuple):
+    eigenvalues: Array
+    eigenvectors: Array
+
 class QRResult(NamedTuple):
     Q: Array
     R: Array
@@ -144,6 +148,63 @@ def eigvalsh(x: Array, /) -> Array:
 
     return Array._new(np.linalg.eigvalsh(x._array), device=x.device)
 
+@requires_extension('linalg')
+@requires_api_version('2025.12')
+def eigvals(x: Array, /) -> Array:
+    """
+    Array API compatible wrapper for :py:func:`np.linalg.eigvals <numpy.linalg.eigvals>`.
+
+    See its docstring for more information.
+    """
+    # Note: the restriction to floating-point dtypes only is different from
+    # np.linalg.eigvals.
+    if x.dtype not in _floating_dtypes:
+        raise TypeError('Only floating-point dtypes are allowed in eigvals')
+
+    res = np.linalg.eigvals(x._array)
+
+    # numpy return reals for real inputs
+    res_dtype = res.dtype
+    if res.dtype == np.float32:
+        res_dtype = np.complex64
+    elif res.dtype == np.float64:
+        res_dtype = np.complex128
+
+    if res_dtype != res.dtype:
+        res = res.astype(res_dtype)
+
+    return Array._new(res, device=x.device)
+
+
+@requires_extension('linalg')
+@requires_api_version('2025.12')
+def eig(x: Array, /) -> EigResult:
+    """
+    Array API compatible wrapper for :py:func:`np.linalg.eig <numpy.linalg.eig>`.
+
+    See its docstring for more information.
+    """
+    # Note: the restriction to floating-point dtypes only is different from
+    # np.linalg.eig.
+    if x.dtype not in _floating_dtypes:
+        raise TypeError('Only floating-point dtypes are allowed in eig')
+
+    w, vr = np.linalg.eig(x._array)
+
+    # numpy return reals for real inputs
+    res_dtype = w.dtype
+    if w.dtype == np.float32:
+        res_dtype = np.complex64
+    elif w.dtype == np.float64:
+        res_dtype = np.complex128
+
+    if res_dtype != w.dtype:
+        w = w.astype(res_dtype)
+        vr = vr.astype(res_dtype)
+
+    return EigResult(Array._new(w, device=x.device), Array._new(vr, device=x.device))
+
+
 @requires_extension('linalg')
 def inv(x: Array, /) -> Array:
     """

array_api_strict/_manipulation_functions.py

@@ -30,7 +30,7 @@ def concat(
     )
 
 
-def expand_dims(x: Array, /, *, axis: int) -> Array:
+def expand_dims(x: Array, /, axis: int) -> Array:
     """
     Array API compatible wrapper for :py:func:`np.expand_dims <numpy.expand_dims>`.
 

array_api_strict/_searching_functions.py

@@ -5,7 +5,7 @@ import numpy as np
 from ._array_object import Array
 from ._dtypes import _real_numeric_dtypes, _result_type
 from ._dtypes import bool as _bool
-from ._flags import requires_api_version, requires_data_dependent_shapes
+from ._flags import requires_api_version, requires_data_dependent_shapes, get_array_api_strict_flags
 from ._helpers import _maybe_normalize_py_scalars
 
 
@@ -64,7 +64,7 @@ def count_nonzero(
 @requires_api_version('2023.12')
 def searchsorted(
     x1: Array,
-    x2: Array,
+    x2: Array | int | float,
     /,
     *,
     side: Literal["left", "right"] = "left",
@@ -75,6 +75,12 @@ def searchsorted(
 
     See its docstring for more information.
     """
+    flags = get_array_api_strict_flags()
+    if flags["api_version"] >= "2025.12":
+        # scalar x2 support is new in 2025.12
+        if isinstance(x2, bool | int | float | complex):
+            x2 = x1._promote_scalar(x2)
+
     if x1.dtype not in _real_numeric_dtypes or x2.dtype not in _real_numeric_dtypes:
         raise TypeError("Only real numeric dtypes are allowed in searchsorted")
 

array_api_strict/_set_functions.py

@@ -3,7 +3,9 @@ from typing import NamedTuple
 import numpy as np
 
 from ._array_object import Array
-from ._flags import requires_data_dependent_shapes
+from ._flags import requires_data_dependent_shapes, requires_api_version
+from ._helpers import _maybe_normalize_py_scalars
+from ._dtypes import _result_type
 
 # Note: np.unique() is split into four functions in the array API:
 # unique_all, unique_counts, unique_inverse, and unique_values (this is done
@@ -109,3 +111,23 @@ def unique_values(x: Array, /) -> Array:
         equal_nan=False,
     )
     return Array._new(res, device=x.device)
+
+
+@requires_api_version('2025.12')
+def isin(x1: Array | int, x2: Array | int, /, *, invert: bool = False) -> Array:
+    """
+    Array API compatible wrapper for :py:func:`np.isin <numpy.isin>`.
+
+    See its docstring for more information.
+    """
+    # implementation here is from _elementwise_functions.py::_binary_ufunc_proto
+    x1, x2 = _maybe_normalize_py_scalars(x1, x2, "integer", "isin")
+
+    if x1.device != x2.device:
+        raise ValueError(
+            f"Arrays from two different devices ({x1.device} and {x2.device}) can not be combined."
+        )
+    # Call result type here just to raise on disallowed type combinations
+    _result_type(x1.dtype, x2.dtype)
+    # x1, x2 = Array._normalize_two_args(x1, x2)   # no need to change 0D -> 1D here
+    return Array._new(np.isin(x1._array, x2._array), device=x1.device)

array_api_strict/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '2.4'
-__version_tuple__ = version_tuple = (2, 4)
+__version__ = version = '2.5'
+__version_tuple__ = version_tuple = (2, 5)
+
+__commit_id__ = commit_id = None

array_api_strict/tests/test_array_object.py

@@ -1,8 +1,10 @@
 import sys
+import warnings
 import operator
+import pickle
 from builtins import all as all_
 
-from numpy.testing import assert_raises, suppress_warnings
+from numpy.testing import assert_raises
 import numpy as np
 import pytest
 
@@ -18,12 +20,14 @@ from .._dtypes import (
     _integer_or_boolean_dtypes,
     _real_numeric_dtypes,
     _numeric_dtypes,
+    uint8,
     int8,
     int16,
     int32,
     int64,
     uint64,
     float64,
+    complex128,
     bool as bool_,
 )
 from .._flags import set_array_api_strict_flags
@@ -193,6 +197,29 @@ def test_indexing_arrays_different_devices():
         a[idx1, idx2]
 
 
+def test_setitem_invalid_promotions():
+    # Check that violating these two raises:
+    #   Setting array values must not affect the data type of self, and
+    #   Behavior must otherwise follow Type Promotion Rules.
+    a = asarray([1, 2, 3])
+    with pytest.raises(TypeError):
+        a[0] = 3.5
+
+    with pytest.raises(TypeError):
+        a[0] = asarray(3.5)
+
+    a = asarray([1, 2, 3], dtype=uint8)
+    with pytest.raises(TypeError):
+        a[0] = asarray(42, dtype=uint64)
+
+    a = asarray([1, 2, 3], dtype=float64)
+    with pytest.raises(TypeError):
+        a[0] = 3.5j
+
+    with pytest.raises(TypeError):
+        a[0] = asarray(3.5j, dtype=complex128)
+
+
 def test_promoted_scalar_inherits_device():
     device1 = Device("device1")
     x = asarray([1., 2, 3], device=device1)
@@ -244,10 +271,12 @@ def _check_op_array_scalar(dtypes, a, s, func, func_name, BIG_INT=BIG_INT):
 
         else:
             # Only test for no error
-            with suppress_warnings() as sup:
+            with warnings.catch_warnings():
                 # ignore warnings from pow(BIG_INT)
-                sup.filter(RuntimeWarning,
-                           "invalid value encountered in power")
+                warnings.filterwarnings(
+                    "ignore", category=RuntimeWarning,
+                    message="invalid value encountered in power"
+                )
                 func(s)
             return True
 
@@ -344,6 +373,13 @@ def test_operators():
                                 getattr(x, _op)(y)
                             else:
                                 assert_raises(TypeError, lambda: getattr(x, _op)(y))
+                            # finally, test that array op ndarray raises
+                            # XXX: as long as there is __array__ or __buffer__, __rop__s
+                            #  still return ndarrays
+                            if not _op.startswith("__r"):
+                                with assert_raises(TypeError):
+                                    getattr(x, _op)(y._array)
+
 
     for op, dtypes in unary_op_dtypes.items():
         for a in _array_vals():
@@ -527,36 +563,54 @@ def test_array_properties():
     assert b.mT.shape == (3, 2)
 
 
-@pytest.mark.xfail(sys.version_info.major*100 + sys.version_info.minor < 312,
-                   reason="array conversion relies on buffer protocol, and "
-                          "requires python >= 3.12"
-)
 def test_array_conversion():
     # Check that arrays on the CPU device can be converted to NumPy
     # but arrays on other devices can't. Note this is testing the logic in
-    # __array__, which is only used in asarray when converting lists of
-    # arrays.
+    # __array__ on Python 3.10~3.11 and in __buffer__ on Python >=3.12.
     a = ones((2, 3))
-    np.asarray(a)
+    na = np.asarray(a)
+    assert na.shape == (2, 3)
+    assert na.dtype == np.float64
+    na[0, 0] = 10
+    assert a[0, 0] == 10  # return view when possible
+
+    a = arange(5, dtype=uint8)
+    na = np.asarray(a)
+    assert na.dtype == np.uint8
 
     for device in ("device1", "device2"):
         a = ones((2, 3), device=array_api_strict.Device(device))
-        with pytest.raises((RuntimeError, ValueError)):
+        with pytest.raises(RuntimeError, match=device):
             np.asarray(a)
 
-    # __buffer__ should work for now for conversion to numpy
-    a = ones((2, 3))
-    na = np.array(a)
-    assert na.shape == (2, 3)
-    assert na.dtype == np.float64
 
-@pytest.mark.skipif(not sys.version_info.major*100 + sys.version_info.minor < 312,
-                    reason="conversion to numpy errors out unless python >= 3.12"
+@pytest.mark.skipif(np.__version__ < "2", reason="np.asarray has no copy kwarg")
+def test_array_conversion_copy():
+    a = arange(5)
+    na = np.asarray(a, copy=False)
+    na[0] = 10
+    assert a[0] == 10
+
+    a = arange(5)
+    na = np.asarray(a, copy=True)
+    na[0] = 10
+    assert a[0] == 0
+
+    a = arange(5)
+    with pytest.raises(ValueError):
+        np.asarray(a, dtype=np.uint8, copy=False)
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 12), reason="Python <3.12 has no __buffer__ interface"
 )
-def test_array_conversion_2():
+def test_no_array_interface():
+    """When the __buffer__ interface is available, the __array__ interface is not."""
     a = ones((2, 3))
-    with pytest.raises(TypeError):
-        np.array(a)
+    with pytest.raises(TypeError, match="not supported"):
+        # Because NumPy prefers __buffer__ when available, we can't trigger this
+        # exception from np.asarray().
+        a.__array__()
 
 
 def test_allow_newaxis():
@@ -616,10 +670,10 @@ def test_array_keys_use_private_array():
 def test_array_namespace():
     a = ones((3, 3))
     assert a.__array_namespace__() == array_api_strict
-    assert array_api_strict.__array_api_version__ == "2024.12"
+    assert array_api_strict.__array_api_version__ == "2025.12"
 
     assert a.__array_namespace__(api_version=None) is array_api_strict
-    assert array_api_strict.__array_api_version__ == "2024.12"
+    assert array_api_strict.__array_api_version__ == "2025.12"
 
     assert a.__array_namespace__(api_version="2022.12") is array_api_strict
     assert array_api_strict.__array_api_version__ == "2022.12"
@@ -632,12 +686,12 @@ def test_array_namespace():
     assert array_api_strict.__array_api_version__ == "2021.12"
 
     with pytest.warns(UserWarning):
-        assert a.__array_namespace__(api_version="2025.12") is array_api_strict
-    assert array_api_strict.__array_api_version__ == "2025.12"
+        assert a.__array_namespace__(api_version="2026.12") is array_api_strict
+    assert array_api_strict.__array_api_version__ == "2026.12"
 
 
     pytest.raises(ValueError, lambda: a.__array_namespace__(api_version="2021.11"))
-    pytest.raises(ValueError, lambda: a.__array_namespace__(api_version="2026.12"))
+    pytest.raises(ValueError, lambda: a.__array_namespace__(api_version="2027.12"))
 
 def test_iter():
     pytest.raises(TypeError, lambda: next(iter(asarray(3))))
@@ -694,3 +748,15 @@ def test_dlpack_2023_12(api_version):
         a.__dlpack__(copy=False)
         a.__dlpack__(copy=True)
         a.__dlpack__(copy=None)
+
+def test_pickle():
+    """Check that arrays are pickleable (despite raising on `__new__`)"""
+    a = ones(2)
+    min_supported_protocol = 2
+    for protocol in range(min_supported_protocol, pickle.HIGHEST_PROTOCOL + 1):
+        bytes = pickle.dumps(a, protocol=protocol)
+        a_from_pickle = pickle.loads(bytes)
+        assert a_from_pickle.device == a.device
+        assert a_from_pickle.dtype == a.dtype
+        assert a_from_pickle.shape == a.shape
+        assert all(a_from_pickle == a)

array_api_strict/tests/test_creation_functions.py

@@ -161,6 +161,7 @@ def test_full_errors():
     assert_raises(ValueError, lambda: full((1,), 0, device="gpu"))
     assert_raises(ValueError, lambda: full((1,), 0, dtype=int))
     assert_raises(ValueError, lambda: full((1,), 0, dtype="i"))
+    assert_raises(TypeError, lambda: full((1,), asarray(0)))
 
 
 def test_full_like_errors():
@@ -169,6 +170,7 @@ def test_full_like_errors():
     assert_raises(ValueError, lambda: full_like(asarray(1), 0, device="gpu"))
     assert_raises(ValueError, lambda: full_like(asarray(1), 0, dtype=int))
     assert_raises(ValueError, lambda: full_like(asarray(1), 0, dtype="i"))
+    assert_raises(TypeError, lambda: full(asarray(1), asarray(0)))
 
 
 def test_linspace_errors():

array_api_strict/tests/test_elementwise_functions.py

@@ -1,8 +1,8 @@
+import warnings
 from inspect import signature, getmodule
 
 import numpy as np
 import pytest
-from numpy.testing import suppress_warnings
 
 
 from .. import asarray, _elementwise_functions
@@ -300,12 +300,24 @@ def test_scalars():
                     if allowed:
                         conv_scalar = a._promote_scalar(s)
 
-                        with suppress_warnings() as sup:
+                        with warnings.catch_warnings():
                             # ignore warnings from pow(BIG_INT)
-                            sup.filter(RuntimeWarning,
-                                       "invalid value encountered in power")
+                            warnings.filterwarnings(
+                                "ignore", category=RuntimeWarning,
+                                message="invalid value encountered in power"
+                            )
+
                             assert func(s, a) == func(conv_scalar, a)
                             assert func(a, s) == func(a, conv_scalar)
 
                         with pytest.raises(TypeError):
                             func(s, s)
+
+
+def test_clip_none():
+    # regression test: clip(x) is a copy of x, not a view
+    x = asarray([1, 2, 3])
+    y = array_api_strict.clip(x)
+
+    y[1] = 42
+    assert x[1] == 2

array_api_strict/tests/test_flags.py

@@ -19,7 +19,7 @@ import pytest
 def test_flag_defaults():
     flags = get_array_api_strict_flags()
     assert flags == {
-        'api_version': '2024.12',
+        'api_version': '2025.12',
         'boolean_indexing': True,
         'data_dependent_shapes': True,
         'enabled_extensions': ('linalg', 'fft'),
@@ -36,7 +36,7 @@ def test_reset_flags():
     reset_array_api_strict_flags()
     flags = get_array_api_strict_flags()
     assert flags == {
-        'api_version': '2024.12',
+        'api_version': '2025.12',
         'boolean_indexing': True,
         'data_dependent_shapes': True,
         'enabled_extensions': ('linalg', 'fft'),
@@ -47,7 +47,7 @@ def test_setting_flags():
     set_array_api_strict_flags(data_dependent_shapes=False)
     flags = get_array_api_strict_flags()
     assert flags == {
-        'api_version': '2024.12',
+        'api_version': '2025.12',
         'boolean_indexing': True,
         'data_dependent_shapes': False,
         'enabled_extensions': ('linalg', 'fft'),
@@ -55,7 +55,7 @@ def test_setting_flags():
     set_array_api_strict_flags(enabled_extensions=('fft',))
     flags = get_array_api_strict_flags()
     assert flags == {
-        'api_version': '2024.12',
+        'api_version': '2025.12',
         'boolean_indexing': True,
         'data_dependent_shapes': False,
         'enabled_extensions': ('fft',),
@@ -109,15 +109,15 @@ def test_flags_api_version_2024_12():
 
 
 def test_flags_api_version_2025_12():
-    # Make sure setting the version to 2025.12 issues a warning.
+    # Make sure setting the version to 2026.12 issues a warning.
     with pytest.warns(UserWarning) as record:
-        set_array_api_strict_flags(api_version='2025.12')
+        set_array_api_strict_flags(api_version='2026.12')
     assert len(record) == 1
-    assert '2025.12' in str(record[0].message)
+    assert '2026.12' in str(record[0].message)
     assert 'draft' in str(record[0].message)
     flags = get_array_api_strict_flags()
     assert flags == {
-        'api_version': '2025.12',
+        'api_version': '2026.12',
         'boolean_indexing': True,
         'data_dependent_shapes': True,
         'enabled_extensions': ('linalg', 'fft'),
@@ -136,7 +136,7 @@ def test_setting_flags_invalid():
 
 def test_api_version():
     # Test defaults
-    assert xp.__array_api_version__ == '2024.12'
+    assert xp.__array_api_version__ == '2025.12'
 
     # Test setting the version
     set_array_api_strict_flags(api_version='2023.12')
@@ -444,9 +444,9 @@ def test_environment_variables():
         # ARRAY_API_STRICT_API_VERSION
         ('''\
 import array_api_strict as xp
-assert xp.__array_api_version__ == '2024.12'
+assert xp.__array_api_version__ == '2025.12'
 
-assert xp.get_array_api_strict_flags()['api_version'] == '2024.12'
+assert xp.get_array_api_strict_flags()['api_version'] == '2025.12'
 
 ''', {}),
         *[

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: array_api_strict
-Version: 2.4
+Version: 2.5
 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
@@ -48,6 +48,9 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
+Provides-Extra: test
+Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: hypothesis ; extra == 'test'
 
 # array-api-strict
 

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

@@ -1,34 +1,34 @@
-array_api_strict/__init__.py,sha256=ej0VGyz6OCxIDCyBsLRzj1w9B4Z6-BAHUOaaZRZ7Xn4,7113
-array_api_strict/_array_object.py,sha256=y3OPuGTl7roe5UYjEgFQuGwGzvvvUqgxeRe_erNo3CE,53017
+array_api_strict/__init__.py,sha256=kexXRJ7WHgMTeMi80H6XiObC3ePtUEr5gf92dnwyPGE,7173
+array_api_strict/_array_object.py,sha256=m5197OW2aW778dGDMjQI4Zxaw5BfIqXWQ6sJK_DpgaA,54393
 array_api_strict/_constants.py,sha256=ilkAGjIceZxT4zPywIoWbl3Xv8k19UOI4SSF6EPegpg,93
-array_api_strict/_creation_functions.py,sha256=6_KZsI64t3pXTxLhjCye82T7aPPUcmCxC6ZcIliqF3E,12316
-array_api_strict/_data_type_functions.py,sha256=gr7pZiMDMIKpZJjmiXzLbsGfk8SA0ltomcI05Wf9Ykk,8351
+array_api_strict/_creation_functions.py,sha256=TXookrcG1zeUBMvgFdbiwXxZJ1aMvViSef24tqVo53s,12658
+array_api_strict/_data_type_functions.py,sha256=5OPnsIj4QafrSlnizUZcO4DHO5u0ap9OyDNovV4qrns,8765
 array_api_strict/_dtypes.py,sha256=PNSd4LpGdnRiEGoB2uqxi93d0dmtiyFp_awUzUcdHJE,6597
-array_api_strict/_elementwise_functions.py,sha256=YLk_sNTTJmF7jXCjOlBvtOvuj486sDK7x8JJv9zfHM4,13050
+array_api_strict/_elementwise_functions.py,sha256=D3jOalyR5-kDSzeGTZLKnGPVwjKBuPihkwn23YSxcUc,13198
 array_api_strict/_fft.py,sha256=DVw7KK4Xvyf3_0rJuWdskggGRCSxS4OrguYNVBf9fH0,10189
-array_api_strict/_flags.py,sha256=JJGDGRq06p-D0GOBAzv58SBUrzmOuBqcNOKxmEvrVrU,14743
+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=r9HC12AoBb7mg2NcPamWRPs7qR3uL75sQDBUPm7MAjM,4407
-array_api_strict/_linalg.py,sha256=N-ynKeoR4lvI3aNhEfXNzig6IeyJ9e7MfDsqpb-3eUM,19706
+array_api_strict/_info.py,sha256=nGLPkobKqDuLlLD4yOxG4y3JVO98o9UNEImXu6YeKH8,4532
+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=QhtVv5bGr3fFRlcjLuKZJlyA7r6PdYhmgi_JII3RVVE,6938
-array_api_strict/_searching_functions.py,sha256=gO-JRdAbaiZutwiN9pEQ1UAeH_OFw1fBdR2t7_GEuY8,3994
-array_api_strict/_set_functions.py,sha256=E3roHcUKzWVGIIxahGt6vc83PzCOva_rbT6Nm9hJQl4,3259
+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/_typing.py,sha256=FVM2m6ZTZYDnznCo0SlMRpcXxGR49y6k4ejNEiuGUtc,1486
 array_api_strict/_utility_functions.py,sha256=L7FJM-RT90gqkAqvMEfQ6FkzurTziHByROk_5R8a5fY,1938
-array_api_strict/_version.py,sha256=y6CMfyyHwwbY96E29GddO9odxAQSle0U0iPOGFS5v2k,506
+array_api_strict/_version.py,sha256=hJiFMfUPM_IAKDdGwMOVrwsdi46DfhTA5ZGiPklON8o,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=gBfAsp_1luPIhftdSEwshRwZmkCbyDYdnQ-istodTx0,27114
-array_api_strict/tests/test_creation_functions.py,sha256=JGXO_-cwxTrQGF9LkirGp6zmpq0IiOzffVtKvz1mJgw,8510
+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_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=R8QFP3k57T-xC3J0s56Cwtw_KsRJxJgNDf2N1cTPokI,11151
-array_api_strict/tests/test_flags.py,sha256=kcBbFB4aq3XY_9HM1j3wKmq8MVNfU4YxwK21mARM0iw,18982
+array_api_strict/tests/test_elementwise_functions.py,sha256=ZZOfPaCNIug026zv9IdhV2164jZZkRSwmteAnefFBGw,11396
+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
@@ -37,8 +37,8 @@ array_api_strict/tests/test_set_functions.py,sha256=ikzab1j3SXxGf0OqwHrOAM13HwQe
 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_validation.py,sha256=VDci4SgcAhxzSFVnFYBvJWXEsWRxHARnq9TwTfH02xg,635
-array_api_strict-2.4.dist-info/LICENSE,sha256=djDm4UfHAJmycwFUNyUmrTdRkrFF9Ac8uqIlbxH7j5Y,1585
-array_api_strict-2.4.dist-info/METADATA,sha256=wNNJkgnrMq9hYSpcL2rTf5lH6lg25hmhrG_RrLc3QVM,3508
-array_api_strict-2.4.dist-info/WHEEL,sha256=5Mi1sN9lKoFv_gxcPtisEVrJZihrm_beibeg5R6xb4I,91
-array_api_strict-2.4.dist-info/top_level.txt,sha256=M4cE8VLgRHp_d9TPkbk7_I4JriELFdEJz-NKJJqAkAE,17
-array_api_strict-2.4.dist-info/RECORD,,
+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,,