array-api-strict 2.4.1__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

@@ -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
+from typing import Any, Final, Literal, SupportsIndex, Callable
 
 import numpy as np
 import numpy.typing as npt
@@ -125,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.

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.1'
-__version_tuple__ = version_tuple = (2, 4, 1)
+__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
 
@@ -269,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
 
@@ -666,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"
@@ -682,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))))
@@ -744,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.1.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.1
+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.1.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=UIAMiRwUYSqxP_i-E9n5Pf0-OlB-5_rzg5mp1jNLTQc,54244
+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=H3hbvip-BJTNbNG0ITRXctaII3Vc2949yckZEGuAGg8,511
+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=16zibpbp86T70tfpcSNb2M-_Ct-s44xf1wMCiEgpHw8,28610
-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.1.dist-info/LICENSE,sha256=djDm4UfHAJmycwFUNyUmrTdRkrFF9Ac8uqIlbxH7j5Y,1585
-array_api_strict-2.4.1.dist-info/METADATA,sha256=tc9jDUXbhRw28uVLOe0sWSR695THu45Zy2QvqFviEus,3510
-array_api_strict-2.4.1.dist-info/WHEEL,sha256=5Mi1sN9lKoFv_gxcPtisEVrJZihrm_beibeg5R6xb4I,91
-array_api_strict-2.4.1.dist-info/top_level.txt,sha256=M4cE8VLgRHp_d9TPkbk7_I4JriELFdEJz-NKJJqAkAE,17
-array_api_strict-2.4.1.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,,