🎨 replace npt.NDArray with _nt.Array in the tests

Author: jorenham

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

@@ -13,15 +13,15 @@
 N = 10_000
 W = H = int(N**0.5)
 
-a: np.ndarray[_nt.Shape2, np.dtype[np.int32]]
-ua: container[_nt.Shape2, np.dtype[np.int32]]
+a: _nt.Array2D[np.int32]
+ua: container[_nt.Rank2, np.dtype[np.int32]]
 
 a = np.arange(N, dtype=np.int32).reshape(W, H)
 ua = container(a)
 
-ua_small: container[_nt.Shape2, np.dtype[np.int32]] = ua[:3, :5]
+ua_small: container[_nt.Rank2, np.dtype[np.int32]] = ua[:3, :5]
 ua_small[0, 0] = 10
 
-ua_bool: container[_nt.Shape2, np.dtype[np.bool]] = ua_small > 1
+ua_bool: container[_nt.Rank2, np.dtype[np.bool]] = ua_small > 1
 
-# shape: tuple[int, int] = np.shape(ua)
+shape: tuple[int, int] = np.shape(ua)

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

@@ -1,17 +1,18 @@
 """These tests are based on the doctests from `numpy/lib/recfunctions.py`."""
 
+from __future__ import annotations
+
 from typing import TYPE_CHECKING, Any, assert_type
 
 import numpy as np
-import numpy.typing as npt
 from numpy.lib import recfunctions as rfn
 
 if TYPE_CHECKING:
-    import _numtype as _nt  # noqa: F401, PLC2701
+    import _numtype as _nt
 
 
 def test_recursive_fill_fields() -> None:
-    a: npt.NDArray[np.void] = np.array(
+    a: _nt.Array[np.void] = np.array(
         [(1, 10.0), (2, 20.0)],
         dtype=[("A", np.int64), ("B", np.float64)],
     )
@@ -101,13 +102,13 @@ def test_repack_fields() -> None:
 
 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), npt.NDArray[Any])
+    assert_type(rfn.structured_to_unstructured(a), "_nt.Array")
 
 
 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), npt.NDArray[np.void])
+    assert_type(rfn.unstructured_to_structured(a, dt), "_nt.Array[np.void]")
 
 
 def test_apply_along_fields() -> None:
@@ -134,21 +135,15 @@ def test_stack_arrays() -> None:
 
     z = np.ones((int(2),), [("A", "|S3"), ("B", float)])
     zz = np.ones((int(2),), [("A", "|S3"), ("B", np.float64), ("C", np.float64)])
-    assert_type(
-        rfn.stack_arrays((z, zz)),
-        "_nt.MArray[np.void]",
-    )
+    assert_type(rfn.stack_arrays((z, zz)), "_nt.MArray[np.void]")
 
 
 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)
-    assert_type(rfn.find_duplicates(a), np.ma.MaskedArray[Any, np.dtype[np.void]])
+    assert_type(rfn.find_duplicates(a), "_nt.MArray[np.void, Any]")
     assert_type(
         rfn.find_duplicates(a, ignoremask=True, return_index=True),
-        tuple[
-            np.ma.MaskedArray[Any, np.dtype[np.void]],
-            np.ndarray[Any, np.dtype[np.int_]],
-        ],
+        "tuple[_nt.MArray[np.void, Any], _nt.Array[np.intp, Any]]",
     )

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

@@ -1,8 +1,8 @@
 import datetime as dt
-from typing import Any, assert_type
+from typing import assert_type
 
+import _numtype as _nt
 import numpy as np
-import numpy.typing as npt
 
 i: int
 i8: np.int64
@@ -18,7 +18,7 @@ m8_int: np.timedelta64[int]
 m8_delta: np.timedelta64[dt.timedelta]
 delta: dt.timedelta
 
-AR_Any: npt.NDArray[Any]
+AR_Any: _nt.Array
 
 # Time structures
 
@@ -59,4 +59,4 @@ assert_type(m8_delta.__divmod__(delta), tuple[int, dt.timedelta])
 
 # Any
 
-assert_type(AR_Any + 2, npt.NDArray[Any])
+assert_type(AR_Any + 2, _nt.Array)

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

@@ -1,22 +1,22 @@
 from collections.abc import Mapping
 from typing import Any, SupportsIndex, assert_type
 
+import _numtype as _nt
 import numpy as np
-import numpy.typing as npt
 
 def mode_func(
-    ar: npt.NDArray[np.number],
+    ar: _nt.Array[np.number],
     width: tuple[int, int],
     iaxis: SupportsIndex,
     kwargs: Mapping[str, Any],
 ) -> None: ...
 
-AR_i8: npt.NDArray[np.int64]
-AR_f8: npt.NDArray[np.float64]
+AR_i8: _nt.Array[np.int64]
+AR_f8: _nt.Array[np.float64]
 AR_LIKE: list[int]
 
-assert_type(np.pad(AR_i8, (2, 3), "constant"), npt.NDArray[np.int64])
-assert_type(np.pad(AR_LIKE, (2, 3), "constant"), npt.NDArray[Any])
+assert_type(np.pad(AR_i8, (2, 3), "constant"), _nt.Array[np.int64])
+assert_type(np.pad(AR_LIKE, (2, 3), "constant"), _nt.Array)
 
-assert_type(np.pad(AR_f8, (2, 3), mode_func), npt.NDArray[np.float64])
-assert_type(np.pad(AR_f8, (2, 3), mode_func, a=1, b=2), npt.NDArray[np.float64])
+assert_type(np.pad(AR_f8, (2, 3), mode_func), _nt.Array[np.float64])
+assert_type(np.pad(AR_f8, (2, 3), mode_func, a=1, b=2), _nt.Array[np.float64])

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

@@ -2,11 +2,11 @@ import contextlib
 from collections.abc import Callable
 from typing import assert_type
 
+import _numtype as _nt
 import numpy as np
-import numpy.typing as npt
 from numpy._core.arrayprint import _FormatOptions
 
-AR: npt.NDArray[np.int64]
+AR: _nt.Array[np.int64]
 func_float: Callable[[np.floating], str]
 func_int: Callable[[np.integer], str]
 

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

@@ -1,26 +1,26 @@
 from collections.abc import Generator
 from typing import assert_type
 
+import _numtype as _nt
 import numpy as np
-import numpy.typing as npt
 
-AR_i8: npt.NDArray[np.int64]
+AR_i8: _nt.Array[np.int64]
 ar_iter: np.lib.Arrayterator[tuple[int, ...], np.dtype[np.int64]]
 
 ###
 
-assert_type(ar_iter.var, npt.NDArray[np.int64])
+assert_type(ar_iter.var, _nt.Array[np.int64])
 assert_type(ar_iter.buf_size, int | None)
 assert_type(ar_iter.start, list[int])
 assert_type(ar_iter.stop, list[int])
 assert_type(ar_iter.step, list[int])
 assert_type(ar_iter.shape, tuple[int, ...])
 assert_type(ar_iter.flat, Generator[np.int64, None, None])
 
-assert_type(ar_iter.__array__(), npt.NDArray[np.int64])
+assert_type(ar_iter.__array__(), _nt.Array[np.int64])
 
 for i in ar_iter:
-    assert_type(i, npt.NDArray[np.int64])
+    assert_type(i, _nt.Array[np.int64])
 
 assert_type(ar_iter[0], np.lib.Arrayterator[tuple[int, ...], np.dtype[np.int64]])
 assert_type(ar_iter[...], np.lib.Arrayterator[tuple[int, ...], np.dtype[np.int64]])