🎨 enforce import _numtype as _nt everywhere

pyproject.toml

@@ -225,6 +225,7 @@ preview = true
             "sys",
             "numpy",
             "numpy.typing",
+            "_numtype",
         ]
             [tool.ruff.lint.flake8-import-conventions.extend-aliases]
             "ctypes" = "ct"

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

@@ -1,97 +1,96 @@
 from typing import Any
 from typing_extensions import assert_type
 
+import _numtype as _nt
 import numpy as np
-import numpy.typing as npt
-from _numtype import Array1D
 from numpy.lib._arraysetops_impl import UniqueAllResult, UniqueCountsResult, UniqueInverseResult
 
-AR_b: npt.NDArray[np.bool]
-AR_i_: npt.NDArray[np.intp]
-AR_f8: npt.NDArray[np.float64]
-AR_M: npt.NDArray[np.datetime64]
-AR_O: npt.NDArray[np.object_]
+AR_b: _nt.Array[np.bool]
+AR_i_: _nt.Array[np.intp]
+AR_f8: _nt.Array[np.float64]
+AR_M: _nt.Array[np.datetime64]
+AR_O: _nt.Array[np.object_]
 AR_LIKE_i_: list[int]
 
 ###
 
-assert_type(np.intersect1d(AR_i_, AR_i_), Array1D[np.intp])
-assert_type(np.intersect1d(AR_f8, AR_i_), Array1D[np.float64])
-assert_type(np.intersect1d(AR_M, AR_M, assume_unique=True), Array1D[np.datetime64])
+assert_type(np.intersect1d(AR_i_, AR_i_), _nt.Array1D[np.intp])
+assert_type(np.intersect1d(AR_f8, AR_i_), _nt.Array1D[np.float64])
+assert_type(np.intersect1d(AR_M, AR_M, assume_unique=True), _nt.Array1D[np.datetime64])
 assert_type(
     np.intersect1d(AR_f8, AR_f8, return_indices=True),
-    tuple[Array1D[np.float64], Array1D[np.intp], Array1D[np.intp]],
+    tuple[_nt.Array1D[np.float64], _nt.Array1D[np.intp], _nt.Array1D[np.intp]],
 )
 
-assert_type(np.union1d(AR_i_, AR_i_), Array1D[np.intp])
-assert_type(np.union1d(AR_f8, AR_i_), Array1D[np.float64])
-assert_type(np.union1d(AR_M, AR_M), Array1D[np.datetime64])
+assert_type(np.union1d(AR_i_, AR_i_), _nt.Array1D[np.intp])
+assert_type(np.union1d(AR_f8, AR_i_), _nt.Array1D[np.float64])
+assert_type(np.union1d(AR_M, AR_M), _nt.Array1D[np.datetime64])
 
-assert_type(np.ediff1d(AR_b), Array1D[np.int8])
-assert_type(np.ediff1d(AR_M), Array1D[np.timedelta64])
-assert_type(np.ediff1d(AR_O), Array1D[np.object_])
-assert_type(np.ediff1d(AR_i_, to_end=[1, 2, 3]), Array1D[np.intp])
-assert_type(np.ediff1d(AR_LIKE_i_, to_begin=[0, 1]), Array1D[np.intp])
+assert_type(np.ediff1d(AR_b), _nt.Array1D[np.int8])
+assert_type(np.ediff1d(AR_M), _nt.Array1D[np.timedelta64])
+assert_type(np.ediff1d(AR_O), _nt.Array1D[np.object_])
+assert_type(np.ediff1d(AR_i_, to_end=[1, 2, 3]), _nt.Array1D[np.intp])
+assert_type(np.ediff1d(AR_LIKE_i_, to_begin=[0, 1]), _nt.Array1D[np.intp])
 
-assert_type(np.setxor1d(AR_i_, AR_i_), Array1D[np.intp])
-assert_type(np.setxor1d(AR_f8, AR_i_), Array1D[np.float64])
-assert_type(np.setxor1d(AR_M, AR_M, assume_unique=True), Array1D[np.datetime64])
+assert_type(np.setxor1d(AR_i_, AR_i_), _nt.Array1D[np.intp])
+assert_type(np.setxor1d(AR_f8, AR_i_), _nt.Array1D[np.float64])
+assert_type(np.setxor1d(AR_M, AR_M, assume_unique=True), _nt.Array1D[np.datetime64])
 
-assert_type(np.setdiff1d(AR_i_, AR_i_), Array1D[np.intp])
-assert_type(np.setdiff1d(AR_f8, AR_i_), Array1D[np.float64])
-assert_type(np.setdiff1d(AR_M, AR_M, assume_unique=True), Array1D[np.datetime64])
+assert_type(np.setdiff1d(AR_i_, AR_i_), _nt.Array1D[np.intp])
+assert_type(np.setdiff1d(AR_f8, AR_i_), _nt.Array1D[np.float64])
+assert_type(np.setdiff1d(AR_M, AR_M, assume_unique=True), _nt.Array1D[np.datetime64])
 
-assert_type(np.isin(AR_i_, AR_i_), npt.NDArray[np.bool])
-assert_type(np.isin(AR_f8, AR_i_), npt.NDArray[np.bool])
-assert_type(np.isin(AR_M, AR_M, assume_unique=True), npt.NDArray[np.bool])
-assert_type(np.isin(AR_f8, AR_LIKE_i_, invert=True), npt.NDArray[np.bool])
+assert_type(np.isin(AR_i_, AR_i_), _nt.Array[np.bool])
+assert_type(np.isin(AR_f8, AR_i_), _nt.Array[np.bool])
+assert_type(np.isin(AR_M, AR_M, assume_unique=True), _nt.Array[np.bool])
+assert_type(np.isin(AR_f8, AR_LIKE_i_, invert=True), _nt.Array[np.bool])
 
-assert_type(np.unique(AR_f8), npt.NDArray[np.float64])
-assert_type(np.unique(AR_f8, return_index=True), tuple[npt.NDArray[np.float64], npt.NDArray[np.intp]])
-assert_type(np.unique(AR_f8, return_inverse=True), tuple[npt.NDArray[np.float64], npt.NDArray[np.intp]])
-assert_type(np.unique(AR_f8, return_counts=True), tuple[npt.NDArray[np.float64], npt.NDArray[np.intp]])
-assert_type(np.unique(AR_LIKE_i_, axis=0), npt.NDArray[Any])
-assert_type(np.unique(AR_LIKE_i_, return_index=True), tuple[npt.NDArray[Any], npt.NDArray[np.intp]])
-assert_type(np.unique(AR_LIKE_i_, return_inverse=True), tuple[npt.NDArray[Any], npt.NDArray[np.intp]])
-assert_type(np.unique(AR_LIKE_i_, return_counts=True), tuple[npt.NDArray[Any], npt.NDArray[np.intp]])
+assert_type(np.unique(AR_f8), _nt.Array[np.float64])
+assert_type(np.unique(AR_f8, return_index=True), tuple[_nt.Array[np.float64], _nt.Array[np.intp]])
+assert_type(np.unique(AR_f8, return_inverse=True), tuple[_nt.Array[np.float64], _nt.Array[np.intp]])
+assert_type(np.unique(AR_f8, return_counts=True), tuple[_nt.Array[np.float64], _nt.Array[np.intp]])
+assert_type(np.unique(AR_LIKE_i_, axis=0), _nt.Array[Any])
+assert_type(np.unique(AR_LIKE_i_, return_index=True), tuple[_nt.Array[Any], _nt.Array[np.intp]])
+assert_type(np.unique(AR_LIKE_i_, return_inverse=True), tuple[_nt.Array[Any], _nt.Array[np.intp]])
+assert_type(np.unique(AR_LIKE_i_, return_counts=True), tuple[_nt.Array[Any], _nt.Array[np.intp]])
 assert_type(
     np.unique(AR_f8, return_index=True, return_inverse=True),
-    tuple[npt.NDArray[np.float64], npt.NDArray[np.intp], npt.NDArray[np.intp]],
+    tuple[_nt.Array[np.float64], _nt.Array[np.intp], _nt.Array[np.intp]],
 )
 assert_type(
     np.unique(AR_LIKE_i_, return_index=True, return_inverse=True),
-    tuple[npt.NDArray[Any], npt.NDArray[np.intp], npt.NDArray[np.intp]],
+    tuple[_nt.Array[Any], _nt.Array[np.intp], _nt.Array[np.intp]],
 )
 assert_type(
     np.unique(AR_f8, return_index=True, return_counts=True),
-    tuple[npt.NDArray[np.float64], npt.NDArray[np.intp], npt.NDArray[np.intp]],
+    tuple[_nt.Array[np.float64], _nt.Array[np.intp], _nt.Array[np.intp]],
 )
 assert_type(
     np.unique(AR_LIKE_i_, return_index=True, return_counts=True),
-    tuple[npt.NDArray[Any], npt.NDArray[np.intp], npt.NDArray[np.intp]],
+    tuple[_nt.Array[Any], _nt.Array[np.intp], _nt.Array[np.intp]],
 )
 assert_type(
     np.unique(AR_f8, return_inverse=True, return_counts=True),
-    tuple[npt.NDArray[np.float64], npt.NDArray[np.intp], npt.NDArray[np.intp]],
+    tuple[_nt.Array[np.float64], _nt.Array[np.intp], _nt.Array[np.intp]],
 )
 assert_type(
     np.unique(AR_LIKE_i_, return_inverse=True, return_counts=True),
-    tuple[npt.NDArray[Any], npt.NDArray[np.intp], npt.NDArray[np.intp]],
+    tuple[_nt.Array[Any], _nt.Array[np.intp], _nt.Array[np.intp]],
 )
 assert_type(
     np.unique(AR_f8, return_index=True, return_inverse=True, return_counts=True),
-    tuple[npt.NDArray[np.float64], npt.NDArray[np.intp], npt.NDArray[np.intp], npt.NDArray[np.intp]],
+    tuple[_nt.Array[np.float64], _nt.Array[np.intp], _nt.Array[np.intp], _nt.Array[np.intp]],
 )
 assert_type(
     np.unique(AR_LIKE_i_, return_index=True, return_inverse=True, return_counts=True),
-    tuple[npt.NDArray[Any], npt.NDArray[np.intp], npt.NDArray[np.intp], npt.NDArray[np.intp]],
+    tuple[_nt.Array[Any], _nt.Array[np.intp], _nt.Array[np.intp], _nt.Array[np.intp]],
 )
 
 assert_type(np.unique_all(AR_f8), UniqueAllResult[np.float64])
 assert_type(np.unique_counts(AR_f8), UniqueCountsResult[np.float64])
 assert_type(np.unique_inverse(AR_f8), UniqueInverseResult[np.float64])
-assert_type(np.unique_values(AR_f8), Array1D[np.float64])
+assert_type(np.unique_values(AR_f8), _nt.Array1D[np.float64])
 assert_type(np.unique_all(AR_LIKE_i_), UniqueAllResult[np.intp])
 assert_type(np.unique_counts(AR_LIKE_i_), UniqueCountsResult[np.intp])
 assert_type(np.unique_inverse(AR_LIKE_i_), UniqueInverseResult[np.intp])
-assert_type(np.unique_values(AR_LIKE_i_), Array1D[np.intp])
+assert_type(np.unique_values(AR_LIKE_i_), _nt.Array1D[np.intp])

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

@@ -1,14 +1,14 @@
 from typing import Any, Literal, TypeAlias
 from typing_extensions import TypeVar, assert_type
 
+import _numtype as _nt
 import numpy as np
 import numpy.typing as npt
-from _numtype import Array, AtLeast2D
 from numpy.linalg._linalg import EigResult, EighResult, QRResult, SVDResult, SlogdetResult
 
 _ScalarT = TypeVar("_ScalarT", bound=np.generic)
-_Array_2d: TypeAlias = Array[_ScalarT, tuple[int, int]]
-_Array_2nd: TypeAlias = Array[_ScalarT, AtLeast2D]
+_Array_2d: TypeAlias = _nt.Array[_ScalarT, tuple[int, int]]
+_Array_2nd: TypeAlias = _nt.Array[_ScalarT, _nt.AtLeast2D]
 
 ###
 

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

@@ -122,7 +122,7 @@ assert_type(PS_lag.integ(SC_i_co, SC_f_co), npp.Laguerre)
 assert_type(PS_poly.deriv(), npp.Polynomial)
 assert_type(PS_herm.deriv(SC_i_co), npp.Hermite)
 
-assert_type(PS_poly.roots(), _Array1D[np.float64] | _Array1D[np.complex128])
+assert_type(PS_poly.roots(), _Array1D[np.float64 | np.complex128])
 
 assert_type(
     PS_poly.linspace(),

src/numpy-stubs/@test/static/reject/lib_function_base.pyi

@@ -28,7 +28,7 @@ np.piecewise(AR_f8, AR_b_list, [fn_ar_i], 42, _=None)  # pyright: ignore[reportC
 
 np.interp(AR_f8, AR_c16, AR_f8)  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType, reportCallIssue]
 np.interp(AR_c16, AR_f8, AR_f8)  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType, reportCallIssue]
-np.interp(AR_f8, AR_f8, AR_f8, period=AR_c16)  # type: ignore[call-overload]  # pyright: ignore[reportArgumentType, reportCallIssue]
+np.interp(AR_f8, AR_f8, AR_f8, period=AR_c16)  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType, reportCallIssue]
 np.interp(AR_f8, AR_f8, AR_O)  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType, reportCallIssue]
 
 np.average(AR_m)  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType, reportCallIssue]

src/numpy-stubs/_core/_asarray.pyi

@@ -2,15 +2,15 @@ from collections.abc import Iterable
 from typing import Any, Final, Literal as L, TypeAlias, overload
 from typing_extensions import TypeVar
 
+import _numtype as _nt
 import numpy as np
-from _numtype import ToBool_nd, ToBytes_nd, ToComplex128_nd, ToFloat64_nd, ToInt_nd, ToObject_nd, ToStr_nd
-from numpy._typing import DTypeLike, NDArray, _ArrayLike, _DTypeLike, _SupportsArrayFunc as _Like
+from numpy._typing import _SupportsArrayFunc as _Like
 
 __all__ = ["require"]
 
 ###
 
-_ArrayT = TypeVar("_ArrayT", bound=NDArray[Any])
+_ArrayT = TypeVar("_ArrayT", bound=_nt.Array[Any])
 _ScalarT = TypeVar("_ScalarT", bound=np.generic[Any])
 
 _Req: TypeAlias = L[
@@ -30,89 +30,45 @@ POSSIBLE_FLAGS: Final[dict[_ReqE, L["C", "F", "A", "W", "O", "E"]]]
 
 @overload
 def require(
-    a: _ArrayT,
-    dtype: None = None,
-    requirements: _ToReqs | None = None,
-    *,
-    like: _Like | None = None,
+    a: _ArrayT, dtype: None = None, requirements: _ToReqs | None = None, *, like: _Like | None = None
 ) -> _ArrayT: ...
 @overload
 def require(
-    a: ToBool_nd,
-    dtype: None = None,
-    requirements: _ToReqsE | None = None,
-    *,
-    like: _Like | None = None,
-) -> NDArray[np.bool]: ...
+    a: _nt.ToBool_nd, dtype: None = None, requirements: _ToReqsE | None = None, *, like: _Like | None = None
+) -> _nt.Array[np.bool]: ...
 @overload
 def require(
-    a: ToInt_nd,
-    dtype: None = None,
-    requirements: _ToReqsE | None = None,
-    *,
-    like: _Like | None = None,
-) -> NDArray[np.intp]: ...
+    a: _nt.ToInt_nd, dtype: None = None, requirements: _ToReqsE | None = None, *, like: _Like | None = None
+) -> _nt.Array[np.intp]: ...
 @overload
 def require(
-    a: ToFloat64_nd,
-    dtype: None = None,
-    requirements: _ToReqsE | None = None,
-    *,
-    like: _Like | None = None,
-) -> NDArray[np.float64]: ...
+    a: _nt.ToFloat64_nd, dtype: None = None, requirements: _ToReqsE | None = None, *, like: _Like | None = None
+) -> _nt.Array[np.float64]: ...
 @overload
 def require(
-    a: ToComplex128_nd,
-    dtype: None = None,
-    requirements: _ToReqsE | None = None,
-    *,
-    like: _Like | None = None,
-) -> NDArray[np.complex128]: ...
+    a: _nt.ToComplex128_nd, dtype: None = None, requirements: _ToReqsE | None = None, *, like: _Like | None = None
+) -> _nt.Array[np.complex128]: ...
 @overload
 def require(
-    a: ToBytes_nd,
-    dtype: None = None,
-    requirements: _ToReqsE | None = None,
-    *,
-    like: _Like | None = None,
-) -> NDArray[np.bytes_]: ...
+    a: _nt.ToBytes_nd, dtype: None = None, requirements: _ToReqsE | None = None, *, like: _Like | None = None
+) -> _nt.Array[np.bytes_]: ...
 @overload
 def require(
-    a: ToStr_nd,
-    dtype: None = None,
-    requirements: _ToReqsE | None = None,
-    *,
-    like: _Like | None = None,
-) -> NDArray[np.str_]: ...
+    a: _nt.ToStr_nd, dtype: None = None, requirements: _ToReqsE | None = None, *, like: _Like | None = None
+) -> _nt.Array[np.str_]: ...
 @overload
 def require(
-    a: ToObject_nd,
-    dtype: None = None,
-    requirements: _ToReqsE | None = None,
-    *,
-    like: _Like | None = None,
-) -> NDArray[np.object_]: ...
+    a: _nt.ToObject_nd, dtype: None = None, requirements: _ToReqsE | None = None, *, like: _Like | None = None
+) -> _nt.Array[np.object_]: ...
 @overload
 def require(
-    a: _ArrayLike[_ScalarT],
-    dtype: None = None,
-    requirements: _ToReqsE | None = None,
-    *,
-    like: _Like | None = None,
-) -> NDArray[_ScalarT]: ...
+    a: _nt._ToArray_nd[_ScalarT], dtype: None = None, requirements: _ToReqsE | None = None, *, like: _Like | None = None
+) -> _nt.Array[_ScalarT]: ...
 @overload
 def require(
-    a: object,
-    dtype: _DTypeLike[_ScalarT],
-    requirements: _ToReqsE | None = None,
-    *,
-    like: _Like | None = None,
-) -> NDArray[_ScalarT]: ...
+    a: object, dtype: _nt._ToDType[_ScalarT], requirements: _ToReqsE | None = None, *, like: _Like | None = None
+) -> _nt.Array[_ScalarT]: ...
 @overload
 def require(
-    a: object,
-    dtype: DTypeLike | None = None,
-    requirements: _ToReqsE | None = None,
-    *,
-    like: _Like | None = None,
-) -> NDArray[Any]: ...
+    a: object, dtype: _nt.ToDType | None = None, requirements: _ToReqsE | None = None, *, like: _Like | None = None
+) -> _nt.Array[Any]: ...