numpy 2.3.2__cp313-cp313t-win32.whl → 2.3.4__cp313-cp313t-win32.whl

numpy/lib/mixins.pyi

@@ -14,6 +14,8 @@ __all__ = ["NDArrayOperatorsMixin"]
 # As such, only little type safety can be provided here.
 
 class NDArrayOperatorsMixin(ABC):
+    __slots__ = ()
+
     @abstractmethod
     def __array_ufunc__(
         self,

numpy/lib/tests/test_index_tricks.py

@@ -199,6 +199,11 @@ class TestRavelUnravelIndex:
         with assert_raises(ValueError):
             np.unravel_index([1], (2, 1, 0))
 
+    def test_regression_size_1_index(self):
+        # actually tests the nditer size one index tracking
+        # regression test for gh-29690
+        np.unravel_index(np.array([[1, 0, 1, 0]], dtype=np.uint32), (4,))
+
 class TestGrid:
     def test_basic(self):
         a = mgrid[-1:1:10j]

numpy/linalg/_linalg.py

@@ -2029,6 +2029,7 @@ def cond(x, p=None):
         # contain nans in the entries where inversion failed.
         _assert_stacked_square(x)
         t, result_t = _commonType(x)
+        result_t = _realType(result_t)  # condition number is always real
         signature = 'D->D' if isComplexType(t) else 'd->d'
         with errstate(all='ignore'):
             invx = _umath_linalg.inv(x, signature=signature)

numpy/linalg/_linalg.pyi

@@ -28,6 +28,7 @@ from numpy import (
 )
 from numpy._core.fromnumeric import matrix_transpose
 from numpy._core.numeric import tensordot
+from numpy._globals import _NoValueType
 from numpy._typing import (
     ArrayLike,
     DTypeLike,
@@ -78,7 +79,7 @@ __all__ = [
     "vecdot",
 ]
 
-_ArrayT = TypeVar("_ArrayT", bound=NDArray[Any])
+_NumberT = TypeVar("_NumberT", bound=np.number)
 
 _ModeKind: TypeAlias = L["reduced", "complete", "r", "raw"]
 
@@ -182,33 +183,29 @@ def cholesky(a: _ArrayLikeFloat_co, /, *, upper: bool = False) -> NDArray[floati
 def cholesky(a: _ArrayLikeComplex_co, /, *, upper: bool = False) -> NDArray[complexfloating]: ...
 
 @overload
-def outer(x1: _ArrayLike[Never], x2: _ArrayLike[Never]) -> NDArray[Any]: ...
+def outer(x1: _ArrayLike[Never], x2: _ArrayLike[Never], /) -> NDArray[Any]: ...
 @overload
-def outer(x1: _ArrayLikeBool_co, x2: _ArrayLikeBool_co) -> NDArray[np.bool]: ...
+def outer(x1: _ArrayLikeBool_co, x2: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ...
 @overload
-def outer(x1: _ArrayLikeUInt_co, x2: _ArrayLikeUInt_co) -> NDArray[unsignedinteger]: ...
+def outer(x1: _ArrayLike[_NumberT], x2: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ...
 @overload
-def outer(x1: _ArrayLikeInt_co, x2: _ArrayLikeInt_co) -> NDArray[signedinteger]: ...
+def outer(x1: _ArrayLikeUInt_co, x2: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ...
 @overload
-def outer(x1: _ArrayLikeFloat_co, x2: _ArrayLikeFloat_co) -> NDArray[floating]: ...
+def outer(x1: _ArrayLikeInt_co, x2: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ...
 @overload
-def outer(
-    x1: _ArrayLikeComplex_co,
-    x2: _ArrayLikeComplex_co,
-) -> NDArray[complexfloating]: ...
+def outer(x1: _ArrayLikeFloat_co, x2: _ArrayLikeFloat_co, /) -> NDArray[floating]: ...
 @overload
-def outer(
-    x1: _ArrayLikeTD64_co,
-    x2: _ArrayLikeTD64_co,
-    out: None = ...,
-) -> NDArray[timedelta64]: ...
+def outer(x1: _ArrayLikeComplex_co, x2: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ...
+@overload
+def outer(x1: _ArrayLikeTD64_co, x2: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ...
 @overload
-def outer(x1: _ArrayLikeObject_co, x2: _ArrayLikeObject_co) -> NDArray[object_]: ...
+def outer(x1: _ArrayLikeObject_co, x2: _ArrayLikeObject_co, /) -> NDArray[object_]: ...
 @overload
 def outer(
     x1: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
     x2: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
-) -> _ArrayT: ...
+    /,
+) -> NDArray[Any]: ...
 
 @overload
 def qr(a: _ArrayLikeInt_co, mode: _ModeKind = ...) -> QRResult: ...
@@ -308,20 +305,26 @@ def matrix_rank(
 @overload
 def pinv(
     a: _ArrayLikeInt_co,
-    rcond: _ArrayLikeFloat_co = ...,
-    hermitian: bool = ...,
+    rcond: _ArrayLikeFloat_co | None = None,
+    hermitian: bool = False,
+    *,
+    rtol: _ArrayLikeFloat_co | _NoValueType = ...,
 ) -> NDArray[float64]: ...
 @overload
 def pinv(
     a: _ArrayLikeFloat_co,
-    rcond: _ArrayLikeFloat_co = ...,
-    hermitian: bool = ...,
+    rcond: _ArrayLikeFloat_co | None = None,
+    hermitian: bool = False,
+    *,
+    rtol: _ArrayLikeFloat_co | _NoValueType = ...,
 ) -> NDArray[floating]: ...
 @overload
 def pinv(
     a: _ArrayLikeComplex_co,
-    rcond: _ArrayLikeFloat_co = ...,
-    hermitian: bool = ...,
+    rcond: _ArrayLikeFloat_co | None = None,
+    hermitian: bool = False,
+    *,
+    rtol: _ArrayLikeFloat_co | _NoValueType = ...,
 ) -> NDArray[complexfloating]: ...
 
 # TODO: Returns a 2-tuple of scalars for 2D arrays and
@@ -461,22 +464,12 @@ def cross(
 ) -> NDArray[complexfloating]: ...
 
 @overload
-def matmul(
-    x1: _ArrayLikeInt_co,
-    x2: _ArrayLikeInt_co,
-) -> NDArray[signedinteger]: ...
+def matmul(x1: _ArrayLike[_NumberT], x2: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ...
 @overload
-def matmul(
-    x1: _ArrayLikeUInt_co,
-    x2: _ArrayLikeUInt_co,
-) -> NDArray[unsignedinteger]: ...
+def matmul(x1: _ArrayLikeInt_co, x2: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ...
 @overload
-def matmul(
-    x1: _ArrayLikeFloat_co,
-    x2: _ArrayLikeFloat_co,
-) -> NDArray[floating]: ...
+def matmul(x1: _ArrayLikeUInt_co, x2: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ...
 @overload
-def matmul(
-    x1: _ArrayLikeComplex_co,
-    x2: _ArrayLikeComplex_co,
-) -> NDArray[complexfloating]: ...
+def matmul(x1: _ArrayLikeFloat_co, x2: _ArrayLikeFloat_co, /) -> NDArray[floating]: ...
+@overload
+def matmul(x1: _ArrayLikeComplex_co, x2: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ...

numpy/linalg/tests/test_linalg.py

@@ -793,15 +793,28 @@ class CondCases(LinalgSquareTestCase, LinalgGeneralizedSquareTestCase):
 
 
 class TestCond(CondCases):
-    def test_basic_nonsvd(self):
+    @pytest.mark.parametrize('is_complex', [False, True])
+    def test_basic_nonsvd(self, is_complex):
         # Smoketest the non-svd norms
         A = array([[1., 0, 1], [0, -2., 0], [0, 0, 3.]])
+        if is_complex:
+            # Since A is linearly scaled, the condition number should not change
+            A = A * (1 + 1j)
         assert_almost_equal(linalg.cond(A, inf), 4)
         assert_almost_equal(linalg.cond(A, -inf), 2 / 3)
         assert_almost_equal(linalg.cond(A, 1), 4)
         assert_almost_equal(linalg.cond(A, -1), 0.5)
         assert_almost_equal(linalg.cond(A, 'fro'), np.sqrt(265 / 12))
 
+    @pytest.mark.parametrize('dtype', [single, double, csingle, cdouble])
+    @pytest.mark.parametrize('norm_ord', [1, -1, 2, -2, 'fro', np.inf, -np.inf])
+    def test_cond_dtypes(self, dtype, norm_ord):
+        # Check that the condition number is computed in the same dtype
+        # as the input matrix
+        A = array([[1., 0, 1], [0, -2., 0], [0, 0, 3.]], dtype=dtype)
+        out_type = get_real_dtype(dtype)
+        assert_equal(linalg.cond(A, p=norm_ord).dtype, out_type)
+
     def test_singular(self):
         # Singular matrices have infinite condition number for
         # positive norms, and negative norms shouldn't raise

numpy/ma/extras.pyi

@@ -110,12 +110,16 @@ def cov(x, y=..., rowvar=..., bias=..., allow_masked=..., ddof=...): ...
 def corrcoef(x, y=..., rowvar=..., bias=..., allow_masked=..., ddof=...): ...
 
 class MAxisConcatenator(AxisConcatenator):
+    __slots__ = ()
+
     @staticmethod
     def concatenate(arrays: Incomplete, axis: int = 0) -> Incomplete: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
     @classmethod
     def makemat(cls, arr: Incomplete) -> Incomplete: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleVariableOverride]
 
 class mr_class(MAxisConcatenator):
+    __slots__ = ()
+
     def __init__(self) -> None: ...
 
 mr_: mr_class

numpy/random/tests/test_generator_mt19937.py

@@ -1858,6 +1858,11 @@ class TestRandomDist:
                             [2.07093587449261, 0.73073890064369]])
         assert_array_almost_equal(actual, desired, decimal=14)
 
+    def test_wald_nonnegative(self):
+        random = Generator(MT19937(self.seed))
+        samples = random.wald(mean=1e9, scale=2.25, size=1000)
+        assert_(np.all(samples >= 0.0))
+
     def test_weibull(self):
         random = Generator(MT19937(self.seed))
         actual = random.weibull(a=1.23, size=(3, 2))

numpy/testing/_private/extbuild.pyi

@@ -10,7 +10,7 @@ def build_and_import_extension(
     *,
     prologue: str = "",
     build_dir: pathlib.Path | None = None,
-    include_dirs: Sequence[str] = [],
+    include_dirs: Sequence[str] | None = None,
     more_init: str = "",
 ) -> types.ModuleType: ...
 
@@ -20,6 +20,6 @@ def compile_extension_module(
     builddir: pathlib.Path,
     include_dirs: Sequence[str],
     source_string: str,
-    libraries: Sequence[str] = [],
-    library_dirs: Sequence[str] = [],
+    libraries: Sequence[str] | None = None,
+    library_dirs: Sequence[str] | None = None,
 ) -> pathlib.Path: ...

numpy/testing/_private/utils.pyi

@@ -170,7 +170,7 @@ else:
     def memusage() -> NoReturn: ...
 
 if sys.platform == "linux":
-    def jiffies(_proc_pid_stat: StrOrBytesPath = ..., _load_time: list[float] = []) -> int: ...
+    def jiffies(_proc_pid_stat: StrOrBytesPath | None = None, _load_time: list[float] | None = None) -> int: ...
 else:
     def jiffies(_load_time: list[float] = []) -> int: ...
 

numpy/tests/test_configtool.py

@@ -33,7 +33,7 @@ class TestNumpyConfig:
 
     def test_configtool_pkgconfigdir(self):
         stdout = self.check_numpyconfig('--pkgconfigdir')
-        assert pathlib.Path(stdout) == PKG_CONFIG_DIR
+        assert pathlib.Path(stdout) == PKG_CONFIG_DIR.resolve()
 
 
 @pytest.mark.skipif(not IS_INSTALLED, reason="numpy must be installed to check its entrypoints")

numpy/typing/tests/data/fail/arithmetic.pyi

@@ -114,7 +114,7 @@ AR_f **= AR_LIKE_c  # type: ignore[arg-type]
 
 # Scalars
 
-b_ - b_  # type: ignore[call-overload]
+b_ - b_  # type: ignore[operator]
 
 dt + dt  # type: ignore[operator]
 td - dt  # type: ignore[operator]

numpy/typing/tests/data/fail/bitwise_ops.pyi

@@ -8,10 +8,10 @@ i = int()
 
 f8 = np.float64()
 
-b_ >> f8  # type: ignore[call-overload]
-i8 << f8  # type: ignore[call-overload]
+b_ >> f8  # type: ignore[operator]
+i8 << f8  # type: ignore[operator]
 i | f8  # type: ignore[operator]
-i8 ^ f8  # type: ignore[call-overload]
-u8 & f8  # type: ignore[call-overload]
+i8 ^ f8  # type: ignore[operator]
+u8 & f8  # type: ignore[operator]
 ~f8  # type: ignore[operator]
 # TODO: Certain mixes like i4 << u8 go to float and thus should fail

numpy/typing/tests/data/fail/scalars.pyi

@@ -47,12 +47,12 @@ np.uint64(A())  # type: ignore[arg-type]
 np.void("test")  # type: ignore[call-overload]
 np.void("test", dtype=None)  # type: ignore[call-overload]
 
-np.generic(1)  # type: ignore[abstract]
-np.number(1)  # type: ignore[abstract]
-np.integer(1)  # type: ignore[abstract]
-np.inexact(1)  # type: ignore[abstract]
-np.character("test")  # type: ignore[abstract]
-np.flexible(b"test")  # type: ignore[abstract]
+np.generic(1)  # type: ignore[abstract, call-arg]
+np.number(1)  # type: ignore[abstract, call-arg]
+np.integer(1)  # type: ignore[abstract, call-arg]
+np.inexact(1)  # type: ignore[abstract, call-arg]
+np.character("test")  # type: ignore[abstract, call-arg]
+np.flexible(b"test")  # type: ignore[abstract, call-arg]
 
 np.float64(value=0.0)  # type: ignore[call-arg]
 np.int64(value=0)  # type: ignore[call-arg]

numpy/typing/tests/data/reveal/arithmetic.pyi

@@ -3,7 +3,7 @@ from typing import Any, assert_type
 
 import numpy as np
 import numpy.typing as npt
-from numpy._typing import _32Bit, _64Bit, _128Bit
+from numpy._typing import _64Bit, _128Bit
 
 b: bool
 c: complex
@@ -487,7 +487,7 @@ assert_type(c8 / b_, np.complex64)
 
 # Complex
 
-assert_type(c16 + f16, np.complex128 | np.complexfloating[_128Bit, _128Bit])
+assert_type(c16 + f16, np.complexfloating)
 assert_type(c16 + c16, np.complex128)
 assert_type(c16 + f8, np.complex128)
 assert_type(c16 + i8, np.complex128)
@@ -500,12 +500,12 @@ assert_type(c16 + c, np.complex128)
 assert_type(c16 + f, np.complex128)
 assert_type(c16 + AR_f, npt.NDArray[np.complex128])
 
-assert_type(f16 + c16, np.complex128 | np.complexfloating[_128Bit, _128Bit])
+assert_type(f16 + c16, np.complexfloating)
 assert_type(c16 + c16, np.complex128)
 assert_type(f8 + c16, np.complex128)
 assert_type(i8 + c16, np.complex128)
 assert_type(c8 + c16, np.complex128 | np.complex64)
-assert_type(f4 + c16, np.complex128 | np.complex64)
+assert_type(f4 + c16, np.complexfloating)
 assert_type(i4 + c16, np.complex128)
 assert_type(b_ + c16, np.complex128)
 assert_type(b + c16, np.complex128)
@@ -513,10 +513,10 @@ assert_type(c + c16, np.complex128)
 assert_type(f + c16, np.complex128)
 assert_type(AR_f + c16, npt.NDArray[np.complex128])
 
-assert_type(c8 + f16, np.complexfloating[_32Bit, _32Bit] | np.complexfloating[_128Bit, _128Bit])
+assert_type(c8 + f16, np.complex64 | np.complexfloating[_128Bit, _128Bit])
 assert_type(c8 + c16, np.complex64 | np.complex128)
 assert_type(c8 + f8, np.complex64 | np.complex128)
-assert_type(c8 + i8, np.complexfloating[_32Bit, _32Bit] | np.complexfloating[_64Bit, _64Bit])
+assert_type(c8 + i8, np.complex64 | np.complexfloating[_64Bit, _64Bit])
 assert_type(c8 + c8, np.complex64)
 assert_type(c8 + f4, np.complex64)
 assert_type(c8 + i4, np.complex64)
@@ -541,7 +541,7 @@ assert_type(AR_f + c8, npt.NDArray[np.complexfloating])
 
 # Float
 
-assert_type(f8 + f16, np.float64 | np.floating[_128Bit])
+assert_type(f8 + f16, np.floating)
 assert_type(f8 + f8, np.float64)
 assert_type(f8 + i8, np.float64)
 assert_type(f8 + f4, np.float64)
@@ -552,44 +552,44 @@ assert_type(f8 + c, np.float64 | np.complex128)
 assert_type(f8 + f, np.float64)
 assert_type(f8 + AR_f, npt.NDArray[np.float64])
 
-assert_type(f16 + f8, np.floating[_128Bit] | np.float64)
+assert_type(f16 + f8, np.floating)
 assert_type(f8 + f8, np.float64)
 assert_type(i8 + f8, np.float64)
-assert_type(f4 + f8, np.float32 | np.float64)
-assert_type(i4 + f8,np.float64)
+assert_type(f4 + f8, np.floating)
+assert_type(i4 + f8, np.float64)
 assert_type(b_ + f8, np.float64)
 assert_type(b + f8, np.float64)
 assert_type(c + f8, np.complex128 | np.float64)
 assert_type(f + f8, np.float64)
 assert_type(AR_f + f8, npt.NDArray[np.float64])
 
-assert_type(f4 + f16, np.float32 | np.floating[_128Bit])
-assert_type(f4 + f8, np.float32 | np.float64)
-assert_type(f4 + i8, np.float32 | np.floating[_64Bit])
+assert_type(f4 + f16, np.floating)
+assert_type(f4 + f8, np.floating)
+assert_type(f4 + i8, np.floating)
 assert_type(f4 + f4, np.float32)
-assert_type(f4 + i4, np.float32)
+assert_type(f4 + i4, np.floating)
 assert_type(f4 + b_, np.float32)
 assert_type(f4 + b, np.float32)
-assert_type(f4 + c, np.complex64 | np.complex128)
-assert_type(f4 + f, np.float32 | np.float64)
+assert_type(f4 + c, np.complexfloating)
+assert_type(f4 + f, np.float32)
 assert_type(f4 + AR_f, npt.NDArray[np.float64])
 
-assert_type(f16 + f4, np.floating[_128Bit] | np.float32)
+assert_type(f16 + f4, np.floating)
 assert_type(f8 + f4, np.float64)
-assert_type(i8 + f4, np.floating[_32Bit] | np.floating[_64Bit])
+assert_type(i8 + f4, np.floating)
 assert_type(f4 + f4, np.float32)
-assert_type(i4 + f4, np.float32)
+assert_type(i4 + f4, np.floating)
 assert_type(b_ + f4, np.float32)
 assert_type(b + f4, np.float32)
-assert_type(c + f4, np.complex64 | np.complex128)
-assert_type(f + f4, np.float64 | np.float32)
+assert_type(c + f4, np.complexfloating)
+assert_type(f + f4, np.float32)
 assert_type(AR_f + f4, npt.NDArray[np.float64])
 
 # Int
 
 assert_type(i8 + i8, np.int64)
 assert_type(i8 + u8, Any)
-assert_type(i8 + i4, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
+assert_type(i8 + i4, np.signedinteger)
 assert_type(i8 + u4, Any)
 assert_type(i8 + b_, np.int64)
 assert_type(i8 + b, np.int64)
@@ -599,7 +599,7 @@ assert_type(i8 + AR_f, npt.NDArray[np.float64])
 
 assert_type(u8 + u8, np.uint64)
 assert_type(u8 + i4, Any)
-assert_type(u8 + u4, np.unsignedinteger[_32Bit] | np.unsignedinteger[_64Bit])
+assert_type(u8 + u4, np.unsignedinteger)
 assert_type(u8 + b_, np.uint64)
 assert_type(u8 + b, np.uint64)
 assert_type(u8 + c, np.complex128)
@@ -608,7 +608,7 @@ assert_type(u8 + AR_f, npt.NDArray[np.float64])
 
 assert_type(i8 + i8, np.int64)
 assert_type(u8 + i8, Any)
-assert_type(i4 + i8, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
+assert_type(i4 + i8, np.signedinteger)
 assert_type(u4 + i8, Any)
 assert_type(b_ + i8, np.int64)
 assert_type(b + i8, np.int64)
@@ -618,14 +618,14 @@ assert_type(AR_f + i8, npt.NDArray[np.float64])
 
 assert_type(u8 + u8, np.uint64)
 assert_type(i4 + u8, Any)
-assert_type(u4 + u8, np.unsignedinteger[_32Bit] | np.unsignedinteger[_64Bit])
+assert_type(u4 + u8, np.unsignedinteger)
 assert_type(b_ + u8, np.uint64)
 assert_type(b + u8, np.uint64)
 assert_type(c + u8, np.complex128)
 assert_type(f + u8, np.float64)
 assert_type(AR_f + u8, npt.NDArray[np.float64])
 
-assert_type(i4 + i8, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
+assert_type(i4 + i8, np.signedinteger)
 assert_type(i4 + i4, np.int32)
 assert_type(i4 + b_, np.int32)
 assert_type(i4 + b, np.int32)
@@ -633,13 +633,13 @@ assert_type(i4 + AR_f, npt.NDArray[np.float64])
 
 assert_type(u4 + i8, Any)
 assert_type(u4 + i4, Any)
-assert_type(u4 + u8, np.unsignedinteger[_32Bit] | np.unsignedinteger[_64Bit])
+assert_type(u4 + u8, np.unsignedinteger)
 assert_type(u4 + u4, np.uint32)
 assert_type(u4 + b_, np.uint32)
 assert_type(u4 + b, np.uint32)
 assert_type(u4 + AR_f, npt.NDArray[np.float64])
 
-assert_type(i8 + i4, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
+assert_type(i8 + i4, np.signedinteger)
 assert_type(i4 + i4, np.int32)
 assert_type(b_ + i4, np.int32)
 assert_type(b + i4, np.int32)
@@ -647,7 +647,7 @@ assert_type(AR_f + i4, npt.NDArray[np.float64])
 
 assert_type(i8 + u4, Any)
 assert_type(i4 + u4, Any)
-assert_type(u8 + u4, np.unsignedinteger[_32Bit] | np.unsignedinteger[_64Bit])
+assert_type(u8 + u4, np.unsignedinteger)
 assert_type(u4 + u4, np.uint32)
 assert_type(b_ + u4, np.uint32)
 assert_type(b + u4, np.uint32)

numpy/typing/tests/data/reveal/array_constructors.pyi

@@ -53,7 +53,7 @@ assert_type(np.empty([1, 5, 6], dtype='c16'), npt.NDArray[Any])
 assert_type(np.empty(mixed_shape), npt.NDArray[np.float64])
 
 assert_type(np.concatenate(A), npt.NDArray[np.float64])
-assert_type(np.concatenate([A, A]), Any)  # pyright correctly infers this as NDArray[float64]
+assert_type(np.concatenate([A, A]), npt.NDArray[Any])  # pyright correctly infers this as NDArray[float64]
 assert_type(np.concatenate([[1], A]), npt.NDArray[Any])
 assert_type(np.concatenate([[1], [1]]), npt.NDArray[Any])
 assert_type(np.concatenate((A, A)), npt.NDArray[np.float64])
@@ -222,19 +222,19 @@ assert_type(np.atleast_3d(A), npt.NDArray[np.float64])
 assert_type(np.atleast_3d(A, A), tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]])
 assert_type(np.atleast_3d(A, A, A), tuple[npt.NDArray[np.float64], ...])
 
-assert_type(np.vstack([A, A]), np.ndarray[Any, Any])  # pyright correctly infers this as NDArray[float64]
+assert_type(np.vstack([A, A]), npt.NDArray[np.float64])
 assert_type(np.vstack([A, A], dtype=np.float32), npt.NDArray[np.float32])
 assert_type(np.vstack([A, C]), npt.NDArray[Any])
 assert_type(np.vstack([C, C]), npt.NDArray[Any])
 
-assert_type(np.hstack([A, A]), np.ndarray[Any, Any])  # pyright correctly infers this as NDArray[float64]
+assert_type(np.hstack([A, A]), npt.NDArray[np.float64])
 assert_type(np.hstack([A, A], dtype=np.float32), npt.NDArray[np.float32])
 
-assert_type(np.stack([A, A]), np.ndarray[Any, Any])  # pyright correctly infers this as NDArray[float64]
+assert_type(np.stack([A, A]), npt.NDArray[np.float64])
 assert_type(np.stack([A, A], dtype=np.float32), npt.NDArray[np.float32])
 assert_type(np.stack([A, C]), npt.NDArray[Any])
 assert_type(np.stack([C, C]), npt.NDArray[Any])
-assert_type(np.stack([A, A], axis=0), np.ndarray[Any, Any])  # pyright correctly infers this as NDArray[float64]
+assert_type(np.stack([A, A], axis=0), npt.NDArray[np.float64])
 assert_type(np.stack([A, A], out=B), SubClass[np.float64])
 
 assert_type(np.block([[A, A], [A, A]]), npt.NDArray[Any])  # pyright correctly infers this as NDArray[float64]

numpy/typing/tests/data/reveal/bitwise_ops.pyi

@@ -3,7 +3,6 @@ from typing import Literal as L
 
 import numpy as np
 import numpy.typing as npt
-from numpy._typing import _32Bit, _64Bit
 
 FalseType: TypeAlias = L[False]
 TrueType: TypeAlias = L[True]
@@ -44,11 +43,11 @@ assert_type(i4 | i4, np.int32)
 assert_type(i4 ^ i4, np.int32)
 assert_type(i4 & i4, np.int32)
 
-assert_type(i8 << i4, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
-assert_type(i8 >> i4, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
-assert_type(i8 | i4, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
-assert_type(i8 ^ i4, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
-assert_type(i8 & i4, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
+assert_type(i8 << i4, np.signedinteger)
+assert_type(i8 >> i4, np.signedinteger)
+assert_type(i8 | i4, np.signedinteger)
+assert_type(i8 ^ i4, np.signedinteger)
+assert_type(i8 & i4, np.signedinteger)
 
 assert_type(i8 << b_, np.int64)
 assert_type(i8 >> b_, np.int64)
@@ -86,11 +85,11 @@ assert_type(u4 | i4, np.signedinteger)
 assert_type(u4 ^ i4, np.signedinteger)
 assert_type(u4 & i4, np.signedinteger)
 
-assert_type(u4 << i, np.signedinteger)
-assert_type(u4 >> i, np.signedinteger)
-assert_type(u4 | i, np.signedinteger)
-assert_type(u4 ^ i, np.signedinteger)
-assert_type(u4 & i, np.signedinteger)
+assert_type(u4 << i, np.uint32)
+assert_type(u4 >> i, np.uint32)
+assert_type(u4 | i, np.uint32)
+assert_type(u4 ^ i, np.uint32)
+assert_type(u4 & i, np.uint32)
 
 assert_type(u8 << b_, np.uint64)
 assert_type(u8 >> b_, np.uint64)

numpy/typing/tests/data/reveal/linalg.pyi

@@ -43,9 +43,9 @@ assert_type(np.linalg.cholesky(AR_i8), npt.NDArray[np.float64])
 assert_type(np.linalg.cholesky(AR_f8), npt.NDArray[np.floating])
 assert_type(np.linalg.cholesky(AR_c16), npt.NDArray[np.complexfloating])
 
-assert_type(np.linalg.outer(AR_i8, AR_i8), npt.NDArray[np.signedinteger])
-assert_type(np.linalg.outer(AR_f8, AR_f8), npt.NDArray[np.floating])
-assert_type(np.linalg.outer(AR_c16, AR_c16), npt.NDArray[np.complexfloating])
+assert_type(np.linalg.outer(AR_i8, AR_i8), npt.NDArray[np.int64])
+assert_type(np.linalg.outer(AR_f8, AR_f8), npt.NDArray[np.float64])
+assert_type(np.linalg.outer(AR_c16, AR_c16), npt.NDArray[np.complex128])
 assert_type(np.linalg.outer(AR_b, AR_b), npt.NDArray[np.bool])
 assert_type(np.linalg.outer(AR_O, AR_O), npt.NDArray[np.object_])
 assert_type(np.linalg.outer(AR_i8, AR_m), npt.NDArray[np.timedelta64])
@@ -127,6 +127,6 @@ assert_type(np.linalg.cross(AR_i8, AR_i8), npt.NDArray[np.signedinteger])
 assert_type(np.linalg.cross(AR_f8, AR_f8), npt.NDArray[np.floating])
 assert_type(np.linalg.cross(AR_c16, AR_c16), npt.NDArray[np.complexfloating])
 
-assert_type(np.linalg.matmul(AR_i8, AR_i8), npt.NDArray[np.signedinteger])
-assert_type(np.linalg.matmul(AR_f8, AR_f8), npt.NDArray[np.floating])
-assert_type(np.linalg.matmul(AR_c16, AR_c16), npt.NDArray[np.complexfloating])
+assert_type(np.linalg.matmul(AR_i8, AR_i8), npt.NDArray[np.int64])
+assert_type(np.linalg.matmul(AR_f8, AR_f8), npt.NDArray[np.float64])
+assert_type(np.linalg.matmul(AR_c16, AR_c16), npt.NDArray[np.complex128])