Merge master into move_tensor_impl_ext

Author: vlad-perevezentsev

.github/workflows/conda-package.yml

@@ -20,7 +20,7 @@ env:
   test-env-name: 'test'
   rerun-tests-on-failure: 'true'
   rerun-tests-max-attempts: 2
-  rerun-tests-timeout: 40
+  rerun-tests-timeout: 45
 
 jobs:
   build:

.github/workflows/openssf-scorecard.yml

@@ -72,6 +72,6 @@ jobs:
 
       # Upload the results to GitHub's code scanning dashboard.
       - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@19b2f06db2b6f5108140aeb04014ef02b648f789 # v4.31.11
+        uses: github/codeql-action/upload-sarif@45cbd0c69e560cd9e7cd7f8c32362050c9b7ded2 # v4.32.2
         with:
           sarif_file: results.sarif

.pre-commit-config.yaml

@@ -127,7 +127,7 @@ repos:
     hooks:
     -   id: actionlint
 -   repo: https://github.com/BlankSpruce/gersemi
-    rev: 0.25.1
+    rev: 0.25.4
     hooks:
     -   id: gersemi
         exclude: "dpnp/backend/cmake/Modules/"

CHANGELOG.md

@@ -45,6 +45,8 @@ Also, that release drops support for Python 3.9, making Python 3.10 the minimum
 * Updated `dpnp.fix` to reuse `dpnp.trunc` internally [#2722](https://github.com/IntelPython/dpnp/pull/2722)
 * Changed the build scripts and documentation due to `python setup.py develop` deprecation notice [#2716](https://github.com/IntelPython/dpnp/pull/2716)
 * Clarified behavior on repeated `axes` in `dpnp.tensordot` and `dpnp.linalg.tensordot` functions [#2733](https://github.com/IntelPython/dpnp/pull/2733)
+* Improved documentation of `file` argument in `dpnp.fromfile` [#2745](https://github.com/IntelPython/dpnp/pull/2745)
+* Aligned `dpnp.trim_zeros` with NumPy 2.4 to support a tuple of integers passed with `axis` keyword [#2746](https://github.com/IntelPython/dpnp/pull/2746)
 
 ### Deprecated
 

doc/reference/set.rst

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

dpnp/dpnp_iface_arraycreation.py

@@ -1721,7 +1721,9 @@ def fromfile(
     Parameters
     ----------
     file : file or str or Path
-        Open file object or filename.
+        An open file object, a string containing the filename, or a Path object.
+        When reading from a file object it must support random access (i.e. it
+        must have tell and seek methods).
     dtype : {None, str, dtype object}, optional
         Data type of the returned array.
         For binary files, it is used to determine the size and byte-order

dpnp/dpnp_iface_manipulation.py

@@ -3983,7 +3983,7 @@ def trim_zeros(filt, trim="fb", axis=None):
         (or index -1).
 
         Default: ``"fb"``.
-    axis : {None, int}, optional
+    axis : {None, int, tuple of ints}, optional
         If ``None``, `filt` is cropped such that the smallest bounding box is
         returned that still contains all values which are not zero.
         If an `axis` is specified, `filt` will be sliced in that dimension only
@@ -4038,11 +4038,14 @@ def trim_zeros(filt, trim="fb", axis=None):
         raise ValueError(f"unexpected character(s) in `trim`: {trim!r}")
 
     nd = filt.ndim
-    if axis is not None:
-        axis = normalize_axis_index(axis, nd)
+    if axis is None:
+        axis = tuple(range(nd))
+    else:
+        axis = normalize_axis_tuple(axis, nd, argname="axis")
 
-    if filt.size == 0:
-        return filt  # no trailing zeros in empty array
+    # check if an empty array or no trimming requested
+    if filt.size == 0 or not axis:
+        return filt
 
     non_zero = dpnp.argwhere(filt)
     if non_zero.size == 0:
@@ -4061,13 +4064,10 @@ def trim_zeros(filt, trim="fb", axis=None):
         else:
             stop = (None,) * nd
 
-    if axis is None:
-        # trim all axes
-        sl = tuple(slice(*x) for x in zip(start, stop))
-    else:
-        # only trim single axis
-        sl = (slice(None),) * axis + (slice(start[axis], stop[axis]),) + (...,)
-
+    sl = tuple(
+        slice(start[ax], stop[ax]) if ax in axis else slice(None)
+        for ax in range(nd)
+    )
     return filt[sl]
 
 

dpnp/tests/test_manipulation.py

@@ -1432,6 +1432,8 @@ def test_usm_array(self):
 
 
 class TestTrimZeros:
+    ALL_TRIMS = ["F", "B", "fb"]
+
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     def test_basic(self, dtype):
         a = numpy.array([0, 0, 1, 0, 2, 3, 4, 0], dtype=dtype)
@@ -1443,7 +1445,7 @@ def test_basic(self, dtype):
 
     @testing.with_requires("numpy>=2.2")
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
-    @pytest.mark.parametrize("trim", ["F", "B", "fb"])
+    @pytest.mark.parametrize("trim", ALL_TRIMS)
     @pytest.mark.parametrize("ndim", [0, 1, 2, 3])
     def test_basic_nd(self, dtype, trim, ndim):
         a = numpy.ones((2,) * ndim, dtype=dtype)
@@ -1477,7 +1479,7 @@ def test_all_zero(self, dtype, trim):
 
     @testing.with_requires("numpy>=2.2")
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
-    @pytest.mark.parametrize("trim", ["F", "B", "fb"])
+    @pytest.mark.parametrize("trim", ALL_TRIMS)
     @pytest.mark.parametrize("ndim", [0, 1, 2, 3])
     def test_all_zero_nd(self, dtype, trim, ndim):
         a = numpy.zeros((3,) * ndim, dtype=dtype)
@@ -1496,6 +1498,60 @@ def test_size_zero(self):
         expected = numpy.trim_zeros(a)
         assert_array_equal(result, expected)
 
+    @testing.with_requires("numpy>=2.4")
+    @pytest.mark.parametrize(
+        "shape, axis",
+        [
+            [(5,), None],
+            [(5,), ()],
+            [(5,), 0],
+            [(5, 6), None],
+            [(5, 6), ()],
+            [(5, 6), 0],
+            [(5, 6), (-1,)],
+            [(5, 6, 7), None],
+            [(5, 6, 7), ()],
+            [(5, 6, 7), 1],
+            [(5, 6, 7), (0, 2)],
+            [(5, 6, 7, 8), None],
+            [(5, 6, 7, 8), ()],
+            [(5, 6, 7, 8), -2],
+            [(5, 6, 7, 8), (0, 1, 3)],
+        ],
+    )
+    @pytest.mark.parametrize("trim", ALL_TRIMS)
+    def test_multiple_axes(self, shape, axis, trim):
+        # standardize axis to a tuple
+        if axis is None:
+            axis = tuple(range(len(shape)))
+        elif isinstance(axis, int):
+            axis = (len(shape) + axis if axis < 0 else axis,)
+        else:
+            axis = tuple(len(shape) + ax if ax < 0 else ax for ax in axis)
+
+        # populate a random interior slice with nonzero entries
+        rng = numpy.random.default_rng(4321)
+        a = numpy.zeros(shape)
+        start = rng.integers(low=0, high=numpy.array(shape) - 1)
+        end = rng.integers(low=start + 1, high=shape)
+        shape = tuple(end - start)
+        data = 1 + rng.random(shape)
+        a[tuple(slice(i, j) for i, j in zip(start, end))] = data
+        ia = dpnp.array(a)
+
+        result = dpnp.trim_zeros(ia, axis=axis, trim=trim)
+        expected = numpy.trim_zeros(a, axis=axis, trim=trim)
+        assert_array_equal(result, expected)
+
+    # NOTE: numpy behaves differently on 0-sized input array
+    # and returns the input array with reduced shapes
+    @pytest.mark.parametrize("axis", [None, -1, 0])
+    @pytest.mark.parametrize("trim", ALL_TRIMS)
+    def test_empty_array(self, axis, trim):
+        a = dpnp.ones((0, 3))
+        result = dpnp.trim_zeros(a, axis=axis, trim=trim)
+        assert result is a
+
     @pytest.mark.parametrize(
         "a", [numpy.array([0, 2**62, 0]), numpy.array([0, 2**63, 0])]
     )

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 = """