array-api-strict 2.2__py3-none-any.whl → 2.3.1__py3-none-any.whl

array_api_strict/tests/test_creation_functions.py

@@ -236,3 +236,10 @@ def from_dlpack_2023_12(api_version):
     pytest.raises(exception, lambda: from_dlpack(capsule, copy=False))
     pytest.raises(exception, lambda: from_dlpack(capsule, copy=True))
     pytest.raises(exception, lambda: from_dlpack(capsule, copy=None))
+
+
+def test_from_dlpack_default_device():
+    x = asarray([1, 2, 3])
+    y = from_dlpack(x)
+    z = from_dlpack(np.asarray([1, 2, 3]))
+    assert x.device == y.device == z.device == CPU_DEVICE

array_api_strict/tests/test_data_type_functions.py

@@ -6,9 +6,9 @@ from numpy.testing import assert_raises
 import numpy as np
 
 from .._creation_functions import asarray
-from .._data_type_functions import astype, can_cast, isdtype
+from .._data_type_functions import astype, can_cast, isdtype, result_type
 from .._dtypes import (
-    bool, int8, int16, uint8, float64,
+    bool, int8, int16, uint8, float64, int64
 )
 from .._flags import set_array_api_strict_flags
 
@@ -31,15 +31,17 @@ def test_can_cast(from_, to, expected):
 def test_isdtype_strictness():
     assert_raises(TypeError, lambda: isdtype(float64, 64))
     assert_raises(ValueError, lambda: isdtype(float64, 'f8'))
-
     assert_raises(TypeError, lambda: isdtype(float64, (('integral',),)))
+    assert_raises(TypeError, lambda: isdtype(float64, None))
+    assert_raises(TypeError, lambda: isdtype(np.float64, float64))
+    assert_raises(TypeError, lambda: isdtype(asarray(1.0), float64))
+
     with assert_raises(TypeError), warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
         isdtype(float64, np.object_)
         assert len(w) == 1
         assert issubclass(w[-1].category, UserWarning)
 
-    assert_raises(TypeError, lambda: isdtype(float64, None))
     with assert_raises(TypeError), warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
         isdtype(float64, np.float64)
@@ -68,3 +70,21 @@ def astype_device(api_version):
     else:
         pytest.raises(TypeError, lambda: astype(a, int8, device=None))
         pytest.raises(TypeError, lambda: astype(a, int8, device=a.device))
+
+
+@pytest.mark.parametrize("api_version", ['2023.12', '2024.12'])
+def test_result_type_py_scalars(api_version):
+    if api_version <= '2023.12':
+        set_array_api_strict_flags(api_version=api_version)
+
+        with pytest.raises(TypeError):
+            result_type(int16, 3)
+    else:
+        set_array_api_strict_flags(api_version=api_version)
+
+        assert result_type(int8, 3) == int8
+        assert result_type(uint8, 3) == uint8
+        assert result_type(float64, 3) == float64
+
+        with pytest.raises(TypeError):
+            result_type(int64, True)

array_api_strict/tests/test_elementwise_functions.py

@@ -1,8 +1,8 @@
 from inspect import signature, getmodule
 
-from numpy.testing import assert_raises
+from pytest import raises as assert_raises
+from numpy.testing import suppress_warnings
 
-import pytest
 
 from .. import asarray, _elementwise_functions
 from .._elementwise_functions import bitwise_left_shift, bitwise_right_shift
@@ -19,6 +19,8 @@ from .._dtypes import (
 )
 from .._flags import set_array_api_strict_flags
 
+from .test_array_object import _check_op_array_scalar, BIG_INT
+
 import array_api_strict
 
 
@@ -49,7 +51,7 @@ elementwise_function_input_types = {
     "bitwise_xor": "integer or boolean",
     "ceil": "real numeric",
     "clip": "real numeric",
-    "conj": "complex floating-point",
+    "conj": "numeric",
     "copysign": "real floating-point",
     "cos": "floating-point",
     "cosh": "floating-point",
@@ -85,7 +87,7 @@ elementwise_function_input_types = {
     "not_equal": "all",
     "positive": "numeric",
     "pow": "numeric",
-    "real": "complex floating-point",
+    "real": "numeric",
     "reciprocal": "floating-point",
     "remainder": "real numeric",
     "round": "numeric",
@@ -120,6 +122,7 @@ def test_missing_functions():
     # Ensure the above dictionary is complete.
     import array_api_strict._elementwise_functions as mod
     mod_funcs = [n for n in dir(mod) if getmodule(getattr(mod, n)) is mod]
+    mod_funcs = [n for n in mod_funcs if not n.startswith("_")]
     assert set(mod_funcs) == set(elementwise_function_input_types)
 
 
@@ -130,8 +133,7 @@ def test_function_device_persists():
             yield asarray(1., dtype=d)
 
     # Use the latest version of the standard so all functions are included
-    with pytest.warns(UserWarning):
-        set_array_api_strict_flags(api_version="2024.12")
+    set_array_api_strict_flags(api_version="2024.12")
 
     for func_name, types in elementwise_function_input_types.items():
         dtypes = _dtype_categories[types]
@@ -167,8 +169,7 @@ def test_function_types():
             yield asarray(1.0, dtype=d)
 
     # Use the latest version of the standard so all functions are included
-    with pytest.warns(UserWarning):
-        set_array_api_strict_flags(api_version="2024.12")
+    set_array_api_strict_flags(api_version="2024.12")
 
     for x in _array_vals():
         for func_name, types in elementwise_function_input_types.items():
@@ -202,3 +203,60 @@ def test_bitwise_shift_error():
     assert_raises(
         ValueError, lambda: bitwise_right_shift(asarray([1, 1]), asarray([1, -1]))
     )
+
+
+
+def test_scalars():
+    # mirror test_array_object.py::test_operators()
+    #
+    # Also check that binary functions accept (array, scalar) and (scalar, array)
+    # arguments, and reject (scalar, scalar) arguments.
+
+    # Use the latest version of the standard so that scalars are actually allowed
+    set_array_api_strict_flags(api_version="2024.12")
+
+    def _array_vals():
+        for d in _integer_dtypes:
+            yield asarray(1, dtype=d)
+        for d in _boolean_dtypes:
+            yield asarray(False, dtype=d)
+        for d in _floating_dtypes:
+            yield asarray(1.0, dtype=d)
+
+
+    for func_name, dtypes in elementwise_function_input_types.items():
+        func = getattr(_elementwise_functions, func_name)
+        if nargs(func) != 2:
+            continue
+
+        nocomplex = [
+            'atan2', 'copysign', 'floor_divide', 'hypot', 'logaddexp',  'nextafter',
+            'remainder',
+            'greater', 'less', 'greater_equal', 'less_equal', 'maximum', 'minimum',
+        ]
+
+        for s in [1, 1.0, 1j, BIG_INT, False]:
+            for a in _array_vals():
+                for func1 in [lambda s: func(a, s), lambda s: func(s, a)]:
+
+                    if func_name in nocomplex and type(s) == complex:
+                        allowed = False
+                    else:
+                        allowed = _check_op_array_scalar(dtypes, a, s, func1, func_name)
+
+                    # only check `func(array, scalar) == `func(array, array)` if
+                    # the former is legal under the promotion rules
+                    if allowed:
+                        conv_scalar = a._promote_scalar(s)
+
+                        with suppress_warnings() as sup:
+                            # ignore warnings from pow(BIG_INT)
+                            sup.filter(RuntimeWarning,
+                                       "invalid value encountered in power")
+                            assert func(s, a) == func(conv_scalar, a)
+                            assert func(a, s) == func(a, conv_scalar)
+
+                        with assert_raises(TypeError):
+                            func(s, s)
+
+

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': '2023.12',
+        'api_version': '2024.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': '2023.12',
+        'api_version': '2024.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': '2023.12',
+        'api_version': '2024.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': '2023.12',
+        'api_version': '2024.12',
         'boolean_indexing': True,
         'data_dependent_shapes': False,
         'enabled_extensions': ('fft',),
@@ -98,15 +98,26 @@ def test_flags_api_version_2023_12():
     }
 
 def test_flags_api_version_2024_12():
-    # Make sure setting the version to 2024.12 issues a warning.
+    set_array_api_strict_flags(api_version='2024.12')
+    flags = get_array_api_strict_flags()
+    assert flags == {
+        'api_version': '2024.12',
+        'boolean_indexing': True,
+        'data_dependent_shapes': True,
+        'enabled_extensions': ('linalg', 'fft'),
+    }
+
+
+def test_flags_api_version_2025_12():
+    # Make sure setting the version to 2025.12 issues a warning.
     with pytest.warns(UserWarning) as record:
-        set_array_api_strict_flags(api_version='2024.12')
+        set_array_api_strict_flags(api_version='2025.12')
     assert len(record) == 1
-    assert '2024.12' in str(record[0].message)
+    assert '2025.12' in str(record[0].message)
     assert 'draft' in str(record[0].message)
     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'),
@@ -125,9 +136,12 @@ def test_setting_flags_invalid():
 
 def test_api_version():
     # Test defaults
-    assert xp.__array_api_version__ == '2023.12'
+    assert xp.__array_api_version__ == '2024.12'
 
     # Test setting the version
+    set_array_api_strict_flags(api_version='2023.12')
+    assert xp.__array_api_version__ == '2023.12'
+
     set_array_api_strict_flags(api_version='2022.12')
     assert xp.__array_api_version__ == '2022.12'
 
@@ -307,14 +321,16 @@ api_version_2024_12_examples = {
     'reciprocal': lambda: xp.reciprocal(xp.asarray([2.])),
     'take_along_axis': lambda: xp.take_along_axis(xp.zeros((2, 3)),
                                                   xp.zeros((1, 4), dtype=xp.int64)),
+    'count_nonzero': lambda: xp.count_nonzero(xp.arange(3)),
+    'cumulative_prod': lambda: xp.cumulative_prod(xp.arange(1, 5)),
 }
 
 @pytest.mark.parametrize('func_name', api_version_2024_12_examples.keys())
 def test_api_version_2024_12(func_name):
     func = api_version_2024_12_examples[func_name]
 
-    # By default, these functions should error
-    pytest.raises(RuntimeError, func)
+    # By default, these functions should not error
+    func()
 
     # In 2022.12 and 2023.12, these functions should error
     set_array_api_strict_flags(api_version='2022.12')
@@ -322,11 +338,6 @@ def test_api_version_2024_12(func_name):
     set_array_api_strict_flags(api_version='2023.12')
     pytest.raises(RuntimeError, func)
 
-    # They should not error in 2024.12
-    with pytest.warns(UserWarning):
-        set_array_api_strict_flags(api_version='2024.12')
-    func()
-
     # Test the behavior gets updated properly
     set_array_api_strict_flags(api_version='2023.12')
     pytest.raises(RuntimeError, func)
@@ -433,9 +444,9 @@ def test_environment_variables():
         # ARRAY_API_STRICT_API_VERSION
         ('''\
 import array_api_strict as xp
-assert xp.__array_api_version__ == '2023.12'
+assert xp.__array_api_version__ == '2024.12'
 
-assert xp.get_array_api_strict_flags()['api_version'] == '2023.12'
+assert xp.get_array_api_strict_flags()['api_version'] == '2024.12'
 
 ''', {}),
         *[

array_api_strict/tests/test_manipulation_functions.py

@@ -11,7 +11,7 @@ from .._manipulation_functions import (
 
 
 def test_concat_errors():
-    assert_raises(TypeError, lambda: concat((1, 1), axis=None))
+    assert_raises((TypeError, ValueError), lambda: concat((1, 1), axis=None))
     assert_raises(TypeError, lambda: concat([asarray([1], dtype=int8),
                                              asarray([1], dtype=float64)]))
 

array_api_strict/tests/test_searching_functions.py

@@ -0,0 +1,44 @@
+import pytest
+
+import array_api_strict as xp
+
+from array_api_strict import ArrayAPIStrictFlags
+
+
+def test_where_with_scalars():
+    x = xp.asarray([1, 2, 3, 1])
+
+    # Versions up to and including 2023.12 don't support scalar arguments
+    with ArrayAPIStrictFlags(api_version='2023.12'):
+        with pytest.raises(AttributeError, match="object has no attribute 'dtype'"):
+            xp.where(x == 1, 42, 44)
+
+    # Versions after 2023.12 support scalar arguments
+    x_where = xp.where(x == 1, xp.asarray(42), 44)
+
+    expected = xp.asarray([42, 44, 44, 42])
+    assert xp.all(x_where == expected)
+
+    # The spec does not allow both x1 and x2 to be scalars
+    with pytest.raises(TypeError, match="Two scalars"):
+        xp.where(x == 1, 42, 44)
+
+
+def test_where_mixed_dtypes():
+    # https://github.com/data-apis/array-api-strict/issues/131
+    x =  xp.asarray([1., 2.])
+    res = xp.where(x > 1.5, x, 0)
+    assert res.dtype == x.dtype
+    assert all(res == xp.asarray([0., 2.]))
+
+    # retry with boolean x1, x2
+    c = x > 1.5
+    res = xp.where(c, False, c)
+    assert all(res == xp.asarray([False, False]))
+
+
+def test_where_f32():
+    # https://github.com/data-apis/array-api-strict/issues/131#issuecomment-2723016294
+    res = xp.where(xp.asarray([True, False]), 1., xp.asarray([2, 2], dtype=xp.float32))
+    assert res.dtype == xp.float32
+

array_api_strict/tests/test_statistical_functions.py

@@ -1,6 +1,7 @@
+import cmath
 import pytest
 
-from .._flags import set_array_api_strict_flags
+from .._flags import set_array_api_strict_flags, ArrayAPIStrictFlags
 
 import array_api_strict as xp
 
@@ -37,3 +38,20 @@ def test_sum_prod_trace_2023_12(func_name):
     assert func(a_real).dtype == xp.float32
     assert func(a_complex).dtype == xp.complex64
     assert func(a_int).dtype == xp.int64
+
+
+# mean(complex-valued array) is allowed from 2024.12 onwards
+def test_mean_complex():
+    a = xp.asarray([1j, 2j, 3j])
+
+    with ArrayAPIStrictFlags(api_version='2023.12'):
+        with pytest.raises(TypeError):
+            xp.mean(a)
+
+    m = xp.mean(a)
+    assert cmath.isclose(complex(m), 2j)
+
+    # mean of integer arrays is still not allowed
+    with pytest.raises(TypeError):
+        xp.mean(xp.arange(3))
+

array_api_strict/tests/test_validation.py

@@ -18,7 +18,7 @@ def p(func: Callable, *args, **kwargs):
     [
         p(xp.can_cast, 42, xp.int8),
         p(xp.can_cast, xp.int8, 42),
-        p(xp.result_type, 42),
+        p(xp.result_type, "42"),
     ],
 )
 def test_raises_on_invalid_types(func, args, kwargs):

array_api_strict-2.3.1.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.1
+Name: array_api_strict
+Version: 2.3.1
+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
+        
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are
+        met:
+        
+            * Redistributions of source code must retain the above copyright
+               notice, this list of conditions and the following disclaimer.
+        
+            * Redistributions in binary form must reproduce the above
+               copyright notice, this list of conditions and the following
+               disclaimer in the documentation and/or other materials provided
+               with the distribution.
+        
+            * Neither the name of the NumPy Developers nor the names of any
+               contributors may be used to endorse or promote products derived
+               from this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+        "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+        LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+        A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+        OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+        SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+        LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+        DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+        THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+        (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+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: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+
+# array-api-strict
+
+`array_api_strict` is a strict, minimal implementation of the [Python array
+API](https://data-apis.org/array-api/latest/).
+
+The purpose of array-api-strict is to provide an implementation of the array
+API for consuming libraries to test against so they can be completely sure
+their usage of the array API is portable.
+
+It is *not* intended to be used by end-users. End-users of the array API
+should just use their favorite array library (NumPy, CuPy, PyTorch, etc.) as
+usual. It is also not intended to be used as a dependency by consuming
+libraries. Consuming library code should use the
+[array-api-compat](https://data-apis.org/array-api-compat/) package to
+support the array API. Rather, it is intended to be used in the test suites of
+consuming libraries to test their array API usage.
+
+See the documentation for more details https://data-apis.org/array-api-strict/

array_api_strict-2.3.1.dist-info/RECORD

@@ -0,0 +1,43 @@
+array_api_strict/__init__.py,sha256=GDez0wXMz0GD2RvY9QF60kiueaYYOAcUTOjUhtT2xSI,7023
+array_api_strict/_array_object.py,sha256=Ig6WJNPjYvTnf1Ry4JsSt09OfkEjcG6TYXtG_TaZ6d8,53111
+array_api_strict/_constants.py,sha256=AYayN2jf1Dp5rXZ7WPBdUhtPBo_JMCi-pD9oW5zmFkI,87
+array_api_strict/_creation_functions.py,sha256=sjkIVxh0gbiIgpRGwjo5_R2i4Purb2MJfAljl1v6ogY,13017
+array_api_strict/_data_type_functions.py,sha256=FvIlbcHo0QdOHirF4Kumkm_GJ6EVSbap9uBK2fBSDRQ,8135
+array_api_strict/_dtypes.py,sha256=UxX6e2pEBeRrd_V21bdg85Wxr94d1YUq4USrT1I8Ioo,6278
+array_api_strict/_elementwise_functions.py,sha256=ClJ2aDwPazGW_wvYnGjzBXL-YdgY6ejkU8s_Ev8wif4,23510
+array_api_strict/_fft.py,sha256=qm9xcjKQAxjmNuq6fgkf-49E6OHhLodyHpfPIpoHmxc,10302
+array_api_strict/_flags.py,sha256=m3Q117wbnOmgg4fr4cBuDw5x4VAOUn05pnPrTFAZ5vk,13647
+array_api_strict/_helpers.py,sha256=MUUbpaahyweRK-TbSp-mHUn05y-x6hSWg0N4JqBpVqs,1336
+array_api_strict/_indexing_functions.py,sha256=3AqC8Mgi9BakrStlZoIV34d0Au5dMk6qT07TxpvvCGk,1520
+array_api_strict/_info.py,sha256=QvW1PV7dO2oGPWAerG3wJn61QAqjqxx4iHkWPUturI4,4455
+array_api_strict/_linalg.py,sha256=sfmd5fuq2nHy_9kD2QQ23_JbbVZo7LHFgb10qjrr7nw,19846
+array_api_strict/_linear_algebra_functions.py,sha256=FNvaEbiOL4HkHpTtav9OvEFsSrv-6ezaqeajRPALn1Y,3881
+array_api_strict/_manipulation_functions.py,sha256=njyE4GiGsjLL-wNC8Uw4hk9H6bLaEUneyn2DAYB6TDM,6878
+array_api_strict/_searching_functions.py,sha256=7dxQPuKq8-TV260mxLCBjTMvzF03h0TDvEMdkMcVP-I,4106
+array_api_strict/_set_functions.py,sha256=PZVsxkRQi5Zi104dI2fHZBFqpluOAW0IJzzdJSyajiI,3295
+array_api_strict/_sorting_functions.py,sha256=GG7g2NYCFn2G2fFS6ZdfYOWpuuSIrdZdJWEuL72_-LI,2065
+array_api_strict/_statistical_functions.py,sha256=I_nNZyv4aKRmrJjdsw0PJZCtQ-TgKuMyaBMWbSioTlI,6237
+array_api_strict/_typing.py,sha256=oaHM01VhgC5JIHxXMouEEajNs0OXtwOasnIznK7z9fk,1889
+array_api_strict/_utility_functions.py,sha256=Mu07FogReaAFToPMHE_j90YBEDEvxD5jPcMK3zeUiG0,2007
+array_api_strict/_version.py,sha256=4lLWfgycoQE7rafXKcKQeSzbG6DAo6_kH0qn9J_0diQ,511
+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=N84q_642ypibxihmRssWth4eHPs8AbpQrktCbZDipIc,23567
+array_api_strict/tests/test_creation_functions.py,sha256=qPflQZN4Bc1aGwTPqodSNcEdvXjvOeNp59cvxUGq0lg,8515
+array_api_strict/tests/test_data_type_functions.py,sha256=1zQ4qkA6x9GWB-OQuAr9ndpUcocfNY95W8Zt4iC4Kgs,2860
+array_api_strict/tests/test_device_support.py,sha256=zpfhHxeRREoXfp0qZTlilm2ZceBc71uCKea1GMVe-ZU,855
+array_api_strict/tests/test_elementwise_functions.py,sha256=K2bUKe-YZOR-T0G-Kz2xtgNr06xKi_ks0uk8v_rJziQ,9293
+array_api_strict/tests/test_flags.py,sha256=kcBbFB4aq3XY_9HM1j3wKmq8MVNfU4YxwK21mARM0iw,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=ivDcpggiQkSdGVqboJmwczj3Zfmgojp86tNWJphxB0k,1352
+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_validation.py,sha256=Dtl-kGRtdslaPVWWtr3rBrIsJPuj7LZz6_pw2yjwkWE,674
+array_api_strict-2.3.1.dist-info/LICENSE,sha256=djDm4UfHAJmycwFUNyUmrTdRkrFF9Ac8uqIlbxH7j5Y,1585
+array_api_strict-2.3.1.dist-info/METADATA,sha256=VURFsgnmY7crtgcQGW8mXfQzlD_YMZoFXP2WmYokTdI,3425
+array_api_strict-2.3.1.dist-info/WHEEL,sha256=5Mi1sN9lKoFv_gxcPtisEVrJZihrm_beibeg5R6xb4I,91
+array_api_strict-2.3.1.dist-info/top_level.txt,sha256=M4cE8VLgRHp_d9TPkbk7_I4JriELFdEJz-NKJJqAkAE,17
+array_api_strict-2.3.1.dist-info/RECORD,,

{array_api_strict-2.2.dist-info → array_api_strict-2.3.1.dist-info}/WHEEL

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

array_api_strict-2.2.dist-info/METADATA

@@ -1,37 +0,0 @@
-Metadata-Version: 2.1
-Name: array_api_strict
-Version: 2.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: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy
-
-# array-api-strict
-
-`array_api_strict` is a strict, minimal implementation of the [Python array
-API](https://data-apis.org/array-api/latest/).
-
-The purpose of array-api-strict is to provide an implementation of the array
-API for consuming libraries to test against so they can be completely sure
-their usage of the array API is portable.
-
-It is *not* intended to be used by end-users. End-users of the array API
-should just use their favorite array library (NumPy, CuPy, PyTorch, etc.) as
-usual. It is also not intended to be used as a dependency by consuming
-libraries. Consuming library code should use the
-[array-api-compat](https://data-apis.org/array-api-compat/) package to
-support the array API. Rather, it is intended to be used in the test suites of
-consuming libraries to test their array API usage.
-
-See the documentation for more details https://data-apis.org/array-api-strict/

array_api_strict-2.2.dist-info/RECORD

@@ -1,41 +0,0 @@
-array_api_strict/__init__.py,sha256=Nm_8GFfA0bpkVMw3urULYSadngGPaW6C2VuEpM-ziyI,6904
-array_api_strict/_array_object.py,sha256=Q69HJ8qdQqqugWIRf4RsifZUEypbhNV_y5EVSygmbrQ,52571
-array_api_strict/_constants.py,sha256=AYayN2jf1Dp5rXZ7WPBdUhtPBo_JMCi-pD9oW5zmFkI,87
-array_api_strict/_creation_functions.py,sha256=A9TTvPSznF9NsxT0Pd_G9yU6IZAfW1tpBkFMYoJyguw,12985
-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=epo92ppRP4XDcDhS431J599NA1pT4DK08wIdV9vVO8s,39713
-array_api_strict/_fft.py,sha256=xH1o4j_amq3e1yGVChV6vms7oAfCzpzB18I-IzjNSXw,9702
-array_api_strict/_flags.py,sha256=lUb-SowhHvA9MLBm0ICO5L7M7FgclWPF8v8z5N--Q_o,13558
-array_api_strict/_indexing_functions.py,sha256=3AqC8Mgi9BakrStlZoIV34d0Au5dMk6qT07TxpvvCGk,1520
-array_api_strict/_info.py,sha256=QvW1PV7dO2oGPWAerG3wJn61QAqjqxx4iHkWPUturI4,4455
-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
-array_api_strict/_set_functions.py,sha256=PZVsxkRQi5Zi104dI2fHZBFqpluOAW0IJzzdJSyajiI,3295
-array_api_strict/_sorting_functions.py,sha256=GG7g2NYCFn2G2fFS6ZdfYOWpuuSIrdZdJWEuL72_-LI,2065
-array_api_strict/_statistical_functions.py,sha256=dMJ-x8TQW5MD2rFYCmRH6QthA2KDKXjhkj4hcbd3LSU,5148
-array_api_strict/_typing.py,sha256=oaHM01VhgC5JIHxXMouEEajNs0OXtwOasnIznK7z9fk,1889
-array_api_strict/_utility_functions.py,sha256=Mu07FogReaAFToPMHE_j90YBEDEvxD5jPcMK3zeUiG0,2007
-array_api_strict/_version.py,sha256=20M94v12DlLnRLp4vkFO-TkQKxHY21bls4ZgOvbf7jE,495
-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=IzfVo63eiPoFFwb4woNT15e4gJFfYVyD7zK-wddRMBY,21865
-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=ManUmYZF3oT-UXH4lqWJna3zDHdxVBeuvIdFlFPABQ4,7114
-array_api_strict/tests/test_flags.py,sha256=YadbyJEu7DmMo3TKl3nROf7R4xDIrQfm8acifHA3CYc,18598
-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=CzcudVxUKhQ4Ec94Vda4C6HaAqrOQPQfQxT4uTM2fsM,1064
-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=JwS4DhASt5T0YUNtbFK2nSXgDrVVZx1tVpe7LU2aPK4,1365
-array_api_strict/tests/test_validation.py,sha256=JdsK4z1M0U5YoJrfWSzOpEhmlehvZHF5SG0I0k6oDy8,672
-array_api_strict-2.2.dist-info/LICENSE,sha256=djDm4UfHAJmycwFUNyUmrTdRkrFF9Ac8uqIlbxH7j5Y,1585
-array_api_strict-2.2.dist-info/METADATA,sha256=uCWtV4ZiiCzUkNRWapj10LpJxUCPHy8fzddfOiFt2cM,1593
-array_api_strict-2.2.dist-info/WHEEL,sha256=a7TGlA-5DaHMRrarXjVbQagU3Man_dCnGIWMJr5kRWo,91
-array_api_strict-2.2.dist-info/top_level.txt,sha256=M4cE8VLgRHp_d9TPkbk7_I4JriELFdEJz-NKJJqAkAE,17
-array_api_strict-2.2.dist-info/RECORD,,