array-api-strict 2.3__py3-none-any.whl → 2.4__py3-none-any.whl

array_api_strict/tests/test_array_object.py

@@ -1,3 +1,4 @@
+import sys
 import operator
 from builtins import all as all_
 
@@ -5,7 +6,7 @@ from numpy.testing import assert_raises, suppress_warnings
 import numpy as np
 import pytest
 
-from .. import ones, arange, reshape, asarray, result_type, all, equal
+from .. import ones, arange, reshape, asarray, result_type, all, equal, stack
 from .._array_object import Array, CPU_DEVICE, Device
 from .._dtypes import (
     _all_dtypes,
@@ -100,34 +101,71 @@ def test_validate_index():
     assert_raises(IndexError, lambda: a[:])
     assert_raises(IndexError, lambda: a[idx])
 
+class DummyIndex:
+    def __init__(self, x):
+        self.x = x
+    def __index__(self):
+        return self.x
 
-def test_indexing_arrays():
+
+@pytest.mark.parametrize("device", [None, "CPU_DEVICE", "device1", "device2"])
+@pytest.mark.parametrize(
+    "integer_index",
+    [
+        0,
+        np.int8(0),
+        np.uint8(0),
+        np.int16(0),
+        np.uint16(0),
+        np.int32(0),
+        np.uint32(0),
+        np.int64(0),
+        np.uint64(0),
+        DummyIndex(0),
+    ],
+)
+def test_indexing_ints(integer_index, device):
+    # Ensure indexing with different integer types works on all Devices.
+    device = None if device is None else Device(device)
+
+    a = arange(5, device=device)
+    assert a[(integer_index,)] == a[integer_index] == a[0]
+
+
+@pytest.mark.parametrize("device", [None, "CPU_DEVICE", "device1", "device2"])
+def test_indexing_arrays(device):
     # indexing with 1D integer arrays and mixes of integers and 1D integer are allowed
+    device = None if device is None else Device(device)
 
     # 1D array
-    a = arange(5)
-    idx = asarray([1, 0, 1, 2, -1])
+    a = arange(5, device=device)
+    idx = asarray([1, 0, 1, 2, -1], device=device)
     a_idx = a[idx]
 
-    a_idx_loop = asarray([a[idx[i]] for i in range(idx.shape[0])])
+    a_idx_loop = stack([a[idx[i]] for i in range(idx.shape[0])])
     assert all(a_idx == a_idx_loop)
+    assert a_idx.shape == idx.shape
+    assert a.device == idx.device == a_idx.device
 
     # setitem with arrays is not allowed
     with assert_raises(IndexError):
         a[idx] = 42
 
     # mixed array and integer indexing
-    a = reshape(arange(3*4), (3, 4))
-    idx = asarray([1, 0, 1, 2, -1])
+    a = reshape(arange(3*4, device=device), (3, 4))
+    idx = asarray([1, 0, 1, 2, -1], device=device)
     a_idx = a[idx, 1]
-
-    a_idx_loop = asarray([a[idx[i], 1] for i in range(idx.shape[0])])
+    a_idx_loop = stack([a[idx[i], 1] for i in range(idx.shape[0])])
     assert all(a_idx == a_idx_loop)
+    assert a_idx.shape == idx.shape
+    assert a.device == idx.device == a_idx.device
 
     # index with two arrays
     a_idx = a[idx, idx]
-    a_idx_loop = asarray([a[idx[i], idx[i]] for i in range(idx.shape[0])])
+    a_idx_loop = stack([a[idx[i], idx[i]] for i in range(idx.shape[0])])
     assert all(a_idx == a_idx_loop)
+    assert a_idx.shape == a_idx.shape
+    assert a.device == idx.device == a_idx.device
 
     # setitem with arrays is not allowed
     with assert_raises(IndexError):
@@ -135,7 +173,24 @@ def test_indexing_arrays():
 
     # smoke test indexing with ndim > 1 arrays
     idx = idx[..., None]
-    a[idx, idx]
+    a_idx = a[idx, idx]
+    assert a.device == idx.device == a_idx.device
+
+
+def test_indexing_arrays_different_devices():
+    # Ensure indexing via array on different device errors
+    device1 = Device("CPU_DEVICE")
+    device2 = Device("device1")
+
+    a = arange(5, device=device1)
+    idx1 = asarray([1, 0, 1, 2, -1], device=device2)
+    idx2 = asarray([1, 0, 1, 2, -1], device=device1)
+
+    with pytest.raises(ValueError, match="Array indexing is only allowed when"):
+        a[idx1]
+
+    with pytest.raises(ValueError, match="Array indexing is only allowed when"):
+        a[idx1, idx2]
 
 
 def test_promoted_scalar_inherits_device():
@@ -201,30 +256,37 @@ def _check_op_array_scalar(dtypes, a, s, func, func_name, BIG_INT=BIG_INT):
             func(s)
         return False
 
+binary_op_dtypes = {
+    "__add__": "numeric",
+    "__and__": "integer or boolean",
+    "__eq__": "all",
+    "__floordiv__": "real numeric",
+    "__ge__": "real numeric",
+    "__gt__": "real numeric",
+    "__le__": "real numeric",
+    "__lshift__": "integer",
+    "__lt__": "real numeric",
+    "__mod__": "real numeric",
+    "__mul__": "numeric",
+    "__ne__": "all",
+    "__or__": "integer or boolean",
+    "__pow__": "numeric",
+    "__rshift__": "integer",
+    "__sub__": "numeric",
+    "__truediv__": "floating-point",
+    "__xor__": "integer or boolean",
+}
+unary_op_dtypes = {
+    "__abs__": "numeric",
+    "__invert__": "integer or boolean",
+    "__neg__": "numeric",
+    "__pos__": "numeric",
+}
 
 def test_operators():
     # For every operator, we test that it works for the required type
     # combinations and raises TypeError otherwise
-    binary_op_dtypes = {
-        "__add__": "numeric",
-        "__and__": "integer or boolean",
-        "__eq__": "all",
-        "__floordiv__": "real numeric",
-        "__ge__": "real numeric",
-        "__gt__": "real numeric",
-        "__le__": "real numeric",
-        "__lshift__": "integer",
-        "__lt__": "real numeric",
-        "__mod__": "real numeric",
-        "__mul__": "numeric",
-        "__ne__": "all",
-        "__or__": "integer or boolean",
-        "__pow__": "numeric",
-        "__rshift__": "integer",
-        "__sub__": "numeric",
-        "__truediv__": "floating-point",
-        "__xor__": "integer or boolean",
-    }
+
     # Recompute each time because of in-place ops
     def _array_vals():
         for d in _integer_dtypes:
@@ -283,12 +345,6 @@ def test_operators():
                             else:
                                 assert_raises(TypeError, lambda: getattr(x, _op)(y))
 
-    unary_op_dtypes = {
-        "__abs__": "numeric",
-        "__invert__": "integer or boolean",
-        "__neg__": "numeric",
-        "__pos__": "numeric",
-    }
     for op, dtypes in unary_op_dtypes.items():
         for a in _array_vals():
             if (
@@ -356,6 +412,55 @@ def test_operators():
                     x.__imatmul__(y)
 
 
+@pytest.mark.parametrize("op,dtypes", binary_op_dtypes.items())
+def test_binary_operators_numpy_scalars(op, dtypes):
+    """
+    Test that NumPy scalars (np.generic) are explicitly disallowed.
+
+    This must notably include np.float64 and np.complex128, which are
+    subclasses of float and complex respectively, so they need
+    special treatment in order to be rejected.
+    """
+    match = "Expected Array or Python scalar"
+
+    if dtypes not in ("numeric", "integer", "real numeric", "floating-point"):
+        a = asarray(True)
+        func = getattr(a, op)
+        with pytest.raises(TypeError, match=match):
+            func(np.bool_(True))
+
+    if dtypes != "floating-point":
+        a = asarray(1)
+        func = getattr(a, op)
+        with pytest.raises(TypeError, match=match):
+            func(np.int64(1))
+
+    if dtypes not in ("integer", "integer or boolean"):
+        a = asarray(1.,)
+        func = getattr(a, op)
+        with pytest.raises(TypeError, match=match):
+            func(np.float32(1.))
+        with pytest.raises(TypeError, match=match):
+            func(np.float64(1.))
+
+    if dtypes not in ("integer", "integer or boolean", "real numeric"):
+        a = asarray(1.,)
+        func = getattr(a, op)
+        with pytest.raises(TypeError, match=match):
+            func(np.complex64(1.))
+        with pytest.raises(TypeError, match=match):
+            func(np.complex128(1.))
+
+
+@pytest.mark.parametrize("op,dtypes", binary_op_dtypes.items())
+def test_binary_operators_device_mismatch(op, dtypes):
+    dtype = float64 if dtypes == "floating-point" else int64
+    a = asarray(1, dtype=dtype, device=CPU_DEVICE)
+    b = asarray(1, dtype=dtype, device=Device("device1"))
+    with pytest.raises(ValueError, match="different devices"):
+        getattr(a, op)(b)
+
+
 def test_python_scalar_construtors():
     b = asarray(False)
     i = asarray(0)
@@ -422,35 +527,37 @@ def test_array_properties():
     assert b.mT.shape == (3, 2)
 
 
+@pytest.mark.xfail(sys.version_info.major*100 + sys.version_info.minor < 312,
+                   reason="array conversion relies on buffer protocol, and "
+                          "requires python >= 3.12"
+)
 def test_array_conversion():
     # Check that arrays on the CPU device can be converted to NumPy
     # but arrays on other devices can't. Note this is testing the logic in
     # __array__, which is only used in asarray when converting lists of
     # arrays.
     a = ones((2, 3))
-    asarray([a])
+    np.asarray(a)
 
     for device in ("device1", "device2"):
         a = ones((2, 3), device=array_api_strict.Device(device))
-        with pytest.raises(RuntimeError, match="Can not convert array"):
-            asarray([a])
+        with pytest.raises((RuntimeError, ValueError)):
+            np.asarray(a)
+
+    # __buffer__ should work for now for conversion to numpy
+    a = ones((2, 3))
+    na = np.array(a)
+    assert na.shape == (2, 3)
+    assert na.dtype == np.float64
 
-def test__array__():
-    # __array__ should work for now
+@pytest.mark.skipif(not sys.version_info.major*100 + sys.version_info.minor < 312,
+                    reason="conversion to numpy errors out unless python >= 3.12"
+)
+def test_array_conversion_2():
     a = ones((2, 3))
-    np.array(a)
-
-    # Test the _allow_array private global flag for disabling it in the
-    # future.
-    from .. import _array_object
-    original_value = _array_object._allow_array
-    try:
-        _array_object._allow_array = False
-        a = ones((2, 3))
-        with pytest.raises(ValueError, match="Conversion from an array_api_strict array to a NumPy ndarray is not supported"):
-            np.array(a)
-    finally:
-        _array_object._allow_array = original_value
+    with pytest.raises(TypeError):
+        np.array(a)
+
 
 def test_allow_newaxis():
     a = ones(5)
@@ -533,7 +640,7 @@ def test_array_namespace():
     pytest.raises(ValueError, lambda: a.__array_namespace__(api_version="2026.12"))
 
 def test_iter():
-    pytest.raises(TypeError, lambda: iter(asarray(3)))
+    pytest.raises(TypeError, lambda: next(iter(asarray(3))))
     assert list(ones(3)) == [asarray(1.), asarray(1.), asarray(1.)]
     assert all_(isinstance(a, Array) for a in iter(ones(3)))
     assert all_(a.shape == () for a in iter(ones(3)))

array_api_strict/tests/test_creation_functions.py

@@ -22,7 +22,7 @@ from .._creation_functions import (
     zeros,
     zeros_like,
 )
-from .._dtypes import int16, float32, float64
+from .._dtypes import float32, float64
 from .._array_object import Array, CPU_DEVICE, Device
 from .._flags import set_array_api_strict_flags
 
@@ -97,18 +97,20 @@ def test_asarray_copy():
     a[0] = 0
     assert all(b[0] == 0)
 
+
 def test_asarray_list_of_lists():
-    a = asarray(1, dtype=int16)
-    b = asarray([1], dtype=int16)
-    res = asarray([a, a])
-    assert res.shape == (2,)
-    assert res.dtype == int16
-    assert all(res == asarray([1, 1]))
-
-    res = asarray([b, b])
-    assert res.shape == (2, 1)
-    assert res.dtype == int16
-    assert all(res == asarray([[1], [1]]))
+    lst = [[1, 2, 3], [4, 5, 6]]
+    res = asarray(lst)
+    assert res.shape == (2, 3)
+
+
+def test_asarray_nested_arrays():
+    # do not allow arrays in nested sequences
+    with pytest.raises(TypeError):
+        asarray([[1, 2, 3], asarray([4, 5, 6])])
+
+    with pytest.raises(TypeError):
+        asarray([1, asarray(1)])
 
 
 def test_asarray_device_inference():

array_api_strict/tests/test_data_type_functions.py

@@ -1,15 +1,12 @@
 import warnings
 
+import numpy as np
 import pytest
-
 from numpy.testing import assert_raises
-import numpy as np
 
 from .._creation_functions import asarray
-from .._data_type_functions import astype, can_cast, isdtype, result_type
-from .._dtypes import (
-    bool, int8, int16, uint8, float64, int64
-)
+from .._data_type_functions import astype, can_cast, finfo, iinfo, isdtype, result_type
+from .._dtypes import bool, float64, int8, int16, int64, uint8
 from .._flags import set_array_api_strict_flags
 
 
@@ -88,3 +85,40 @@ def test_result_type_py_scalars(api_version):
 
         with pytest.raises(TypeError):
             result_type(int64, True)
+
+
+def test_finfo_iinfo_dtypelike():
+    """np.finfo() and np.iinfo() accept any DTypeLike.
+    Array API only accepts Array | DType.
+    """
+    match = "must be a dtype or array"
+    with pytest.raises(TypeError, match=match):
+        finfo("float64")
+    with pytest.raises(TypeError, match=match):
+        finfo(float)
+    with pytest.raises(TypeError, match=match):
+        iinfo("int8")
+    with pytest.raises(TypeError, match=match):
+        iinfo(int)
+
+
+def test_finfo_iinfo_wrap_output():
+    """Test that the finfo(...).dtype and iinfo(...).dtype
+    are array-api-strict.DType objects; not numpy.dtype.
+    """
+    # Note: array_api_strict.DType objects are not singletons
+    assert finfo(float64).dtype == float64
+    assert iinfo(int8).dtype == int8
+
+
+@pytest.mark.parametrize("func,arg", [(finfo, float64), (iinfo, int8)])
+def test_finfo_iinfo_output_assumptions(func, arg):
+    """There should be no expectation for the output of finfo()/iinfo()
+    to be comparable, hashable, or writeable.
+    """
+    obj = func(arg)
+    assert obj != func(arg)  # Defaut behaviour for custom classes
+    with pytest.raises(TypeError):
+        hash(obj)
+    with pytest.raises(Exception, match="cannot assign"):
+        obj.min = 0

array_api_strict/tests/test_elementwise_functions.py

@@ -1,24 +1,26 @@
 from inspect import signature, getmodule
 
-from pytest import raises as assert_raises
+import numpy as np
+import pytest
 from numpy.testing import suppress_warnings
 
 
 from .. import asarray, _elementwise_functions
+from .._array_object import ALL_DEVICES, CPU_DEVICE, Device
 from .._elementwise_functions import bitwise_left_shift, bitwise_right_shift
 from .._dtypes import (
     _dtype_categories,
     _boolean_dtypes,
     _floating_dtypes,
     _integer_dtypes,
+    bool as xp_bool,
+    float64,
     int8,
     int16,
     int32,
     int64,
     uint64,
 )
-from .._flags import set_array_api_strict_flags
-
 from .test_array_object import _check_op_array_scalar, BIG_INT
 
 import array_api_strict
@@ -104,6 +106,13 @@ elementwise_function_input_types = {
 }
 
 
+elementwise_binary_function_names = [
+    func_name
+    for func_name in elementwise_function_input_types
+    if nargs(getattr(_elementwise_functions, func_name)) == 2
+]
+
+
 def test_nargs():
     # Explicitly check number of arguments for a few functions
     assert nargs(array_api_strict.logaddexp) == 2
@@ -126,33 +135,81 @@ def test_missing_functions():
     assert set(mod_funcs) == set(elementwise_function_input_types)
 
 
-def test_function_device_persists():
-    # Test that the device of the input and output array are the same
+@pytest.mark.parametrize("device", ALL_DEVICES)
+@pytest.mark.parametrize("func_name,types", elementwise_function_input_types.items())
+def test_elementwise_function_device_persists(func_name, types, device):
+    """Test that the device of the input and output array are the same"""
     def _array_vals(dtypes):
-        for d in dtypes:
-            yield asarray(1., dtype=d)
-
-    # Use the latest version of the standard so all functions are included
-    set_array_api_strict_flags(api_version="2024.12")
-
-    for func_name, types in elementwise_function_input_types.items():
-        dtypes = _dtype_categories[types]
-        func = getattr(_elementwise_functions, func_name)
+        for dtype in dtypes:
+            yield asarray(1., dtype=dtype, device=device)
+
+    dtypes = _dtype_categories[types]
+    func = getattr(_elementwise_functions, func_name)
+
+    for x in _array_vals(dtypes):
+        if nargs(func) == 2:
+            # This way we don't have to deal with incompatible
+            # types of the two arguments.
+            r = func(x, x)
+            assert r.device == x.device
+
+        else:
+            # `atanh` needs a slightly different input value from
+            # everyone else
+            if func_name == "atanh":
+                x -= 0.1
+            r = func(x)
+            assert r.device == x.device
+
+
+@pytest.mark.parametrize("func_name", elementwise_binary_function_names)
+def test_elementwise_function_device_mismatch(func_name):
+    func = getattr(_elementwise_functions, func_name)
+    dtypes = elementwise_function_input_types[func_name]
+    if dtypes in ("floating-point", "real floating-point"):
+        dtype = float64
+    elif dtypes == "boolean":
+        dtype = xp_bool
+    else:
+        dtype = int64
+
+    a = asarray(1, dtype=dtype, device=CPU_DEVICE)
+    b = asarray(1, dtype=dtype, device=Device("device1"))
+    _ = func(a, a)
+    with pytest.raises(ValueError, match="different devices"):
+        func(a, b)
+
+
+@pytest.mark.parametrize("func_name", elementwise_function_input_types)
+def test_elementwise_function_numpy_scalars(func_name):
+    """
+    Test that NumPy scalars (np.generic) are explicitly disallowed.
+
+    This must notably include np.float64 and np.complex128, which are
+    subclasses of float and complex respectively, so they need
+    special treatment in order to be rejected.
+    """
+    func = getattr(_elementwise_functions, func_name)
+    dtypes = elementwise_function_input_types[func_name]
+    xp_dtypes = _dtype_categories[dtypes]
+    np_dtypes = [dtype._np_dtype for dtype in xp_dtypes]
+
+    value = 0.5 if func_name == "atanh" else 1
+    for xp_dtype in xp_dtypes:
+        for np_dtype in np_dtypes:
+            a = asarray(value, dtype=xp_dtype, device=CPU_DEVICE)
+            b = np.asarray(value, dtype=np_dtype)[()]
 
-        for x in _array_vals(dtypes):
             if nargs(func) == 2:
-                # This way we don't have to deal with incompatible
-                # types of the two arguments.
-                r = func(x, x)
-                assert r.device == x.device
-
+                _ = func(a, a)
+                with pytest.raises(TypeError, match="neither Array nor Python scalars"):
+                    func(a, b)
+                with pytest.raises(TypeError, match="neither Array nor Python scalars"):
+                    func(b, a)
             else:
-                # `atanh` needs a slightly different input value from
-                # everyone else
-                if func_name == "atanh":
-                    x -= 0.1
-                r = func(x)
-                assert r.device == x.device
+                _ = func(a)
+                with pytest.raises(TypeError, match="allowed"):
+                    func(b)
 
 
 def test_function_types():
@@ -168,9 +225,6 @@ def test_function_types():
         for d in _floating_dtypes:
             yield asarray(1.0, dtype=d)
 
-    # Use the latest version of the standard so all functions are included
-    set_array_api_strict_flags(api_version="2024.12")
-
     for x in _array_vals():
         for func_name, types in elementwise_function_input_types.items():
             dtypes = _dtype_categories[types]
@@ -187,23 +241,23 @@ def test_function_types():
                          or x.dtype in _floating_dtypes and y.dtype not in _floating_dtypes
                          or y.dtype in _floating_dtypes and x.dtype not in _floating_dtypes
                          ):
-                        assert_raises(TypeError, func, x, y)
+                        with pytest.raises(TypeError):
+                            func(x, y)
                     if x.dtype not in dtypes or y.dtype not in dtypes:
-                        assert_raises(TypeError, func, x, y)
+                        with pytest.raises(TypeError):
+                            func(x, y)
             else:
                 if x.dtype not in dtypes:
-                    assert_raises(TypeError, func, x)
+                    with pytest.raises(TypeError):
+                        func(x)
 
 
 def test_bitwise_shift_error():
     # bitwise shift functions should raise when the second argument is negative
-    assert_raises(
-        ValueError, lambda: bitwise_left_shift(asarray([1, 1]), asarray([1, -1]))
-    )
-    assert_raises(
-        ValueError, lambda: bitwise_right_shift(asarray([1, 1]), asarray([1, -1]))
-    )
-
+    with pytest.raises(ValueError):
+        bitwise_left_shift(asarray([1, 1]), asarray([1, -1]))
+    with pytest.raises(ValueError):
+        bitwise_right_shift(asarray([1, 1]), asarray([1, -1]))
 
 
 def test_scalars():
@@ -212,9 +266,6 @@ def test_scalars():
     # Also check that binary functions accept (array, scalar) and (scalar, array)
     # arguments, and reject (scalar, scalar) arguments.
 
-    # Use the latest version of the standard so that scalars are actually allowed
-    set_array_api_strict_flags(api_version="2024.12")
-
     def _array_vals():
         for d in _integer_dtypes:
             yield asarray(1, dtype=d)
@@ -256,7 +307,5 @@ def test_scalars():
                             assert func(s, a) == func(conv_scalar, a)
                             assert func(a, s) == func(a, conv_scalar)
 
-                        with assert_raises(TypeError):
+                        with pytest.raises(TypeError):
                             func(s, s)
-
-