TYP: Type MaskedArray.resize, wrap NoReturn tests in functions (#29401)

MarcoGorelli · jorenham · web-flow · commit ec3ac3d31e24 · 2025-07-21T20:01:42.000+02:00
Co-authored-by: Joren Hammudoglu &lt;jhammudoglu@gmail.com&gt;
diff --git a/numpy/ma/core.pyi b/numpy/ma/core.pyi
@@ -3,7 +3,16 @@
 
 from _typeshed import Incomplete
 from collections.abc import Sequence
-from typing import Any, Literal, NoReturn, Self, SupportsIndex, TypeAlias, overload
+from typing import (
+    Any,
+    Literal,
+    Never,
+    NoReturn,
+    Self,
+    SupportsIndex,
+    TypeAlias,
+    overload,
+)
 from typing_extensions import TypeIs, TypeVar
 
 import numpy as np
@@ -1073,7 +1082,7 @@ class MaskedArray(ndarray[_ShapeT_co, _DTypeT_co]):
 
     def ravel(self, order: _OrderKACF = "C") -> MaskedArray[tuple[int], _DTypeT_co]: ...
     def reshape(self, *s, **kwargs): ...
-    def resize(self, newshape, refcheck=..., order=...): ...
+    def resize(self, newshape: Never, refcheck: bool = True, order: bool = False) -> NoReturn: ...
     def put(self, indices: _ArrayLikeInt_co, values: ArrayLike, mode: _ModeKind = "raise") -> None: ...
     def ids(self) -> tuple[int, int]: ...
     def iscontiguous(self) -> bool: ...
diff --git a/numpy/typing/tests/data/reveal/lib_polynomial.pyi b/numpy/typing/tests/data/reveal/lib_polynomial.pyi
@@ -118,7 +118,10 @@ assert_type(np.polyadd(AR_O, AR_O), npt.NDArray[np.object_])
 
 assert_type(np.polysub(poly_obj, AR_i8), np.poly1d)
 assert_type(np.polysub(AR_f8, poly_obj), np.poly1d)
-assert_type(np.polysub(AR_b, AR_b), NoReturn)
+
+def test_invalid_polysub() -> None:
+    assert_type(np.polysub(AR_b, AR_b), NoReturn)
+
 assert_type(np.polysub(AR_u4, AR_b), npt.NDArray[np.unsignedinteger])
 assert_type(np.polysub(AR_i8, AR_i8), npt.NDArray[np.signedinteger])
 assert_type(np.polysub(AR_f8, AR_i8), npt.NDArray[np.floating])
diff --git a/numpy/typing/tests/data/reveal/ma.pyi b/numpy/typing/tests/data/reveal/ma.pyi
@@ -1,4 +1,4 @@
-from typing import Any, Literal, TypeAlias, TypeVar, assert_type
+from typing import Any, Literal, TypeAlias, TypeVar, assert_type, NoReturn
 
 import numpy as np
 from numpy import dtype, generic
@@ -405,6 +405,9 @@ assert_type(MAR_f8.cumprod(out=MAR_subclass), MaskedArraySubclass)
 assert_type(MAR_f8.cumsum(), MaskedArray[Any])
 assert_type(MAR_f8.cumsum(out=MAR_subclass), MaskedArraySubclass)
 
+def invalid_resize() -> None:
+    assert_type(MAR_f8.resize((1,1)), NoReturn)  # type: ignore[arg-type]
+
 # Masked Array addition
 
 assert_type(MAR_b + AR_LIKE_u, MaskedArray[np.uint32])
diff --git a/numpy/typing/tests/data/reveal/ufuncs.pyi b/numpy/typing/tests/data/reveal/ufuncs.pyi
@@ -98,26 +98,45 @@ 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)
+def test_absolute_outer_invalid() -> None:
+    assert_type(np.absolute.outer(), NoReturn)
+def test_frexp_outer_invalid() -> None:
+    assert_type(np.frexp.outer(), NoReturn)
+def test_divmod_outer_invalid() -> None:
+    assert_type(np.divmod.outer(), NoReturn)
+def test_matmul_outer_invalid() -> None:
+    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)
+def test_absolute_reduceat_invalid() -> None:
+    assert_type(np.absolute.reduceat(), NoReturn)
+def test_frexp_reduceat_invalid() -> None:
+    assert_type(np.frexp.reduceat(), NoReturn)
+def test_divmod_reduceat_invalid() -> None:
+    assert_type(np.divmod.reduceat(), NoReturn)
+def test_matmul_reduceat_invalid() -> None:
+    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)
+def test_absolute_reduce_invalid() -> None:
+    assert_type(np.absolute.reduce(), NoReturn)
+def test_frexp_reduce_invalid() -> None:
+    assert_type(np.frexp.reduce(), NoReturn)
+def test_divmod_reduce_invalid() -> None:
+    assert_type(np.divmod.reduce(), NoReturn)
+def test_matmul_reduce_invalid() -> None:
+    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)
+def test_absolute_accumulate_invalid() -> None:
+    assert_type(np.absolute.accumulate(), NoReturn)
+def test_frexp_accumulate_invalid() -> None:
+    assert_type(np.frexp.accumulate(), NoReturn)
+def test_divmod_accumulate_invalid() -> None:
+    assert_type(np.divmod.accumulate(), NoReturn)
+def test_matmul_accumulate_invalid() -> None:
+    assert_type(np.matmul.accumulate(), NoReturn)
 
-assert_type(np.frexp.at(), NoReturn)
-assert_type(np.divmod.at(), NoReturn)
-assert_type(np.matmul.at(), NoReturn)
+def test_frexp_at_invalid() -> None:
+    assert_type(np.frexp.at(), NoReturn)
+def test_divmod_at_invalid() -> None:
+    assert_type(np.divmod.at(), NoReturn)
+def test_matmul_at_invalid() -> None:
+    assert_type(np.matmul.at(), NoReturn)
