Move the asarray numpy implementation to numpy/_aliases

This now properly supports all relevant versions of NumPy.

This also removes the asarray_numpy function from the namespace.

I plan to do the same for cupy and dask as well.

Author: asmeurer

array_api_compat/numpy/__init__.py

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

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,65 @@
 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.
+
+    'namespace' may be an array module namespace. This is needed to support
+    conversion of sequences of Python scalars.
+    """
+    if np.__version__[0] >= '2':
+        # NumPy 2.0 asarray() is completely array API compatible. No need for
+        # the complicated logic below
+        return np.asarray(obj, dtype=dtype, device=device, copy=copy, **kwargs)
+
+    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 +131,7 @@
 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']

tests/test_common.py

@@ -93,6 +93,11 @@ def test_asarray_copy(library):
     is_lib_func = globals()[is_functions[library]]
     all = xp.all
 
+    if library == 'numpy' and xp.__version__[0] < '2' and not hasattr(xp, '_CopyMode') :
+        supports_copy_false = False
+    else:
+        supports_copy_false = True
+
     a = asarray([1])
     b = asarray(a, copy=True)
     assert is_lib_func(b)
@@ -101,13 +106,20 @@ def test_asarray_copy(library):
     assert all(a[0] == 0)
 
     a = asarray([1])
-    b = asarray(a, copy=False)
-    assert is_lib_func(b)
-    a[0] = 0
-    assert all(b[0] == 0)
+    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])
-    pytest.raises(ValueError, lambda: asarray(a, copy=False, dtype=xp.float64))
+    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)
@@ -131,7 +143,10 @@ def test_asarray_copy(library):
     for obj in [True, 0, 0.0, 0j, [0], [[0]]]:
         asarray(obj, copy=True) # No error
         asarray(obj, copy=None) # No error
-        pytest.raises(ValueError, lambda: asarray(obj, copy=False))
+        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])
@@ -141,10 +156,13 @@ def test_asarray_copy(library):
     assert all(b[0] == 1.0)
 
     a = array.array('f', [1.0])
-    b = asarray(a, copy=False)
-    assert is_lib_func(b)
-    a[0] = 0.0
-    assert all(b[0] == 0.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)