Raise TypeError in dpnp.ndarray.__array__ (#2260)

The PR implements `dpnp.ndarray.__array__` method that raises
`TypeError` to disallow implicit conversion of `dpnp.ndarray` to
`numpy.ndarray`.
While explicit conversion using `dpnp.ndarray.asnumpy` method is
advised.

Disallowing implicit conversion prevents `numpy.asarray(dpnp_arr)` from
creating an array of 0D `dpnp.ndarray` instances, because
using it is very costly due to multitude of short-array transfers from
GPU to host.

Author: antonwolfy

dpnp/dpnp_array.py

@@ -185,7 +185,12 @@ def __and__(self, other):
         """Return ``self&value``."""
         return dpnp.bitwise_and(self, other)
 
-    # '__array__',
+    def __array__(self, dtype=None, /, *, copy=None):
+        raise TypeError(
+            "Implicit conversion to a NumPy array is not allowed. "
+            "Please use `.asnumpy()` to construct a NumPy array explicitly."
+        )
+
     # '__array_finalize__',
     # '__array_function__',
     # '__array_interface__',

dpnp/dpnp_iface_linearalgebra.py

@@ -548,6 +548,12 @@ def einsum_path(*operands, optimize="greedy", einsum_call=False):
 
     """
 
+    # explicit casting to numpy array if applicable
+    operands = [
+        dpnp.asnumpy(x) if dpnp.is_supported_array_type(x) else x
+        for x in operands
+    ]
+
     return numpy.einsum_path(
         *operands,
         optimize=optimize,

dpnp/dpnp_iface_manipulation.py

@@ -3207,10 +3207,14 @@ def roll(x, shift, axis=None):
            [3, 4, 0, 1, 2]])
 
     """
-    if axis is None:
-        return roll(x.reshape(-1), shift, 0).reshape(x.shape)
 
     usm_x = dpnp.get_usm_ndarray(x)
+    if dpnp.is_supported_array_type(shift):
+        shift = dpnp.asnumpy(shift)
+
+    if axis is None:
+        return roll(dpt.reshape(usm_x, -1), shift, 0).reshape(x.shape)
+
     usm_res = dpt.roll(usm_x, shift=shift, axis=axis)
     return dpnp_array._create_from_usm_ndarray(usm_res)
 

dpnp/dpnp_utils/dpnp_utils_pad.py

@@ -74,7 +74,12 @@ def _as_pairs(x, ndim, as_index=False):
             x = round(x)
         return ((x, x),) * ndim
 
-    x = numpy.array(x)
+    # explicitly cast input "x" to NumPy array
+    if dpnp.is_supported_array_type(x):
+        x = dpnp.asnumpy(x)
+    else:
+        x = numpy.array(x)
+
     if as_index:
         x = numpy.asarray(numpy.round(x), dtype=numpy.intp)
 

dpnp/tests/__init__.py

@@ -3,5 +3,7 @@
 from . import testing
 
 numpy.testing.assert_allclose = testing.assert_allclose
+numpy.testing.assert_almost_equal = testing.assert_almost_equal
+numpy.testing.assert_array_almost_equal = testing.assert_array_almost_equal
 numpy.testing.assert_array_equal = testing.assert_array_equal
 numpy.testing.assert_equal = testing.assert_equal

dpnp/tests/test_indexing.py

@@ -17,7 +17,12 @@
 import dpnp
 from dpnp.dpnp_array import dpnp_array
 
-from .helper import get_all_dtypes, get_integer_dtypes, has_support_aspect64
+from .helper import (
+    get_all_dtypes,
+    get_array,
+    get_integer_dtypes,
+    has_support_aspect64,
+)
 from .third_party.cupy import testing
 
 
@@ -441,16 +446,15 @@ class TestPut:
     )
     @pytest.mark.parametrize("ind_dt", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize(
-        "vals",
+        "ivals",
         [0, [1, 2], (2, 2), dpnp.array([1, 2])],
         ids=["0", "[1, 2]", "(2, 2)", "dpnp.array([1,2])"],
     )
     @pytest.mark.parametrize("mode", ["clip", "wrap"])
-    def test_input_1d(self, a_dt, indices, ind_dt, vals, mode):
+    def test_input_1d(self, a_dt, indices, ind_dt, ivals, mode):
         a = numpy.array([-2, -1, 0, 1, 2], dtype=a_dt)
-        b = numpy.copy(a)
-        ia = dpnp.array(a)
-        ib = dpnp.array(b)
+        b, vals = numpy.copy(a), get_array(numpy, ivals)
+        ia, ib = dpnp.array(a), dpnp.array(b)
 
         ind = numpy.array(indices, dtype=ind_dt)
         if ind_dt == dpnp.bool and ind.all():
@@ -459,18 +463,18 @@ def test_input_1d(self, a_dt, indices, ind_dt, vals, mode):
 
         if numpy.can_cast(ind_dt, numpy.intp, casting="safe"):
             numpy.put(a, ind, vals, mode=mode)
-            dpnp.put(ia, iind, vals, mode=mode)
+            dpnp.put(ia, iind, ivals, mode=mode)
             assert_array_equal(ia, a)
 
             b.put(ind, vals, mode=mode)
-            ib.put(iind, vals, mode=mode)
+            ib.put(iind, ivals, mode=mode)
             assert_array_equal(ib, b)
         else:
             assert_raises(TypeError, numpy.put, a, ind, vals, mode=mode)
-            assert_raises(TypeError, dpnp.put, ia, iind, vals, mode=mode)
+            assert_raises(TypeError, dpnp.put, ia, iind, ivals, mode=mode)
 
             assert_raises(TypeError, b.put, ind, vals, mode=mode)
-            assert_raises(TypeError, ib.put, iind, vals, mode=mode)
+            assert_raises(TypeError, ib.put, iind, ivals, mode=mode)
 
     @pytest.mark.parametrize("a_dt", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize(
@@ -637,7 +641,7 @@ def test_values(self, arr_dt, idx_dt, ndim, values):
         ia, iind = dpnp.array(a), dpnp.array(ind)
 
         for axis in range(ndim):
-            numpy.put_along_axis(a, ind, values, axis)
+            numpy.put_along_axis(a, ind, get_array(numpy, values), axis)
             dpnp.put_along_axis(ia, iind, values, axis)
             assert_array_equal(ia, a)
 

dpnp/tests/test_random_state.py

@@ -15,7 +15,7 @@
 from dpnp.dpnp_array import dpnp_array
 from dpnp.random import RandomState
 
-from .helper import is_cpu_device
+from .helper import get_array, is_cpu_device
 
 # aspects of default device:
 _def_device = dpctl.SyclQueue().sycl_device
@@ -224,7 +224,7 @@ def test_fallback(self, loc, scale):
         # dpnp accepts only scalar as low and/or high, in other cases it will be a fallback to numpy
         actual = data.asnumpy()
         expected = numpy.random.RandomState(seed).normal(
-            loc=loc, scale=scale, size=size
+            loc=get_array(numpy, loc), scale=get_array(numpy, scale), size=size
         )
 
         dtype = get_default_floating()
@@ -557,7 +557,7 @@ def test_bounds_fallback(self, low, high):
             RandomState(seed).randint(low=low, high=high, size=size).asnumpy()
         )
         expected = numpy.random.RandomState(seed).randint(
-            low=low, high=high, size=size
+            low=get_array(numpy, low), high=get_array(numpy, high), size=size
         )
         assert_equal(actual, expected)
 
@@ -1139,7 +1139,7 @@ def test_fallback(self, low, high):
         # dpnp accepts only scalar as low and/or high, in other cases it will be a fallback to numpy
         actual = data.asnumpy()
         expected = numpy.random.RandomState(seed).uniform(
-            low=low, high=high, size=size
+            low=get_array(numpy, low), high=get_array(numpy, high), size=size
         )
 
         dtype = get_default_floating()

dpnp/tests/test_search.py

@@ -272,7 +272,7 @@ def test_ndim(self):
         assert_array_equal(np_res, dpnp_res)
 
         np_res = numpy.where(c, a.T, b.T)
-        dpnp_res = numpy.where(ic, ia.T, ib.T)
+        dpnp_res = dpnp.where(ic, ia.T, ib.T)
         assert_array_equal(np_res, dpnp_res)
 
     def test_dtype_mix(self):

dpnp/tests/testing/__init__.py

@@ -1,5 +1,7 @@
 from .array import (
     assert_allclose,
+    assert_almost_equal,
+    assert_array_almost_equal,
     assert_array_equal,
     assert_equal,
 )

dpnp/tests/testing/array.py

@@ -29,6 +29,8 @@
 from dpnp.dpnp_utils import convert_item
 
 assert_allclose_orig = numpy.testing.assert_allclose
+assert_almost_equal_orig = numpy.testing.assert_almost_equal
+assert_array_almost_equal_orig = numpy.testing.assert_array_almost_equal
 assert_array_equal_orig = numpy.testing.assert_array_equal
 assert_equal_orig = numpy.testing.assert_equal
 
@@ -44,6 +46,14 @@ def assert_allclose(result, expected, *args, **kwargs):
     _assert(assert_allclose_orig, result, expected, *args, **kwargs)
 
 
+def assert_almost_equal(result, expected, *args, **kwargs):
+    _assert(assert_almost_equal_orig, result, expected, *args, **kwargs)
+
+
+def assert_array_almost_equal(result, expected, *args, **kwargs):
+    _assert(assert_array_almost_equal_orig, result, expected, *args, **kwargs)
+
+
 def assert_array_equal(result, expected, *args, **kwargs):
     _assert(assert_array_equal_orig, result, expected, *args, **kwargs)