array-api-strict 2.1.2__tar.gz → 2.2__tar.gz

{array_api_strict-2.1.2 → array_api_strict-2.2}/PKG-INFO

@@ -1,22 +1,21 @@
 Metadata-Version: 2.1
 Name: array_api_strict
-Version: 2.1.2
+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: Programming Language :: Python :: 3.13
-Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy>=2.1
+Requires-Dist: numpy
 
 # array-api-strict
 

{array_api_strict-2.1.2 → array_api_strict-2.2}/array_api_strict/__init__.py

@@ -16,12 +16,6 @@ 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
@@ -178,10 +172,12 @@ from ._elementwise_functions import (
     minimum,
     multiply,
     negative,
+    nextafter,
     not_equal,
     positive,
     pow,
     real,
+    reciprocal,
     remainder,
     round,
     sign,
@@ -246,10 +242,12 @@ __all__ += [
     "minimum",
     "multiply",
     "negative",
+    "nextafter",
     "not_equal",
     "positive",
     "pow",
     "real",
+    "reciprocal",
     "remainder",
     "round",
     "sign",
@@ -264,9 +262,9 @@ __all__ += [
     "trunc",
 ]
 
-from ._indexing_functions import take
+from ._indexing_functions import take, take_along_axis
 
-__all__ += ["take"]
+__all__ += ["take", "take_along_axis"]
 
 from ._info import __array_namespace_info__
 
@@ -311,9 +309,9 @@ from ._statistical_functions import cumulative_sum, max, mean, min, prod, std, s
 
 __all__ += ["cumulative_sum", "max", "mean", "min", "prod", "std", "sum", "var"]
 
-from ._utility_functions import all, any
+from ._utility_functions import all, any, diff
 
-__all__ += ["all", "any"]
+__all__ += ["all", "any", "diff"]
 
 from ._array_object import Device
 __all__ += ["Device"]

{array_api_strict-2.1.2 → array_api_strict-2.2}/array_api_strict/_array_object.py

@@ -66,7 +66,9 @@ ALL_DEVICES = (CPU_DEVICE, Device("device1"), Device("device2"))
 
 _default = object()
 
-_allow_array = False
+# See https://github.com/data-apis/array-api-strict/issues/67 and the comment
+# on __array__ below.
+_allow_array = True
 
 class Array:
     """
@@ -147,22 +149,37 @@ class Array:
             mid = np.array2string(self._array, separator=', ', prefix=prefix, suffix=suffix)
         return prefix + mid + suffix
 
-    # 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
+    # In the future, _allow_array will be set to False, which will disallow
+    # __array__. This means 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 reason for doing this
+    # is that __array__ is not actually supported by the standard, so it can
     # lead to code assuming np.asarray(other_array) would always work in the
     # standard.
+    #
+    # This 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).
     def __array__(self, dtype: None | np.dtype[Any] = None, copy: None | bool = None) -> npt.NDArray[Any]:
         # 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)
+            # 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:
+                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
@@ -574,14 +591,24 @@ class Array:
             if copy is not _default:
                 raise ValueError("The copy argument to __dlpack__ requires at least version 2023.12 of the array API")
 
-        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)
+        if np.lib.NumpyVersion(np.__version__) < '2.1.0':
+            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)
+        else:
+            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-2.1.2 → array_api_strict-2.2}/array_api_strict/_creation_functions.py

@@ -83,6 +83,29 @@ def asarray(
     if isinstance(obj, Array) and device is None:
         device = obj.device
 
+    if np.lib.NumpyVersion(np.__version__) < '2.0.0':
+        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):
         return Array._new(np.array(obj._array, copy=copy, dtype=_np_dtype), device=device)
     if dtype is None and isinstance(obj, int) and (obj > 2 ** 64 or obj < -(2 ** 63)):

{array_api_strict-2.1.2 → array_api_strict-2.2}/array_api_strict/_elementwise_functions.py

@@ -805,6 +805,20 @@ def negative(x: Array, /) -> Array:
     return Array._new(np.negative(x._array), device=x.device)
 
 
+@requires_api_version('2024.12')
+def nextafter(x1: Array, x2: Array, /) -> Array:
+    """
+    Array API compatible wrapper for :py:func:`np.nextafter <numpy.nextafter>`.
+
+    See its docstring for more information.
+    """
+    if x1.device != x2.device:
+        raise ValueError(f"Arrays from two different devices ({x1.device} and {x2.device}) can not be combined.")
+    if x1.dtype not in _real_floating_dtypes or x2.dtype not in _real_floating_dtypes:
+        raise TypeError("Only real floating-point dtypes are allowed in nextafter")
+    x1, x2 = Array._normalize_two_args(x1, x2)
+    return Array._new(np.nextafter(x1._array, x2._array), device=x1.device)
+
 def not_equal(x1: Array, x2: Array, /) -> Array:
     """
     Array API compatible wrapper for :py:func:`np.not_equal <numpy.not_equal>`.
@@ -858,6 +872,17 @@ def real(x: Array, /) -> Array:
     return Array._new(np.real(x._array), device=x.device)
 
 
+@requires_api_version('2024.12')
+def reciprocal(x: Array, /) -> Array:
+    """
+    Array API compatible wrapper for :py:func:`np.reciprocal <numpy.reciprocal>`.
+
+    See its docstring for more information.
+    """
+    if x.dtype not in _floating_dtypes:
+        raise TypeError("Only floating-point dtypes are allowed in reciprocal")
+    return Array._new(np.reciprocal(x._array), device=x.device)
+
 def remainder(x1: Array, x2: Array, /) -> Array:
     """
     Array API compatible wrapper for :py:func:`np.remainder <numpy.remainder>`.

{array_api_strict-2.1.2 → array_api_strict-2.2}/array_api_strict/_flags.py

@@ -24,6 +24,8 @@ supported_versions = (
     "2023.12",
 )
 
+draft_version = "2024.12"
+
 API_VERSION = default_version = "2023.12"
 
 BOOLEAN_INDEXING = True
@@ -70,8 +72,8 @@ def set_array_api_strict_flags(
     ----------
     api_version : str, optional
         The version of the standard to use. Supported versions are:
-        ``{supported_versions}``. The default version number is
-        ``{default_version!r}``.
+        ``{supported_versions}``, plus the draft version ``{draft_version}``.
+        The default version number is ``{default_version!r}``.
 
         Note that 2021.12 is supported, but currently gives the same thing as
         2022.12 (except that the fft extension will be disabled).
@@ -134,10 +136,12 @@ def set_array_api_strict_flags(
     global API_VERSION, BOOLEAN_INDEXING, DATA_DEPENDENT_SHAPES, ENABLED_EXTENSIONS
 
     if api_version is not None:
-        if api_version not in supported_versions:
+        if api_version not in [*supported_versions, draft_version]:
             raise ValueError(f"Unsupported standard version {api_version!r}")
         if api_version == "2021.12":
             warnings.warn("The 2021.12 version of the array API specification was requested but the returned namespace is actually version 2022.12", stacklevel=2)
+        if api_version == draft_version:
+            warnings.warn(f"The {draft_version} version of the array API specification is in draft status. Not all features are implemented in array_api_strict, some functions may not be fully tested, and behaviors are subject to change before the final standard release.")
         API_VERSION = api_version
         array_api_strict.__array_api_version__ = API_VERSION
 
@@ -169,6 +173,7 @@ set_array_api_strict_flags.__doc__ = set_array_api_strict_flags.__doc__.format(
     supported_versions=supported_versions,
     default_version=default_version,
     default_extensions=default_extensions,
+    draft_version=draft_version,
 )
 
 def get_array_api_strict_flags():

{array_api_strict-2.1.2 → array_api_strict-2.2}/array_api_strict/_indexing_functions.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from ._array_object import Array
 from ._dtypes import _integer_dtypes
+from ._flags import requires_api_version
 
 from typing import TYPE_CHECKING
 
@@ -25,3 +26,14 @@ def take(x: Array, indices: Array, /, *, axis: Optional[int] = None) -> Array:
     if x.device != indices.device:
         raise ValueError(f"Arrays from two different devices ({x.device} and {indices.device}) can not be combined.")
     return Array._new(np.take(x._array, indices._array, axis=axis), device=x.device)
+
+@requires_api_version('2024.12')
+def take_along_axis(x: Array, indices: Array, /, *, axis: int = -1) -> Array:
+    """
+    Array API compatible wrapper for :py:func:`np.take_along_axis <numpy.take_along_axis>`.
+
+    See its docstring for more information.
+    """
+    if x.device != indices.device:
+        raise ValueError(f"Arrays from two different devices ({x.device} and {indices.device}) can not be combined.")
+    return Array._new(np.take_along_axis(x._array, indices._array, axis), device=x.device)

array_api_strict-2.2/array_api_strict/_info.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from typing import Optional, Union, Tuple, List
+    from ._typing import device, DefaultDataTypes, DataTypes, Capabilities
+
+from ._array_object import ALL_DEVICES, CPU_DEVICE
+from ._flags import get_array_api_strict_flags, requires_api_version
+from ._dtypes import bool, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float32, float64, complex64, complex128
+
+@requires_api_version('2023.12')
+class __array_namespace_info__:
+    @requires_api_version('2023.12')
+    def capabilities(self) -> Capabilities:
+        flags = get_array_api_strict_flags()
+        res = {"boolean indexing": flags['boolean_indexing'],
+                "data-dependent shapes": flags['data_dependent_shapes'],
+                }
+        if flags['api_version'] >= '2024.12':
+            # maxdims is 32 for NumPy 1.x and 64 for NumPy 2.0. Eventually we will
+            # drop support for NumPy 1 but for now, just compute the number
+            # directly
+            for i in range(1, 100):
+                try:
+                    np.zeros((1,)*i)
+                except ValueError:
+                    maxdims = i - 1
+                    break
+            else:
+                raise RuntimeError("Could not get max dimensions (this is a bug in array-api-strict)")
+            res['max dimensions'] = maxdims
+        return res
+
+    @requires_api_version('2023.12')
+    def default_device(self) -> device:
+        return CPU_DEVICE
+
+    @requires_api_version('2023.12')
+    def default_dtypes(
+        self,
+        *,
+        device: Optional[device] = None,
+    ) -> DefaultDataTypes:
+        return {
+            "real floating": float64,
+            "complex floating": complex128,
+            "integral": int64,
+            "indexing": int64,
+        }
+
+    @requires_api_version('2023.12')
+    def dtypes(
+        self,
+        *,
+        device: Optional[device] = None,
+        kind: Optional[Union[str, Tuple[str, ...]]] = None,
+    ) -> DataTypes:
+        if kind is None:
+            return {
+                "bool": bool,
+                "int8": int8,
+                "int16": int16,
+                "int32": int32,
+                "int64": int64,
+                "uint8": uint8,
+                "uint16": uint16,
+                "uint32": uint32,
+                "uint64": uint64,
+                "float32": float32,
+                "float64": float64,
+                "complex64": complex64,
+                "complex128": complex128,
+            }
+        if kind == "bool":
+            return {"bool": bool}
+        if kind == "signed integer":
+            return {
+                "int8": int8,
+                "int16": int16,
+                "int32": int32,
+                "int64": int64,
+            }
+        if kind == "unsigned integer":
+            return {
+                "uint8": uint8,
+                "uint16": uint16,
+                "uint32": uint32,
+                "uint64": uint64,
+            }
+        if kind == "integral":
+            return {
+                "int8": int8,
+                "int16": int16,
+                "int32": int32,
+                "int64": int64,
+                "uint8": uint8,
+                "uint16": uint16,
+                "uint32": uint32,
+                "uint64": uint64,
+            }
+        if kind == "real floating":
+            return {
+                "float32": float32,
+                "float64": float64,
+            }
+        if kind == "complex floating":
+            return {
+                "complex64": complex64,
+                "complex128": complex128,
+            }
+        if kind == "numeric":
+            return {
+                "int8": int8,
+                "int16": int16,
+                "int32": int32,
+                "int64": int64,
+                "uint8": uint8,
+                "uint16": uint16,
+                "uint32": uint32,
+                "uint64": uint64,
+                "float32": float32,
+                "float64": float64,
+                "complex64": complex64,
+                "complex128": complex128,
+            }
+        if isinstance(kind, tuple):
+            res = {}
+            for k in kind:
+                res.update(self.dtypes(kind=k))
+            return res
+        raise ValueError(f"unsupported kind: {kind!r}")
+
+    @requires_api_version('2023.12')
+    def devices(self) -> List[device]:
+        return list(ALL_DEVICES)

{array_api_strict-2.1.2 → array_api_strict-2.2}/array_api_strict/_typing.py

@@ -21,7 +21,6 @@ import sys
 
 from typing import (
     Any,
-    ModuleType,
     TypedDict,
     TypeVar,
     Protocol,
@@ -29,6 +28,7 @@ from typing import (
 
 from ._array_object import Array, _device
 from ._dtypes import _DType
+from ._info import __array_namespace_info__
 
 _T_co = TypeVar("_T_co", covariant=True)
 
@@ -41,7 +41,7 @@ Device = _device
 
 Dtype = _DType
 
-Info = ModuleType
+Info = __array_namespace_info__
 
 if sys.version_info >= (3, 12):
     from collections.abc import Buffer as SupportsBufferProtocol
@@ -54,7 +54,8 @@ class SupportsDLPack(Protocol):
     def __dlpack__(self, /, *, stream: None = ...) -> PyCapsule: ...
 
 Capabilities = TypedDict(
-    "Capabilities", {"boolean indexing": bool, "data-dependent shapes": bool}
+    "Capabilities", {"boolean indexing": bool, "data-dependent shapes": bool,
+                     "max dimensions": int}
 )
 
 DefaultDataTypes = TypedDict(

array_api_strict-2.2/array_api_strict/_utility_functions.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from ._array_object import Array
+from ._flags import requires_api_version
+from ._dtypes import _numeric_dtypes
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from typing import Optional, Tuple, Union
+
+import numpy as np
+
+
+def all(
+    x: Array,
+    /,
+    *,
+    axis: Optional[Union[int, Tuple[int, ...]]] = None,
+    keepdims: bool = False,
+) -> Array:
+    """
+    Array API compatible wrapper for :py:func:`np.all <numpy.all>`.
+
+    See its docstring for more information.
+    """
+    return Array._new(np.asarray(np.all(x._array, axis=axis, keepdims=keepdims)), device=x.device)
+
+
+def any(
+    x: Array,
+    /,
+    *,
+    axis: Optional[Union[int, Tuple[int, ...]]] = None,
+    keepdims: bool = False,
+) -> Array:
+    """
+    Array API compatible wrapper for :py:func:`np.any <numpy.any>`.
+
+    See its docstring for more information.
+    """
+    return Array._new(np.asarray(np.any(x._array, axis=axis, keepdims=keepdims)), device=x.device)
+
+@requires_api_version('2024.12')
+def diff(
+    x: Array,
+    /,
+    *,
+    axis: int = -1,
+    n: int = 1,
+    prepend: Optional[Array] = None,
+    append: Optional[Array] = None,
+) -> Array:
+    if x.dtype not in _numeric_dtypes:
+        raise TypeError("Only numeric dtypes are allowed in diff")
+
+    # TODO: The type promotion behavior for prepend and append is not
+    # currently specified.
+
+    # NumPy does not support prepend=None or append=None
+    kwargs = dict(axis=axis, n=n)
+    if prepend is not None:
+        if prepend.device != x.device:
+            raise ValueError(f"Arrays from two different devices ({prepend.device} and {x.device}) can not be combined.")
+        kwargs['prepend'] = prepend._array
+    if append is not None:
+        if append.device != x.device:
+            raise ValueError(f"Arrays from two different devices ({append.device} and {x.device}) can not be combined.")
+        kwargs['append'] = append._array
+    return Array._new(np.diff(x._array, **kwargs), device=x.device)

{array_api_strict-2.1.2 → array_api_strict-2.2}/array_api_strict/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-11-07T18:09:02-0700",
+ "date": "2024-11-11T15:30:59-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "c9fe697bec8de8e402d8beb71bbeb96ca70c772e",
- "version": "2.1.2"
+ "full-revisionid": "fe4f34ad30ba59c1c981037dd181f6b4daf23b22",
+ "version": "2.2"
 }
 '''  # END VERSION_JSON
 

{array_api_strict-2.1.2 → array_api_strict-2.2}/array_api_strict/tests/test_array_object.py

@@ -364,6 +364,23 @@ def test_array_conversion():
         with pytest.raises(RuntimeError, match="Can not convert array"):
             asarray([a])
 
+def test__array__():
+    # __array__ should work for now
+    a = ones((2, 3))
+    np.array(a)
+
+    # Test the _allow_array private global flag for disabling it in the
+    # future.
+    from .. import _array_object
+    original_value = _array_object._allow_array
+    try:
+        _array_object._allow_array = False
+        a = ones((2, 3))
+        with pytest.raises(ValueError, match="Conversion from an array_api_strict array to a NumPy ndarray is not supported"):
+            np.array(a)
+    finally:
+        _array_object._allow_array = original_value
+
 def test_allow_newaxis():
     a = ones(5)
     indexed_a = a[None, :]
@@ -436,8 +453,12 @@ def test_array_namespace():
         assert a.__array_namespace__(api_version="2021.12") is array_api_strict
     assert array_api_strict.__array_api_version__ == "2021.12"
 
+    with pytest.warns(UserWarning):
+        assert a.__array_namespace__(api_version="2024.12") is array_api_strict
+    assert array_api_strict.__array_api_version__ == "2024.12"
+
     pytest.raises(ValueError, lambda: a.__array_namespace__(api_version="2021.11"))
-    pytest.raises(ValueError, lambda: a.__array_namespace__(api_version="2024.12"))
+    pytest.raises(ValueError, lambda: a.__array_namespace__(api_version="2025.12"))
 
 def test_iter():
     pytest.raises(TypeError, lambda: iter(asarray(3)))
@@ -448,7 +469,7 @@ def test_iter():
     pytest.raises(TypeError, lambda: iter(ones((3, 3))))
 
 @pytest.mark.parametrize("api_version", ['2021.12', '2022.12', '2023.12'])
-def dlpack_2023_12(api_version):
+def test_dlpack_2023_12(api_version):
     if api_version == '2021.12':
         with pytest.warns(UserWarning):
             set_array_api_strict_flags(api_version=api_version)
@@ -456,19 +477,41 @@ def dlpack_2023_12(api_version):
         set_array_api_strict_flags(api_version=api_version)
 
     a = asarray([1, 2, 3], dtype=int8)
-
-    # Do not error
+    # Never an 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]))
+
+    if api_version < '2023.12':
+        pytest.raises(ValueError, lambda:
+                      a.__dlpack__(dl_device=a.__dlpack_device__()))
+        pytest.raises(ValueError, lambda:
+                      a.__dlpack__(dl_device=None))
+        pytest.raises(ValueError, lambda:
+                      a.__dlpack__(max_version=(1, 0)))
+        pytest.raises(ValueError, lambda:
+                      a.__dlpack__(max_version=None))
+        pytest.raises(ValueError, lambda:
+                      a.__dlpack__(copy=False))
+        pytest.raises(ValueError, lambda:
+                      a.__dlpack__(copy=True))
+        pytest.raises(ValueError, lambda:
+                      a.__dlpack__(copy=None))
+    elif np.lib.NumpyVersion(np.__version__) < '2.1.0':
+        pytest.raises(NotImplementedError, lambda:
+                      a.__dlpack__(dl_device=CPU_DEVICE))
+        a.__dlpack__(dl_device=None)
+        pytest.raises(NotImplementedError, lambda:
+                      a.__dlpack__(max_version=(1, 0)))
+        a.__dlpack__(max_version=None)
+        pytest.raises(NotImplementedError, lambda:
+                      a.__dlpack__(copy=False))
+        pytest.raises(NotImplementedError, lambda:
+                      a.__dlpack__(copy=True))
+        a.__dlpack__(copy=None)
+    else:
+        a.__dlpack__(dl_device=a.__dlpack_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)

{array_api_strict-2.1.2 → array_api_strict-2.2}/array_api_strict/tests/test_elementwise_functions.py

@@ -2,6 +2,8 @@ from inspect import signature, getmodule
 
 from numpy.testing import assert_raises
 
+import pytest
+
 from .. import asarray, _elementwise_functions
 from .._elementwise_functions import bitwise_left_shift, bitwise_right_shift
 from .._dtypes import (
@@ -79,10 +81,12 @@ elementwise_function_input_types = {
     "minimum": "real numeric",
     "multiply": "numeric",
     "negative": "numeric",
+    "nextafter": "real floating-point",
     "not_equal": "all",
     "positive": "numeric",
     "pow": "numeric",
     "real": "complex floating-point",
+    "reciprocal": "floating-point",
     "remainder": "real numeric",
     "round": "numeric",
     "sign": "numeric",
@@ -126,7 +130,8 @@ def test_function_device_persists():
             yield asarray(1., dtype=d)
 
     # Use the latest version of the standard so all functions are included
-    set_array_api_strict_flags(api_version="2023.12")
+    with pytest.warns(UserWarning):
+        set_array_api_strict_flags(api_version="2024.12")
 
     for func_name, types in elementwise_function_input_types.items():
         dtypes = _dtype_categories[types]
@@ -162,7 +167,8 @@ def test_function_types():
             yield asarray(1.0, dtype=d)
 
     # Use the latest version of the standard so all functions are included
-    set_array_api_strict_flags(api_version="2023.12")
+    with pytest.warns(UserWarning):
+        set_array_api_strict_flags(api_version="2024.12")
 
     for x in _array_vals():
         for func_name, types in elementwise_function_input_types.items():

{array_api_strict-2.1.2 → array_api_strict-2.2}/array_api_strict/tests/test_flags.py

@@ -3,8 +3,6 @@ import subprocess
 
 from .._flags import (set_array_api_strict_flags, get_array_api_strict_flags,
                       reset_array_api_strict_flags)
-from .._info import (capabilities, default_device, default_dtypes, devices,
-                     dtypes)
 from .._fft import (fft, ifft, fftn, ifftn, rfft, irfft, rfftn, irfftn, hfft,
                     ihfft, fftfreq, rfftfreq, fftshift, ifftshift)
 from .._linalg import (cholesky, cross, det, diagonal, eigh, eigvalsh, inv,
@@ -99,6 +97,21 @@ def test_flags_api_version_2023_12():
         'enabled_extensions': ('linalg', 'fft'),
     }
 
+def test_flags_api_version_2024_12():
+    # Make sure setting the version to 2024.12 issues a warning.
+    with pytest.warns(UserWarning) as record:
+        set_array_api_strict_flags(api_version='2024.12')
+    assert len(record) == 1
+    assert '2024.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',
+        'boolean_indexing': True,
+        'data_dependent_shapes': True,
+        'enabled_extensions': ('linalg', 'fft'),
+    }
+
 def test_setting_flags_invalid():
     # Test setting flags with invalid values
     pytest.raises(ValueError, lambda:
@@ -245,14 +258,17 @@ def test_fft(func_name):
     set_array_api_strict_flags(enabled_extensions=('fft',))
     func()
 
+# Test functionality even if the info object is already created
+_info = xp.__array_namespace_info__()
+
 api_version_2023_12_examples = {
     '__array_namespace_info__': lambda: xp.__array_namespace_info__(),
     # Test these functions directly to ensure they are properly decorated
-    'capabilities': capabilities,
-    'default_device': default_device,
-    'default_dtypes': default_dtypes,
-    'devices': devices,
-    'dtypes': dtypes,
+    'capabilities': _info.capabilities,
+    'default_device': _info.default_device,
+    'default_dtypes': _info.default_dtypes,
+    'devices': _info.devices,
+    'dtypes': _info.dtypes,
     'clip': lambda: xp.clip(xp.asarray([1, 2, 3]), 1, 2),
     'copysign': lambda: xp.copysign(xp.asarray([1., 2., 3.]), xp.asarray([-1., -1., -1.])),
     'cumulative_sum': lambda: xp.cumulative_sum(xp.asarray([1, 2, 3])),
@@ -285,6 +301,36 @@ def test_api_version_2023_12(func_name):
     set_array_api_strict_flags(api_version='2022.12')
     pytest.raises(RuntimeError, func)
 
+api_version_2024_12_examples = {
+    'diff': lambda: xp.diff(xp.asarray([0, 1, 2])),
+    'nextafter': lambda: xp.nextafter(xp.asarray(0.), xp.asarray(1.)),
+    '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)),
+}
+
+@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)
+
+    # In 2022.12 and 2023.12, these functions should error
+    set_array_api_strict_flags(api_version='2022.12')
+    pytest.raises(RuntimeError, func)
+    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)
+
 def test_disabled_extensions():
     # Test that xp.extension errors when an extension is disabled, and that
     # xp.__all__ is updated properly.

{array_api_strict-2.1.2 → array_api_strict-2.2}/array_api_strict.egg-info/PKG-INFO

@@ -1,22 +1,21 @@
 Metadata-Version: 2.1
 Name: array_api_strict
-Version: 2.1.2
+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: Programming Language :: Python :: 3.13
-Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy>=2.1
+Requires-Dist: numpy
 
 # array-api-strict
 

array_api_strict-2.2/array_api_strict.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy

{array_api_strict-2.1.2 → array_api_strict-2.2}/setup.py

@@ -15,15 +15,14 @@ setup(
     long_description_content_type="text/markdown",
     url="https://data-apis.org/array-api-strict/",
     license="MIT",
-    python_requires=">=3.10",
-    install_requires=["numpy>=2.1"],
+    python_requires=">=3.9",
+    install_requires=["numpy"],
     classifiers=[
         "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
-        "Programming Language :: Python :: 3.13",
-        "Intended Audience :: Developers",
         "License :: OSI Approved :: BSD License",
         "Operating System :: OS Independent",
     ],

array_api_strict-2.1.2/array_api_strict/_info.py

@@ -1,132 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from typing import Optional, Union, Tuple, List
-    from ._typing import device, DefaultDataTypes, DataTypes, Capabilities, Info
-
-from ._array_object import ALL_DEVICES, CPU_DEVICE
-from ._flags import get_array_api_strict_flags, requires_api_version
-from ._dtypes import bool, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float32, float64, complex64, complex128
-
-@requires_api_version('2023.12')
-def __array_namespace_info__() -> Info:
-    import array_api_strict._info
-    return array_api_strict._info
-
-@requires_api_version('2023.12')
-def capabilities() -> Capabilities:
-    flags = get_array_api_strict_flags()
-    return {"boolean indexing": flags['boolean_indexing'],
-            "data-dependent shapes": flags['data_dependent_shapes'],
-            }
-
-@requires_api_version('2023.12')
-def default_device() -> device:
-    return CPU_DEVICE
-
-@requires_api_version('2023.12')
-def default_dtypes(
-    *,
-    device: Optional[device] = None,
-) -> DefaultDataTypes:
-    return {
-        "real floating": float64,
-        "complex floating": complex128,
-        "integral": int64,
-        "indexing": int64,
-    }
-
-@requires_api_version('2023.12')
-def dtypes(
-    *,
-    device: Optional[device] = None,
-    kind: Optional[Union[str, Tuple[str, ...]]] = None,
-) -> DataTypes:
-    if kind is None:
-        return {
-            "bool": bool,
-            "int8": int8,
-            "int16": int16,
-            "int32": int32,
-            "int64": int64,
-            "uint8": uint8,
-            "uint16": uint16,
-            "uint32": uint32,
-            "uint64": uint64,
-            "float32": float32,
-            "float64": float64,
-            "complex64": complex64,
-            "complex128": complex128,
-        }
-    if kind == "bool":
-        return {"bool": bool}
-    if kind == "signed integer":
-        return {
-            "int8": int8,
-            "int16": int16,
-            "int32": int32,
-            "int64": int64,
-        }
-    if kind == "unsigned integer":
-        return {
-            "uint8": uint8,
-            "uint16": uint16,
-            "uint32": uint32,
-            "uint64": uint64,
-        }
-    if kind == "integral":
-        return {
-            "int8": int8,
-            "int16": int16,
-            "int32": int32,
-            "int64": int64,
-            "uint8": uint8,
-            "uint16": uint16,
-            "uint32": uint32,
-            "uint64": uint64,
-        }
-    if kind == "real floating":
-        return {
-            "float32": float32,
-            "float64": float64,
-        }
-    if kind == "complex floating":
-        return {
-            "complex64": complex64,
-            "complex128": complex128,
-        }
-    if kind == "numeric":
-        return {
-            "int8": int8,
-            "int16": int16,
-            "int32": int32,
-            "int64": int64,
-            "uint8": uint8,
-            "uint16": uint16,
-            "uint32": uint32,
-            "uint64": uint64,
-            "float32": float32,
-            "float64": float64,
-            "complex64": complex64,
-            "complex128": complex128,
-        }
-    if isinstance(kind, tuple):
-        res = {}
-        for k in kind:
-            res.update(dtypes(kind=k))
-        return res
-    raise ValueError(f"unsupported kind: {kind!r}")
-
-@requires_api_version('2023.12')
-def devices() -> List[device]:
-    return list(ALL_DEVICES)
-
-__all__ = [
-    "capabilities",
-    "default_device",
-    "default_dtypes",
-    "devices",
-    "dtypes",
-]

array_api_strict-2.1.2/array_api_strict/_utility_functions.py

@@ -1,39 +0,0 @@
-from __future__ import annotations
-
-from ._array_object import Array
-
-from typing import TYPE_CHECKING
-if TYPE_CHECKING:
-    from typing import Optional, Tuple, Union
-
-import numpy as np
-
-
-def all(
-    x: Array,
-    /,
-    *,
-    axis: Optional[Union[int, Tuple[int, ...]]] = None,
-    keepdims: bool = False,
-) -> Array:
-    """
-    Array API compatible wrapper for :py:func:`np.all <numpy.all>`.
-
-    See its docstring for more information.
-    """
-    return Array._new(np.asarray(np.all(x._array, axis=axis, keepdims=keepdims)), device=x.device)
-
-
-def any(
-    x: Array,
-    /,
-    *,
-    axis: Optional[Union[int, Tuple[int, ...]]] = None,
-    keepdims: bool = False,
-) -> Array:
-    """
-    Array API compatible wrapper for :py:func:`np.any <numpy.any>`.
-
-    See its docstring for more information.
-    """
-    return Array._new(np.asarray(np.any(x._array, axis=axis, keepdims=keepdims)), device=x.device)

array_api_strict-2.1.2/array_api_strict.egg-info/requires.txt

@@ -1 +0,0 @@
-numpy>=2.1