array-api-compat 1.5.1__tar.gz → 1.6__tar.gz

{array_api_compat-1.5.1 → array_api_compat-1.6}/PKG-INFO

@@ -1,24 +1,28 @@
 Metadata-Version: 2.1
 Name: array_api_compat
-Version: 1.5.1
+Version: 1.6
 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
 License: MIT
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: numpy
 Requires-Dist: numpy; extra == "numpy"
 Provides-Extra: cupy
 Requires-Dist: cupy; extra == "cupy"
+Provides-Extra: jax
+Requires-Dist: jax; extra == "jax"
+Provides-Extra: pytorch
+Requires-Dist: pytorch; extra == "pytorch"
+Provides-Extra: dask
+Requires-Dist: dask; extra == "dask"
 
 # Array API compatibility library
 

{array_api_compat-1.5.1 → array_api_compat-1.6}/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.5.1'
+__version__ = '1.6'
 
 from .common import *  # noqa: F401, F403

{array_api_compat-1.5.1 → array_api_compat-1.6}/array_api_compat/common/_aliases.py

@@ -6,18 +6,18 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
-    import numpy as np
     from typing import Optional, Sequence, Tuple, Union
-    from ._typing import ndarray, Device, Dtype, NestedSequence, SupportsBufferProtocol
+    from ._typing import ndarray, Device, Dtype
 
 from typing import NamedTuple
-from types import ModuleType
 import inspect
 
-from ._helpers import _check_device, is_numpy_array, array_namespace
+from ._helpers import _check_device
 
 # These functions are modified from the NumPy versions.
 
+# Creation functions add the device keyword (which does nothing for NumPy)
+
 def arange(
     start: Union[int, float],
     /,
@@ -268,90 +268,6 @@ def var(
 def permute_dims(x: ndarray, /, axes: Tuple[int, ...], xp) -> ndarray:
     return xp.transpose(x, axes)
 
-# Creation functions add the device keyword (which does nothing for NumPy)
-
-# asarray also adds the copy keyword
-def _asarray(
-    obj: Union[
-        ndarray,
-        bool,
-        int,
-        float,
-        NestedSequence[bool | int | float],
-        SupportsBufferProtocol,
-    ],
-    /,
-    *,
-    dtype: Optional[Dtype] = None,
-    device: Optional[Device] = None,
-    copy: "Optional[Union[bool, np._CopyMode]]" = None,
-    namespace = None,
-    **kwargs,
-) -> ndarray:
-    """
-    Array API compatibility wrapper for asarray().
-
-    See the corresponding documentation in NumPy/CuPy and/or the array API
-    specification for more details.
-
-    """
-    if namespace is None:
-        try:
-            xp = array_namespace(obj, _use_compat=False)
-        except ValueError:
-            # TODO: What about lists of arrays?
-            raise ValueError("A namespace must be specified for asarray() with non-array input")
-    elif isinstance(namespace, ModuleType):
-        xp = namespace
-    elif namespace == 'numpy':
-        import numpy as xp
-    elif namespace == 'cupy':
-        import cupy as xp
-    elif namespace == 'dask.array':
-        import dask.array as xp
-    else:
-        raise ValueError("Unrecognized namespace argument to asarray()")
-
-    _check_device(xp, device)
-    if is_numpy_array(obj):
-        import numpy as np
-        if hasattr(np, '_CopyMode'):
-            # Not present in older NumPys
-            COPY_FALSE = (False, np._CopyMode.IF_NEEDED)
-            COPY_TRUE = (True, np._CopyMode.ALWAYS)
-        else:
-            COPY_FALSE = (False,)
-            COPY_TRUE = (True,)
-    else:
-        COPY_FALSE = (False,)
-        COPY_TRUE = (True,)
-    if copy in COPY_FALSE and namespace != "dask.array":
-        # copy=False is not yet implemented in xp.asarray
-        raise NotImplementedError("copy=False is not yet implemented")
-    if (hasattr(xp, "ndarray") and isinstance(obj, xp.ndarray)):
-        if dtype is not None and obj.dtype != dtype:
-            copy = True
-        if copy in COPY_TRUE:
-            return xp.array(obj, copy=True, dtype=dtype)
-        return obj
-    elif namespace == "dask.array":
-        if copy in COPY_TRUE:
-            if dtype is None:
-                return obj.copy()
-            # Go through numpy, since dask copy is no-op by default
-            import numpy as np
-            obj = np.array(obj, dtype=dtype, copy=True)
-            return xp.array(obj, dtype=dtype)
-        else:
-            import dask.array as da
-            import numpy as np
-            if not isinstance(obj, da.Array):
-                obj = np.asarray(obj, dtype=dtype)
-                return da.from_array(obj)
-            return obj
-
-    return xp.asarray(obj, dtype=dtype, **kwargs)
-
 # np.reshape calls the keyword argument 'newshape' instead of 'shape'
 def reshape(x: ndarray,
             /,

{array_api_compat-1.5.1 → array_api_compat-1.6}/array_api_compat/common/_helpers.py

@@ -178,7 +178,7 @@ def _check_api_version(api_version):
     elif api_version is not None and api_version != '2022.12':
         raise ValueError("Only the 2022.12 version of the array API specification is currently supported")
 
-def array_namespace(*xs, api_version=None, _use_compat=True):
+def array_namespace(*xs, api_version=None, use_compat=None):
     """
     Get the array API compatible namespace for the arrays `xs`.
 
@@ -191,6 +191,12 @@ def array_namespace(*xs, api_version=None, _use_compat=True):
         The newest version of the spec that you need support for (currently
         the compat library wrapped APIs support v2022.12).
 
+    use_compat: bool or None
+        If None (the default), the native namespace will be returned if it is
+        already array API compatible, otherwise a compat wrapper is used. If
+        True, the compat library wrapped library will be returned. If False,
+        the native library namespace is returned.
+
     Returns
     -------
 
@@ -234,46 +240,66 @@ def array_namespace(*xs, api_version=None, _use_compat=True):
     is_jax_array
 
     """
+    if use_compat not in [None, True, False]:
+        raise ValueError("use_compat must be None, True, or False")
+
+    _use_compat = use_compat in [None, True]
+
     namespaces = set()
     for x in xs:
         if is_numpy_array(x):
-            _check_api_version(api_version)
-            if _use_compat:
-                from .. import numpy as numpy_namespace
+            from .. import numpy as numpy_namespace
+            import numpy as np
+            if use_compat is True:
+                _check_api_version(api_version)
                 namespaces.add(numpy_namespace)
-            else:
-                import numpy as np
+            elif use_compat is False:
                 namespaces.add(np)
+            else:
+                # numpy 2.0 has __array_namespace__ and is fully array API
+                # compatible.
+                if hasattr(x, '__array_namespace__'):
+                    namespaces.add(x.__array_namespace__(api_version=api_version))
+                else:
+                    namespaces.add(numpy_namespace)
         elif is_cupy_array(x):
-            _check_api_version(api_version)
             if _use_compat:
+                _check_api_version(api_version)
                 from .. import cupy as cupy_namespace
                 namespaces.add(cupy_namespace)
             else:
                 import cupy as cp
                 namespaces.add(cp)
         elif is_torch_array(x):
-            _check_api_version(api_version)
             if _use_compat:
+                _check_api_version(api_version)
                 from .. import torch as torch_namespace
                 namespaces.add(torch_namespace)
             else:
                 import torch
                 namespaces.add(torch)
         elif is_dask_array(x):
-            _check_api_version(api_version)
             if _use_compat:
+                _check_api_version(api_version)
                 from ..dask import array as dask_namespace
                 namespaces.add(dask_namespace)
             else:
-                raise TypeError("_use_compat cannot be False if input array is a dask array!")
+                import dask.array as da
+                namespaces.add(da)
         elif is_jax_array(x):
-            _check_api_version(api_version)
-            # jax.experimental.array_api is already an array namespace. We do
-            # not have a wrapper submodule for it.
-            import jax.experimental.array_api as jnp
+            if use_compat is True:
+                _check_api_version(api_version)
+                raise ValueError("JAX does not have an array-api-compat wrapper")
+            elif use_compat is False:
+                import jax.numpy as jnp
+            else:
+                # jax.experimental.array_api is already an array namespace. We do
+                # not have a wrapper submodule for it.
+                import jax.experimental.array_api as jnp
             namespaces.add(jnp)
         elif hasattr(x, '__array_namespace__'):
+            if use_compat is True:
+                raise ValueError("The given array does not have an array-api-compat wrapper")
             namespaces.add(x.__array_namespace__(api_version=api_version))
         else:
             # TODO: Support Python scalars?

{array_api_compat-1.5.1 → array_api_compat-1.6}/array_api_compat/cupy/_aliases.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
 
-from functools import partial
-
 import cupy as cp
 
 from ..common import _aliases
 from .._internal import get_xp
 
-asarray = asarray_cupy = partial(_aliases._asarray, namespace='cupy')
-asarray.__doc__ = _aliases._asarray.__doc__
-del partial
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from typing import Optional, Union
+    from ._typing import ndarray, Device, Dtype, NestedSequence, SupportsBufferProtocol
 
 bool = cp.bool_
 
@@ -62,6 +61,52 @@ matmul = get_xp(cp)(_aliases.matmul)
 matrix_transpose = get_xp(cp)(_aliases.matrix_transpose)
 tensordot = get_xp(cp)(_aliases.tensordot)
 
+_copy_default = object()
+
+# asarray also adds the copy keyword, which is not present in numpy 1.0.
+def asarray(
+    obj: Union[
+        ndarray,
+        bool,
+        int,
+        float,
+        NestedSequence[bool | int | float],
+        SupportsBufferProtocol,
+    ],
+    /,
+    *,
+    dtype: Optional[Dtype] = None,
+    device: Optional[Device] = None,
+    copy: Optional[bool] = _copy_default,
+    **kwargs,
+) -> ndarray:
+    """
+    Array API compatibility wrapper for asarray().
+
+    See the corresponding documentation in the array library and/or the array API
+    specification for more details.
+    """
+    with cp.cuda.Device(device):
+        # cupy is like NumPy 1.26 (except without _CopyMode). See the comments
+        # in asarray in numpy/_aliases.py.
+        if copy is not _copy_default:
+            # A future version of CuPy will change the meaning of copy=False
+            # to mean no-copy. We don't know for certain what version it will
+            # be yet, so to avoid breaking that version, we use a different
+            # default value for copy so asarray(obj) with no copy kwarg will
+            # always do the copy-if-needed behavior.
+
+            # This will still need to be updated to remove the
+            # NotImplementedError for copy=False, but at least this won't
+            # break the default or existing behavior.
+            if copy is None:
+                copy = False
+            elif copy is False:
+                raise NotImplementedError("asarray(copy=False) is not yet supported in cupy")
+            kwargs['copy'] = copy
+
+        return cp.array(obj, dtype=dtype, **kwargs)
+
 # 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'):
@@ -73,7 +118,7 @@ if hasattr(cp, 'isdtype'):
 else:
     isdtype = get_xp(cp)(_aliases.isdtype)
 
-__all__ = _aliases.__all__ + ['asarray', 'asarray_cupy', 'bool', 'acos',
+__all__ = _aliases.__all__ + ['asarray', 'bool', 'acos',
                               'acosh', 'asin', 'asinh', 'atan', 'atan2',
                               'atanh', 'bitwise_left_shift', 'bitwise_invert',
                               'bitwise_right_shift', 'concat', 'pow']

{array_api_compat-1.5.1 → array_api_compat-1.6}/array_api_compat/dask/array/_aliases.py

@@ -37,7 +37,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from typing import Optional, Union
 
-    from ...common._typing import Device, Dtype, Array
+    from ...common._typing import Device, Dtype, Array, NestedSequence, SupportsBufferProtocol
 
 import dask.array as da
 
@@ -76,10 +76,6 @@ def _dask_arange(
 arange = get_xp(da)(_dask_arange)
 eye = get_xp(da)(_aliases.eye)
 
-from functools import partial
-asarray = partial(_aliases._asarray, namespace='dask.array')
-asarray.__doc__ = _aliases._asarray.__doc__
-
 linspace = get_xp(da)(_aliases.linspace)
 eye = get_xp(da)(_aliases.eye)
 UniqueAllResult = get_xp(da)(_aliases.UniqueAllResult)
@@ -113,6 +109,47 @@ trunc = get_xp(np)(_aliases.trunc)
 matmul = get_xp(np)(_aliases.matmul)
 tensordot = get_xp(np)(_aliases.tensordot)
 
+
+# asarray also adds the copy keyword, which is not present in numpy 1.0.
+def asarray(
+    obj: Union[
+        Array,
+        bool,
+        int,
+        float,
+        NestedSequence[bool | int | float],
+        SupportsBufferProtocol,
+    ],
+    /,
+    *,
+    dtype: Optional[Dtype] = None,
+    device: Optional[Device] = None,
+    copy: "Optional[Union[bool, np._CopyMode]]" = None,
+    **kwargs,
+) -> Array:
+    """
+    Array API compatibility wrapper for asarray().
+
+    See the corresponding documentation in the array library and/or the array API
+    specification for more details.
+    """
+    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:
+            obj = np.asarray(obj, dtype=dtype)
+            return da.from_array(obj)
+        return obj
+
+    return da.asarray(obj, dtype=dtype, **kwargs)
+
 from dask.array import (
     # Element wise aliases
     arccos as acos,

{array_api_compat-1.5.1 → array_api_compat-1.6}/array_api_compat/numpy/__init__.py

@@ -21,4 +21,10 @@ from .linalg import matrix_transpose, vecdot # noqa: F401
 
 from ..common._helpers import * # noqa: F403
 
+try:
+    # Used in asarray(). Not present in older versions.
+    from numpy import _CopyMode # noqa: F401
+except ImportError:
+    pass
+
 __array_api_version__ = '2022.12'

{array_api_compat-1.5.1 → array_api_compat-1.6}/array_api_compat/numpy/_aliases.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
-from functools import partial
-
 from ..common import _aliases
 
 from .._internal import get_xp
 
-asarray = asarray_numpy = partial(_aliases._asarray, namespace='numpy')
-asarray.__doc__ = _aliases._asarray.__doc__
-del partial
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from typing import Optional, Union
+    from ._typing import ndarray, Device, Dtype, NestedSequence, SupportsBufferProtocol
 
 import numpy as np
 bool = np.bool_
@@ -62,6 +61,57 @@ matmul = get_xp(np)(_aliases.matmul)
 matrix_transpose = get_xp(np)(_aliases.matrix_transpose)
 tensordot = get_xp(np)(_aliases.tensordot)
 
+def _supports_buffer_protocol(obj):
+    try:
+        memoryview(obj)
+    except TypeError:
+        return False
+    return True
+
+# asarray also adds the copy keyword, which is not present in numpy 1.0.
+# asarray() is different enough between numpy, cupy, and dask, the logic
+# complicated enough that it's easier to define it separately for each module
+# rather than trying to combine everything into one function in common/
+def asarray(
+    obj: Union[
+        ndarray,
+        bool,
+        int,
+        float,
+        NestedSequence[bool | int | float],
+        SupportsBufferProtocol,
+    ],
+    /,
+    *,
+    dtype: Optional[Dtype] = None,
+    device: Optional[Device] = None,
+    copy: "Optional[Union[bool, np._CopyMode]]" = None,
+    **kwargs,
+) -> ndarray:
+    """
+    Array API compatibility wrapper for asarray().
+
+    See the corresponding documentation in the array library and/or the array API
+    specification for more details.
+    """
+    if device not in ["cpu", None]:
+        raise ValueError(f"Unsupported device for NumPy: {device!r}")
+
+    if hasattr(np, '_CopyMode'):
+        if copy is None:
+            copy = np._CopyMode.IF_NEEDED
+        elif copy is False:
+            copy = np._CopyMode.NEVER
+        elif copy is True:
+            copy = np._CopyMode.ALWAYS
+    else:
+        # Not present in older NumPys. In this case, we cannot really support
+        # copy=False.
+        if copy is False:
+            raise NotImplementedError("asarray(copy=False) requires a newer version of NumPy.")
+
+    return np.array(obj, copy=copy, dtype=dtype, **kwargs)
+
 # 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'):
@@ -73,7 +123,7 @@ if hasattr(np, 'isdtype'):
 else:
     isdtype = get_xp(np)(_aliases.isdtype)
 
-__all__ = _aliases.__all__ + ['asarray', 'asarray_numpy', 'bool', 'acos',
+__all__ = _aliases.__all__ + ['asarray', 'bool', 'acos',
                               'acosh', 'asin', 'asinh', 'atan', 'atan2',
                               'atanh', 'bitwise_left_shift', 'bitwise_invert',
                               'bitwise_right_shift', 'concat', 'pow']

{array_api_compat-1.5.1 → array_api_compat-1.6}/array_api_compat.egg-info/PKG-INFO

@@ -1,24 +1,28 @@
 Metadata-Version: 2.1
 Name: array_api_compat
-Version: 1.5.1
+Version: 1.6
 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
 License: MIT
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: numpy
 Requires-Dist: numpy; extra == "numpy"
 Provides-Extra: cupy
 Requires-Dist: cupy; extra == "cupy"
+Provides-Extra: jax
+Requires-Dist: jax; extra == "jax"
+Provides-Extra: pytorch
+Requires-Dist: pytorch; extra == "pytorch"
+Provides-Extra: dask
+Requires-Dist: dask; extra == "dask"
 
 # Array API compatibility library
 

{array_api_compat-1.5.1 → array_api_compat-1.6}/array_api_compat.egg-info/SOURCES.txt

@@ -36,4 +36,5 @@ tests/test_all.py
 tests/test_array_namespace.py
 tests/test_common.py
 tests/test_isdtype.py
+tests/test_no_dependencies.py
 tests/test_vendoring.py

array_api_compat-1.6/array_api_compat.egg-info/requires.txt

@@ -0,0 +1,15 @@
+
+[cupy]
+cupy
+
+[dask]
+dask
+
+[jax]
+jax
+
+[numpy]
+numpy
+
+[pytorch]
+pytorch

{array_api_compat-1.5.1 → array_api_compat-1.6}/setup.py

@@ -15,14 +15,15 @@ setup(
     long_description_content_type="text/markdown",
     url="https://data-apis.org/array-api-compat/",
     license="MIT",
-    python_requires=">=3.8",
     extras_require={
         "numpy": "numpy",
         "cupy": "cupy",
+        "jax": "jax",
+        "pytorch": "pytorch",
+        "dask": "dask",
     },
     classifiers=[
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",

{array_api_compat-1.5.1 → array_api_compat-1.6}/tests/test_all.py

@@ -12,11 +12,11 @@ used inside of a function. Note that names starting with an underscore are autom
 
 import sys
 
-from ._helpers import import_
+from ._helpers import import_, wrapped_libraries
 
 import pytest
 
-@pytest.mark.parametrize("library", ["common", "cupy", "numpy", "torch", "dask.array"])
+@pytest.mark.parametrize("library", ["common"] + wrapped_libraries)
 def test_all(library):
     import_(library, wrapper=True)
 

{array_api_compat-1.5.1 → array_api_compat-1.6}/tests/test_array_namespace.py

@@ -9,24 +9,29 @@ import torch
 import array_api_compat
 from array_api_compat import array_namespace
 
-from ._helpers import import_
+from ._helpers import import_, all_libraries, wrapped_libraries
 
-@pytest.mark.parametrize("library", ["cupy", "numpy", "torch", "dask.array", "jax.numpy"])
-@pytest.mark.parametrize("api_version", [None, "2021.12"])
-def test_array_namespace(library, api_version):
+@pytest.mark.parametrize("use_compat", [True, False, None])
+@pytest.mark.parametrize("api_version", [None, "2021.12", "2022.12"])
+@pytest.mark.parametrize("library", all_libraries + ['array_api_strict'])
+def test_array_namespace(library, api_version, use_compat):
     xp = import_(library)
 
     array = xp.asarray([1.0, 2.0, 3.0])
-    namespace = array_api_compat.array_namespace(array, api_version=api_version)
+    if use_compat is True and library in ['array_api_strict', 'jax.numpy']:
+        pytest.raises(ValueError, lambda: array_namespace(array, use_compat=use_compat))
+        return
+    namespace = array_api_compat.array_namespace(array, api_version=api_version, use_compat=use_compat)
 
-    if "array_api" in library:
-        assert namespace == xp
+    if use_compat is False or use_compat is None and library not in wrapped_libraries:
+        if library == "jax.numpy" and use_compat is None:
+            import jax.experimental.array_api
+            assert namespace == jax.experimental.array_api
+        else:
+            assert namespace == xp
     else:
         if library == "dask.array":
             assert namespace == array_api_compat.dask.array
-        elif library == "jax.numpy":
-            import jax.experimental.array_api
-            assert namespace == jax.experimental.array_api
         else:
             assert namespace == getattr(array_api_compat, library)
 
@@ -64,14 +69,14 @@ def test_array_namespace_errors_torch():
     pytest.raises(TypeError, lambda: array_namespace(x, y))
 
 def test_api_version():
-    x = np.asarray([1, 2])
-    np_ = import_("numpy", wrapper=True)
-    assert array_namespace(x, api_version="2022.12") == np_
-    assert array_namespace(x, api_version=None) == np_
-    assert array_namespace(x) == np_
+    x = torch.asarray([1, 2])
+    torch_ = import_("torch", wrapper=True)
+    assert array_namespace(x, api_version="2022.12") == torch_
+    assert array_namespace(x, api_version=None) == torch_
+    assert array_namespace(x) == torch_
     # Should issue a warning
     with warnings.catch_warnings(record=True) as w:
-        assert array_namespace(x, api_version="2021.12") == np_
+        assert array_namespace(x, api_version="2021.12") == torch_
         assert len(w) == 1
         assert "2021.12" in str(w[0].message)
 

array_api_compat-1.6/tests/test_common.py

@@ -0,0 +1,184 @@
+from array_api_compat import (is_numpy_array, is_cupy_array, is_torch_array, # noqa: F401
+                              is_dask_array, is_jax_array)
+
+from array_api_compat import is_array_api_obj, device, to_device
+
+from ._helpers import import_, wrapped_libraries, all_libraries
+
+import pytest
+import numpy as np
+import array
+from numpy.testing import assert_allclose
+
+is_functions = {
+    'numpy': 'is_numpy_array',
+    'cupy': 'is_cupy_array',
+    'torch': 'is_torch_array',
+    'dask.array': 'is_dask_array',
+    'jax.numpy': 'is_jax_array',
+}
+
+@pytest.mark.parametrize('library', is_functions.keys())
+@pytest.mark.parametrize('func', is_functions.values())
+def test_is_xp_array(library, func):
+    lib = import_(library)
+    is_func = globals()[func]
+
+    x = lib.asarray([1, 2, 3])
+
+    assert is_func(x) == (func == is_functions[library])
+
+    assert is_array_api_obj(x)
+
+@pytest.mark.parametrize("library", all_libraries)
+def test_device(library):
+    xp = import_(library, wrapper=True)
+
+    # We can't test much for device() and to_device() other than that
+    # x.to_device(x.device) works.
+
+    x = xp.asarray([1, 2, 3])
+    dev = device(x)
+
+    x2 = to_device(x, dev)
+    assert device(x) == device(x2)
+
+
+@pytest.mark.parametrize("library", wrapped_libraries)
+def test_to_device_host(library):
+    # different libraries have different semantics
+    # for DtoH transfers; ensure that we support a portable
+    # shim for common array libs
+    # see: https://github.com/scipy/scipy/issues/18286#issuecomment-1527552919
+    xp = import_(library, wrapper=True)
+
+    expected = np.array([1, 2, 3])
+    x = xp.asarray([1, 2, 3])
+    x = to_device(x, "cpu")
+    # torch will return a genuine Device object, but
+    # the other libs will do something different with
+    # a `device(x)` query; however, what's really important
+    # here is that we can test portably after calling
+    # to_device(x, "cpu") to return to host
+    assert_allclose(x, expected)
+
+
+@pytest.mark.parametrize("target_library", is_functions.keys())
+@pytest.mark.parametrize("source_library", is_functions.keys())
+def test_asarray_cross_library(source_library, target_library, request):
+    if source_library == "dask.array" and target_library == "torch":
+        # Allow rest of test to execute instead of immediately xfailing
+        # xref https://github.com/pandas-dev/pandas/issues/38902
+
+        # TODO: remove xfail once
+        # https://github.com/dask/dask/issues/8260 is resolved
+        request.node.add_marker(pytest.mark.xfail(reason="Bug in dask raising error on conversion"))
+    if source_library == "cupy" and target_library != "cupy":
+        # cupy explicitly disallows implicit conversions to CPU
+        pytest.skip(reason="cupy does not support implicit conversion to CPU")
+    src_lib = import_(source_library, wrapper=True)
+    tgt_lib = import_(target_library, wrapper=True)
+    is_tgt_type = globals()[is_functions[target_library]]
+
+    a = src_lib.asarray([1, 2, 3])
+    b = tgt_lib.asarray(a)
+
+    assert is_tgt_type(b), f"Expected {b} to be a {tgt_lib.ndarray}, but was {type(b)}"
+
+@pytest.mark.parametrize("library", wrapped_libraries)
+def test_asarray_copy(library):
+    # Note, we have this test here because the test suite currently doesn't
+    # test the copy flag to asarray() very rigorously. Once
+    # https://github.com/data-apis/array-api-tests/issues/241 is fixed we
+    # should be able to delete this.
+    xp = import_(library, wrapper=True)
+    asarray = xp.asarray
+    is_lib_func = globals()[is_functions[library]]
+    all = xp.all if library != 'dask.array' else lambda x: xp.all(x).compute()
+
+    if library == 'numpy' and xp.__version__[0] < '2' and not hasattr(xp, '_CopyMode') :
+        supports_copy_false = False
+    elif library in ['cupy', 'dask.array']:
+        supports_copy_false = False
+    else:
+        supports_copy_false = True
+
+    a = asarray([1])
+    b = asarray(a, copy=True)
+    assert is_lib_func(b)
+    a[0] = 0
+    assert all(b[0] == 1)
+    assert all(a[0] == 0)
+
+    a = asarray([1])
+    if supports_copy_false:
+        b = asarray(a, copy=False)
+        assert is_lib_func(b)
+        a[0] = 0
+        assert all(b[0] == 0)
+    else:
+        pytest.raises(NotImplementedError, lambda: asarray(a, copy=False))
+
+    a = asarray([1])
+    if supports_copy_false:
+        pytest.raises(ValueError, lambda: asarray(a, copy=False,
+                                                  dtype=xp.float64))
+    else:
+        pytest.raises(NotImplementedError, lambda: asarray(a, copy=False, dtype=xp.float64))
+
+    a = asarray([1])
+    b = asarray(a, copy=None)
+    assert is_lib_func(b)
+    a[0] = 0
+    assert all(b[0] == 0)
+
+    a = asarray([1.0], dtype=xp.float32)
+    assert a.dtype == xp.float32
+    b = asarray(a, dtype=xp.float64, copy=None)
+    assert is_lib_func(b)
+    assert b.dtype == xp.float64
+    a[0] = 0.0
+    assert all(b[0] == 1.0)
+
+    a = asarray([1.0], dtype=xp.float64)
+    assert a.dtype == xp.float64
+    b = asarray(a, dtype=xp.float64, copy=None)
+    assert is_lib_func(b)
+    assert b.dtype == xp.float64
+    a[0] = 0.0
+    assert all(b[0] == 0.0)
+
+    # Python built-in types
+    for obj in [True, 0, 0.0, 0j, [0], [[0]]]:
+        asarray(obj, copy=True) # No error
+        asarray(obj, copy=None) # No error
+        if supports_copy_false:
+            pytest.raises(ValueError, lambda: asarray(obj, copy=False))
+        else:
+            pytest.raises(NotImplementedError, lambda: asarray(obj, copy=False))
+
+    # Use the standard library array to test the buffer protocol
+    a = array.array('f', [1.0])
+    b = asarray(a, copy=True)
+    assert is_lib_func(b)
+    a[0] = 0.0
+    assert all(b[0] == 1.0)
+
+    a = array.array('f', [1.0])
+    if supports_copy_false:
+        b = asarray(a, copy=False)
+        assert is_lib_func(b)
+        a[0] = 0.0
+        assert all(b[0] == 0.0)
+    else:
+        pytest.raises(NotImplementedError, lambda: asarray(a, copy=False))
+
+    a = array.array('f', [1.0])
+    b = asarray(a, copy=None)
+    assert is_lib_func(b)
+    a[0] = 0.0
+    if library == 'cupy':
+        # A copy is required for libraries where the default device is not CPU
+        assert all(b[0] == 1.0)
+    else:
+        assert all(b[0] == 0.0)

{array_api_compat-1.5.1 → array_api_compat-1.6}/tests/test_isdtype.py

@@ -5,7 +5,7 @@ non-spec dtypes
 
 import pytest
 
-from ._helpers import import_
+from ._helpers import import_, wrapped_libraries
 
 # Check the known dtypes by their string names
 
@@ -64,7 +64,7 @@ def isdtype_(dtype_, kind):
     assert type(res) is bool #  noqa: E721
     return res
 
-@pytest.mark.parametrize("library", ["cupy", "numpy", "torch", "dask.array", "jax.numpy"])
+@pytest.mark.parametrize("library", wrapped_libraries)
 def test_isdtype_spec_dtypes(library):
     xp = import_(library, wrapper=True)
 
@@ -98,7 +98,7 @@ additional_dtypes = [
     'bfloat16',
 ]
 
-@pytest.mark.parametrize("library", ["cupy", "numpy", "torch", "dask.array", "jax.numpy"])
+@pytest.mark.parametrize("library", wrapped_libraries)
 @pytest.mark.parametrize("dtype_", additional_dtypes)
 def test_isdtype_additional_dtypes(library, dtype_):
     xp = import_(library, wrapper=True)

array_api_compat-1.6/tests/test_no_dependencies.py

@@ -0,0 +1,73 @@
+"""
+Test that array_api_compat has no "hard" dependencies.
+
+Libraries like NumPy should only be imported if a numpy array is passed to
+array_namespace or if array_api_compat.numpy is explicitly imported.
+
+We have to test this in a subprocess because these libraries have already been
+imported from the other tests.
+"""
+
+import sys
+import subprocess
+
+import pytest
+
+class Array:
+    # Dummy array namespace that doesn't depend on any array library
+    def __array_namespace__(self, api_version=None):
+        class Namespace:
+            pass
+        return Namespace()
+
+def _test_dependency(mod):
+    assert mod not in sys.modules
+
+    # Run various functions that shouldn't depend on mod and check that they
+    # don't import it.
+
+    import array_api_compat
+    assert mod not in sys.modules
+
+    a = Array()
+
+    # array-api-strict is an example of an array API library that isn't
+    # wrapped by array-api-compat.
+    if "strict" not in mod:
+        is_mod_array = getattr(array_api_compat, f"is_{mod.split('.')[0]}_array")
+        assert not is_mod_array(a)
+        assert mod not in sys.modules
+
+    is_array_api_obj = getattr(array_api_compat, "is_array_api_obj")
+    assert is_array_api_obj(a)
+    assert mod not in sys.modules
+
+    array_namespace = getattr(array_api_compat, "array_namespace")
+    array_namespace(Array())
+    assert mod not in sys.modules
+
+# TODO: Test that wrapper for library X doesn't depend on wrappers for library
+# Y (except most array libraries actually do themselves depend on numpy).
+
+@pytest.mark.parametrize("library", ["cupy", "numpy", "torch", "dask.array",
+                                     "jax.numpy", "array_api_strict"])
+def test_numpy_dependency(library):
+    # This import is here because it imports numpy
+    from ._helpers import import_
+
+    # This unfortunately won't go through any of the pytest machinery. We
+    # reraise the exception as an AssertionError so that pytest will show it
+    # in a semi-reasonable way
+
+    # Import (in this process) to make sure 'library' is actually installed and
+    # so that cupy can be skipped.
+    import_(library)
+
+    try:
+        subprocess.run([sys.executable, '-c', f'''\
+from tests.test_no_dependencies import _test_dependency
+
+_test_dependency({library!r})'''], check=True, capture_output=True, encoding='utf-8')
+    except subprocess.CalledProcessError as e:
+        print(e.stdout, end='')
+        raise AssertionError(e.stderr)

array_api_compat-1.5.1/array_api_compat.egg-info/requires.txt

@@ -1,6 +0,0 @@
-
-[cupy]
-cupy
-
-[numpy]
-numpy

array_api_compat-1.5.1/tests/test_common.py

@@ -1,85 +0,0 @@
-from array_api_compat import (is_numpy_array, is_cupy_array, is_torch_array, # noqa: F401
-                              is_dask_array, is_jax_array)
-
-from array_api_compat import is_array_api_obj, device, to_device
-
-from ._helpers import import_
-
-import pytest
-import numpy as np
-from numpy.testing import assert_allclose
-
-is_functions = {
-    'numpy': 'is_numpy_array',
-    'cupy': 'is_cupy_array',
-    'torch': 'is_torch_array',
-    'dask.array': 'is_dask_array',
-    'jax.numpy': 'is_jax_array',
-}
-
-@pytest.mark.parametrize('library', is_functions.keys())
-@pytest.mark.parametrize('func', is_functions.values())
-def test_is_xp_array(library, func):
-    lib = import_(library)
-    is_func = globals()[func]
-
-    x = lib.asarray([1, 2, 3])
-
-    assert is_func(x) == (func == is_functions[library])
-
-    assert is_array_api_obj(x)
-
-@pytest.mark.parametrize("library", ["cupy", "numpy", "torch", "dask.array", "jax.numpy"])
-def test_device(library):
-    xp = import_(library, wrapper=True)
-
-    # We can't test much for device() and to_device() other than that
-    # x.to_device(x.device) works.
-
-    x = xp.asarray([1, 2, 3])
-    dev = device(x)
-
-    x2 = to_device(x, dev)
-    assert device(x) == device(x2)
-
-
-@pytest.mark.parametrize("library", ["cupy", "numpy", "torch", "dask.array"])
-def test_to_device_host(library):
-    # different libraries have different semantics
-    # for DtoH transfers; ensure that we support a portable
-    # shim for common array libs
-    # see: https://github.com/scipy/scipy/issues/18286#issuecomment-1527552919
-    xp = import_(library, wrapper=True)
-
-    expected = np.array([1, 2, 3])
-    x = xp.asarray([1, 2, 3])
-    x = to_device(x, "cpu")
-    # torch will return a genuine Device object, but
-    # the other libs will do something different with
-    # a `device(x)` query; however, what's really important
-    # here is that we can test portably after calling
-    # to_device(x, "cpu") to return to host
-    assert_allclose(x, expected)
-
-
-@pytest.mark.parametrize("target_library", is_functions.keys())
-@pytest.mark.parametrize("source_library", is_functions.keys())
-def test_asarray(source_library, target_library, request):
-    if source_library == "dask.array" and target_library == "torch":
-        # Allow rest of test to execute instead of immediately xfailing
-        # xref https://github.com/pandas-dev/pandas/issues/38902
-
-        # TODO: remove xfail once
-        # https://github.com/dask/dask/issues/8260 is resolved
-        request.node.add_marker(pytest.mark.xfail(reason="Bug in dask raising error on conversion"))
-    if source_library == "cupy" and target_library != "cupy":
-        # cupy explicitly disallows implicit conversions to CPU
-        pytest.skip(reason="cupy does not support implicit conversion to CPU")
-    src_lib = import_(source_library, wrapper=True)
-    tgt_lib = import_(target_library, wrapper=True)
-    is_tgt_type = globals()[is_functions[target_library]]
-
-    a = src_lib.asarray([1, 2, 3])
-    b = tgt_lib.asarray(a)
-
-    assert is_tgt_type(b), f"Expected {b} to be a {tgt_lib.ndarray}, but was {type(b)}"