👽️ ma.core: sync 2.4 changes with upstream

src/numpy-stubs/@test/runtime/legacy/recfunctions.py

@@ -1,5 +1,6 @@
 """These tests are based on the doctests from `numpy/lib/recfunctions.py`."""
 
+from collections.abc import Callable
 from typing import TYPE_CHECKING, Any, assert_type
 
 import numpy as np
@@ -11,6 +12,11 @@
 # ruff: noqa: S101
 
 
+def _test(fn: Callable[[], None]) -> None:
+    fn()
+
+
+@_test
 def test_recursive_fill_fields() -> None:
     a: _nt.Array[np.void] = np.array(
         [(1, 10.0), (2, 20.0)], dtype=[("A", np.int64), ("B", np.float64)]
@@ -20,6 +26,7 @@ def test_recursive_fill_fields() -> None:
     assert_type(out, "_nt.Array1D[np.void]")
 
 
+@_test
 def test_get_names() -> None:
     names: tuple[str | Any, ...]
     names = rfn.get_names(np.empty((1,), dtype=[("A", int)]).dtype)
@@ -30,6 +37,7 @@ def test_get_names() -> None:
     assert names
 
 
+@_test
 def test_get_names_flat() -> None:
     names: tuple[str, ...]
     names = rfn.get_names_flat(np.empty((1,), dtype=[("A", int)]).dtype)
@@ -40,11 +48,13 @@ def test_get_names_flat() -> None:
     assert names
 
 
+@_test
 def test_flatten_descr() -> None:
     ndtype = np.dtype([("a", "<i4"), ("b", [("b_a", "<f8"), ("b_b", "<i4")])])
     assert_type(rfn.flatten_descr(ndtype), tuple[tuple[str, np.dtype]])
 
 
+@_test
 def test_get_fieldstructure() -> None:
     ndtype = np.dtype([
         ("A", int),
@@ -53,13 +63,15 @@ def test_get_fieldstructure() -> None:
     assert_type(rfn.get_fieldstructure(ndtype), dict[str, list[str]])
 
 
+@_test
 def test_merge_arrays() -> None:
     assert_type(
         rfn.merge_arrays((np.ones(((2),), np.int_), np.ones(((3),), np.float64))),
         "np.recarray[_nt.Rank1, np.dtype[np.void]]",
     )
 
 
+@_test
 def test_drop_fields() -> None:
     ndtype = [("a", np.int64), ("b", [("b_a", np.double), ("b_b", np.int64)])]
     a = np.ones(((3),), dtype=ndtype)
@@ -74,13 +86,15 @@ def test_drop_fields() -> None:
     )
 
 
+@_test
 def test_rename_fields() -> None:
     ndtype = [("a", np.int64), ("b", [("b_a", np.double), ("b_b", np.int64)])]
     a = np.ones(((3),), dtype=ndtype)
 
     assert_type(rfn.rename_fields(a, {"a": "A", "b_b": "B_B"}), "_nt.Array1D[np.void]")
 
 
+@_test
 def test_repack_fields() -> None:
     dt: np.dtype[np.void] = np.dtype("u1, <i8, <f8", align=True)
 
@@ -89,34 +103,40 @@ def test_repack_fields() -> None:
     assert_type(rfn.repack_fields(np.ones((3,), dtype=dt)), "_nt.Array1D[np.void]")
 
 
+@_test
 def test_structured_to_unstructured() -> None:
     a = np.zeros(4, dtype=[("a", "i4"), ("b", "f4,u2"), ("c", "f4", 2)])
     assert_type(rfn.structured_to_unstructured(a), "_nt.Array")
 
 
+@_test
 def unstructured_to_structured() -> None:
     dt: np.dtype[np.void] = np.dtype([("a", "i4"), ("b", "f4,u2"), ("c", "f4", 2)])
     a = np.arange(20, dtype=np.int32).reshape((4, 5))
     assert_type(rfn.unstructured_to_structured(a, dt), "_nt.Array[np.void]")
 
 
+@_test
 def test_apply_along_fields() -> None:
     b = np.ones(4, dtype=[("x", "i4"), ("y", "f4"), ("z", "f8")])
     assert_type(rfn.apply_along_fields(np.mean, b), "_nt.Array1D[np.void]")
 
 
+@_test
 def test_assign_fields_by_name() -> None:
     b = np.ones(4, dtype=[("x", "i4"), ("y", "f4"), ("z", "f8")])
     assert_type(rfn.apply_along_fields(np.mean, b), "_nt.Array1D[np.void]")
 
 
+@_test
 def test_require_fields() -> None:
     a = np.ones(4, dtype=[("a", "i4"), ("b", "f8"), ("c", "u1")])
     assert_type(
         rfn.require_fields(a, [("b", "f4"), ("c", "u1")]), "_nt.Array1D[np.void]"
     )
 
 
+@_test
 def test_stack_arrays() -> None:
     x = np.zeros(((2),), np.int32)
     assert_type(rfn.stack_arrays(x), "_nt.Array1D[np.int32]")
@@ -126,10 +146,11 @@ def test_stack_arrays() -> None:
     assert_type(rfn.stack_arrays((z, zz)), "_nt.MArray[np.void]")
 
 
+@_test
 def test_find_duplicates() -> None:
     ndtype = np.dtype([("a", int)])
 
-    a = np.ma.ones(7, mask=[0, 0, 1, 0, 0, 0, 1]).view(ndtype)
+    a = np.ma.ones(7).view(ndtype)
     assert_type(rfn.find_duplicates(a), "_nt.MArray[np.void, Any]")
     assert_type(
         rfn.find_duplicates(a, ignoremask=True, return_index=True),

src/numpy-stubs/@test/static/accept/ndarray_misc.pyi

@@ -157,7 +157,7 @@ assert_type(AR_f8.dot(1), _nt.Array[Any])
 assert_type(AR_f8.dot([1]), Any)
 assert_type(AR_f8.dot(1, out=AR_O_sub), SubArray)
 
-assert_type(AR_f8.nonzero(), tuple[_nt.Array[np.intp], ...])
+assert_type(AR_f8.nonzero(), tuple[_nt.Array1D[np.intp], ...])
 
 assert_type(AR_f8.searchsorted(1), np.intp)
 assert_type(AR_f8.searchsorted([1]), _nt.Array[np.intp])

src/numpy-stubs/__init__.pyi

@@ -2873,7 +2873,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DTypeT_co]):
     def dot(self, b: ArrayLike, /, out: _ArrayT) -> _ArrayT: ...
 
     # `nonzero()` is deprecated for 0d arrays/generics
-    def nonzero(self) -> tuple[_nt.Array[intp], ...]: ...
+    def nonzero(self) -> tuple[_nt.Array1D[intp], ...]: ...
 
     #
     @overload

src/numpy-stubs/_core/fromnumeric.pyi

@@ -170,13 +170,14 @@ def reshape(
     a: ArrayLike, /, shape: Sequence[CanIndex], order: _OrderACF = "C", *, copy: bool | None = None
 ) -> _nt.Array[Incomplete]: ...
 
-#
+# keep in sync with `ma.core.swapaxes`
 @overload
 def swapaxes(a: _nt._ToArray_nd[_ScalarT], axis1: CanIndex, axis2: CanIndex) -> _nt.Array[_ScalarT]: ...
 @overload
 def swapaxes(a: ArrayLike, axis1: CanIndex, axis2: CanIndex) -> _nt.Array[Incomplete]: ...
 
-#
+# TODO: port shape-typing improvements from upstream
+# keep in sync with `ma.core.repeat`
 @overload
 def repeat(
     a: _nt._ToArray_nd[_ScalarT], repeats: _nt.CoInteger_nd, axis: CanIndex | None = None

src/numpy-stubs/_core/numeric.pyi

@@ -2294,7 +2294,7 @@ def indices(dimensions: _nt.ToInteger_1d, dtype: DTypeLike, sparse: L[True]) ->
 @overload
 def indices(dimensions: _nt.ToInteger_1d, dtype: DTypeLike = ..., *, sparse: L[True]) -> tuple[_nt.Array, ...]: ...
 
-#
+# keep in sync with `ma.core.fromfunction`
 def fromfunction(
     function: Callable[..., _T],
     shape: Sequence[int],