array-api-compat 1.10.0__py3-none-any.whl → 1.11__py3-none-any.whl

array_api_compat/__init__.py

@@ -17,6 +17,6 @@ to ensure they are not using functionality outside of the standard, but prefer
 this implementation for the default when working with NumPy arrays.
 
 """
-__version__ = '1.10.0'
+__version__ = '1.11'
 
 from .common import *  # noqa: F401, F403

array_api_compat/common/_aliases.py

@@ -233,11 +233,6 @@ def unique_values(x: ndarray, /, xp) -> ndarray:
         **kwargs,
     )
 
-def astype(x: ndarray, dtype: Dtype, /, *, copy: bool = True) -> ndarray:
-    if not copy and dtype == x.dtype:
-        return x
-    return x.astype(dtype=dtype, copy=copy)
-
 # These functions have different keyword argument names
 
 def std(
@@ -297,6 +292,36 @@ def cumulative_sum(
         )
     return res
 
+
+def cumulative_prod(
+    x: ndarray,
+    /,
+    xp,
+    *,
+    axis: Optional[int] = None,
+    dtype: Optional[Dtype] = None,
+    include_initial: bool = False,
+    **kwargs
+) -> ndarray:
+    wrapped_xp = array_namespace(x)
+
+    if axis is None:
+        if x.ndim > 1:
+            raise ValueError("axis must be specified in cumulative_prod for more than one dimension")
+        axis = 0
+
+    res = xp.cumprod(x, axis=axis, dtype=dtype, **kwargs)
+
+    # np.cumprod does not support include_initial
+    if include_initial:
+        initial_shape = list(x.shape)
+        initial_shape[axis] = 1
+        res = xp.concatenate(
+            [wrapped_xp.ones(shape=initial_shape, dtype=res.dtype, device=device(res)), res],
+            axis=axis,
+        )
+    return res
+
 # The min and max argument names in clip are different and not optional in numpy, and type
 # promotion behavior is different.
 def clip(
@@ -549,7 +574,7 @@ __all__ = ['arange', 'empty', 'empty_like', 'eye', 'full', 'full_like',
            'linspace', 'ones', 'ones_like', 'zeros', 'zeros_like',
            'UniqueAllResult', 'UniqueCountsResult', 'UniqueInverseResult',
            'unique_all', 'unique_counts', 'unique_inverse', 'unique_values',
-           'astype', 'std', 'var', 'cumulative_sum', 'clip', 'permute_dims',
+           'std', 'var', 'cumulative_sum', 'cumulative_prod','clip', 'permute_dims',
            'reshape', 'argsort', 'sort', 'nonzero', 'ceil', 'floor', 'trunc',
            'matmul', 'matrix_transpose', 'tensordot', 'vecdot', 'isdtype',
            'unstack', 'sign']

array_api_compat/common/_fft.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Union, Optional, Literal
 
 if TYPE_CHECKING:
-    from ._typing import Device, ndarray
+    from ._typing import Device, ndarray, DType
     from collections.abc import Sequence
 
 # Note: NumPy fft functions improperly upcast float32 and complex64 to
@@ -149,15 +149,37 @@ def ihfft(
         return res.astype(xp.complex64)
     return res
 
-def fftfreq(n: int, /, xp, *, d: float = 1.0, device: Optional[Device] = None) -> ndarray:
+def fftfreq(
+    n: int,
+    /,
+    xp,
+    *,
+    d: float = 1.0,
+    dtype: Optional[DType] = None,
+    device: Optional[Device] = None
+) -> ndarray:
     if device not in ["cpu", None]:
         raise ValueError(f"Unsupported device {device!r}")
-    return xp.fft.fftfreq(n, d=d)
+    res = xp.fft.fftfreq(n, d=d)
+    if dtype is not None:
+        return res.astype(dtype)
+    return res
 
-def rfftfreq(n: int, /, xp, *, d: float = 1.0, device: Optional[Device] = None) -> ndarray:
+def rfftfreq(
+    n: int,
+    /,
+    xp,
+    *,
+    d: float = 1.0,
+    dtype: Optional[DType] = None,
+    device: Optional[Device] = None
+) -> ndarray:
     if device not in ["cpu", None]:
         raise ValueError(f"Unsupported device {device!r}")
-    return xp.fft.rfftfreq(n, d=d)
+    res = xp.fft.rfftfreq(n, d=d)
+    if dtype is not None:
+        return res.astype(dtype)
+    return res
 
 def fftshift(x: ndarray, /, xp, *, axes: Union[int, Sequence[int]] = None) -> ndarray:
     return xp.fft.fftshift(x, axes=axes)

array_api_compat/common/_helpers.py

@@ -11,14 +11,14 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Optional, Union, Any
-    from ._typing import Array, Device
+    from ._typing import Array, Device, Namespace
 
 import sys
 import math
 import inspect
 import warnings
 
-def _is_jax_zero_gradient_array(x):
+def _is_jax_zero_gradient_array(x: object) -> bool:
     """Return True if `x` is a zero-gradient array.
 
     These arrays are a design quirk of Jax that may one day be removed.
@@ -32,7 +32,8 @@ def _is_jax_zero_gradient_array(x):
 
     return isinstance(x, np.ndarray) and x.dtype == jax.float0
 
-def is_numpy_array(x):
+
+def is_numpy_array(x: object) -> bool:
     """
     Return True if `x` is a NumPy array.
 
@@ -63,7 +64,8 @@ def is_numpy_array(x):
     return (isinstance(x, (np.ndarray, np.generic))
             and not _is_jax_zero_gradient_array(x))
 
-def is_cupy_array(x):
+
+def is_cupy_array(x: object) -> bool:
     """
     Return True if `x` is a CuPy array.
 
@@ -93,7 +95,8 @@ def is_cupy_array(x):
     # TODO: Should we reject ndarray subclasses?
     return isinstance(x, cp.ndarray)
 
-def is_torch_array(x):
+
+def is_torch_array(x: object) -> bool:
     """
     Return True if `x` is a PyTorch tensor.
 
@@ -120,7 +123,8 @@ def is_torch_array(x):
     # TODO: Should we reject ndarray subclasses?
     return isinstance(x, torch.Tensor)
 
-def is_ndonnx_array(x):
+
+def is_ndonnx_array(x: object) -> bool:
     """
     Return True if `x` is a ndonnx Array.
 
@@ -147,7 +151,8 @@ def is_ndonnx_array(x):
 
     return isinstance(x, ndx.Array)
 
-def is_dask_array(x):
+
+def is_dask_array(x: object) -> bool:
     """
     Return True if `x` is a dask.array Array.
 
@@ -174,7 +179,8 @@ def is_dask_array(x):
 
     return isinstance(x, dask.array.Array)
 
-def is_jax_array(x):
+
+def is_jax_array(x: object) -> bool:
     """
     Return True if `x` is a JAX array.
 
@@ -202,6 +208,7 @@ def is_jax_array(x):
 
     return isinstance(x, jax.Array) or _is_jax_zero_gradient_array(x)
 
+
 def is_pydata_sparse_array(x) -> bool:
     """
     Return True if `x` is an array from the `sparse` package.
@@ -231,7 +238,8 @@ def is_pydata_sparse_array(x) -> bool:
     # TODO: Account for other backends.
     return isinstance(x, sparse.SparseArray)
 
-def is_array_api_obj(x):
+
+def is_array_api_obj(x: object) -> bool:
     """
     Return True if `x` is an array API compatible array object.
 
@@ -254,10 +262,12 @@ def is_array_api_obj(x):
         or is_pydata_sparse_array(x) \
         or hasattr(x, '__array_namespace__')
 
-def _compat_module_name():
+
+def _compat_module_name() -> str:
     assert __name__.endswith('.common._helpers')
     return __name__.removesuffix('.common._helpers')
 
+
 def is_numpy_namespace(xp) -> bool:
     """
     Returns True if `xp` is a NumPy namespace.
@@ -278,6 +288,7 @@ def is_numpy_namespace(xp) -> bool:
     """
     return xp.__name__ in {'numpy', _compat_module_name() + '.numpy'}
 
+
 def is_cupy_namespace(xp) -> bool:
     """
     Returns True if `xp` is a CuPy namespace.
@@ -298,6 +309,7 @@ def is_cupy_namespace(xp) -> bool:
     """
     return xp.__name__ in {'cupy', _compat_module_name() + '.cupy'}
 
+
 def is_torch_namespace(xp) -> bool:
     """
     Returns True if `xp` is a PyTorch namespace.
@@ -319,7 +331,7 @@ def is_torch_namespace(xp) -> bool:
     return xp.__name__ in {'torch', _compat_module_name() + '.torch'}
 
 
-def is_ndonnx_namespace(xp):
+def is_ndonnx_namespace(xp) -> bool:
     """
     Returns True if `xp` is an NDONNX namespace.
 
@@ -337,7 +349,8 @@ def is_ndonnx_namespace(xp):
     """
     return xp.__name__ == 'ndonnx'
 
-def is_dask_namespace(xp):
+
+def is_dask_namespace(xp) -> bool:
     """
     Returns True if `xp` is a Dask namespace.
 
@@ -357,7 +370,8 @@ def is_dask_namespace(xp):
     """
     return xp.__name__ in {'dask.array', _compat_module_name() + '.dask.array'}
 
-def is_jax_namespace(xp):
+
+def is_jax_namespace(xp) -> bool:
     """
     Returns True if `xp` is a JAX namespace.
 
@@ -378,7 +392,8 @@ def is_jax_namespace(xp):
     """
     return xp.__name__ in {'jax.numpy', 'jax.experimental.array_api'}
 
-def is_pydata_sparse_namespace(xp):
+
+def is_pydata_sparse_namespace(xp) -> bool:
     """
     Returns True if `xp` is a pydata/sparse namespace.
 
@@ -396,7 +411,8 @@ def is_pydata_sparse_namespace(xp):
     """
     return xp.__name__ == 'sparse'
 
-def is_array_api_strict_namespace(xp):
+
+def is_array_api_strict_namespace(xp) -> bool:
     """
     Returns True if `xp` is an array-api-strict namespace.
 
@@ -414,14 +430,16 @@ def is_array_api_strict_namespace(xp):
     """
     return xp.__name__ == 'array_api_strict'
 
-def _check_api_version(api_version):
-    if api_version in ['2021.12', '2022.12']:
-        warnings.warn(f"The {api_version} version of the array API specification was requested but the returned namespace is actually version 2023.12")
+
+def _check_api_version(api_version: str) -> None:
+    if api_version in ['2021.12', '2022.12', '2023.12']:
+        warnings.warn(f"The {api_version} version of the array API specification was requested but the returned namespace is actually version 2024.12")
     elif api_version is not None and api_version not in ['2021.12', '2022.12',
-                                                         '2023.12']:
-        raise ValueError("Only the 2023.12 version of the array API specification is currently supported")
+                                                         '2023.12', '2024.12']:
+        raise ValueError("Only the 2024.12 version of the array API specification is currently supported")
 
-def array_namespace(*xs, api_version=None, use_compat=None):
+
+def array_namespace(*xs, api_version=None, use_compat=None) -> Namespace:
     """
     Get the array API compatible namespace for the arrays `xs`.
 
@@ -433,7 +451,7 @@ def array_namespace(*xs, api_version=None, use_compat=None):
 
     api_version: str
         The newest version of the spec that you need support for (currently
-        the compat library wrapped APIs support v2023.12).
+        the compat library wrapped APIs support v2024.12).
 
     use_compat: bool or None
         If None (the default), the native namespace will be returned if it is
@@ -630,24 +648,24 @@ def device(x: Array, /) -> Device:
     if is_numpy_array(x):
         return "cpu"
     elif is_dask_array(x):
-        # Peek at the metadata of the jax array to determine type
-        try:
-            import numpy as np
-            if isinstance(x._meta, np.ndarray):
-                # Must be on CPU since backed by numpy
-                return "cpu"
-        except ImportError:
-            pass
+        # Peek at the metadata of the Dask array to determine type
+        if is_numpy_array(x._meta):
+            # Must be on CPU since backed by numpy
+            return "cpu"
         return _DASK_DEVICE
     elif is_jax_array(x):
-        # JAX has .device() as a method, but it is being deprecated so that it
-        # can become a property, in accordance with the standard. In order for
-        # this function to not break when JAX makes the flip, we check for
-        # both here.
-        if inspect.ismethod(x.device):
-            return x.device()
+        # FIXME Jitted JAX arrays do not have a device attribute
+        #       https://github.com/jax-ml/jax/issues/26000
+        #       Return None in this case. Note that this workaround breaks
+        #       the standard and will result in new arrays being created on the
+        #       default device instead of the same device as the input array(s).
+        x_device = getattr(x, 'device', None)
+        # Older JAX releases had .device() as a method, which has been replaced
+        # with a property in accordance with the standard.
+        if inspect.ismethod(x_device):
+            return x_device()
         else:
-            return x.device
+            return x_device
     elif is_pydata_sparse_array(x):
         # `sparse` will gain `.device`, so check for this first.
         x_device = getattr(x, 'device', None)
@@ -778,8 +796,11 @@ def to_device(x: Array, device: Device, /, *, stream: Optional[Union[int, Any]]
         raise ValueError(f"Unsupported device {device!r}")
     elif is_jax_array(x):
         if not hasattr(x, "__array_namespace__"):
-            # In JAX v0.4.31 and older, this import adds to_device method to x.
+            # In JAX v0.4.31 and older, this import adds to_device method to x...
             import jax.experimental.array_api # noqa: F401
+            # ... but only on eager JAX. It won't work inside jax.jit.
+            if not hasattr(x, "to_device"):
+                return x
         return x.to_device(device, stream=stream)
     elif is_pydata_sparse_array(x) and device == _device(x):
         # Perform trivial check to return the same array if
@@ -788,24 +809,30 @@ def to_device(x: Array, device: Device, /, *, stream: Optional[Union[int, Any]]
     return x.to_device(device, stream=stream)
 
 
-def size(x):
+def size(x: Array) -> int | None:
     """
     Return the total number of elements of x.
 
     This is equivalent to `x.size` according to the `standard
     <https://data-apis.org/array-api/latest/API_specification/generated/array_api.array.size.html>`__.
+
     This helper is included because PyTorch defines `size` in an
     :external+torch:meth:`incompatible way <torch.Tensor.size>`.
-
+    It also fixes dask.array's behaviour which returns nan for unknown sizes, whereas
+    the standard requires None.
     """
+    # Lazy API compliant arrays, such as ndonnx, can contain None in their shape
     if None in x.shape:
         return None
-    return math.prod(x.shape)
+    out = math.prod(x.shape)
+    # dask.array.Array.shape can contain NaN
+    return None if math.isnan(out) else out
 
 
-def is_writeable_array(x) -> bool:
+def is_writeable_array(x: object) -> bool:
     """
     Return False if ``x.__setitem__`` is expected to raise; True otherwise.
+    Return False if `x` is not an array API compatible object.
 
     Warning
     -------
@@ -816,7 +843,67 @@ def is_writeable_array(x) -> bool:
         return x.flags.writeable
     if is_jax_array(x) or is_pydata_sparse_array(x):
         return False
-    return True
+    return is_array_api_obj(x)
+
+
+def is_lazy_array(x: object) -> bool:
+    """Return True if x is potentially a future or it may be otherwise impossible or
+    expensive to eagerly read its contents, regardless of their size, e.g. by
+    calling ``bool(x)`` or ``float(x)``.
+
+    Return False otherwise; e.g. ``bool(x)`` etc. is guaranteed to succeed and to be
+    cheap as long as the array has the right dtype and size.
+
+    Note
+    ----
+    This function errs on the side of caution for array types that may or may not be
+    lazy, e.g. JAX arrays, by always returning True for them.
+    """
+    if (
+        is_numpy_array(x)
+        or is_cupy_array(x)
+        or is_torch_array(x)
+        or is_pydata_sparse_array(x)
+    ):
+        return False
+
+    # **JAX note:** while it is possible to determine if you're inside or outside
+    # jax.jit by testing the subclass of a jax.Array object, as well as testing bool()
+    # as we do below for unknown arrays, this is not recommended by JAX best practices.
+
+    # **Dask note:** Dask eagerly computes the graph on __bool__, __float__, and so on.
+    # This behaviour, while impossible to change without breaking backwards
+    # compatibility, is highly detrimental to performance as the whole graph will end
+    # up being computed multiple times.
+
+    if is_jax_array(x) or is_dask_array(x) or is_ndonnx_array(x):
+        return True
+
+    if not is_array_api_obj(x):
+        return False
+
+    # Unknown Array API compatible object. Note that this test may have dire consequences
+    # in terms of performance, e.g. for a lazy object that eagerly computes the graph
+    # on __bool__ (dask is one such example, which however is special-cased above).
+
+    # Select a single point of the array
+    s = size(x)
+    if s is None:
+        return True
+    xp = array_namespace(x)
+    if s > 1:
+        x = xp.reshape(x, (-1,))[0]
+    # Cast to dtype=bool and deal with size 0 arrays
+    x = xp.any(x)
+
+    try:
+        bool(x)
+        return False
+    # The Array API standard dictactes that __bool__ should raise TypeError if the
+    # output cannot be defined.
+    # Here we allow for it to raise arbitrary exceptions, e.g. like Dask does.
+    except Exception:
+        return True
 
 
 __all__ = [
@@ -840,6 +927,7 @@ __all__ = [
     "is_pydata_sparse_array",
     "is_pydata_sparse_namespace",
     "is_writeable_array",
+    "is_lazy_array",
     "size",
     "to_device",
 ]

array_api_compat/common/_typing.py

@@ -5,6 +5,7 @@ __all__ = [
     "SupportsBufferProtocol",
 ]
 
+from types import ModuleType
 from typing import (
     Any,
     TypeVar,
@@ -21,3 +22,5 @@ SupportsBufferProtocol = Any
 
 Array = Any
 Device = Any
+DType = Any
+Namespace = ModuleType

array_api_compat/cupy/__init__.py

@@ -13,4 +13,4 @@ __import__(__package__ + '.fft')
 
 from ..common._helpers import * # noqa: F401,F403
 
-__array_api_version__ = '2023.12'
+__array_api_version__ = '2024.12'

array_api_compat/cupy/_aliases.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import cupy as cp
 
-from ..common import _aliases
+from ..common import _aliases, _helpers
 from .._internal import get_xp
 
 from ._info import __array_namespace_info__
@@ -46,10 +46,10 @@ unique_all = get_xp(cp)(_aliases.unique_all)
 unique_counts = get_xp(cp)(_aliases.unique_counts)
 unique_inverse = get_xp(cp)(_aliases.unique_inverse)
 unique_values = get_xp(cp)(_aliases.unique_values)
-astype = _aliases.astype
 std = get_xp(cp)(_aliases.std)
 var = get_xp(cp)(_aliases.var)
 cumulative_sum = get_xp(cp)(_aliases.cumulative_sum)
+cumulative_prod = get_xp(cp)(_aliases.cumulative_prod)
 clip = get_xp(cp)(_aliases.clip)
 permute_dims = get_xp(cp)(_aliases.permute_dims)
 reshape = get_xp(cp)(_aliases.reshape)
@@ -110,6 +110,21 @@ def asarray(
 
         return cp.array(obj, dtype=dtype, **kwargs)
 
+
+def astype(
+    x: ndarray,
+    dtype: Dtype,
+    /,
+    *,
+    copy: bool = True,
+    device: Optional[Device] = None,
+) -> ndarray:
+    if device is None:
+        return x.astype(dtype=dtype, copy=copy)
+    out = _helpers.to_device(x.astype(dtype=dtype, copy=False), device)
+    return out.copy() if copy and out is x else out
+
+
 # These functions are completely new here. If the library already has them
 # (i.e., numpy 2.0), use the library version instead of our wrapper.
 if hasattr(cp, 'vecdot'):
@@ -127,10 +142,10 @@ if hasattr(cp, 'unstack'):
 else:
     unstack = get_xp(cp)(_aliases.unstack)
 
-__all__ = _aliases.__all__ + ['__array_namespace_info__', 'asarray', 'bool',
+__all__ = _aliases.__all__ + ['__array_namespace_info__', 'asarray', 'astype',
                               'acos', 'acosh', 'asin', 'asinh', 'atan',
                               'atan2', 'atanh', 'bitwise_left_shift',
                               'bitwise_invert', 'bitwise_right_shift',
-                              'concat', 'pow', 'sign']
+                              'bool', 'concat', 'pow', 'sign']
 
 _all_ignore = ['cp', 'get_xp']

array_api_compat/cupy/_info.py

@@ -101,7 +101,7 @@ class __array_namespace_info__:
             "boolean indexing": True,
             "data-dependent shapes": True,
             # 'max rank' will be part of the 2024.12 standard
-            # "max rank": 64,
+            "max dimensions": 64,
         }
 
     def default_device(self):

array_api_compat/dask/array/__init__.py

@@ -3,7 +3,7 @@ from dask.array import * # noqa: F403
 # These imports may overwrite names from the import * above.
 from ._aliases import * # noqa: F403
 
-__array_api_version__ = '2023.12'
+__array_api_version__ = '2024.12'
 
 __import__(__package__ + '.linalg')
 __import__(__package__ + '.fft')

array_api_compat/dask/array/_aliases.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-from ...common import _aliases
-from ...common._helpers import _check_device
+from typing import Callable
+
+from ...common import _aliases, array_namespace
 
 from ..._internal import get_xp
 
@@ -30,36 +31,71 @@ from numpy import (
 )
 
 from typing import TYPE_CHECKING
+
 if TYPE_CHECKING:
     from typing import Optional, Union
 
-    from ...common._typing import Device, Dtype, Array, NestedSequence, SupportsBufferProtocol
+    from ...common._typing import (
+        Device,
+        Dtype,
+        Array,
+        NestedSequence,
+        SupportsBufferProtocol,
+    )
 
 import dask.array as da
 
 isdtype = get_xp(np)(_aliases.isdtype)
 unstack = get_xp(da)(_aliases.unstack)
-astype = _aliases.astype
+
+
+# da.astype doesn't respect copy=True
+def astype(
+    x: Array,
+    dtype: Dtype,
+    /,
+    *,
+    copy: bool = True,
+    device: Optional[Device] = None,
+) -> Array:
+    """
+    Array API compatibility wrapper for astype().
+
+    See the corresponding documentation in the array library and/or the array API
+    specification for more details.
+    """
+    # TODO: respect device keyword?
+
+    if not copy and dtype == x.dtype:
+        return x
+    x = x.astype(dtype)
+    return x.copy() if copy else x
+
 
 # Common aliases
 
+
 # This arange func is modified from the common one to
 # not pass stop/step as keyword arguments, which will cause
 # an error with dask
-
-# TODO: delete the xp stuff, it shouldn't be necessary
-def _dask_arange(
+def arange(
     start: Union[int, float],
     /,
     stop: Optional[Union[int, float]] = None,
     step: Union[int, float] = 1,
     *,
-    xp,
     dtype: Optional[Dtype] = None,
     device: Optional[Device] = None,
     **kwargs,
 ) -> Array:
-    _check_device(xp, device)
+    """
+    Array API compatibility wrapper for arange().
+
+    See the corresponding documentation in the array library and/or the array API
+    specification for more details.
+    """
+    # TODO: respect device keyword?
+
     args = [start]
     if stop is not None:
         args.append(stop)
@@ -68,13 +104,12 @@ def _dask_arange(
         # prepend the default value for start which is 0
         args.insert(0, 0)
     args.append(step)
-    return xp.arange(*args, dtype=dtype, **kwargs)
 
-arange = get_xp(da)(_dask_arange)
-eye = get_xp(da)(_aliases.eye)
+    return da.arange(*args, dtype=dtype, **kwargs)
+
 
-linspace = get_xp(da)(_aliases.linspace)
 eye = get_xp(da)(_aliases.eye)
+linspace = get_xp(da)(_aliases.linspace)
 UniqueAllResult = get_xp(da)(_aliases.UniqueAllResult)
 UniqueCountsResult = get_xp(da)(_aliases.UniqueCountsResult)
 UniqueInverseResult = get_xp(da)(_aliases.UniqueInverseResult)
@@ -86,6 +121,7 @@ permute_dims = get_xp(da)(_aliases.permute_dims)
 std = get_xp(da)(_aliases.std)
 var = get_xp(da)(_aliases.var)
 cumulative_sum = get_xp(da)(_aliases.cumulative_sum)
+cumulative_prod = get_xp(da)(_aliases.cumulative_prod)
 empty = get_xp(da)(_aliases.empty)
 empty_like = get_xp(da)(_aliases.empty_like)
 full = get_xp(da)(_aliases.full)
@@ -97,7 +133,6 @@ zeros_like = get_xp(da)(_aliases.zeros_like)
 reshape = get_xp(da)(_aliases.reshape)
 matrix_transpose = get_xp(da)(_aliases.matrix_transpose)
 vecdot = get_xp(da)(_aliases.vecdot)
-
 nonzero = get_xp(da)(_aliases.nonzero)
 ceil = get_xp(np)(_aliases.ceil)
 floor = get_xp(np)(_aliases.floor)
@@ -106,6 +141,7 @@ matmul = get_xp(np)(_aliases.matmul)
 tensordot = get_xp(np)(_aliases.tensordot)
 sign = get_xp(np)(_aliases.sign)
 
+
 # asarray also adds the copy keyword, which is not present in numpy 1.0.
 def asarray(
     obj: Union[
@@ -120,7 +156,7 @@ def asarray(
     *,
     dtype: Optional[Dtype] = None,
     device: Optional[Device] = None,
-    copy: "Optional[Union[bool, np._CopyMode]]" = None,
+    copy: Optional[Union[bool, np._CopyMode]] = None,
     **kwargs,
 ) -> Array:
     """
@@ -129,24 +165,25 @@ def asarray(
     See the corresponding documentation in the array library and/or the array API
     specification for more details.
     """
+    # TODO: respect device keyword?
+
+    if isinstance(obj, da.Array):
+        if dtype is not None and dtype != obj.dtype:
+            if copy is False:
+                raise ValueError("Unable to avoid copy when changing dtype")
+            obj = obj.astype(dtype)
+        return obj.copy() if copy else obj
+
     if copy is False:
-        # copy=False is not yet implemented in dask
-        raise NotImplementedError("copy=False is not yet implemented")
-    elif copy is True:
-        if isinstance(obj, da.Array) and dtype is None:
-            return obj.copy()
-        # Go through numpy, since dask copy is no-op by default
-        obj = np.array(obj, dtype=dtype, copy=True)
-        return da.array(obj, dtype=dtype)
-    else:
-        if not isinstance(obj, da.Array) or dtype is not None and obj.dtype != dtype:
-            # copy=True to be uniform across dask < 2024.12 and >= 2024.12
-            # see https://github.com/dask/dask/pull/11524/
-            obj = np.array(obj, dtype=dtype, copy=True)
-            return da.from_array(obj)
-        return obj
+        raise NotImplementedError(
+            "Unable to avoid copy when converting a non-dask object to dask"
+        )
+
+    # copy=None to be uniform across dask < 2024.12 and >= 2024.12
+    # see https://github.com/dask/dask/pull/11524/
+    obj = np.array(obj, dtype=dtype, copy=True)
+    return da.from_array(obj)
 
-    return da.asarray(obj, dtype=dtype, **kwargs)
 
 from dask.array import (
     # Element wise aliases
@@ -165,49 +202,141 @@ from dask.array import (
     concatenate as concat,
 )
 
+
 # dask.array.clip does not work unless all three arguments are provided.
 # Furthermore, the masking workaround in common._aliases.clip cannot work with
 # dask (meaning uint64 promoting to float64 is going to just be unfixed for
 # now).
-@get_xp(da)
 def clip(
     x: Array,
     /,
     min: Optional[Union[int, float, Array]] = None,
     max: Optional[Union[int, float, Array]] = None,
-    *,
-    xp,
 ) -> Array:
+    """
+    Array API compatibility wrapper for clip().
+
+    See the corresponding documentation in the array library and/or the array API
+    specification for more details.
+    """
+
     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
 
     # TODO: This won't handle dask unknown shapes
-    import numpy as np
     result_shape = np.broadcast_shapes(x.shape, min_shape, max_shape)
 
     if min is not None:
-        min = xp.broadcast_to(xp.asarray(min), result_shape)
+        min = da.broadcast_to(da.asarray(min), result_shape)
     if max is not None:
-        max = xp.broadcast_to(xp.asarray(max), result_shape)
+        max = da.broadcast_to(da.asarray(max), result_shape)
 
     if min is None and max is None:
-        return xp.positive(x)
+        return da.positive(x)
 
     if min is None:
-        return astype(xp.minimum(x, max), x.dtype)
+        return astype(da.minimum(x, max), x.dtype)
     if max is None:
-        return astype(xp.maximum(x, min), x.dtype)
+        return astype(da.maximum(x, min), x.dtype)
+
+    return astype(da.minimum(da.maximum(x, min), max), x.dtype)
+
+
+def _ensure_single_chunk(x: Array, axis: int) -> tuple[Array, Callable[[Array], Array]]:
+    """
+    Make sure that Array is not broken into multiple chunks along axis.
+
+    Returns
+    -------
+    x : Array
+        The input Array with a single chunk along axis.
+    restore : Callable[Array, Array]
+        function to apply to the output to rechunk it back into reasonable chunks
+    """
+    if axis < 0:
+        axis += x.ndim
+    if x.numblocks[axis] < 2:
+        return x, lambda x: x
+
+    # Break chunks on other axes in an attempt to keep chunk size low
+    x = x.rechunk({i: -1 if i == axis else "auto" for i in range(x.ndim)})
+
+    # Rather than reconstructing the original chunks, which can be a
+    # very expensive affair, just break down oversized chunks without
+    # incurring in any transfers over the network.
+    # This has the downside of a risk of overchunking if the array is
+    # then used in operations against other arrays that match the
+    # original chunking pattern.
+    return x, lambda x: x.rechunk()
+
+
+def sort(
+    x: Array, /, *, axis: int = -1, descending: bool = False, stable: bool = True
+) -> Array:
+    """
+    Array API compatibility layer around the lack of sort() in Dask.
+
+    Warnings
+    --------
+    This function temporarily rechunks the array along `axis` to a single chunk.
+    This can be extremely inefficient and can lead to out-of-memory errors.
+
+    See the corresponding documentation in the array library and/or the array API
+    specification for more details.
+    """
+    x, restore = _ensure_single_chunk(x, axis)
+
+    meta_xp = array_namespace(x._meta)
+    x = da.map_blocks(
+        meta_xp.sort,
+        x,
+        axis=axis,
+        meta=x._meta,
+        dtype=x.dtype,
+        descending=descending,
+        stable=stable,
+    )
+
+    return restore(x)
+
+
+def argsort(
+    x: Array, /, *, axis: int = -1, descending: bool = False, stable: bool = True
+) -> Array:
+    """
+    Array API compatibility layer around the lack of argsort() in Dask.
+
+    See the corresponding documentation in the array library and/or the array API
+    specification for more details.
+
+    Warnings
+    --------
+    This function temporarily rechunks the array along `axis` into a single chunk.
+    This can be extremely inefficient and can lead to out-of-memory errors.
+    """
+    x, restore = _ensure_single_chunk(x, axis)
 
-    return astype(xp.minimum(xp.maximum(x, min), max), x.dtype)
+    meta_xp = array_namespace(x._meta)
+    dtype = meta_xp.argsort(x._meta).dtype
+    meta = meta_xp.astype(x._meta, dtype)
+    x = da.map_blocks(
+        meta_xp.argsort,
+        x,
+        axis=axis,
+        meta=meta,
+        dtype=dtype,
+        descending=descending,
+        stable=stable,
+    )
 
-# exclude these from all since dask.array has no sorting functions
-_da_unsupported = ['sort', 'argsort']
+    return restore(x)
 
-_common_aliases = [alias for alias in _aliases.__all__ if alias not in _da_unsupported]
 
-__all__ = _common_aliases + ['__array_namespace_info__', 'asarray', 'acos',
+__all__ = _aliases.__all__ + [
+                    '__array_namespace_info__', 'asarray', 'astype', 'acos',
                     'acosh', 'asin', 'asinh', 'atan', 'atan2',
                     'atanh', 'bitwise_left_shift', 'bitwise_invert',
                     'bitwise_right_shift', 'concat', 'pow', 'iinfo', 'finfo', 'can_cast',
@@ -216,4 +345,4 @@ __all__ = _common_aliases + ['__array_namespace_info__', 'asarray', 'acos',
                     'complex64', 'complex128', 'iinfo', 'finfo',
                     'can_cast', 'result_type']
 
-_all_ignore = ["get_xp", "da", "np"]
+_all_ignore = ["Callable", "array_namespace", "get_xp", "da", "np"]

array_api_compat/dask/array/_info.py

@@ -102,7 +102,7 @@ class __array_namespace_info__:
             "boolean indexing": False,
             "data-dependent shapes": False,
             # 'max rank' will be part of the 2024.12 standard
-            # "max rank": 64,
+            "max dimensions": 64,
         }
 
     def default_device(self):

array_api_compat/numpy/__init__.py

@@ -27,4 +27,4 @@ try:
 except ImportError:
     pass
 
-__array_api_version__ = '2023.12'
+__array_api_version__ = '2024.12'

array_api_compat/numpy/_aliases.py

@@ -46,10 +46,10 @@ unique_all = get_xp(np)(_aliases.unique_all)
 unique_counts = get_xp(np)(_aliases.unique_counts)
 unique_inverse = get_xp(np)(_aliases.unique_inverse)
 unique_values = get_xp(np)(_aliases.unique_values)
-astype = _aliases.astype
 std = get_xp(np)(_aliases.std)
 var = get_xp(np)(_aliases.var)
 cumulative_sum = get_xp(np)(_aliases.cumulative_sum)
+cumulative_prod = get_xp(np)(_aliases.cumulative_prod)
 clip = get_xp(np)(_aliases.clip)
 permute_dims = get_xp(np)(_aliases.permute_dims)
 reshape = get_xp(np)(_aliases.reshape)
@@ -115,6 +115,18 @@ def asarray(
 
     return np.array(obj, copy=copy, dtype=dtype, **kwargs)
 
+
+def astype(
+    x: ndarray,
+    dtype: Dtype,
+    /,
+    *,
+    copy: bool = True,
+    device: Optional[Device] = None,
+) -> ndarray:
+    return x.astype(dtype=dtype, copy=copy)
+
+
 # These functions are completely new here. If the library already has them
 # (i.e., numpy 2.0), use the library version instead of our wrapper.
 if hasattr(np, 'vecdot'):
@@ -132,10 +144,10 @@ if hasattr(np, 'unstack'):
 else:
     unstack = get_xp(np)(_aliases.unstack)
 
-__all__ = _aliases.__all__ + ['__array_namespace_info__', 'asarray', 'bool',
+__all__ = _aliases.__all__ + ['__array_namespace_info__', 'asarray', 'astype',
                               'acos', 'acosh', 'asin', 'asinh', 'atan',
                               'atan2', 'atanh', 'bitwise_left_shift',
                               'bitwise_invert', 'bitwise_right_shift',
-                              'concat', 'pow']
+                              'bool', 'concat', 'pow']
 
 _all_ignore = ['np', 'get_xp']

array_api_compat/numpy/_info.py

@@ -101,7 +101,7 @@ class __array_namespace_info__:
             "boolean indexing": True,
             "data-dependent shapes": True,
             # 'max rank' will be part of the 2024.12 standard
-            # "max rank": 64,
+            "max dimensions": 64,
         }
 
     def default_device(self):

array_api_compat/torch/__init__.py

@@ -21,4 +21,4 @@ __import__(__package__ + '.fft')
 
 from ..common._helpers import * # noqa: F403
 
-__array_api_version__ = '2023.12'
+__array_api_version__ = '2024.12'

array_api_compat/torch/_aliases.py

@@ -8,6 +8,7 @@ from ..common._aliases import (matrix_transpose as _aliases_matrix_transpose,
                                clip as _aliases_clip,
                                unstack as _aliases_unstack,
                                cumulative_sum as _aliases_cumulative_sum,
+                               cumulative_prod as _aliases_cumulative_prod,
                                )
 from .._internal import get_xp
 
@@ -30,6 +31,12 @@ _int_dtypes = {
     torch.int32,
     torch.int64,
 }
+try:
+    # torch >=2.3
+    _int_dtypes |= {torch.uint16, torch.uint32, torch.uint64}
+except AttributeError:
+    pass
+
 
 _array_api_dtypes = {
     torch.bool,
@@ -118,7 +125,11 @@ def _fix_promotion(x1, x2, only_scalar=True):
         x1 = x1.to(dtype)
     return x1, x2
 
-def result_type(*arrays_and_dtypes: Union[array, Dtype]) -> Dtype:
+
+_py_scalars = (bool, int, float, complex)
+
+
+def result_type(*arrays_and_dtypes: Union[array, Dtype, bool, int, float, complex]) -> Dtype:
     if len(arrays_and_dtypes) == 0:
         raise TypeError("At least one array or dtype must be provided")
     if len(arrays_and_dtypes) == 1:
@@ -130,6 +141,9 @@ def result_type(*arrays_and_dtypes: Union[array, Dtype]) -> Dtype:
         return result_type(arrays_and_dtypes[0], result_type(*arrays_and_dtypes[1:]))
 
     x, y = arrays_and_dtypes
+    if isinstance(x, _py_scalars) or isinstance(y, _py_scalars):
+        return torch.result_type(x, y)
+
     xdt = x.dtype if not isinstance(x, torch.dtype) else x
     ydt = y.dtype if not isinstance(y, torch.dtype) else y
 
@@ -204,6 +218,7 @@ def min(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keep
 clip = get_xp(torch)(_aliases_clip)
 unstack = get_xp(torch)(_aliases_unstack)
 cumulative_sum = get_xp(torch)(_aliases_cumulative_sum)
+cumulative_prod = get_xp(torch)(_aliases_cumulative_prod)
 
 # torch.sort also returns a tuple
 # https://github.com/pytorch/pytorch/issues/70921
@@ -498,6 +513,31 @@ def nonzero(x: array, /, **kwargs) -> Tuple[array, ...]:
         raise ValueError("nonzero() does not support zero-dimensional arrays")
     return torch.nonzero(x, as_tuple=True, **kwargs)
 
+
+# torch uses `dim` instead of `axis`
+def diff(
+    x: array,
+    /,
+    *,
+    axis: int = -1,
+    n: int = 1,
+    prepend: Optional[array] = None,
+    append: Optional[array] = None,
+) -> array:
+    return torch.diff(x, dim=axis, n=n, prepend=prepend, append=append)
+
+
+# torch uses `dim` instead of `axis`
+def count_nonzero(
+    x: array,
+    /,
+    *,
+    axis: Optional[Union[int, Tuple[int, ...]]] = None,
+    keepdims: bool = False,
+) -> array:
+    return torch.count_nonzero(x, dim=axis, keepdims=keepdims)
+
+
 def where(condition: array, x1: array, x2: array, /) -> array:
     x1, x2 = _fix_promotion(x1, x2)
     return torch.where(condition, x1, x2)
@@ -613,8 +653,19 @@ def triu(x: array, /, *, k: int = 0) -> array:
 def expand_dims(x: array, /, *, axis: int = 0) -> array:
     return torch.unsqueeze(x, axis)
 
-def astype(x: array, dtype: Dtype, /, *, copy: bool = True) -> array:
-    return x.to(dtype, copy=copy)
+
+def astype(
+    x: array,
+    dtype: Dtype,
+    /,
+    *,
+    copy: bool = True,
+    device: Optional[Device] = None,
+) -> array:
+    if device is not None:
+        return x.to(device, dtype=dtype, copy=copy)
+    return x.to(dtype=dtype, copy=copy)
+
 
 def broadcast_arrays(*arrays: array) -> List[array]:
     shape = torch.broadcast_shapes(*[a.shape for a in arrays])
@@ -717,6 +768,11 @@ def take(x: array, indices: array, /, *, axis: Optional[int] = None, **kwargs) -
         axis = 0
     return torch.index_select(x, axis, indices, **kwargs)
 
+
+def take_along_axis(x: array, indices: array, /, *, axis: int = -1) -> array:
+    return torch.take_along_dim(x, indices, dim=axis)
+
+
 def sign(x: array, /) -> array:
     # torch sign() does not support complex numbers and does not propagate
     # nans. See https://github.com/data-apis/array-api-compat/issues/136
@@ -735,11 +791,12 @@ def sign(x: array, /) -> array:
 __all__ = ['__array_namespace_info__', 'result_type', 'can_cast',
            'permute_dims', 'bitwise_invert', 'newaxis', 'conj', 'add',
            'atan2', 'bitwise_and', 'bitwise_left_shift', 'bitwise_or',
-           'bitwise_right_shift', 'bitwise_xor', 'copysign', 'divide',
+           'bitwise_right_shift', 'bitwise_xor', 'copysign', 'count_nonzero',
+           'diff', 'divide',
            'equal', 'floor_divide', 'greater', 'greater_equal', 'hypot',
            'less', 'less_equal', 'logaddexp', 'maximum', 'minimum',
            'multiply', 'not_equal', 'pow', 'remainder', 'subtract', 'max',
-           'min', 'clip', 'unstack', 'cumulative_sum', 'sort', 'prod', 'sum',
+           'min', 'clip', 'unstack', 'cumulative_sum', 'cumulative_prod', 'sort', 'prod', 'sum',
            'any', 'all', 'mean', 'std', 'var', 'concat', 'squeeze',
            'broadcast_to', 'flip', 'roll', 'nonzero', 'where', 'reshape',
            'arange', 'eye', 'linspace', 'full', 'ones', 'zeros', 'empty',
@@ -747,6 +804,6 @@ __all__ = ['__array_namespace_info__', 'result_type', 'can_cast',
            'UniqueAllResult', 'UniqueCountsResult', 'UniqueInverseResult',
            'unique_all', 'unique_counts', 'unique_inverse', 'unique_values',
            'matmul', 'matrix_transpose', 'vecdot', 'tensordot', 'isdtype',
-           'take', 'sign']
+           'take', 'take_along_axis', 'sign']
 
 _all_ignore = ['torch', 'get_xp']

array_api_compat/torch/_info.py

@@ -86,7 +86,7 @@ class __array_namespace_info__:
             "boolean indexing": True,
             "data-dependent shapes": True,
             # 'max rank' will be part of the 2024.12 standard
-            # "max rank": 64,
+            "max dimensions": 64,
         }
 
     def default_device(self):

{array_api_compat-1.10.0.dist-info → array_api_compat-1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: array_api_compat
-Version: 1.10.0
+Version: 1.11
 Summary: A wrapper around NumPy and other array libraries to make them compatible with the Array API standard
 Home-page: https://data-apis.org/array-api-compat/
 Author: Consortium for Python Data API Standards
@@ -28,6 +28,15 @@ Provides-Extra: dask
 Requires-Dist: dask; extra == "dask"
 Provides-Extra: sparse
 Requires-Dist: sparse>=0.15.1; extra == "sparse"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
 
 # Array API compatibility library
 

array_api_compat-1.11.dist-info/RECORD

@@ -0,0 +1,36 @@
+array_api_compat/__init__.py,sha256=ST4tFa84YyTEresLvKAdYddeBZhy7e_m3NFs9d6JCu0,990
+array_api_compat/_internal.py,sha256=0GHLUJRbBHZLsbgRYE0OCtxAKdYuLtr1qzh70N5vBQI,1010
+array_api_compat/common/__init__.py,sha256=HB4vvyS0GnH6JQSEgAC75oa-s2WBIiQQebpgXnW00N0,37
+array_api_compat/common/_aliases.py,sha256=DY_bAnVpA0zcLbO4A8OvknTiVKHLuZtZ4GYqEIHxWuQ,18484
+array_api_compat/common/_fft.py,sha256=o5097rkGCd_0Y6bonv-k6PDsIT6znNyi2xrZ2QAHF0U,4795
+array_api_compat/common/_helpers.py,sha256=G8gsIcTxhndRacPY4HWwYq7BXJ5ywbwPQSmdCVwFEpo,27817
+array_api_compat/common/_linalg.py,sha256=BebUx7WRkz9DAx9lrrP8d57-uN0VobwLGX0xbvI-7Wg,6142
+array_api_compat/common/_typing.py,sha256=lNxZYl5ajs8rKNWgIj7nGDuqjZxDjAypwQAdKbLskS4,478
+array_api_compat/cupy/__init__.py,sha256=DdnXhTZPfmyCyrejnxBcgPJLP0vHMZQl1ed1oiaaj-A,442
+array_api_compat/cupy/_aliases.py,sha256=p6oiLqof7paweR1p8HCulBsooB0bcWiQbacw2fgI7LQ,4920
+array_api_compat/cupy/_info.py,sha256=uV9O0LbA9rr9Y_GFFN8oI10e_kH95JX4EFQ8BU6tM-g,9809
+array_api_compat/cupy/_typing.py,sha256=oDhrZB8R-D6wvee7tR4YkyBhTq93M0fFi3Tv-lpN_Dg,617
+array_api_compat/cupy/fft.py,sha256=xCAC42CNAwAyVW7uCREsSoAV23R3rL2dqrT7w877zuE,842
+array_api_compat/cupy/linalg.py,sha256=nKOM-_wcOHzHhEeV9KBzcMVNlviJK4nP1nFBUtvnjTM,1444
+array_api_compat/dask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+array_api_compat/dask/array/__init__.py,sha256=KQy67alfyrWNoaqjXNYzkm4Y8_UctjpmgLyBwIY4z4k,242
+array_api_compat/dask/array/_aliases.py,sha256=wfKgPfqQbIvJABI8uaDJxPW14qnmP74g_-PyclqlswQ,9883
+array_api_compat/dask/array/_info.py,sha256=NjJDNgZ0YVewuuuzusqkHqZJ2DFU7txN_68PLN6QG3E,10414
+array_api_compat/dask/array/fft.py,sha256=FWXfXVz9zUGKVtYJWl-xSb9BUp7UIewQ89FzGimwOOA,553
+array_api_compat/dask/array/linalg.py,sha256=5E3wSAXmiZJ5rf69u6Pzw1Xs0lCdMpiVBnheA4lzY4E,2441
+array_api_compat/numpy/__init__.py,sha256=xdBoXg4nHg3zwF3Bsgng7tLk78EGODdd97bUGRuBWPI,831
+array_api_compat/numpy/_aliases.py,sha256=Dhi-mci8Vr7jK6x7JVydsRMBWdV6PE-R6mAc-WOyZs8,4706
+array_api_compat/numpy/_info.py,sha256=LiphQgoWIHfkIgYun-0w3zXcNDoAoIMgG8qRIXlSFU8,10388
+array_api_compat/numpy/_typing.py,sha256=OFRXfhT8-snL_4VeOjbOCd_yYIGqVS-IRrZoWNcL3v4,618
+array_api_compat/numpy/fft.py,sha256=vlrYUcv2VV5mOOEb5R4u83nFSSDmE-nfJYM-lmq1Dao,679
+array_api_compat/numpy/linalg.py,sha256=ne4h3Ui1esyzD9p7Ko2IueJvgpSUmfF_Z5aWbiBKJc0,3256
+array_api_compat/torch/__init__.py,sha256=vsGeo4X4u0vAqFZ8aNzMiVOd6wd5JM-_Sz3r3Bv5HwA,591
+array_api_compat/torch/_aliases.py,sha256=kOTGZGPiqas9jOdWRgF3NWFgK4c3_n1n0TzFciJ7E30,29860
+array_api_compat/torch/_info.py,sha256=LIMbq4DH2Q3xL9TZac-xSu4zFWUJMmGK5h3m53lTKj4,11417
+array_api_compat/torch/fft.py,sha256=AVHOwIxM-t9_w-FjVF79RrzeC5wYc5g97WPUp7bIHlA,1794
+array_api_compat/torch/linalg.py,sha256=dJ0o1gCbSDtklpvgZCxx3gbHXW9q3I4u8ZLFPW24dJs,4770
+array_api_compat-1.11.dist-info/LICENSE,sha256=T_2Xjj-hjQWNmMZncc_qftY0qvcCPPlhK4tV7umo8P4,1097
+array_api_compat-1.11.dist-info/METADATA,sha256=yQ9XlxBaME4up9d1KfYvQWvkqBd_XBNhMGbB4656u8I,1828
+array_api_compat-1.11.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+array_api_compat-1.11.dist-info/top_level.txt,sha256=I3ahdJi_PlO7taw_OFq_VENWBrs_68Ez_KnB05xditc,17
+array_api_compat-1.11.dist-info/RECORD,,

{array_api_compat-1.10.0.dist-info → array_api_compat-1.11.dist-info}/WHEEL

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

array_api_compat-1.10.0.dist-info/RECORD

@@ -1,36 +0,0 @@
-array_api_compat/__init__.py,sha256=kANHGhPdqQI0GA5ZVQ9q0UZqJWbOm4MRPNAU3YnLx_U,992
-array_api_compat/_internal.py,sha256=0GHLUJRbBHZLsbgRYE0OCtxAKdYuLtr1qzh70N5vBQI,1010
-array_api_compat/common/__init__.py,sha256=HB4vvyS0GnH6JQSEgAC75oa-s2WBIiQQebpgXnW00N0,37
-array_api_compat/common/_aliases.py,sha256=6BGUNUWr-u6bhUWDicuQWm0LF_aQr9al-OnBW7LegFE,17884
-array_api_compat/common/_fft.py,sha256=qZvAveqXFwEQxCbTNx9l_41EpQpAwMfwS2GqWKEVwow,4520
-array_api_compat/common/_helpers.py,sha256=xPQAvGvmb4pkSJXk5NLcEfEPugytPyl1W4o5VEy7UCQ,24624
-array_api_compat/common/_linalg.py,sha256=BebUx7WRkz9DAx9lrrP8d57-uN0VobwLGX0xbvI-7Wg,6142
-array_api_compat/common/_typing.py,sha256=KBJcLRAG2MeID9V38-GBipfpsFWGGrxOKkgfSQmgjXE,414
-array_api_compat/cupy/__init__.py,sha256=3079YH9uF2HoG8E27bp_1lsIVvYsdrq8hKMk_jT3NFs,442
-array_api_compat/cupy/_aliases.py,sha256=aCmWDlvcdhagje7QDxgF-jqTmUk6mnVIl2hOky1IpBE,4538
-array_api_compat/cupy/_info.py,sha256=kdUS8xcIVg_0Mgg2qSzuqOrXgopaHO_G8JmGBB-4qOM,9805
-array_api_compat/cupy/_typing.py,sha256=oDhrZB8R-D6wvee7tR4YkyBhTq93M0fFi3Tv-lpN_Dg,617
-array_api_compat/cupy/fft.py,sha256=xCAC42CNAwAyVW7uCREsSoAV23R3rL2dqrT7w877zuE,842
-array_api_compat/cupy/linalg.py,sha256=nKOM-_wcOHzHhEeV9KBzcMVNlviJK4nP1nFBUtvnjTM,1444
-array_api_compat/dask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-array_api_compat/dask/array/__init__.py,sha256=7_FttjbrGeKtPFGS_CA85WZZmbxPwkpxvsMS8KTMEFw,242
-array_api_compat/dask/array/_aliases.py,sha256=Kn31uXAkUFOX11DzlEXnlH9uSgPGHB0GKkHAfFNCYjA,6692
-array_api_compat/dask/array/_info.py,sha256=D8hG1uRNsF31_WX5bnulbdl75Jkd6G2DbkmhXXTplEs,10410
-array_api_compat/dask/array/fft.py,sha256=FWXfXVz9zUGKVtYJWl-xSb9BUp7UIewQ89FzGimwOOA,553
-array_api_compat/dask/array/linalg.py,sha256=5E3wSAXmiZJ5rf69u6Pzw1Xs0lCdMpiVBnheA4lzY4E,2441
-array_api_compat/numpy/__init__.py,sha256=uxjYAO4xcDhTQPbrD2XmkWT5TyZsjpwc5FD-ViHxN-c,831
-array_api_compat/numpy/_aliases.py,sha256=ZrddTjHOVUNvDM1h9p7NqXqaODVJKkKu2fTyPClCmXg,4485
-array_api_compat/numpy/_info.py,sha256=GAD-zNvAMUSeUJfjABY6p_eYkG--KBBgz1vdQkL2-UA,10384
-array_api_compat/numpy/_typing.py,sha256=OFRXfhT8-snL_4VeOjbOCd_yYIGqVS-IRrZoWNcL3v4,618
-array_api_compat/numpy/fft.py,sha256=vlrYUcv2VV5mOOEb5R4u83nFSSDmE-nfJYM-lmq1Dao,679
-array_api_compat/numpy/linalg.py,sha256=ne4h3Ui1esyzD9p7Ko2IueJvgpSUmfF_Z5aWbiBKJc0,3256
-array_api_compat/torch/__init__.py,sha256=sk32NV12KrlR8a-UjiBdjJspUcex5j7REAGgSJoI3do,591
-array_api_compat/torch/_aliases.py,sha256=kCIeFyzzUqNh86Byo5Ai2s1guK2-OkXg62chBCN_kgU,28559
-array_api_compat/torch/_info.py,sha256=rnInxwjMErvcHLI4S6fzom7N43hoAqS0rysw1K8Riyw,11413
-array_api_compat/torch/fft.py,sha256=AVHOwIxM-t9_w-FjVF79RrzeC5wYc5g97WPUp7bIHlA,1794
-array_api_compat/torch/linalg.py,sha256=dJ0o1gCbSDtklpvgZCxx3gbHXW9q3I4u8ZLFPW24dJs,4770
-array_api_compat-1.10.0.dist-info/LICENSE,sha256=T_2Xjj-hjQWNmMZncc_qftY0qvcCPPlhK4tV7umo8P4,1097
-array_api_compat-1.10.0.dist-info/METADATA,sha256=fv9JiUfwg6YaExW_acxdfuNqIi8EEk9ilVf3gWqDoBc,1637
-array_api_compat-1.10.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-array_api_compat-1.10.0.dist-info/top_level.txt,sha256=I3ahdJi_PlO7taw_OFq_VENWBrs_68Ez_KnB05xditc,17
-array_api_compat-1.10.0.dist-info/RECORD,,