address review comments

Author: ndgrigorian

dpnp/dpnp_iface_logic.py

@@ -1171,6 +1171,8 @@ def isin(
     test_elements,
     assume_unique=False,  # pylint: disable=unused-argument
     invert=False,
+    *,
+    kind=None,  # pylint: disable=unused-argument
 ):
     """
     Calculates ``element in test_elements``, broadcasting over `element` only.
@@ -1190,22 +1192,27 @@ def isin(
     assume_unique : bool, optional
         Ignored, as no performance benefit is gained by assuming the
         input arrays are unique. Included for compatibility with NumPy.
+
         Default: ``False``.
     invert : bool, optional
         If ``True``, the values in the returned array are inverted, as if
-        calculating `element not in test_elements`.
+        calculating ``element not in test_elements``.
         ``dpnp.isin(a, b, invert=True)`` is equivalent to (but faster
         than) ``dpnp.invert(dpnp.isin(a, b))``.
+
         Default: ``False``.
+    kind : {None, "sort"}, optional
+        Ignored, as the only algorithm implemented is ``"sort"``. Included for
+        compatibility with NumPy.
 
+        Default: ``None``.
 
     Returns
     -------
     isin : dpnp.ndarray of bool dtype
         Has the same shape as `element`. The values `element[isin]`
         are in `test_elements`.
 
-
     Examples
     --------
     >>> import dpnp as np
@@ -1238,14 +1245,32 @@ def isin(
     """
 
     dpnp.check_supported_arrays_type(element, test_elements, scalar_type=True)
-    usm_element = dpnp.as_usm_ndarray(
-        element, usm_type=element.usm_type, sycl_queue=element.sycl_queue
-    )
-    usm_test = dpnp.as_usm_ndarray(
-        test_elements,
-        usm_type=test_elements.usm_type,
-        sycl_queue=test_elements.sycl_queue,
-    )
+    if dpnp.isscalar(element):
+        usm_element = dpnp.as_usm_ndarray(
+            element,
+            usm_type=test_elements.usm_type,
+            sycl_queue=test_elements.sycl_queue,
+        )
+        usm_test = dpnp.get_usm_ndarray(test_elements)
+    elif dpnp.isscalar(test_elements):
+        usm_test = dpnp.as_usm_ndarray(
+            test_elements,
+            usm_type=element.usm_type,
+            sycl_queue=element.sycl_queue,
+        )
+        usm_element = dpnp.get_usm_ndarray(element)
+    else:
+        if (
+            dpu.get_execution_queue(
+                (element.sycl_queue, test_elements.sycl_queue)
+            )
+            is None
+        ):
+            raise dpu.ExecutionPlacementError(
+                "Input arrays have incompatible allocation queues"
+            )
+        usm_element = dpnp.get_usm_ndarray(element)
+        usm_test = dpnp.get_usm_ndarray(test_elements)
     return dpnp.get_result_array(
         dpt.isin(
             usm_element,

dpnp/tests/test_logic.py

@@ -797,98 +797,95 @@ def test_array_equal_nan(a):
     assert_equal(result, expected)
 
 
-@pytest.mark.parametrize(
-    "a",
-    [
-        numpy.array([1, 2, 3, 4]),
-        numpy.array([[1, 2], [3, 4]]),
-    ],
-)
-@pytest.mark.parametrize(
-    "b",
-    [
-        numpy.array([2, 4, 6]),
-        numpy.array([[1, 3], [5, 7]]),
-    ],
-)
-def test_isin_basic(a, b):
-    dp_a = dpnp.array(a)
-    dp_b = dpnp.array(b)
-
-    expected = numpy.isin(a, b)
-    result = dpnp.isin(dp_a, dp_b)
-    assert_equal(result, expected)
-
-
-@pytest.mark.parametrize("dtype", get_all_dtypes())
-def test_isin_dtype(dtype):
-    a = numpy.array([1, 2, 3, 4], dtype=dtype)
-    b = numpy.array([2, 4], dtype=dtype)
-
-    dp_a = dpnp.array(a, dtype=dtype)
-    dp_b = dpnp.array(b, dtype=dtype)
-
-    expected = numpy.isin(a, b)
-    result = dpnp.isin(dp_a, dp_b)
-    assert_equal(result, expected)
-
+class TestIsin:
+    @pytest.mark.parametrize(
+        "a",
+        [
+            numpy.array([1, 2, 3, 4]),
+            numpy.array([[1, 2], [3, 4]]),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "b",
+        [
+            numpy.array([2, 4, 6]),
+            numpy.array([[1, 3], [5, 7]]),
+        ],
+    )
+    def test_isin_basic(self, a, b):
+        dp_a = dpnp.array(a)
+        dp_b = dpnp.array(b)
 
-@pytest.mark.parametrize("sh_a, sh_b", [((3, 1), (1, 4)), ((2, 3, 1), (1, 1))])
-def test_isin_broadcast(sh_a, sh_b):
-    a = numpy.arange(numpy.prod(sh_a)).reshape(sh_a)
-    b = numpy.arange(numpy.prod(sh_b)).reshape(sh_b)
+        expected = numpy.isin(a, b)
+        result = dpnp.isin(dp_a, dp_b)
+        assert_equal(result, expected)
 
-    dp_a = dpnp.array(a)
-    dp_b = dpnp.array(b)
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
+    def test_isin_dtype(self, dtype):
+        a = numpy.array([1, 2, 3, 4], dtype=dtype)
+        b = numpy.array([2, 4], dtype=dtype)
 
-    expected = numpy.isin(a, b)
-    result = dpnp.isin(dp_a, dp_b)
-    assert_equal(result, expected)
+        dp_a = dpnp.array(a, dtype=dtype)
+        dp_b = dpnp.array(b, dtype=dtype)
 
+        expected = numpy.isin(a, b)
+        result = dpnp.isin(dp_a, dp_b)
+        assert_equal(result, expected)
 
-def test_isin_scalar_elements():
-    a = numpy.array([1, 2, 3])
-    b = 2
+    @pytest.mark.parametrize(
+        "sh_a, sh_b", [((3, 1), (1, 4)), ((2, 3, 1), (1, 1))]
+    )
+    def test_isin_broadcast(self, sh_a, sh_b):
+        a = numpy.arange(numpy.prod(sh_a)).reshape(sh_a)
+        b = numpy.arange(numpy.prod(sh_b)).reshape(sh_b)
 
-    dp_a = dpnp.array(a)
-    dp_b = dpnp.array(b)
+        dp_a = dpnp.array(a)
+        dp_b = dpnp.array(b)
 
-    expected = numpy.isin(a, b)
-    result = dpnp.isin(dp_a, dp_b)
-    assert_equal(result, expected)
+        expected = numpy.isin(a, b)
+        result = dpnp.isin(dp_a, dp_b)
+        assert_equal(result, expected)
 
+    def test_isin_scalar_elements(self):
+        a = numpy.array([1, 2, 3])
+        b = 2
 
-def test_isin_scalar_test_elements():
-    a = 2
-    b = numpy.array([1, 2, 3])
+        dp_a = dpnp.array(a)
+        dp_b = dpnp.array(b)
 
-    dp_a = dpnp.array(a)
-    dp_b = dpnp.array(b)
+        expected = numpy.isin(a, b)
+        result = dpnp.isin(dp_a, dp_b)
+        assert_equal(result, expected)
 
-    expected = numpy.isin(a, b)
-    result = dpnp.isin(dp_a, dp_b)
-    assert_equal(result, expected)
+    def test_isin_scalar_test_elements(self):
+        a = 2
+        b = numpy.array([1, 2, 3])
 
+        dp_a = dpnp.array(a)
+        dp_b = dpnp.array(b)
 
-def test_isin_empty():
-    a = numpy.array([], dtype=int)
-    b = numpy.array([1, 2, 3])
+        expected = numpy.isin(a, b)
+        result = dpnp.isin(dp_a, dp_b)
+        assert_equal(result, expected)
 
-    dp_a = dpnp.array(a)
-    dp_b = dpnp.array(b)
+    def test_isin_empty(self):
+        a = numpy.array([], dtype=int)
+        b = numpy.array([1, 2, 3])
 
-    expected = numpy.isin(a, b)
-    result = dpnp.isin(dp_a, dp_b)
-    assert_equal(result, expected)
+        dp_a = dpnp.array(a)
+        dp_b = dpnp.array(b)
 
+        expected = numpy.isin(a, b)
+        result = dpnp.isin(dp_a, dp_b)
+        assert_equal(result, expected)
 
-def test_isin_errors():
-    a = dpnp.arange(5)
-    b = dpnp.arange(3)
+    def test_isin_errors(self):
+        a = dpnp.arange(5)
+        b = dpnp.arange(3)
 
-    # unsupported type for elements or test_elements
-    with pytest.raises(TypeError):
-        dpnp.isin(dict(), b)
+        # unsupported type for elements or test_elements
+        with pytest.raises(TypeError):
+            dpnp.isin(dict(), b)
 
-    with pytest.raises(TypeError):
-        dpnp.isin(a, dict())
+        with pytest.raises(TypeError):
+            dpnp.isin(a, dict())