Remove in1d stub from documentation (#2744)

The PR removes TODO implementation stub for `in1d`, because it was
dropped in NumPy 2.4 release and so no plans to add it to dpnp either.

Also this PR refreshes third party tests with recent updates in the
remote repo.

Author: antonwolfy

doc/reference/set.rst

@@ -23,7 +23,6 @@ Boolean operations
    :toctree: generated/
    :nosignatures:
 
-   in1d
    intersect1d
    isin
    setdiff1d

dpnp/tests/third_party/cupy/core_tests/test_elementwise.py

@@ -1,4 +1,4 @@
-import unittest
+from __future__ import annotations
 
 import numpy
 import pytest
@@ -12,7 +12,7 @@
 from dpnp.tests.third_party.cupy import testing
 
 
-class TestElementwise(unittest.TestCase):
+class TestElementwise:
 
     def check_copy(self, dtype, src_id, dst_id):
         with cuda.Device(src_id):
@@ -33,7 +33,7 @@ def test_copy(self, dtype):
     def test_copy_multigpu_nopeer(self, dtype):
         if cuda.runtime.deviceCanAccessPeer(0, 1) == 1:
             pytest.skip("peer access is available")
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             self.check_copy(dtype, 0, 1)
 
     @pytest.mark.skip("elementwise_copy() argument isn't supported")
@@ -74,27 +74,26 @@ def test_copy_orders(self, order):
 
 
 @pytest.mark.skip("`ElementwiseKernel` isn't supported")
-class TestElementwiseInvalidShape(unittest.TestCase):
+class TestElementwiseInvalidShape:
 
     def test_invalid_shape(self):
-        with self.assertRaisesRegex(ValueError, "Out shape is mismatched"):
+        with pytest.raises(ValueError, match="Out shape is mismatched"):
             f = cupy.ElementwiseKernel("T x", "T y", "y += x")
             x = cupy.arange(12).reshape(3, 4)
             y = cupy.arange(4)
             f(x, y)
 
 
 @pytest.mark.skip("`ElementwiseKernel` isn't supported")
-class TestElementwiseInvalidArgument(unittest.TestCase):
+class TestElementwiseInvalidArgument:
 
     def test_invalid_kernel_name(self):
-        with self.assertRaisesRegex(ValueError, "Invalid kernel name"):
+        with pytest.raises(ValueError, match="Invalid kernel name"):
             cupy.ElementwiseKernel("T x", "", "", "1")
 
 
-class TestElementwiseType(unittest.TestCase):
+class TestElementwiseType:
 
-    @testing.with_requires("numpy>=2.0")
     @testing.for_int_dtypes(no_bool=True)
     @testing.numpy_cupy_array_equal(accept_error=OverflowError)
     def test_large_int_upper_1(self, xp, dtype):
@@ -105,14 +104,6 @@ def test_large_int_upper_1(self, xp, dtype):
     @testing.for_int_dtypes(no_bool=True)
     @testing.numpy_cupy_array_equal(accept_error=OverflowError)
     def test_large_int_upper_2(self, xp, dtype):
-        if numpy_version() < "2.0.0":
-            flag = dtype in [xp.int16, xp.int32, xp.int64, xp.longlong]
-            if xp.issubdtype(dtype, xp.unsignedinteger) or flag:
-                pytest.skip("numpy doesn't raise OverflowError")
-
-            if dtype in [xp.int8, xp.intc] and is_win_platform():
-                pytest.skip("numpy promotes dtype differently")
-
         a = xp.array([1], dtype=xp.int8)
         b = xp.iinfo(dtype).max - 1
         return a + b
@@ -121,62 +112,38 @@ def test_large_int_upper_2(self, xp, dtype):
     @testing.numpy_cupy_array_equal()
     def test_large_int_upper_3(self, xp, dtype):
         if (
-            numpy.issubdtype(dtype, numpy.unsignedinteger)
-            and numpy_version() < "2.0.0"
-        ):
-            pytest.skip("numpy promotes dtype differently")
-        elif (
             dtype in (numpy.uint64, numpy.ulonglong)
             and not has_support_aspect64()
         ):
             pytest.skip("no fp64 support")
 
         a = xp.array([xp.iinfo(dtype).max], dtype=dtype)
-        b = numpy.int8(0)
+        b = xp.int8(0)
         return a + b
 
     @testing.for_int_dtypes(no_bool=True)
     @testing.numpy_cupy_array_equal()
     def test_large_int_upper_4(self, xp, dtype):
         if (
-            numpy.issubdtype(dtype, numpy.unsignedinteger)
-            and numpy_version() < "2.0.0"
-        ):
-            pytest.skip("numpy promotes dtype differently")
-        elif (
             dtype in (numpy.uint64, numpy.ulonglong)
             and not has_support_aspect64()
         ):
             pytest.skip("no fp64 support")
 
         a = xp.array([xp.iinfo(dtype).max - 1], dtype=dtype)
-        b = numpy.int8(1)
+        b = xp.int8(1)
         return a + b
 
     @testing.for_int_dtypes(no_bool=True)
     @testing.numpy_cupy_array_equal(accept_error=OverflowError)
     def test_large_int_lower_1(self, xp, dtype):
-        if numpy_version() < "2.0.0":
-            if dtype in [xp.int16, xp.int32, xp.int64, xp.longlong]:
-                pytest.skip("numpy doesn't raise OverflowError")
-
-            if dtype in [xp.int8, xp.intc] and is_win_platform():
-                pytest.skip("numpy promotes dtype differently")
-
         a = xp.array([0], dtype=xp.int8)
         b = xp.iinfo(dtype).min
         return a + b
 
     @testing.for_int_dtypes(no_bool=True)
     @testing.numpy_cupy_array_equal(accept_error=OverflowError)
     def test_large_int_lower_2(self, xp, dtype):
-        if numpy_version() < "2.0.0":
-            if dtype in [xp.int16, xp.int32, xp.int64, xp.longlong]:
-                pytest.skip("numpy doesn't raise OverflowError")
-
-            if dtype in [xp.int8, xp.intc] and is_win_platform():
-                pytest.skip("numpy promotes dtype differently")
-
         a = xp.array([-1], dtype=xp.int8)
         b = xp.iinfo(dtype).min + 1
         return a + b
@@ -185,18 +152,13 @@ def test_large_int_lower_2(self, xp, dtype):
     @testing.numpy_cupy_array_equal()
     def test_large_int_lower_3(self, xp, dtype):
         if (
-            numpy.issubdtype(dtype, numpy.unsignedinteger)
-            and numpy_version() < "2.0.0"
-        ):
-            pytest.skip("numpy promotes dtype differently")
-        elif (
             dtype in (numpy.uint64, numpy.ulonglong)
             and not has_support_aspect64()
         ):
             pytest.skip("no fp64 support")
 
         a = xp.array([xp.iinfo(dtype).min], dtype=dtype)
-        b = numpy.int8(0)
+        b = xp.int8(0)
         return a + b
 
     @testing.for_int_dtypes(no_bool=True)
@@ -209,5 +171,5 @@ def test_large_int_lower_4(self, xp, dtype):
             pytest.skip("no fp64 support")
 
         a = xp.array([xp.iinfo(dtype).min + 1], dtype=dtype)
-        b = numpy.int8(-1)
+        b = xp.int8(-1)
         return a + b

dpnp/tests/third_party/cupy/core_tests/test_function.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
-import unittest
-
+import numpy
 import pytest
 
 import dpnp as cupy
@@ -23,7 +22,7 @@ def _compile_func(kernel_name, code):
     return mod.get_function(kernel_name)
 
 
-class TestFunction(unittest.TestCase):
+class TestFunction:
 
     def test_python_scalar(self):
         code = """

dpnp/tests/third_party/cupy/core_tests/test_include.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
+
 import os
-from unittest import mock
 
 import pytest
 
@@ -71,22 +72,23 @@ def test_nvcc(self):
                 _code_nvcc, options=options, arch=arch
             )
 
-    def test_nvrtc(self):
+    def test_nvrtc(self, monkeypatch):
         cuda_ver = cupy.cuda.runtime.runtimeGetVersion()
         options = self._get_options()
         for arch in self._get_cuda_archs():
-            with mock.patch(
-                "cupy.cuda.compiler._get_arch_for_options_for_nvrtc",
+            monkeypatch.setattr(
+                cupy.cuda.compiler,
+                "_get_arch_for_options_for_nvrtc",
                 lambda _: (f"-arch=compute_{arch}", "ptx"),
-            ):
+            )
+            cupy.cuda.compiler.compile_using_nvrtc(_code_nvrtc, options=options)
+
+            if cuda_ver >= 11010:
+                monkeypatch.setattr(
+                    cupy.cuda.compiler,
+                    "_get_arch_for_options_for_nvrtc",
+                    lambda _: (f"-arch=sm_{arch}", "cubin"),
+                )
                 cupy.cuda.compiler.compile_using_nvrtc(
                     _code_nvrtc, options=options
                 )
-            if cuda_ver >= 11010:
-                with mock.patch(
-                    "cupy.cuda.compiler._get_arch_for_options_for_nvrtc",
-                    lambda _: (f"-arch=sm_{arch}", "cubin"),
-                ):
-                    cupy.cuda.compiler.compile_using_nvrtc(
-                        _code_nvrtc, options=options
-                    )

dpnp/tests/third_party/cupy/core_tests/test_ndarray_complex_ops.py

@@ -1,4 +1,4 @@
-import unittest
+from __future__ import annotations
 
 import numpy
 import pytest
@@ -7,7 +7,7 @@
 from dpnp.tests.third_party.cupy import testing
 
 
-class TestConj(unittest.TestCase):
+class TestConj:
 
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_almost_equal()
@@ -38,7 +38,7 @@ def test_conjugate_pass(self, xp, dtype):
         return y
 
 
-class TestAngle(unittest.TestCase):
+class TestAngle:
 
     # For dtype=int8, uint8, NumPy returns float16, but dpnp returns float32
     # so type_check=False
@@ -49,7 +49,7 @@ def test_angle(self, xp, dtype):
         return xp.angle(x)
 
 
-class TestRealImag(unittest.TestCase):
+class TestRealImag:
 
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_almost_equal(accept_error=False)
@@ -157,7 +157,7 @@ def test_imag_inplace(self, dtype):
         assert cupy.all(x == expected)
 
 
-class TestScalarConversion(unittest.TestCase):
+class TestScalarConversion:
 
     @testing.for_all_dtypes()
     def test_scalar_conversion(self, dtype):

dpnp/tests/third_party/cupy/core_tests/test_ndarray_contiguity.py

@@ -1,9 +1,9 @@
-import unittest
+from __future__ import annotations
 
 from dpnp.tests.third_party.cupy import testing
 
 
-class TestArrayContiguity(unittest.TestCase):
+class TestArrayContiguity:
 
     def test_is_contiguous(self):
         a = testing.shaped_arange((2, 3, 4))

dpnp/tests/third_party/cupy/core_tests/test_ndarray_conversion.py

@@ -1,56 +1,69 @@
 from __future__ import annotations
 
-import unittest
-
 import numpy
 import pytest
 
 import dpnp as cupy
+
+# from cupy.cuda import runtime
 from dpnp.tests.third_party.cupy import testing
 
 
-@testing.parameterize(
-    {"shape": ()},
-    {"shape": (1,)},
-    {"shape": (1, 1, 1)},
+@pytest.mark.parametrize(
+    "shape",
+    [
+        (),
+        (1,),
+        (1, 1, 1),
+    ],
 )
-class TestNdarrayItem(unittest.TestCase):
+class TestNdarrayItem:
 
     @testing.for_all_dtypes()
     @testing.numpy_cupy_equal()
-    def test_item(self, xp, dtype):
-        a = xp.full(self.shape, 3, dtype=dtype)
+    def test_item(self, xp, dtype, shape):
+        a = xp.full(shape, 3, dtype=dtype)
         return a.item()
 
 
-@testing.parameterize(
-    {"shape": (0,)},
-    {"shape": (2, 3)},
-    {"shape": (1, 0, 1)},
+@pytest.mark.parametrize(
+    "shape",
+    [
+        (0,),
+        (2, 3),
+        (1, 0, 1),
+    ],
 )
-class TestNdarrayItemRaise(unittest.TestCase):
+class TestNdarrayItemRaise:
 
-    def test_item(self):
+    def test_item(self, shape):
         for xp in (numpy, cupy):
-            a = testing.shaped_arange(self.shape, xp, xp.float32)
+            a = testing.shaped_arange(shape, xp, xp.float32)
             with pytest.raises(ValueError):
                 a.item()
 
 
-@testing.parameterize(
-    {"shape": ()},
-    {"shape": (1,)},
-    {"shape": (2, 3)},
-    {"shape": (2, 3), "order": "C"},
-    {"shape": (2, 3), "order": "F"},
+@pytest.mark.parametrize(
+    "shape, order",
+    [
+        ((), None),
+        ((1,), None),
+        ((2, 3), None),
+        ((2, 3), "C"),
+        ((2, 3), "F"),
+    ],
 )
-class TestNdarrayToBytes(unittest.TestCase):
+class TestNdarrayToBytes:
 
     @testing.for_all_dtypes()
     @testing.numpy_cupy_equal()
-    def test_item(self, xp, dtype):
-        a = testing.shaped_arange(self.shape, xp, dtype)
-        if hasattr(self, "order"):
-            return a.tobytes(self.order)
+    def test_item(self, xp, dtype, shape, order):
+        # if runtime.is_hip and (
+        #     shape == (1,) or (shape == (2, 3) and order is None)
+        # ):
+        #     pytest.xfail("ROCm/HIP may have a bug")
+        a = testing.shaped_arange(shape, xp, dtype)
+        if order is not None:
+            return a.tobytes(order)
         else:
             return a.tobytes()