numpy 2.3.5__cp313-cp313-macosx_14_0_arm64.whl

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

@@ -0,0 +1,198 @@
+import contextlib
+import re
+import sys
+import types
+import unittest
+import warnings
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any, TypeVar, assert_type
+
+import numpy as np
+import numpy.typing as npt
+
+AR_f8: npt.NDArray[np.float64]
+AR_i8: npt.NDArray[np.int64]
+
+bool_obj: bool
+suppress_obj: np.testing.suppress_warnings
+FT = TypeVar("FT", bound=Callable[..., Any])
+
+def func() -> int: ...
+
+def func2(
+    x: npt.NDArray[np.number],
+    y: npt.NDArray[np.number],
+) -> npt.NDArray[np.bool]: ...
+
+assert_type(np.testing.KnownFailureException(), np.testing.KnownFailureException)
+assert_type(np.testing.IgnoreException(), np.testing.IgnoreException)
+
+assert_type(
+    np.testing.clear_and_catch_warnings(modules=[np.testing]),
+    np.testing.clear_and_catch_warnings[None],
+)
+assert_type(
+    np.testing.clear_and_catch_warnings(True),
+    np.testing.clear_and_catch_warnings[list[warnings.WarningMessage]],
+)
+assert_type(
+    np.testing.clear_and_catch_warnings(False),
+    np.testing.clear_and_catch_warnings[None],
+)
+assert_type(
+    np.testing.clear_and_catch_warnings(bool_obj),
+    np.testing.clear_and_catch_warnings,
+)
+assert_type(
+    np.testing.clear_and_catch_warnings.class_modules,
+    tuple[types.ModuleType, ...],
+)
+assert_type(
+    np.testing.clear_and_catch_warnings.modules,
+    set[types.ModuleType],
+)
+
+with np.testing.clear_and_catch_warnings(True) as c1:
+    assert_type(c1, list[warnings.WarningMessage])
+with np.testing.clear_and_catch_warnings() as c2:
+    assert_type(c2, None)
+
+assert_type(np.testing.suppress_warnings("once"), np.testing.suppress_warnings)
+assert_type(np.testing.suppress_warnings()(func), Callable[[], int])
+assert_type(suppress_obj.filter(RuntimeWarning), None)
+assert_type(suppress_obj.record(RuntimeWarning), list[warnings.WarningMessage])
+with suppress_obj as c3:
+    assert_type(c3, np.testing.suppress_warnings)
+
+assert_type(np.testing.verbose, int)
+assert_type(np.testing.IS_PYPY, bool)
+assert_type(np.testing.HAS_REFCOUNT, bool)
+assert_type(np.testing.HAS_LAPACK64, bool)
+
+assert_type(np.testing.assert_(1, msg="test"), None)
+assert_type(np.testing.assert_(2, msg=lambda: "test"), None)
+
+if sys.platform == "win32" or sys.platform == "cygwin":
+    assert_type(np.testing.memusage(), int)
+elif sys.platform == "linux":
+    assert_type(np.testing.memusage(), int | None)
+
+assert_type(np.testing.jiffies(), int)
+
+assert_type(np.testing.build_err_msg([0, 1, 2], "test"), str)
+assert_type(np.testing.build_err_msg(range(2), "test", header="header"), str)
+assert_type(np.testing.build_err_msg(np.arange(9).reshape(3, 3), "test", verbose=False), str)
+assert_type(np.testing.build_err_msg("abc", "test", names=["x", "y"]), str)
+assert_type(np.testing.build_err_msg([1.0, 2.0], "test", precision=5), str)
+
+assert_type(np.testing.assert_equal({1}, {1}), None)
+assert_type(np.testing.assert_equal([1, 2, 3], [1, 2, 3], err_msg="fail"), None)
+assert_type(np.testing.assert_equal(1, 1.0, verbose=True), None)
+
+assert_type(np.testing.print_assert_equal('Test XYZ of func xyz', [0, 1], [0, 1]), None)
+
+assert_type(np.testing.assert_almost_equal(1.0, 1.1), None)
+assert_type(np.testing.assert_almost_equal([1, 2, 3], [1, 2, 3], err_msg="fail"), None)
+assert_type(np.testing.assert_almost_equal(1, 1.0, verbose=True), None)
+assert_type(np.testing.assert_almost_equal(1, 1.0001, decimal=2), None)
+
+assert_type(np.testing.assert_approx_equal(1.0, 1.1), None)
+assert_type(np.testing.assert_approx_equal("1", "2", err_msg="fail"), None)
+assert_type(np.testing.assert_approx_equal(1, 1.0, verbose=True), None)
+assert_type(np.testing.assert_approx_equal(1, 1.0001, significant=2), None)
+
+assert_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, err_msg="test"), None)
+assert_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, verbose=True), None)
+assert_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, header="header"), None)
+assert_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, precision=np.int64()), None)
+assert_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, equal_nan=False), None)
+assert_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, equal_inf=True), None)
+
+assert_type(np.testing.assert_array_equal(AR_i8, AR_f8), None)
+assert_type(np.testing.assert_array_equal(AR_i8, AR_f8, err_msg="test"), None)
+assert_type(np.testing.assert_array_equal(AR_i8, AR_f8, verbose=True), None)
+
+assert_type(np.testing.assert_array_almost_equal(AR_i8, AR_f8), None)
+assert_type(np.testing.assert_array_almost_equal(AR_i8, AR_f8, err_msg="test"), None)
+assert_type(np.testing.assert_array_almost_equal(AR_i8, AR_f8, verbose=True), None)
+assert_type(np.testing.assert_array_almost_equal(AR_i8, AR_f8, decimal=1), None)
+
+assert_type(np.testing.assert_array_less(AR_i8, AR_f8), None)
+assert_type(np.testing.assert_array_less(AR_i8, AR_f8, err_msg="test"), None)
+assert_type(np.testing.assert_array_less(AR_i8, AR_f8, verbose=True), None)
+
+assert_type(np.testing.runstring("1 + 1", {}), Any)
+assert_type(np.testing.runstring("int64() + 1", {"int64": np.int64}), Any)
+
+assert_type(np.testing.assert_string_equal("1", "1"), None)
+
+assert_type(np.testing.rundocs(), None)
+assert_type(np.testing.rundocs("test.py"), None)
+assert_type(np.testing.rundocs(Path("test.py"), raise_on_error=True), None)
+
+def func3(a: int) -> bool: ...
+
+assert_type(
+    np.testing.assert_raises(RuntimeWarning),
+    unittest.case._AssertRaisesContext[RuntimeWarning],
+)
+assert_type(np.testing.assert_raises(RuntimeWarning, func3, 5), None)
+
+assert_type(
+    np.testing.assert_raises_regex(RuntimeWarning, r"test"),
+    unittest.case._AssertRaisesContext[RuntimeWarning],
+)
+assert_type(np.testing.assert_raises_regex(RuntimeWarning, b"test", func3, 5), None)
+assert_type(np.testing.assert_raises_regex(RuntimeWarning, re.compile(b"test"), func3, 5), None)
+
+class Test: ...
+
+def decorate(a: FT) -> FT:
+    return a
+
+assert_type(np.testing.decorate_methods(Test, decorate), None)
+assert_type(np.testing.decorate_methods(Test, decorate, None), None)
+assert_type(np.testing.decorate_methods(Test, decorate, "test"), None)
+assert_type(np.testing.decorate_methods(Test, decorate, b"test"), None)
+assert_type(np.testing.decorate_methods(Test, decorate, re.compile("test")), None)
+
+assert_type(np.testing.measure("for i in range(1000): np.sqrt(i**2)"), float)
+assert_type(np.testing.measure(b"for i in range(1000): np.sqrt(i**2)", times=5), float)
+
+assert_type(np.testing.assert_allclose(AR_i8, AR_f8), None)
+assert_type(np.testing.assert_allclose(AR_i8, AR_f8, rtol=0.005), None)
+assert_type(np.testing.assert_allclose(AR_i8, AR_f8, atol=1), None)
+assert_type(np.testing.assert_allclose(AR_i8, AR_f8, equal_nan=True), None)
+assert_type(np.testing.assert_allclose(AR_i8, AR_f8, err_msg="err"), None)
+assert_type(np.testing.assert_allclose(AR_i8, AR_f8, verbose=False), None)
+
+assert_type(np.testing.assert_array_almost_equal_nulp(AR_i8, AR_f8, nulp=2), None)
+
+assert_type(np.testing.assert_array_max_ulp(AR_i8, AR_f8, maxulp=2), npt.NDArray[Any])
+assert_type(np.testing.assert_array_max_ulp(AR_i8, AR_f8, dtype=np.float32), npt.NDArray[Any])
+
+assert_type(np.testing.assert_warns(RuntimeWarning), contextlib._GeneratorContextManager[None])
+assert_type(np.testing.assert_warns(RuntimeWarning, func3, 5), bool)
+
+def func4(a: int, b: str) -> bool: ...
+
+assert_type(np.testing.assert_no_warnings(), contextlib._GeneratorContextManager[None])
+assert_type(np.testing.assert_no_warnings(func3, 5), bool)
+assert_type(np.testing.assert_no_warnings(func4, a=1, b="test"), bool)
+assert_type(np.testing.assert_no_warnings(func4, 1, "test"), bool)
+
+assert_type(np.testing.tempdir("test_dir"), contextlib._GeneratorContextManager[str])
+assert_type(np.testing.tempdir(prefix=b"test"), contextlib._GeneratorContextManager[bytes])
+assert_type(np.testing.tempdir("test_dir", dir=Path("here")), contextlib._GeneratorContextManager[str])
+
+assert_type(np.testing.temppath("test_dir", text=True), contextlib._GeneratorContextManager[str])
+assert_type(np.testing.temppath(prefix=b"test"), contextlib._GeneratorContextManager[bytes])
+assert_type(np.testing.temppath("test_dir", dir=Path("here")), contextlib._GeneratorContextManager[str])
+
+assert_type(np.testing.assert_no_gc_cycles(), contextlib._GeneratorContextManager[None])
+assert_type(np.testing.assert_no_gc_cycles(func3, 5), None)
+
+assert_type(np.testing.break_cycles(), None)
+
+assert_type(np.testing.TestCase(), unittest.case.TestCase)

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

@@ -0,0 +1,145 @@
+from typing import Any, TypeVar, assert_type
+
+import numpy as np
+import numpy.typing as npt
+
+_ScalarT = TypeVar("_ScalarT", bound=np.generic)
+
+def func1(ar: npt.NDArray[_ScalarT], a: int) -> npt.NDArray[_ScalarT]: ...
+
+def func2(ar: npt.NDArray[np.number], a: str) -> npt.NDArray[np.float64]: ...
+
+AR_b: npt.NDArray[np.bool]
+AR_u: npt.NDArray[np.uint64]
+AR_i: npt.NDArray[np.int64]
+AR_f: npt.NDArray[np.float64]
+AR_c: npt.NDArray[np.complex128]
+AR_O: npt.NDArray[np.object_]
+
+AR_LIKE_b: list[bool]
+AR_LIKE_c: list[complex]
+
+assert_type(np.fliplr(AR_b), npt.NDArray[np.bool])
+assert_type(np.fliplr(AR_LIKE_b), npt.NDArray[Any])
+
+assert_type(np.flipud(AR_b), npt.NDArray[np.bool])
+assert_type(np.flipud(AR_LIKE_b), npt.NDArray[Any])
+
+assert_type(np.eye(10), npt.NDArray[np.float64])
+assert_type(np.eye(10, M=20, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.eye(10, k=2, dtype=int), npt.NDArray[Any])
+
+assert_type(np.diag(AR_b), npt.NDArray[np.bool])
+assert_type(np.diag(AR_LIKE_b, k=0), npt.NDArray[Any])
+
+assert_type(np.diagflat(AR_b), npt.NDArray[np.bool])
+assert_type(np.diagflat(AR_LIKE_b, k=0), npt.NDArray[Any])
+
+assert_type(np.tri(10), npt.NDArray[np.float64])
+assert_type(np.tri(10, M=20, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.tri(10, k=2, dtype=int), npt.NDArray[Any])
+
+assert_type(np.tril(AR_b), npt.NDArray[np.bool])
+assert_type(np.tril(AR_LIKE_b, k=0), npt.NDArray[Any])
+
+assert_type(np.triu(AR_b), npt.NDArray[np.bool])
+assert_type(np.triu(AR_LIKE_b, k=0), npt.NDArray[Any])
+
+assert_type(np.vander(AR_b), npt.NDArray[np.signedinteger])
+assert_type(np.vander(AR_u), npt.NDArray[np.signedinteger])
+assert_type(np.vander(AR_i, N=2), npt.NDArray[np.signedinteger])
+assert_type(np.vander(AR_f, increasing=True), npt.NDArray[np.floating])
+assert_type(np.vander(AR_c), npt.NDArray[np.complexfloating])
+assert_type(np.vander(AR_O), npt.NDArray[np.object_])
+
+assert_type(
+    np.histogram2d(AR_LIKE_c, AR_LIKE_c),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.complex128 | np.float64],
+        npt.NDArray[np.complex128 | np.float64],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_i, AR_b),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_f, AR_i),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_i, AR_f),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_f, AR_c, weights=AR_LIKE_b),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.complex128],
+        npt.NDArray[np.complex128],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_f, AR_c, bins=8),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.complex128],
+        npt.NDArray[np.complex128],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_c, AR_f, bins=(8, 5)),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.complex128],
+        npt.NDArray[np.complex128],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_c, AR_i, bins=AR_u),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.uint64],
+        npt.NDArray[np.uint64],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_c, AR_c, bins=(AR_u, AR_u)),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.uint64],
+        npt.NDArray[np.uint64],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_c, AR_c, bins=(AR_b, 8)),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.bool | np.complex128],
+        npt.NDArray[np.bool | np.complex128],
+    ],
+)
+
+assert_type(np.mask_indices(10, func1), tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])
+assert_type(np.mask_indices(8, func2, "0"), tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])
+
+assert_type(np.tril_indices(10), tuple[npt.NDArray[np.int_], npt.NDArray[np.int_]])
+
+assert_type(np.tril_indices_from(AR_b), tuple[npt.NDArray[np.int_], npt.NDArray[np.int_]])
+
+assert_type(np.triu_indices(10), tuple[npt.NDArray[np.int_], npt.NDArray[np.int_]])
+
+assert_type(np.triu_indices_from(AR_b), tuple[npt.NDArray[np.int_], npt.NDArray[np.int_]])

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

@@ -0,0 +1,67 @@
+from typing import Any, Literal, assert_type
+
+import numpy as np
+import numpy.typing as npt
+
+f8: np.float64
+f: float
+
+# NOTE: Avoid importing the platform specific `np.float128` type
+AR_i8: npt.NDArray[np.int64]
+AR_i4: npt.NDArray[np.int32]
+AR_f2: npt.NDArray[np.float16]
+AR_f8: npt.NDArray[np.float64]
+AR_f16: npt.NDArray[np.longdouble]
+AR_c8: npt.NDArray[np.complex64]
+AR_c16: npt.NDArray[np.complex128]
+
+AR_LIKE_f: list[float]
+
+class ComplexObj:
+    real: slice
+    imag: slice
+
+assert_type(np.mintypecode(["f8"], typeset="qfQF"), str)
+
+assert_type(np.real(ComplexObj()), slice)
+assert_type(np.real(AR_f8), npt.NDArray[np.float64])
+assert_type(np.real(AR_c16), npt.NDArray[np.float64])
+assert_type(np.real(AR_LIKE_f), npt.NDArray[Any])
+
+assert_type(np.imag(ComplexObj()), slice)
+assert_type(np.imag(AR_f8), npt.NDArray[np.float64])
+assert_type(np.imag(AR_c16), npt.NDArray[np.float64])
+assert_type(np.imag(AR_LIKE_f), npt.NDArray[Any])
+
+assert_type(np.iscomplex(f8), np.bool)
+assert_type(np.iscomplex(AR_f8), npt.NDArray[np.bool])
+assert_type(np.iscomplex(AR_LIKE_f), npt.NDArray[np.bool])
+
+assert_type(np.isreal(f8), np.bool)
+assert_type(np.isreal(AR_f8), npt.NDArray[np.bool])
+assert_type(np.isreal(AR_LIKE_f), npt.NDArray[np.bool])
+
+assert_type(np.iscomplexobj(f8), bool)
+assert_type(np.isrealobj(f8), bool)
+
+assert_type(np.nan_to_num(f8), np.float64)
+assert_type(np.nan_to_num(f, copy=True), Any)
+assert_type(np.nan_to_num(AR_f8, nan=1.5), npt.NDArray[np.float64])
+assert_type(np.nan_to_num(AR_LIKE_f, posinf=9999), npt.NDArray[Any])
+
+assert_type(np.real_if_close(AR_f8), npt.NDArray[np.float64])
+assert_type(np.real_if_close(AR_c16), npt.NDArray[np.float64 | np.complex128])
+assert_type(np.real_if_close(AR_c8), npt.NDArray[np.float32 | np.complex64])
+assert_type(np.real_if_close(AR_LIKE_f), npt.NDArray[Any])
+
+assert_type(np.typename("h"), Literal["short"])
+assert_type(np.typename("B"), Literal["unsigned char"])
+assert_type(np.typename("V"), Literal["void"])
+assert_type(np.typename("S1"), Literal["character"])
+
+assert_type(np.common_type(AR_i4), type[np.float64])
+assert_type(np.common_type(AR_f2), type[np.float16])
+assert_type(np.common_type(AR_f2, AR_i4), type[np.float64])
+assert_type(np.common_type(AR_f16, AR_i4), type[np.longdouble])
+assert_type(np.common_type(AR_c8, AR_f2), type[np.complex64])
+assert_type(np.common_type(AR_f2, AR_c8, AR_i4), type[np.complexfloating])

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

@@ -0,0 +1,30 @@
+"""Typing tests for `_core._ufunc_config`."""
+
+from collections.abc import Callable
+from typing import Any, assert_type
+
+from _typeshed import SupportsWrite
+
+import numpy as np
+
+def func(a: str, b: int) -> None: ...
+
+class Write:
+    def write(self, value: str) -> None: ...
+
+assert_type(np.seterr(all=None), np._core._ufunc_config._ErrDict)
+assert_type(np.seterr(divide="ignore"), np._core._ufunc_config._ErrDict)
+assert_type(np.seterr(over="warn"), np._core._ufunc_config._ErrDict)
+assert_type(np.seterr(under="call"), np._core._ufunc_config._ErrDict)
+assert_type(np.seterr(invalid="raise"), np._core._ufunc_config._ErrDict)
+assert_type(np.geterr(), np._core._ufunc_config._ErrDict)
+
+assert_type(np.setbufsize(4096), int)
+assert_type(np.getbufsize(), int)
+
+assert_type(np.seterrcall(func), Callable[[str, int], Any] | SupportsWrite[str] | None)
+assert_type(np.seterrcall(Write()), Callable[[str, int], Any] | SupportsWrite[str] | None)
+assert_type(np.geterrcall(), Callable[[str, int], Any] | SupportsWrite[str] | None)
+
+assert_type(np.errstate(call=func, all="call"), np.errstate)
+assert_type(np.errstate(call=Write(), divide="log", over="log"), np.errstate)

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

@@ -0,0 +1,31 @@
+from typing import Any, assert_type
+
+import numpy as np
+import numpy.typing as npt
+
+AR_LIKE_b: list[bool]
+AR_LIKE_u: list[np.uint32]
+AR_LIKE_i: list[int]
+AR_LIKE_f: list[float]
+AR_LIKE_O: list[np.object_]
+
+AR_U: npt.NDArray[np.str_]
+
+assert_type(np.fix(AR_LIKE_b), npt.NDArray[np.floating])
+assert_type(np.fix(AR_LIKE_u), npt.NDArray[np.floating])
+assert_type(np.fix(AR_LIKE_i), npt.NDArray[np.floating])
+assert_type(np.fix(AR_LIKE_f), npt.NDArray[np.floating])
+assert_type(np.fix(AR_LIKE_O), npt.NDArray[np.object_])
+assert_type(np.fix(AR_LIKE_f, out=AR_U), npt.NDArray[np.str_])
+
+assert_type(np.isposinf(AR_LIKE_b), npt.NDArray[np.bool])
+assert_type(np.isposinf(AR_LIKE_u), npt.NDArray[np.bool])
+assert_type(np.isposinf(AR_LIKE_i), npt.NDArray[np.bool])
+assert_type(np.isposinf(AR_LIKE_f), npt.NDArray[np.bool])
+assert_type(np.isposinf(AR_LIKE_f, out=AR_U), npt.NDArray[np.str_])
+
+assert_type(np.isneginf(AR_LIKE_b), npt.NDArray[np.bool])
+assert_type(np.isneginf(AR_LIKE_u), npt.NDArray[np.bool])
+assert_type(np.isneginf(AR_LIKE_i), npt.NDArray[np.bool])
+assert_type(np.isneginf(AR_LIKE_f), npt.NDArray[np.bool])
+assert_type(np.isneginf(AR_LIKE_f, out=AR_U), npt.NDArray[np.str_])

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

@@ -0,0 +1,123 @@
+from typing import Any, Literal, NoReturn, assert_type
+
+import numpy as np
+import numpy.typing as npt
+
+i8: np.int64
+f8: np.float64
+AR_f8: npt.NDArray[np.float64]
+AR_i8: npt.NDArray[np.int64]
+
+assert_type(np.absolute.__doc__, str)
+assert_type(np.absolute.types, list[str])
+
+assert_type(np.absolute.__name__, Literal["absolute"])
+assert_type(np.absolute.__qualname__, Literal["absolute"])
+assert_type(np.absolute.ntypes, Literal[20])
+assert_type(np.absolute.identity, None)
+assert_type(np.absolute.nin, Literal[1])
+assert_type(np.absolute.nin, Literal[1])
+assert_type(np.absolute.nout, Literal[1])
+assert_type(np.absolute.nargs, Literal[2])
+assert_type(np.absolute.signature, None)
+assert_type(np.absolute(f8), Any)
+assert_type(np.absolute(AR_f8), npt.NDArray[Any])
+assert_type(np.absolute.at(AR_f8, AR_i8), None)
+
+assert_type(np.add.__name__, Literal["add"])
+assert_type(np.add.__qualname__, Literal["add"])
+assert_type(np.add.ntypes, Literal[22])
+assert_type(np.add.identity, Literal[0])
+assert_type(np.add.nin, Literal[2])
+assert_type(np.add.nout, Literal[1])
+assert_type(np.add.nargs, Literal[3])
+assert_type(np.add.signature, None)
+assert_type(np.add(f8, f8), Any)
+assert_type(np.add(AR_f8, f8), npt.NDArray[Any])
+assert_type(np.add.at(AR_f8, AR_i8, f8), None)
+assert_type(np.add.reduce(AR_f8, axis=0), Any)
+assert_type(np.add.accumulate(AR_f8), npt.NDArray[Any])
+assert_type(np.add.reduceat(AR_f8, AR_i8), npt.NDArray[Any])
+assert_type(np.add.outer(f8, f8), Any)
+assert_type(np.add.outer(AR_f8, f8), npt.NDArray[Any])
+
+assert_type(np.frexp.__name__, Literal["frexp"])
+assert_type(np.frexp.__qualname__, Literal["frexp"])
+assert_type(np.frexp.ntypes, Literal[4])
+assert_type(np.frexp.identity, None)
+assert_type(np.frexp.nin, Literal[1])
+assert_type(np.frexp.nout, Literal[2])
+assert_type(np.frexp.nargs, Literal[3])
+assert_type(np.frexp.signature, None)
+assert_type(np.frexp(f8), tuple[Any, Any])
+assert_type(np.frexp(AR_f8), tuple[npt.NDArray[Any], npt.NDArray[Any]])
+
+assert_type(np.divmod.__name__, Literal["divmod"])
+assert_type(np.divmod.__qualname__, Literal["divmod"])
+assert_type(np.divmod.ntypes, Literal[15])
+assert_type(np.divmod.identity, None)
+assert_type(np.divmod.nin, Literal[2])
+assert_type(np.divmod.nout, Literal[2])
+assert_type(np.divmod.nargs, Literal[4])
+assert_type(np.divmod.signature, None)
+assert_type(np.divmod(f8, f8), tuple[Any, Any])
+assert_type(np.divmod(AR_f8, f8), tuple[npt.NDArray[Any], npt.NDArray[Any]])
+
+assert_type(np.matmul.__name__, Literal["matmul"])
+assert_type(np.matmul.__qualname__, Literal["matmul"])
+assert_type(np.matmul.ntypes, Literal[19])
+assert_type(np.matmul.identity, None)
+assert_type(np.matmul.nin, Literal[2])
+assert_type(np.matmul.nout, Literal[1])
+assert_type(np.matmul.nargs, Literal[3])
+assert_type(np.matmul.signature, Literal["(n?,k),(k,m?)->(n?,m?)"])
+assert_type(np.matmul.identity, None)
+assert_type(np.matmul(AR_f8, AR_f8), Any)
+assert_type(np.matmul(AR_f8, AR_f8, axes=[(0, 1), (0, 1), (0, 1)]), Any)
+
+assert_type(np.vecdot.__name__, Literal["vecdot"])
+assert_type(np.vecdot.__qualname__, Literal["vecdot"])
+assert_type(np.vecdot.ntypes, Literal[19])
+assert_type(np.vecdot.identity, None)
+assert_type(np.vecdot.nin, Literal[2])
+assert_type(np.vecdot.nout, Literal[1])
+assert_type(np.vecdot.nargs, Literal[3])
+assert_type(np.vecdot.signature, Literal["(n),(n)->()"])
+assert_type(np.vecdot.identity, None)
+assert_type(np.vecdot(AR_f8, AR_f8), Any)
+
+assert_type(np.bitwise_count.__name__, Literal["bitwise_count"])
+assert_type(np.bitwise_count.__qualname__, Literal["bitwise_count"])
+assert_type(np.bitwise_count.ntypes, Literal[11])
+assert_type(np.bitwise_count.identity, None)
+assert_type(np.bitwise_count.nin, Literal[1])
+assert_type(np.bitwise_count.nout, Literal[1])
+assert_type(np.bitwise_count.nargs, Literal[2])
+assert_type(np.bitwise_count.signature, None)
+assert_type(np.bitwise_count.identity, None)
+assert_type(np.bitwise_count(i8), Any)
+assert_type(np.bitwise_count(AR_i8), npt.NDArray[Any])
+
+assert_type(np.absolute.outer(), NoReturn)
+assert_type(np.frexp.outer(), NoReturn)
+assert_type(np.divmod.outer(), NoReturn)
+assert_type(np.matmul.outer(), NoReturn)
+
+assert_type(np.absolute.reduceat(), NoReturn)
+assert_type(np.frexp.reduceat(), NoReturn)
+assert_type(np.divmod.reduceat(), NoReturn)
+assert_type(np.matmul.reduceat(), NoReturn)
+
+assert_type(np.absolute.reduce(), NoReturn)
+assert_type(np.frexp.reduce(), NoReturn)
+assert_type(np.divmod.reduce(), NoReturn)
+assert_type(np.matmul.reduce(), NoReturn)
+
+assert_type(np.absolute.accumulate(), NoReturn)
+assert_type(np.frexp.accumulate(), NoReturn)
+assert_type(np.divmod.accumulate(), NoReturn)
+assert_type(np.matmul.accumulate(), NoReturn)
+
+assert_type(np.frexp.at(), NoReturn)
+assert_type(np.divmod.at(), NoReturn)
+assert_type(np.matmul.at(), NoReturn)

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

@@ -0,0 +1,11 @@
+from typing import assert_type
+
+import numpy.exceptions as ex
+
+assert_type(ex.ModuleDeprecationWarning(), ex.ModuleDeprecationWarning)
+assert_type(ex.VisibleDeprecationWarning(), ex.VisibleDeprecationWarning)
+assert_type(ex.ComplexWarning(), ex.ComplexWarning)
+assert_type(ex.RankWarning(), ex.RankWarning)
+assert_type(ex.TooHardError(), ex.TooHardError)
+assert_type(ex.AxisError("test"), ex.AxisError)
+assert_type(ex.AxisError(5, 1), ex.AxisError)

numpy/typing/tests/test_isfile.py

@@ -0,0 +1,32 @@
+import os
+import sys
+from pathlib import Path
+
+import numpy as np
+from numpy.testing import assert_
+
+ROOT = Path(np.__file__).parents[0]
+FILES = [
+    ROOT / "py.typed",
+    ROOT / "__init__.pyi",
+    ROOT / "ctypeslib" / "__init__.pyi",
+    ROOT / "_core" / "__init__.pyi",
+    ROOT / "f2py" / "__init__.pyi",
+    ROOT / "fft" / "__init__.pyi",
+    ROOT / "lib" / "__init__.pyi",
+    ROOT / "linalg" / "__init__.pyi",
+    ROOT / "ma" / "__init__.pyi",
+    ROOT / "matrixlib" / "__init__.pyi",
+    ROOT / "polynomial" / "__init__.pyi",
+    ROOT / "random" / "__init__.pyi",
+    ROOT / "testing" / "__init__.pyi",
+]
+if sys.version_info < (3, 12):
+    FILES += [ROOT / "distutils" / "__init__.pyi"]
+
+
+class TestIsFile:
+    def test_isfile(self):
+        """Test if all ``.pyi`` files are properly installed."""
+        for file in FILES:
+            assert_(os.path.isfile(file))