array-api-strict 2.1__py3-none-any.whl → 2.1.2__py3-none-any.whl

array_api_strict/__init__.py

@@ -16,6 +16,12 @@ consuming libraries to test their array API usage.
 
 """
 
+import numpy as np
+from numpy.lib import NumpyVersion
+
+if NumpyVersion(np.__version__) < NumpyVersion('2.1.0'):
+    raise ImportError("array-api-strict requires NumPy >= 2.1.0")
+
 __all__ = []
 
 # Warning: __array_api_version__ could change globally with

array_api_strict/_array_object.py

@@ -38,7 +38,7 @@ import types
 
 if TYPE_CHECKING:
     from typing import Optional, Tuple, Union, Any
-    from ._typing import PyCapsule, Device, Dtype
+    from ._typing import PyCapsule, Dtype
     import numpy.typing as npt
 
 import numpy as np
@@ -66,6 +66,8 @@ ALL_DEVICES = (CPU_DEVICE, Device("device1"), Device("device2"))
 
 _default = object()
 
+_allow_array = False
+
 class Array:
     """
     n-d array object for the array API namespace.
@@ -145,30 +147,23 @@ class Array:
             mid = np.array2string(self._array, separator=', ', prefix=prefix, suffix=suffix)
         return prefix + mid + suffix
 
-    # This function is not required by the spec, but we implement it here for
-    # convenience so that np.asarray(array_api_strict.Array) will work.
+    # Disallow __array__, meaning calling `np.func()` on an array_api_strict
+    # array will give an error. If we don't explicitly disallow it, NumPy
+    # defaults to creating an object dtype array, which would lead to
+    # confusing error messages at best and surprising bugs at worst.
+    #
+    # The alternative of course is to just support __array__, which is what we
+    # used to do. But this isn't actually supported by the standard, so it can
+    # lead to code assuming np.asarray(other_array) would always work in the
+    # standard.
     def __array__(self, dtype: None | np.dtype[Any] = None, copy: None | bool = None) -> npt.NDArray[Any]:
-        """
-        Warning: this method is NOT part of the array API spec. Implementers
-        of other libraries need not include it, and users should not assume it
-        will be present in other implementations.
-
-        """
-        if self._device != CPU_DEVICE:
-            raise RuntimeError(f"Can not convert array on the '{self._device}' device to a Numpy array.")
-        # copy keyword is new in 2.0.0; for older versions don't use it
-        # retry without that keyword.
-        if np.__version__[0] < '2':
-            return np.asarray(self._array, dtype=dtype)
-        elif np.__version__.startswith('2.0.0-dev0'):
-            # Handle dev version for which we can't know based on version
-            # number whether or not the copy keyword is supported.
-            try:
-                return np.asarray(self._array, dtype=dtype, copy=copy)
-            except TypeError:
-                return np.asarray(self._array, dtype=dtype)
-        else:
+        # We have to allow this to be internally enabled as there's no other
+        # easy way to parse a list of Array objects in asarray().
+        if _allow_array:
+            if self._device != CPU_DEVICE:
+                raise RuntimeError(f"Can not convert array on the '{self._device}' device to a Numpy array.")
             return np.asarray(self._array, dtype=dtype, copy=copy)
+        raise ValueError("Conversion from an array_api_strict array to a NumPy ndarray is not supported")
 
     # 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
@@ -274,7 +269,7 @@ class Array:
         # behavior for integers within the bounds of the integer dtype.
         # Outside of those bounds we use the default NumPy behavior (either
         # cast or raise OverflowError).
-        return Array._new(np.array(scalar, dtype=self.dtype._np_dtype), device=CPU_DEVICE)
+        return Array._new(np.array(scalar, dtype=self.dtype._np_dtype), device=self.device)
 
     @staticmethod
     def _normalize_two_args(x1, x2) -> Tuple[Array, Array]:
@@ -579,15 +574,14 @@ class Array:
             if copy is not _default:
                 raise ValueError("The copy argument to __dlpack__ requires at least version 2023.12 of the array API")
 
-        # Going to wait for upstream numpy support
-        if max_version not in [_default, None]:
-            raise NotImplementedError("The max_version argument to __dlpack__ is not yet implemented")
-        if dl_device not in [_default, None]:
-            raise NotImplementedError("The device argument to __dlpack__ is not yet implemented")
-        if copy not in [_default, None]:
-            raise NotImplementedError("The copy argument to __dlpack__ is not yet implemented")
-
-        return self._array.__dlpack__(stream=stream)
+        kwargs = {'stream': stream}
+        if max_version is not _default:
+            kwargs['max_version'] = max_version
+        if dl_device is not _default:
+            kwargs['dl_device'] = dl_device
+        if copy is not _default:
+            kwargs['copy'] = copy
+        return self._array.__dlpack__(**kwargs)
 
     def __dlpack_device__(self: Array, /) -> Tuple[IntEnum, int]:
         """

array_api_strict/_creation_functions.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-
+from contextlib import contextmanager
 from typing import TYPE_CHECKING, List, Optional, Tuple, Union
 
 if TYPE_CHECKING:
@@ -16,6 +16,19 @@ from ._flags import get_array_api_strict_flags
 
 import numpy as np
 
+@contextmanager
+def allow_array():
+    """
+    Temporarily enable Array.__array__. This is needed for np.array to parse
+    list of lists of Array objects.
+    """
+    from . import _array_object
+    original_value = _array_object._allow_array
+    try:
+        _array_object._allow_array = True
+        yield
+    finally:
+        _array_object._allow_array = original_value
 
 def _check_valid_dtype(dtype):
     # Note: Only spelling dtypes as the dtype objects is supported.
@@ -67,29 +80,8 @@ def asarray(
     if dtype is not None:
         _np_dtype = dtype._np_dtype
     _check_device(device)
-
-    if np.__version__[0] < '2':
-        if copy is False:
-            # Note: copy=False is not yet implemented in np.asarray for
-            # NumPy 1
-
-            # Work around it by creating the new array and seeing if NumPy
-            # copies it.
-            if isinstance(obj, Array):
-                new_array = np.array(obj._array, copy=copy, dtype=_np_dtype)
-                if new_array is not obj._array:
-                    raise ValueError("Unable to avoid copy while creating an array from given array.")
-                return Array._new(new_array, device=device)
-            elif _supports_buffer_protocol(obj):
-                # Buffer protocol will always support no-copy
-                return Array._new(np.array(obj, copy=copy, dtype=_np_dtype), device=device)
-            else:
-                # No-copy is unsupported for Python built-in types.
-                raise ValueError("Unable to avoid copy while creating an array from given object.")
-
-        if copy is None:
-            # NumPy 1 treats copy=False the same as the standard copy=None
-            copy = False
+    if isinstance(obj, Array) and device is None:
+        device = obj.device
 
     if isinstance(obj, Array):
         return Array._new(np.array(obj._array, copy=copy, dtype=_np_dtype), device=device)
@@ -97,7 +89,8 @@ def asarray(
         # Give a better error message in this case. NumPy would convert this
         # to an object array. TODO: This won't handle large integers in lists.
         raise OverflowError("Integer out of bounds for array dtypes")
-    res = np.array(obj, dtype=_np_dtype, copy=copy)
+    with allow_array():
+        res = np.array(obj, dtype=_np_dtype, copy=copy)
     return Array._new(res, device=device)
 
 
@@ -158,6 +151,8 @@ def empty_like(
 
     _check_valid_dtype(dtype)
     _check_device(device)
+    if device is None:
+        device = x.device
 
     if dtype is not None:
         dtype = dtype._np_dtype
@@ -260,6 +255,8 @@ def full_like(
 
     _check_valid_dtype(dtype)
     _check_device(device)
+    if device is None:
+        device = x.device
 
     if dtype is not None:
         dtype = dtype._np_dtype

array_api_strict/_elementwise_functions.py

@@ -14,6 +14,7 @@ from ._dtypes import (
 from ._array_object import Array
 from ._flags import requires_api_version
 from ._creation_functions import asarray
+from ._data_type_functions import broadcast_to, iinfo
 
 from typing import Optional, Union
 
@@ -325,14 +326,51 @@ def clip(
     if min is not None and max is not None and np.any(min > max):
         raise ValueError("min must be less than or equal to max")
 
-    result = np.clip(x._array, min, max)
-    # Note: NumPy applies type promotion, but the standard specifies the
-    # return dtype should be the same as x
-    if result.dtype != x.dtype._np_dtype:
-        # TODO: I'm not completely sure this always gives the correct thing
-        # for integer dtypes. See https://github.com/numpy/numpy/issues/24976
-        result = result.astype(x.dtype._np_dtype)
-    return Array._new(result, device=x.device)
+    # np.clip does type promotion but the array API clip requires that the
+    # output have the same dtype as x. We do this instead of just downcasting
+    # the result of xp.clip() to handle some corner cases better (e.g.,
+    # avoiding uint64 -> float64 promotion).
+
+    # Note: cases where min or max overflow (integer) or round (float) in the
+    # wrong direction when downcasting to x.dtype are unspecified. This code
+    # just does whatever NumPy does when it downcasts in the assignment, but
+    # other behavior could be preferred, especially for integers. For example,
+    # this code produces:
+
+    # >>> clip(asarray(0, dtype=int8), asarray(128, dtype=int16), None)
+    # -128
+
+    # but an answer of 0 might be preferred. See
+    # https://github.com/numpy/numpy/issues/24976 for more discussion on this issue.
+
+    # At least handle the case of Python integers correctly (see
+    # https://github.com/numpy/numpy/pull/26892).
+    if type(min) is int and min <= iinfo(x.dtype).min:
+        min = None
+    if type(max) is int and max >= iinfo(x.dtype).max:
+        max = None
+
+    def _isscalar(a):
+        return isinstance(a, (int, float, type(None)))
+    min_shape = () if _isscalar(min) else min.shape
+    max_shape = () if _isscalar(max) else max.shape
+
+    result_shape = np.broadcast_shapes(x.shape, min_shape, max_shape)
+
+    out = asarray(broadcast_to(x, result_shape), copy=True)._array
+    device = x.device
+    x = x._array
+
+    if min is not None:
+        a = np.broadcast_to(np.asarray(min), result_shape)
+        ia = (out < a) | np.isnan(a)
+
+        out[ia] = a[ia]
+    if max is not None:
+        b = np.broadcast_to(np.asarray(max), result_shape)
+        ib = (out > b) | np.isnan(b)
+        out[ib] = b[ib]
+    return Array._new(out, device=device)
 
 def conj(x: Array, /) -> Array:
     """
@@ -855,6 +893,8 @@ def sign(x: Array, /) -> Array:
     """
     if x.dtype not in _numeric_dtypes:
         raise TypeError("Only numeric dtypes are allowed in sign")
+    if x.dtype in _complex_floating_dtypes:
+        return x/abs(x)
     return Array._new(np.sign(x._array), device=x.device)
 
 

array_api_strict/_linalg.py

@@ -267,6 +267,8 @@ def pinv(x: Array, /, *, rtol: Optional[Union[float, Array]] = None) -> Array:
     # default tolerance by max(M, N).
     if rtol is None:
         rtol = max(x.shape[-2:]) * finfo(x.dtype).eps
+    if isinstance(rtol, Array):
+        rtol = rtol._array
     return Array._new(np.linalg.pinv(x._array, rcond=rtol), device=x.device)
 
 @requires_extension('linalg')

array_api_strict/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-10-18T12:46:30-0600",
+ "date": "2024-11-07T18:09:02-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "c89d77a82e2ef7772c26f6cd10cd4b101ce3f90d",
- "version": "2.1"
+ "full-revisionid": "c9fe697bec8de8e402d8beb71bbeb96ca70c772e",
+ "version": "2.1.2"
 }
 '''  # END VERSION_JSON
 

array_api_strict/tests/test_array_object.py

@@ -6,7 +6,7 @@ import numpy as np
 import pytest
 
 from .. import ones, asarray, result_type, all, equal
-from .._array_object import Array, CPU_DEVICE
+from .._array_object import Array, CPU_DEVICE, Device
 from .._dtypes import (
     _all_dtypes,
     _boolean_dtypes,
@@ -88,6 +88,14 @@ def test_validate_index():
     assert_raises(IndexError, lambda: a[0])
     assert_raises(IndexError, lambda: a[:])
 
+def test_promoted_scalar_inherits_device():
+    device1 = Device("device1")
+    x = asarray([1., 2, 3], device=device1)
+
+    y = x ** 2
+
+    assert y.device == device1
+
 def test_operators():
     # For every operator, we test that it works for the required type
     # combinations and raises TypeError otherwise
@@ -342,23 +350,19 @@ def test_array_properties():
     assert isinstance(b.mT, Array)
     assert b.mT.shape == (3, 2)
 
-def test___array__():
-    a = ones((2, 3), dtype=int16)
-    assert np.asarray(a) is a._array
-    b = np.asarray(a, dtype=np.float64)
-    assert np.all(np.equal(b, np.ones((2, 3), dtype=np.float64)))
-    assert b.dtype == np.float64
 
 def test_array_conversion():
     # Check that arrays on the CPU device can be converted to NumPy
-    # but arrays on other devices can't
+    # 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.
     a = ones((2, 3))
-    np.asarray(a)
+    asarray([a])
 
     for device in ("device1", "device2"):
         a = ones((2, 3), device=array_api_strict.Device(device))
         with pytest.raises(RuntimeError, match="Can not convert array"):
-            np.asarray(a)
+            asarray([a])
 
 def test_allow_newaxis():
     a = ones(5)
@@ -452,22 +456,19 @@ def dlpack_2023_12(api_version):
         set_array_api_strict_flags(api_version=api_version)
 
     a = asarray([1, 2, 3], dtype=int8)
-    # Never an error
-    a.__dlpack__()
-
 
-    exception = NotImplementedError if api_version >= '2023.12' else ValueError
-    pytest.raises(exception, lambda:
-                  a.__dlpack__(dl_device=CPU_DEVICE))
-    pytest.raises(exception, lambda:
-                  a.__dlpack__(dl_device=None))
-    pytest.raises(exception, lambda:
-                  a.__dlpack__(max_version=(1, 0)))
-    pytest.raises(exception, lambda:
-                  a.__dlpack__(max_version=None))
-    pytest.raises(exception, lambda:
-                    a.__dlpack__(copy=False))
-    pytest.raises(exception, lambda:
-                    a.__dlpack__(copy=True))
-    pytest.raises(exception, lambda:
-                    a.__dlpack__(copy=None))
+    # Do not error
+    a.__dlpack__()
+    a.__dlpack__(dl_device=CPU_DEVICE)
+    a.__dlpack__(dl_device=None)
+    a.__dlpack__(max_version=(1, 0))
+    a.__dlpack__(max_version=None)
+    a.__dlpack__(copy=False)
+    a.__dlpack__(copy=True)
+    a.__dlpack__(copy=None)
+
+    x = np.from_dlpack(a)
+    assert isinstance(x, np.ndarray)
+    assert x.dtype == np.int8
+    assert x.shape == (3,)
+    assert np.all(x == np.asarray([1, 2, 3]))

array_api_strict/tests/test_creation_functions.py

@@ -22,8 +22,8 @@ from .._creation_functions import (
     zeros,
     zeros_like,
 )
-from .._dtypes import float32, float64
-from .._array_object import Array, CPU_DEVICE
+from .._dtypes import int16, float32, float64
+from .._array_object import Array, CPU_DEVICE, Device
 from .._flags import set_array_api_strict_flags
 
 def test_asarray_errors():
@@ -97,6 +97,30 @@ def test_asarray_copy():
     a[0] = 0
     assert all(b[0] == 0)
 
+def test_asarray_list_of_lists():
+    a = asarray(1, dtype=int16)
+    b = asarray([1], dtype=int16)
+    res = asarray([a, a])
+    assert res.shape == (2,)
+    assert res.dtype == int16
+    assert all(res == asarray([1, 1]))
+
+    res = asarray([b, b])
+    assert res.shape == (2, 1)
+    assert res.dtype == int16
+    assert all(res == asarray([[1], [1]]))
+
+
+def test_asarray_device_inference():
+    assert asarray([1, 2, 3]).device == CPU_DEVICE
+
+    x = asarray([1, 2, 3])
+    assert asarray(x).device == CPU_DEVICE
+
+    device1 = Device("device1")
+    x = asarray([1, 2, 3], device=device1)
+    assert asarray(x).device == device1
+
 def test_arange_errors():
     arange(1, device=CPU_DEVICE)  # Doesn't error
     assert_raises(ValueError, lambda: arange(1, device="cpu"))

{array_api_strict-2.1.dist-info → array_api_strict-2.1.2.dist-info}/METADATA

@@ -1,21 +1,22 @@
 Metadata-Version: 2.1
 Name: array_api_strict
-Version: 2.1
+Version: 2.1.2
 Summary: A strict, minimal implementation of the Python array API standard.
 Home-page: https://data-apis.org/array-api-strict/
 Author: Consortium for Python Data API Standards
 License: MIT
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy
+Requires-Dist: numpy >=2.1
 
 # array-api-strict
 

{array_api_strict-2.1.dist-info → array_api_strict-2.1.2.dist-info}/RECORD

@@ -1,15 +1,15 @@
-array_api_strict/__init__.py,sha256=iQRjMJ4h-MoNqhxYeerCVRPORO6W6KePiQ8xIeecDac,6788
-array_api_strict/_array_object.py,sha256=BZhkZfWAHkrYOJvxAv_sQWffb6qpP83laEUI_FmP1y4,51353
+array_api_strict/__init__.py,sha256=BKVX_n63ZyGiX5sod0pPMqESM1ae0nZIJtYBGMKQSps,6967
+array_api_strict/_array_object.py,sha256=l79bhjmLZZpjUWGa_eo_vevCcfeuV7_y4eop4exy3Uo,51011
 array_api_strict/_constants.py,sha256=AYayN2jf1Dp5rXZ7WPBdUhtPBo_JMCi-pD9oW5zmFkI,87
-array_api_strict/_creation_functions.py,sha256=pNCYP6dwoVQj-bNCTfbjxM3OpjwUuUiTRjaW12IluiU,12348
+array_api_strict/_creation_functions.py,sha256=6OCWwE_bXN77vkufSNIXlWd3gLFUQT53NSd3tDffLcs,11867
 array_api_strict/_data_type_functions.py,sha256=sKxKRQiwoXPwQJPbiN5BhF9rbc3ZtXfjRuglB7VsIgo,7016
 array_api_strict/_dtypes.py,sha256=QDGo9rqiS_o3quv7QRFM0j6DkvOjRauQ1Ymikwlu8Ns,6213
-array_api_strict/_elementwise_functions.py,sha256=aYxBvyUtkvFMk6y0AkhKC2Lmago82h2c53rz4VYYKns,37196
+array_api_strict/_elementwise_functions.py,sha256=g9YecX4gM4V6UCjl7b7I752EFXhRusjm-EKGZ12jDeI,38651
 array_api_strict/_fft.py,sha256=xH1o4j_amq3e1yGVChV6vms7oAfCzpzB18I-IzjNSXw,9702
 array_api_strict/_flags.py,sha256=hXe5cTFNlFEgbB4nsEazbAPFwnsFnn52wGRYRDjfCFg,13121
 array_api_strict/_indexing_functions.py,sha256=VORFyAFCZjLpL6gZ_PNVNKbQjpjhIXQDNDDHf7Mjy_U,970
 array_api_strict/_info.py,sha256=WWvUjNITc5-jLyS4KrnwTidD3baD9DjHseV254hCUY0,3567
-array_api_strict/_linalg.py,sha256=CGE9-2aiLraRc0bjo7giGllo-cgTF9l7bvswd_hYwKY,19787
+array_api_strict/_linalg.py,sha256=sfmd5fuq2nHy_9kD2QQ23_JbbVZo7LHFgb10qjrr7nw,19846
 array_api_strict/_linear_algebra_functions.py,sha256=12XPBU27X3WZdaq9Ob2eUmL_PxMzDNF76pY4iESlPyo,3872
 array_api_strict/_manipulation_functions.py,sha256=Pa1gVRlaSC39-Zd6n4Q8c9P0anZYdyCh95Wyx3az3lc,6681
 array_api_strict/_searching_functions.py,sha256=32IiLLpa91N-jtzaxj4Nw9nQgF2ROkcNZ-XH6WQQUHY,3233
@@ -18,11 +18,11 @@ array_api_strict/_sorting_functions.py,sha256=GG7g2NYCFn2G2fFS6ZdfYOWpuuSIrdZdJW
 array_api_strict/_statistical_functions.py,sha256=dMJ-x8TQW5MD2rFYCmRH6QthA2KDKXjhkj4hcbd3LSU,5148
 array_api_strict/_typing.py,sha256=TpmU57g3EAPY9PT6hJEhzBduVrwXJUWvmoBlhy5bQuQ,1803
 array_api_strict/_utility_functions.py,sha256=khxtvqPWSDpNp65VgoJUtO4zEfTiGfZZGu_MHwyfmmI,913
-array_api_strict/_version.py,sha256=50WQJ8riNVKMTOMoVw9_1jBMPhrtVR5mgZHcHL1LUSM,495
+array_api_strict/_version.py,sha256=pdm1CW0Mq5qsnK4lz9UzkaRIItnAetbWP3x598JT1sY,497
 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=YUwPIzDu-TwKIZZTFCOwa8cfeMQBNYv4v8ifnLuekNA,20186
-array_api_strict/tests/test_creation_functions.py,sha256=5YDynTg_byrKECICSUkHOKhrb5Yh4ckWv2zlSOSTMDI,7675
+array_api_strict/tests/test_array_object.py,sha256=l-PYVbgjRd5O0c7A2ysMmS7jNjsv6pz6-Qd1kP_-DUg,19964
+array_api_strict/tests/test_creation_functions.py,sha256=ve0MeqZPrG2dmCG3hTVhap1YgIW-lAaSZIJ_ZoOV9cQ,8323
 array_api_strict/tests/test_data_type_functions.py,sha256=pLAtm96gpAduNVqq-914JvjAollzhBp4YojVfNScBzs,2138
 array_api_strict/tests/test_device_support.py,sha256=zpfhHxeRREoXfp0qZTlilm2ZceBc71uCKea1GMVe-ZU,855
 array_api_strict/tests/test_elementwise_functions.py,sha256=bKw3b4G-v3yEmmUW2HNXRRQ2tbEPopkrUKbvF8jvUpI,6943
@@ -34,8 +34,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=JwS4DhASt5T0YUNtbFK2nSXgDrVVZx1tVpe7LU2aPK4,1365
 array_api_strict/tests/test_validation.py,sha256=JdsK4z1M0U5YoJrfWSzOpEhmlehvZHF5SG0I0k6oDy8,672
-array_api_strict-2.1.dist-info/LICENSE,sha256=djDm4UfHAJmycwFUNyUmrTdRkrFF9Ac8uqIlbxH7j5Y,1585
-array_api_strict-2.1.dist-info/METADATA,sha256=lxFEfvEZ845pOZjnQTGSSB3BfSdaSuGNJrT7bjCl050,1593
-array_api_strict-2.1.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-array_api_strict-2.1.dist-info/top_level.txt,sha256=M4cE8VLgRHp_d9TPkbk7_I4JriELFdEJz-NKJJqAkAE,17
-array_api_strict-2.1.dist-info/RECORD,,
+array_api_strict-2.1.2.dist-info/LICENSE,sha256=djDm4UfHAJmycwFUNyUmrTdRkrFF9Ac8uqIlbxH7j5Y,1585
+array_api_strict-2.1.2.dist-info/METADATA,sha256=I0frr8wfn_ufn0Oz65tfCCcO9ySe3SKiiGLn9xPmY7g,1647
+array_api_strict-2.1.2.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+array_api_strict-2.1.2.dist-info/top_level.txt,sha256=M4cE8VLgRHp_d9TPkbk7_I4JriELFdEJz-NKJJqAkAE,17
+array_api_strict-2.1.2.dist-info/RECORD,,

{array_api_strict-2.1.dist-info → array_api_strict-2.1.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any