array-api-strict 1.1__tar.gz → 2.0__tar.gz

array_api_strict-2.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.1
+Name: array_api_strict
+Version: 2.0
+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.
+
+array-api-strict currently supports the 2022.12 version of the standard.
+2023.12 support is planned and is tracked by [this
+issue](https://github.com/data-apis/array-api-strict/issues/25).
+
+See the documentation for more details https://data-apis.org/array-api-strict/

array_api_strict-2.0/README.md

@@ -0,0 +1,22 @@
+# 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.
+
+array-api-strict currently supports the 2022.12 version of the standard.
+2023.12 support is planned and is tracked by [this
+issue](https://github.com/data-apis/array-api-strict/issues/25).
+
+See the documentation for more details https://data-apis.org/array-api-strict/

{array_api_strict-1.1 → array_api_strict-2.0}/array_api_strict/__init__.py

@@ -10,15 +10,21 @@ 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://github.com/data-apis/array-api-compat) package to
+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.
 
 """
 
-__array_api_version__ = "2022.12"
+__all__ = []
 
-__all__ = ["__array_api_version__"]
+# Warning: __array_api_version__ could change globally with
+# set_array_api_strict_flags(). This should always be accessed as an
+# attribute, like xp.__array_api_version__, or using
+# array_api_strict.get_array_api_strict_flags()['api_version'].
+from ._flags import API_VERSION as __array_api_version__
+
+__all__ += ["__array_api_version__"]
 
 from ._constants import e, inf, nan, pi, newaxis
 
@@ -79,6 +85,7 @@ __all__ += [
     "broadcast_to",
     "can_cast",
     "finfo",
+    "isdtype",
     "iinfo",
     "result_type",
 ]
@@ -110,6 +117,8 @@ __all__ += [
     "uint64",
     "float32",
     "float64",
+    "complex64",
+    "complex128",
     "bool",
 ]
 
@@ -130,7 +139,9 @@ from ._elementwise_functions import (
     bitwise_right_shift,
     bitwise_xor,
     ceil,
+    clip,
     conj,
+    copysign,
     cos,
     cosh,
     divide,
@@ -141,6 +152,7 @@ from ._elementwise_functions import (
     floor_divide,
     greater,
     greater_equal,
+    hypot,
     imag,
     isfinite,
     isinf,
@@ -156,6 +168,8 @@ from ._elementwise_functions import (
     logical_not,
     logical_or,
     logical_xor,
+    maximum,
+    minimum,
     multiply,
     negative,
     not_equal,
@@ -165,6 +179,7 @@ from ._elementwise_functions import (
     remainder,
     round,
     sign,
+    signbit,
     sin,
     sinh,
     square,
@@ -192,6 +207,9 @@ __all__ += [
     "bitwise_right_shift",
     "bitwise_xor",
     "ceil",
+    "clip",
+    "conj",
+    "copysign",
     "cos",
     "cosh",
     "divide",
@@ -202,6 +220,8 @@ __all__ += [
     "floor_divide",
     "greater",
     "greater_equal",
+    "hypot",
+    "imag",
     "isfinite",
     "isinf",
     "isnan",
@@ -216,14 +236,18 @@ __all__ += [
     "logical_not",
     "logical_or",
     "logical_xor",
+    "maximum",
+    "minimum",
     "multiply",
     "negative",
     "not_equal",
     "positive",
     "pow",
+    "real",
     "remainder",
     "round",
     "sign",
+    "signbit",
     "sin",
     "sinh",
     "square",
@@ -238,35 +262,36 @@ from ._indexing_functions import take
 
 __all__ += ["take"]
 
-# linalg is an extension in the array API spec, which is a sub-namespace. Only
-# a subset of functions in it are imported into the top-level namespace.
-from . import linalg
+from ._info import __array_namespace_info__
 
-__all__ += ["linalg"]
+__all__ += [
+    "__array_namespace_info__",
+]
 
-from .linalg import matmul, tensordot, matrix_transpose, vecdot
+from ._linear_algebra_functions import matmul, tensordot, matrix_transpose, vecdot
 
 __all__ += ["matmul", "tensordot", "matrix_transpose", "vecdot"]
 
-from . import fft
-__all__ += ["fft"]
-
 from ._manipulation_functions import (
     concat,
     expand_dims,
     flip,
+    moveaxis,
     permute_dims,
+    repeat,
     reshape,
     roll,
     squeeze,
     stack,
+    tile,
+    unstack,
 )
 
-__all__ += ["concat", "expand_dims", "flip", "permute_dims", "reshape", "roll", "squeeze", "stack"]
+__all__ += ["concat", "expand_dims", "flip", "moveaxis", "permute_dims", "repeat", "reshape", "roll", "squeeze", "stack", "tile", "unstack"]
 
-from ._searching_functions import argmax, argmin, nonzero, where
+from ._searching_functions import argmax, argmin, nonzero, searchsorted, where
 
-__all__ += ["argmax", "argmin", "nonzero", "where"]
+__all__ += ["argmax", "argmin", "nonzero", "searchsorted", "where"]
 
 from ._set_functions import unique_all, unique_counts, unique_inverse, unique_values
 
@@ -276,14 +301,44 @@ from ._sorting_functions import argsort, sort
 
 __all__ += ["argsort", "sort"]
 
-from ._statistical_functions import max, mean, min, prod, std, sum, var
+from ._statistical_functions import cumulative_sum, max, mean, min, prod, std, sum, var
 
-__all__ += ["max", "mean", "min", "prod", "std", "sum", "var"]
+__all__ += ["cumulative_sum", "max", "mean", "min", "prod", "std", "sum", "var"]
 
 from ._utility_functions import all, any
 
 __all__ += ["all", "any"]
 
+# Helper functions that are not part of the standard
+
+from ._flags import (
+    set_array_api_strict_flags,
+    get_array_api_strict_flags,
+    reset_array_api_strict_flags,
+    ArrayAPIStrictFlags,
+)
+
+__all__ += ['set_array_api_strict_flags', 'get_array_api_strict_flags', 'reset_array_api_strict_flags', 'ArrayAPIStrictFlags']
+
 from . import _version
 __version__ = _version.get_versions()['version']
 del _version
+
+
+# Extensions can be enabled or disabled dynamically. In order to make
+# "array_api_strict.linalg" give an AttributeError when it is disabled, we
+# use __getattr__. Note that linalg and fft are dynamically added and removed
+# from __all__ in set_array_api_strict_flags.
+
+def __getattr__(name):
+    if name in ['linalg', 'fft']:
+        if name in get_array_api_strict_flags()['enabled_extensions']:
+            if name == 'linalg':
+                from . import _linalg
+                return _linalg
+            elif name == 'fft':
+                from . import _fft
+                return _fft
+        else:
+            raise AttributeError(f"The {name!r} extension has been disabled for array_api_strict")
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

{array_api_strict-1.1 → array_api_strict-2.0}/array_api_strict/_array_object.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 
 import operator
 from enum import IntEnum
+
 from ._creation_functions import asarray
 from ._dtypes import (
     _DType,
@@ -30,12 +31,14 @@ from ._dtypes import (
     _result_type,
     _dtype_categories,
 )
+from ._flags import get_array_api_strict_flags, set_array_api_strict_flags
 
-from typing import TYPE_CHECKING, Optional, Tuple, Union, Any, SupportsIndex
+from typing import TYPE_CHECKING, SupportsIndex
 import types
 
 if TYPE_CHECKING:
-    from ._typing import Any, PyCapsule, Device, Dtype
+    from typing import Optional, Tuple, Union, Any
+    from ._typing import PyCapsule, Device, Dtype
     import numpy.typing as npt
 
 import numpy as np
@@ -48,6 +51,8 @@ class _cpu_device:
 
 CPU_DEVICE = _cpu_device()
 
+_default = object()
+
 class Array:
     """
     n-d array object for the array API namespace.
@@ -425,13 +430,17 @@ class Array:
                                 "the Array API)"
                             )
             elif isinstance(i, Array):
-                if i.dtype in _boolean_dtypes and len(_key) != 1:
-                    assert isinstance(key, tuple)  # sanity check
-                    raise IndexError(
-                        f"Single-axes index {i} is a boolean array and "
-                        f"{len(key)=}, but masking is only specified in the "
-                        "Array API when the array is the sole index."
-                    )
+                if i.dtype in _boolean_dtypes:
+                    if len(_key) != 1:
+                        assert isinstance(key, tuple)  # sanity check
+                        raise IndexError(
+                            f"Single-axes index {i} is a boolean array and "
+                            f"{len(key)=}, but masking is only specified in the "
+                            "Array API when the array is the sole index."
+                        )
+                    if not get_array_api_strict_flags()['boolean_indexing']:
+                        raise RuntimeError("The boolean_indexing flag has been disabled for array-api-strict")
+
                 elif i.dtype in _integer_dtypes and i.ndim != 0:
                     raise IndexError(
                         f"Single-axes index {i} is a non-zero-dimensional "
@@ -480,8 +489,21 @@ class Array:
     def __array_namespace__(
         self: Array, /, *, api_version: Optional[str] = None
     ) -> types.ModuleType:
-        if api_version is not None and not api_version.startswith("2021."):
-            raise ValueError(f"Unrecognized array API version: {api_version!r}")
+        """
+        Return the array_api_strict namespace corresponding to api_version.
+
+        The default API version is '2022.12'. Note that '2021.12' is supported,
+        but currently identical to '2022.12'.
+
+        For array_api_strict, calling this function with api_version will set
+        the API version for the array_api_strict module globally. This can
+        also be achieved with the
+        {func}`array_api_strict.set_array_api_strict_flags` function. If you
+        want to only set the version locally, use the
+        {class}`array_api_strict.ArrayApiStrictFlags` context manager.
+
+        """
+        set_array_api_strict_flags(api_version=api_version)
         import array_api_strict
         return array_api_strict
 
@@ -505,10 +527,34 @@ class Array:
         res = self._array.__complex__()
         return res
 
-    def __dlpack__(self: Array, /, *, stream: None = None) -> PyCapsule:
+    def __dlpack__(
+        self: Array,
+        /,
+        *,
+        stream: Optional[Union[int, Any]] = None,
+        max_version: Optional[tuple[int, int]] = _default,
+        dl_device: Optional[tuple[IntEnum, int]] = _default,
+        copy: Optional[bool] = _default,
+    ) -> PyCapsule:
         """
         Performs the operation __dlpack__.
         """
+        if get_array_api_strict_flags()['api_version'] < '2023.12':
+            if max_version is not _default:
+                raise ValueError("The max_version argument to __dlpack__ requires at least version 2023.12 of the array API")
+            if dl_device is not _default:
+                raise ValueError("The device argument to __dlpack__ requires at least version 2023.12 of the array API")
+            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)
 
     def __dlpack_device__(self: Array, /) -> Tuple[IntEnum, int]:
@@ -570,8 +616,8 @@ class Array:
         key: Union[
             int,
             slice,
-            ellipsis,
-            Tuple[Union[int, slice, ellipsis, None], ...],
+            ellipsis,  # noqa: F821
+            Tuple[Union[int, slice, ellipsis, None], ...],  # noqa: F821
             Array,
         ],
         /,
@@ -627,6 +673,15 @@ class Array:
         res = self._array.__invert__()
         return self.__class__._new(res)
 
+    def __iter__(self: Array, /):
+        """
+        Performs the operation __iter__.
+        """
+        # Manually disable iteration, since __getitem__ raises IndexError on
+        # things like ones((3, 3))[0], which causes list(ones((3, 3))) to give
+        # [].
+        raise TypeError("array iteration is not allowed in array-api-strict")
+
     def __le__(self: Array, other: Union[int, float, Array], /) -> Array:
         """
         Performs the operation __le__.
@@ -761,7 +816,7 @@ class Array:
     def __setitem__(
         self,
         key: Union[
-            int, slice, ellipsis, Tuple[Union[int, slice, ellipsis], ...], Array
+            int, slice, ellipsis, Tuple[Union[int, slice, ellipsis], ...], Array  # noqa: F821
         ],
         value: Union[int, float, bool, Array],
         /,
@@ -1113,7 +1168,7 @@ class Array:
     # Note: mT is new in array API spec (see matrix_transpose)
     @property
     def mT(self) -> Array:
-        from .linalg import matrix_transpose
+        from ._linear_algebra_functions import matrix_transpose
         return matrix_transpose(self)
 
     @property

{array_api_strict-1.1 → array_api_strict-2.0}/array_api_strict/_creation_functions.py

@@ -12,6 +12,7 @@ if TYPE_CHECKING:
         SupportsBufferProtocol,
     )
 from ._dtypes import _DType, _all_dtypes
+from ._flags import get_array_api_strict_flags
 
 import numpy as np
 
@@ -19,7 +20,7 @@ import numpy as np
 def _check_valid_dtype(dtype):
     # Note: Only spelling dtypes as the dtype objects is supported.
     if dtype not in (None,) + _all_dtypes:
-        raise ValueError("dtype must be one of the supported dtypes")
+        raise ValueError(f"dtype must be one of the supported dtypes, got {dtype!r}")
 
 def _supports_buffer_protocol(obj):
     try:
@@ -28,6 +29,14 @@ def _supports_buffer_protocol(obj):
         return False
     return True
 
+def _check_device(device):
+    # _array_object imports in this file are inside the functions to avoid
+    # circular imports
+    from ._array_object import CPU_DEVICE
+
+    if device not in [CPU_DEVICE, None]:
+        raise ValueError(f"Unsupported device {device!r}")
+
 def asarray(
     obj: Union[
         Array,
@@ -48,16 +57,13 @@ def asarray(
 
     See its docstring for more information.
     """
-    # _array_object imports in this file are inside the functions to avoid
-    # circular imports
-    from ._array_object import Array, CPU_DEVICE
+    from ._array_object import Array
 
     _check_valid_dtype(dtype)
     _np_dtype = None
     if dtype is not None:
         _np_dtype = dtype._np_dtype
-    if device not in [CPU_DEVICE, None]:
-        raise ValueError(f"Unsupported device {device!r}")
+    _check_device(device)
 
     if np.__version__[0] < '2':
         if copy is False:
@@ -106,11 +112,11 @@ def arange(
 
     See its docstring for more information.
     """
-    from ._array_object import Array, CPU_DEVICE
+    from ._array_object import Array
 
     _check_valid_dtype(dtype)
-    if device not in [CPU_DEVICE, None]:
-        raise ValueError(f"Unsupported device {device!r}")
+    _check_device(device)
+
     if dtype is not None:
         dtype = dtype._np_dtype
     return Array._new(np.arange(start, stop=stop, step=step, dtype=dtype))
@@ -127,11 +133,11 @@ def empty(
 
     See its docstring for more information.
     """
-    from ._array_object import Array, CPU_DEVICE
+    from ._array_object import Array
 
     _check_valid_dtype(dtype)
-    if device not in [CPU_DEVICE, None]:
-        raise ValueError(f"Unsupported device {device!r}")
+    _check_device(device)
+
     if dtype is not None:
         dtype = dtype._np_dtype
     return Array._new(np.empty(shape, dtype=dtype))
@@ -145,11 +151,11 @@ def empty_like(
 
     See its docstring for more information.
     """
-    from ._array_object import Array, CPU_DEVICE
+    from ._array_object import Array
 
     _check_valid_dtype(dtype)
-    if device not in [CPU_DEVICE, None]:
-        raise ValueError(f"Unsupported device {device!r}")
+    _check_device(device)
+
     if dtype is not None:
         dtype = dtype._np_dtype
     return Array._new(np.empty_like(x._array, dtype=dtype))
@@ -169,19 +175,39 @@ def eye(
 
     See its docstring for more information.
     """
-    from ._array_object import Array, CPU_DEVICE
+    from ._array_object import Array
 
     _check_valid_dtype(dtype)
-    if device not in [CPU_DEVICE, None]:
-        raise ValueError(f"Unsupported device {device!r}")
+    _check_device(device)
+
     if dtype is not None:
         dtype = dtype._np_dtype
     return Array._new(np.eye(n_rows, M=n_cols, k=k, dtype=dtype))
 
 
-def from_dlpack(x: object, /) -> Array:
+_default = object()
+
+def from_dlpack(
+    x: object,
+    /,
+    *,
+    device: Optional[Device] = _default,
+    copy: Optional[bool] = _default,
+) -> Array:
     from ._array_object import Array
 
+    if get_array_api_strict_flags()['api_version'] < '2023.12':
+        if device is not _default:
+            raise ValueError("The device argument to from_dlpack requires at least version 2023.12 of the array API")
+        if copy is not _default:
+            raise ValueError("The copy argument to from_dlpack requires at least version 2023.12 of the array API")
+
+    # Going to wait for upstream numpy support
+    if device is not _default:
+        _check_device(device)
+    if copy not in [_default, None]:
+        raise NotImplementedError("The copy argument to from_dlpack is not yet implemented")
+
     return Array._new(np.from_dlpack(x))
 
 
@@ -197,11 +223,11 @@ def full(
 
     See its docstring for more information.
     """
-    from ._array_object import Array, CPU_DEVICE
+    from ._array_object import Array
 
     _check_valid_dtype(dtype)
-    if device not in [CPU_DEVICE, None]:
-        raise ValueError(f"Unsupported device {device!r}")
+    _check_device(device)
+
     if isinstance(fill_value, Array) and fill_value.ndim == 0:
         fill_value = fill_value._array
     if dtype is not None:
@@ -227,11 +253,11 @@ def full_like(
 
     See its docstring for more information.
     """
-    from ._array_object import Array, CPU_DEVICE
+    from ._array_object import Array
 
     _check_valid_dtype(dtype)
-    if device not in [CPU_DEVICE, None]:
-        raise ValueError(f"Unsupported device {device!r}")
+    _check_device(device)
+
     if dtype is not None:
         dtype = dtype._np_dtype
     res = np.full_like(x._array, fill_value, dtype=dtype)
@@ -257,11 +283,11 @@ def linspace(
 
     See its docstring for more information.
     """
-    from ._array_object import Array, CPU_DEVICE
+    from ._array_object import Array
 
     _check_valid_dtype(dtype)
-    if device not in [CPU_DEVICE, None]:
-        raise ValueError(f"Unsupported device {device!r}")
+    _check_device(device)
+
     if dtype is not None:
         dtype = dtype._np_dtype
     return Array._new(np.linspace(start, stop, num, dtype=dtype, endpoint=endpoint))
@@ -298,11 +324,11 @@ def ones(
 
     See its docstring for more information.
     """
-    from ._array_object import Array, CPU_DEVICE
+    from ._array_object import Array
 
     _check_valid_dtype(dtype)
-    if device not in [CPU_DEVICE, None]:
-        raise ValueError(f"Unsupported device {device!r}")
+    _check_device(device)
+
     if dtype is not None:
         dtype = dtype._np_dtype
     return Array._new(np.ones(shape, dtype=dtype))
@@ -316,11 +342,11 @@ def ones_like(
 
     See its docstring for more information.
     """
-    from ._array_object import Array, CPU_DEVICE
+    from ._array_object import Array
 
     _check_valid_dtype(dtype)
-    if device not in [CPU_DEVICE, None]:
-        raise ValueError(f"Unsupported device {device!r}")
+    _check_device(device)
+
     if dtype is not None:
         dtype = dtype._np_dtype
     return Array._new(np.ones_like(x._array, dtype=dtype))
@@ -365,11 +391,11 @@ def zeros(
 
     See its docstring for more information.
     """
-    from ._array_object import Array, CPU_DEVICE
+    from ._array_object import Array
 
     _check_valid_dtype(dtype)
-    if device not in [CPU_DEVICE, None]:
-        raise ValueError(f"Unsupported device {device!r}")
+    _check_device(device)
+
     if dtype is not None:
         dtype = dtype._np_dtype
     return Array._new(np.zeros(shape, dtype=dtype))
@@ -383,11 +409,11 @@ def zeros_like(
 
     See its docstring for more information.
     """
-    from ._array_object import Array, CPU_DEVICE
+    from ._array_object import Array
 
     _check_valid_dtype(dtype)
-    if device not in [CPU_DEVICE, None]:
-        raise ValueError(f"Unsupported device {device!r}")
+    _check_device(device)
+
     if dtype is not None:
         dtype = dtype._np_dtype
     return Array._new(np.zeros_like(x._array, dtype=dtype))