Merge pull request #17372 from BvB93/from-numeric

ENH: Add annotations for remaining `ndarray` / `generic` non-magic methods

5 files changed, 797 insertions, 66 deletions

diff --git a/numpy/__init__.pyi b/numpy/__init__.pyi
index e712801eb..9966ef199 100644
--- a/numpy/__init__.pyi
+++ b/numpy/__init__.pyi
@@ -615,6 +615,21 @@ _OrderKACF = Optional[Literal["K", "A", "C", "F"]]
 _OrderACF = Optional[Literal["A", "C", "F"]]
 _OrderCF = Optional[Literal["C", "F"]]
 
+_ModeKind = Literal["raise", "wrap", "clip"]
+_PartitionKind = Literal["introselect"]
+_SortKind = Literal["quicksort", "mergesort", "heapsort", "stable"]
+_SortSide = Literal["left", "right"]
+
+_ArrayLikeBool = Union[_BoolLike, Sequence[_BoolLike], ndarray]
+_ArrayLikeIntOrBool = Union[
+    _IntLike,
+    _BoolLike,
+    ndarray,
+    Sequence[_IntLike],
+    Sequence[_BoolLike],
+    Sequence[Sequence[Any]],  # TODO: wait for support for recursive types
+]
+
 _ArraySelf = TypeVar("_ArraySelf", bound=_ArrayOrScalarCommon)
 
 class _ArrayOrScalarCommon(
@@ -724,6 +739,8 @@ class _ArrayOrScalarCommon(
     ) -> _ArraySelf: ...
     def swapaxes(self: _ArraySelf, axis1: int, axis2: int) -> _ArraySelf: ...
     def tobytes(self, order: _OrderKACF = ...) -> bytes: ...
+    # NOTE: `tostring()` is deprecated and therefore excluded
+    # def tostring(self, order=...): ...
     def tofile(
         self, fid: Union[IO[bytes], str], sep: str = ..., format: str = ...
     ) -> None: ...
@@ -752,42 +769,376 @@ class _ArrayOrScalarCommon(
     def __array_struct__(self): ...
     def __array_wrap__(array, context=...): ...
     def __setstate__(self, __state): ...
-    def all(self, axis=..., out=..., keepdims=...): ...
-    def any(self, axis=..., out=..., keepdims=...): ...
-    def argmax(self, axis=..., out=...): ...
-    def argmin(self, axis=..., out=...): ...
-    def argpartition(self, kth, axis=..., kind=..., order=...): ...
-    def argsort(self, axis=..., kind=..., order=...): ...
-    def choose(self, choices, out=..., mode=...): ...
-    def clip(self, min=..., max=..., out=..., **kwargs): ...
-    def compress(self, condition, axis=..., out=...): ...
-    def conj(self): ...
-    def conjugate(self): ...
-    def cumprod(self, axis=..., dtype=..., out=...): ...
-    def cumsum(self, axis=..., dtype=..., out=...): ...
-    def diagonal(self, offset=..., axis1=..., axis2=...): ...
-    def dot(self, b, out=...): ...
-    def max(self, axis=..., out=..., keepdims=..., initial=..., where=...): ...
-    def mean(self, axis=..., dtype=..., out=..., keepdims=...): ...
-    def min(self, axis=..., out=..., keepdims=..., initial=..., where=...): ...
-    def newbyteorder(self, new_order=...): ...
-    def nonzero(self): ...
-    def partition(self, kth, axis=..., kind=..., order=...): ...
-    def prod(self, axis=..., dtype=..., out=..., keepdims=..., initial=..., where=...): ...
-    def ptp(self, axis=..., out=..., keepdims=...): ...
-    def put(self, indices, values, mode=...): ...
-    def repeat(self, repeats, axis=...): ...
-    def round(self, decimals=..., out=...): ...
-    def searchsorted(self, v, side=..., sorter=...): ...
-    def setfield(self, val, dtype, offset=...): ...
-    def sort(self, axis=..., kind=..., order=...): ...
-    def std(self, axis=..., dtype=..., out=..., ddof=..., keepdims=...): ...
-    def sum(self, axis=..., dtype=..., out=..., keepdims=..., initial=..., where=...): ...
-    def take(self, indices, axis=..., out=..., mode=...): ...
-    # NOTE: `tostring()` is deprecated and therefore excluded
-    # def tostring(self, order=...): ...
-    def trace(self, offset=..., axis1=..., axis2=..., dtype=..., out=...): ...
-    def var(self, axis=..., dtype=..., out=..., ddof=..., keepdims=...): ...
+    # a `bool_` is returned when `keepdims=True` and `self` is a 0d array
+    @overload
+    def all(
+        self, axis: None = ..., out: None = ..., keepdims: Literal[False] = ...
+    ) -> bool_: ...
+    @overload
+    def all(
+        self, axis: Optional[_ShapeLike] = ..., out: None = ..., keepdims: bool = ...
+    ) -> Union[bool_, ndarray]: ...
+    @overload
+    def all(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        out: _NdArraySubClass = ...,
+        keepdims: bool = ...,
+    ) -> _NdArraySubClass: ...
+    @overload
+    def any(
+        self, axis: None = ..., out: None = ..., keepdims: Literal[False] = ...
+    ) -> bool_: ...
+    @overload
+    def any(
+        self, axis: Optional[_ShapeLike] = ..., out: None = ..., keepdims: bool = ...
+    ) -> Union[bool_, ndarray]: ...
+    @overload
+    def any(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        out: _NdArraySubClass = ...,
+        keepdims: bool = ...,
+    ) -> _NdArraySubClass: ...
+    @overload
+    def argmax(self, axis: None = ..., out: None = ...) -> signedinteger: ...
+    @overload
+    def argmax(
+        self, axis: _ShapeLike = ..., out: None = ...
+    ) -> Union[signedinteger, ndarray]: ...
+    @overload
+    def argmax(
+        self, axis: Optional[_ShapeLike] = ..., out: _NdArraySubClass = ...
+    ) -> _NdArraySubClass: ...
+    @overload
+    def argmin(self, axis: None = ..., out: None = ...) -> signedinteger: ...
+    @overload
+    def argmin(
+        self, axis: _ShapeLike = ..., out: None = ...
+    ) -> Union[signedinteger, ndarray]: ...
+    @overload
+    def argmin(
+        self, axis: Optional[_ShapeLike] = ..., out: _NdArraySubClass = ...
+    ) -> _NdArraySubClass: ...
+    def argsort(
+        self,
+        axis: Optional[int] = ...,
+        kind: Optional[_SortKind] = ...,
+        order: Union[None, str, Sequence[str]] = ...,
+    ) -> ndarray: ...
+    @overload
+    def choose(
+        self, choices: ArrayLike, out: None = ..., mode: _ModeKind = ...,
+    ) -> ndarray: ...
+    @overload
+    def choose(
+        self, choices: ArrayLike, out: _NdArraySubClass = ..., mode: _ModeKind = ...,
+    ) -> _NdArraySubClass: ...
+    @overload
+    def clip(
+        self,
+        min: ArrayLike = ...,
+        max: Optional[ArrayLike] = ...,
+        out: None = ...,
+        **kwargs: Any,
+    ) -> Union[number, ndarray]: ...
+    @overload
+    def clip(
+        self,
+        min: None = ...,
+        max: ArrayLike = ...,
+        out: None = ...,
+        **kwargs: Any,
+    ) -> Union[number, ndarray]: ...
+    @overload
+    def clip(
+        self,
+        min: ArrayLike = ...,
+        max: Optional[ArrayLike] = ...,
+        out: _NdArraySubClass = ...,
+        **kwargs: Any,
+    ) -> _NdArraySubClass: ...
+    @overload
+    def clip(
+        self,
+        min: None = ...,
+        max: ArrayLike = ...,
+        out: _NdArraySubClass = ...,
+        **kwargs: Any,
+    ) -> _NdArraySubClass: ...
+    @overload
+    def compress(
+        self, a: ArrayLike, axis: Optional[int] = ..., out: None = ...,
+    ) -> ndarray: ...
+    @overload
+    def compress(
+        self, a: ArrayLike, axis: Optional[int] = ..., out: _NdArraySubClass = ...,
+    ) -> _NdArraySubClass: ...
+    def conj(self: _ArraySelf) -> _ArraySelf: ...
+    def conjugate(self: _ArraySelf) -> _ArraySelf: ...
+    @overload
+    def cumprod(
+        self, axis: Optional[int] = ..., dtype: DtypeLike = ..., out: None = ...,
+    ) -> ndarray: ...
+    @overload
+    def cumprod(
+        self,
+        axis: Optional[int] = ...,
+        dtype: DtypeLike = ...,
+        out: _NdArraySubClass = ...,
+    ) -> _NdArraySubClass: ...
+    @overload
+    def cumsum(
+        self, axis: Optional[int] = ..., dtype: DtypeLike = ..., out: None = ...,
+    ) -> ndarray: ...
+    @overload
+    def cumsum(
+        self,
+        axis: Optional[int] = ...,
+        dtype: DtypeLike = ...,
+        out: _NdArraySubClass = ...,
+    ) -> _NdArraySubClass: ...
+    @overload
+    def max(
+        self,
+        axis: None = ...,
+        out: None = ...,
+        keepdims: Literal[False] = ...,
+        initial: _NumberLike = ...,
+        where: _ArrayLikeBool = ...,
+    ) -> number: ...
+    @overload
+    def max(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        out: None = ...,
+        keepdims: bool = ...,
+        initial: _NumberLike = ...,
+        where: _ArrayLikeBool = ...,
+    ) -> Union[number, ndarray]: ...
+    @overload
+    def max(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        out: _NdArraySubClass = ...,
+        keepdims: bool = ...,
+        initial: _NumberLike = ...,
+        where: _ArrayLikeBool = ...,
+    ) -> _NdArraySubClass: ...
+    @overload
+    def mean(
+        self,
+        axis: None = ...,
+        dtype: DtypeLike = ...,
+        out: None = ...,
+        keepdims: Literal[False] = ...,
+    ) -> number: ...
+    @overload
+    def mean(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        dtype: DtypeLike = ...,
+        out: None = ...,
+        keepdims: bool = ...,
+    ) -> Union[number, ndarray]: ...
+    @overload
+    def mean(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        dtype: DtypeLike = ...,
+        out: _NdArraySubClass = ...,
+        keepdims: bool = ...,
+    ) -> _NdArraySubClass: ...
+    @overload
+    def min(
+        self,
+        axis: None = ...,
+        out: None = ...,
+        keepdims: Literal[False] = ...,
+        initial: _NumberLike = ...,
+        where: _ArrayLikeBool = ...,
+    ) -> number: ...
+    @overload
+    def min(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        out: None = ...,
+        keepdims: bool = ...,
+        initial: _NumberLike = ...,
+        where: _ArrayLikeBool = ...,
+    ) -> Union[number, ndarray]: ...
+    @overload
+    def min(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        out: _NdArraySubClass = ...,
+        keepdims: bool = ...,
+        initial: _NumberLike = ...,
+        where: _ArrayLikeBool = ...,
+    ) -> _NdArraySubClass: ...
+    def newbyteorder(self: _ArraySelf, __new_order: _ByteOrder = ...) -> _ArraySelf: ...
+    @overload
+    def prod(
+        self,
+        axis: None = ...,
+        dtype: DtypeLike = ...,
+        out: None = ...,
+        keepdims: Literal[False] = ...,
+        initial: _NumberLike = ...,
+        where: _ArrayLikeBool = ...,
+    ) -> number: ...
+    @overload
+    def prod(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        dtype: DtypeLike = ...,
+        out: None = ...,
+        keepdims: bool = ...,
+        initial: _NumberLike = ...,
+        where: _ArrayLikeBool = ...,
+    ) -> Union[number, ndarray]: ...
+    @overload
+    def prod(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        dtype: DtypeLike = ...,
+        out: _NdArraySubClass = ...,
+        keepdims: bool = ...,
+        initial: _NumberLike = ...,
+        where: _ArrayLikeBool = ...,
+    ) -> _NdArraySubClass: ...
+    @overload
+    def ptp(
+        self, axis: None = ..., out: None = ..., keepdims: Literal[False] = ...,
+    ) -> number: ...
+    @overload
+    def ptp(
+        self, axis: Optional[_ShapeLike] = ..., out: None = ..., keepdims: bool = ...,
+    ) -> Union[number, ndarray]: ...
+    @overload
+    def ptp(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        out: _NdArraySubClass = ...,
+        keepdims: bool = ...,
+    ) -> _NdArraySubClass: ...
+    def repeat(
+        self, repeats: _ArrayLikeIntOrBool, axis: Optional[int] = ...
+    ) -> ndarray: ...
+    @overload
+    def round(self: _ArraySelf, decimals: int = ..., out: None = ...) -> _ArraySelf: ...
+    @overload
+    def round(
+        self, decimals: int = ..., out: _NdArraySubClass = ...
+    ) -> _NdArraySubClass: ...
+    @overload
+    def std(
+        self,
+        axis: None = ...,
+        dtype: DtypeLike = ...,
+        out: None = ...,
+        ddof: int = ...,
+        keepdims: Literal[False] = ...,
+    ) -> number: ...
+    @overload
+    def std(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        dtype: DtypeLike = ...,
+        out: None = ...,
+        ddof: int = ...,
+        keepdims: bool = ...,
+    ) -> Union[number, ndarray]: ...
+    @overload
+    def std(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        dtype: DtypeLike = ...,
+        out: _NdArraySubClass = ...,
+        ddof: int = ...,
+        keepdims: bool = ...,
+    ) -> _NdArraySubClass: ...
+    @overload
+    def sum(
+        self,
+        axis: None = ...,
+        dtype: DtypeLike = ...,
+        out: None = ...,
+        keepdims: Literal[False] = ...,
+        initial: _NumberLike = ...,
+        where: _ArrayLikeBool = ...,
+    ) -> number: ...
+    @overload
+    def sum(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        dtype: DtypeLike = ...,
+        out: None = ...,
+        keepdims: bool = ...,
+        initial: _NumberLike = ...,
+        where: _ArrayLikeBool = ...,
+    ) -> Union[number, ndarray]: ...
+    @overload
+    def sum(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        dtype: DtypeLike = ...,
+        out: _NdArraySubClass = ...,
+        keepdims: bool = ...,
+        initial: _NumberLike = ...,
+        where: _ArrayLikeBool = ...,
+    ) -> _NdArraySubClass: ...
+    @overload
+    def take(
+        self,
+        indices: Union[_IntLike, _BoolLike],
+        axis: Optional[int] = ...,
+        out: None = ...,
+        mode: _ModeKind = ...,
+    ) -> generic: ...
+    @overload
+    def take(
+        self,
+        indices: _ArrayLikeIntOrBool,
+        axis: Optional[int] = ...,
+        out: None = ...,
+        mode: _ModeKind = ...,
+    ) -> ndarray: ...
+    @overload
+    def take(
+        self,
+        indices: _ArrayLikeIntOrBool,
+        axis: Optional[int] = ...,
+        out: _NdArraySubClass = ...,
+        mode: _ModeKind = ...,
+    ) -> _NdArraySubClass: ...
+    @overload
+    def var(
+        self,
+        axis: None = ...,
+        dtype: DtypeLike = ...,
+        out: None = ...,
+        ddof: int = ...,
+        keepdims: Literal[False] = ...,
+    ) -> number: ...
+    @overload
+    def var(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        dtype: DtypeLike = ...,
+        out: None = ...,
+        ddof: int = ...,
+        keepdims: bool = ...,
+    ) -> Union[number, ndarray]: ...
+    @overload
+    def var(
+        self,
+        axis: Optional[_ShapeLike] = ...,
+        dtype: DtypeLike = ...,
+        out: _NdArraySubClass = ...,
+        ddof: int = ...,
+        keepdims: bool = ...,
+    ) -> _NdArraySubClass: ...
 
 _BufferType = Union[ndarray, bytes, bytearray, memoryview]
 _Casting = Literal["no", "equiv", "safe", "same_kind", "unsafe"]
@@ -822,6 +1173,67 @@ class ndarray(_ArrayOrScalarCommon, Iterable, Sized, Container):
     def strides(self) -> _Shape: ...
     @strides.setter
     def strides(self, value: _ShapeLike): ...
+    def argpartition(
+        self,
+        kth: _ArrayLikeIntOrBool,
+        axis: Optional[int] = ...,
+        kind: _PartitionKind = ...,
+        order: Union[None, str, Sequence[str]] = ...,
+    ) -> ndarray: ...
+    def diagonal(
+        self: _ArraySelf, offset: int = ..., axis1: int = ..., axis2: int = ...
+    ) -> _ArraySelf: ...
+    @overload
+    def dot(self, b: ArrayLike, out: None = ...) -> Union[number, ndarray]: ...
+    @overload
+    def dot(self, b: ArrayLike, out: _NdArraySubClass = ...) -> _NdArraySubClass: ...
+    # `nonzero()` is deprecated for 0d arrays/generics
+    def nonzero(self) -> Tuple[ndarray, ...]: ...
+    def partition(
+        self,
+        kth: _ArrayLikeIntOrBool,
+        axis: int = ...,
+        kind: _PartitionKind = ...,
+        order: Union[None, str, Sequence[str]] = ...,
+    ) -> None: ...
+    # `put` is technically available to `generic`,
+    # but is pointless as `generic`s are immutable
+    def put(
+        self, ind: _ArrayLikeIntOrBool, v: ArrayLike, mode: _ModeKind = ...
+    ) -> None: ...
+    def searchsorted(
+        self,  # >= 1D array
+        v: ArrayLike,
+        side: _SortSide = ...,
+        sorter: Optional[_ArrayLikeIntOrBool] = ...,  # 1D int array
+    ) -> ndarray: ...
+    def setfield(
+        self, val: ArrayLike, dtype: DtypeLike, offset: int = ...
+    ) -> None: ...
+    def sort(
+        self,
+        axis: int = ...,
+        kind: Optional[_SortKind] = ...,
+        order: Union[None, str, Sequence[str]] = ...,
+    ) -> None: ...
+    @overload
+    def trace(
+        self,  # >= 2D array
+        offset: int = ...,
+        axis1: int = ...,
+        axis2: int = ...,
+        dtype: DtypeLike = ...,
+        out: None = ...,
+    ) -> Union[number, ndarray]: ...
+    @overload
+    def trace(
+        self,  # >= 2D array
+        offset: int = ...,
+        axis1: int = ...,
+        axis2: int = ...,
+        dtype: DtypeLike = ...,
+        out: _NdArraySubClass = ...,
+    ) -> _NdArraySubClass: ...
     # Many of these special methods are irrelevant currently, since protocols
     # aren't supported yet. That said, I'm adding them for completeness.
     # https://docs.python.org/3/reference/datamodel.html
@@ -1090,6 +1502,9 @@ class void(flexible):
     def real(self: _ArraySelf) -> _ArraySelf: ...
     @property
     def imag(self: _ArraySelf) -> _ArraySelf: ...
+    def setfield(
+        self, val: ArrayLike, dtype: DtypeLike, offset: int = ...
+    ) -> None: ...
 
 class character(flexible): ...  # type: ignore
 
diff --git a/numpy/core/fromnumeric.pyi b/numpy/core/fromnumeric.pyi
index 7ad772b07..6b3d2268f 100644
--- a/numpy/core/fromnumeric.pyi
+++ b/numpy/core/fromnumeric.pyi
@@ -13,6 +13,12 @@ from numpy import (
     _IntLike,
     _BoolLike,
     _NumberLike,
+    _ArrayLikeBool,
+    _ArrayLikeIntOrBool,
+    _ModeKind,
+    _PartitionKind,
+    _SortKind,
+    _SortSide,
 )
 from numpy.typing import DtypeLike, ArrayLike, _ShapeLike, _Shape
 
@@ -21,11 +27,6 @@ if sys.version_info >= (3, 8):
 else:
     from typing_extensions import Literal
 
-_Mode = Literal["raise", "wrap", "clip"]
-_PartitionKind = Literal["introselect"]
-_SortKind = Literal["quicksort", "mergesort", "heapsort", "stable"]
-_Side = Literal["left", "right"]
-
 # Various annotations for scalars
 
 # While dt.datetime and dt.timedelta are not technically part of NumPy,
@@ -44,21 +45,6 @@ _ScalarGenericDT = TypeVar(
 
 _Number = TypeVar("_Number", bound=number)
 
-# An array-like object consisting of integers
-_IntOrBool = Union[_IntLike, _BoolLike]
-_ArrayLikeIntNested = ArrayLike  # TODO: wait for support for recursive types
-_ArrayLikeBoolNested = ArrayLike  # TODO: wait for support for recursive types
-
-# Integers and booleans can generally be used interchangeably
-_ArrayLikeIntOrBool = Union[
-    _IntOrBool,
-    ndarray,
-    Sequence[_IntOrBool],
-    Sequence[_ArrayLikeIntNested],
-    Sequence[_ArrayLikeBoolNested],
-]
-_ArrayLikeBool = Union[_BoolLike, Sequence[_BoolLike], ndarray]
-
 # The signature of take() follows a common theme with its overloads:
 # 1. A generic comes in; the same generic comes out
 # 2. A scalar comes in; a generic comes out
@@ -70,7 +56,7 @@ def take(
     indices: int,
     axis: Optional[int] = ...,
     out: Optional[ndarray] = ...,
-    mode: _Mode = ...,
+    mode: _ModeKind = ...,
 ) -> _ScalarGenericDT: ...
 @overload
 def take(
@@ -78,7 +64,7 @@ def take(
     indices: int,
     axis: Optional[int] = ...,
     out: Optional[ndarray] = ...,
-    mode: _Mode = ...,
+    mode: _ModeKind = ...,
 ) -> _ScalarNumpy: ...
 @overload
 def take(
@@ -86,7 +72,7 @@ def take(
     indices: int,
     axis: Optional[int] = ...,
     out: Optional[ndarray] = ...,
-    mode: _Mode = ...,
+    mode: _ModeKind = ...,
 ) -> _ScalarNumpy: ...
 @overload
 def take(
@@ -94,7 +80,7 @@ def take(
     indices: _ArrayLikeIntOrBool,
     axis: Optional[int] = ...,
     out: Optional[ndarray] = ...,
-    mode: _Mode = ...,
+    mode: _ModeKind = ...,
 ) -> Union[_ScalarNumpy, ndarray]: ...
 def reshape(a: ArrayLike, newshape: _ShapeLike, order: _OrderACF = ...) -> ndarray: ...
 @overload
@@ -102,24 +88,24 @@ def choose(
     a: _ScalarIntOrBool,
     choices: ArrayLike,
     out: Optional[ndarray] = ...,
-    mode: _Mode = ...,
+    mode: _ModeKind = ...,
 ) -> _ScalarIntOrBool: ...
 @overload
 def choose(
-    a: _IntOrBool, choices: ArrayLike, out: Optional[ndarray] = ..., mode: _Mode = ...
+    a: Union[_IntLike, _BoolLike], choices: ArrayLike, out: Optional[ndarray] = ..., mode: _ModeKind = ...
 ) -> Union[integer, bool_]: ...
 @overload
 def choose(
     a: _ArrayLikeIntOrBool,
     choices: ArrayLike,
     out: Optional[ndarray] = ...,
-    mode: _Mode = ...,
+    mode: _ModeKind = ...,
 ) -> ndarray: ...
 def repeat(
     a: ArrayLike, repeats: _ArrayLikeIntOrBool, axis: Optional[int] = ...
 ) -> ndarray: ...
 def put(
-    a: ndarray, ind: _ArrayLikeIntOrBool, v: ArrayLike, mode: _Mode = ...
+    a: ndarray, ind: _ArrayLikeIntOrBool, v: ArrayLike, mode: _ModeKind = ...
 ) -> None: ...
 def swapaxes(a: ArrayLike, axis1: int, axis2: int) -> ndarray: ...
 def transpose(
@@ -184,14 +170,14 @@ def argmin(
 def searchsorted(
     a: ArrayLike,
     v: _Scalar,
-    side: _Side = ...,
+    side: _SortSide = ...,
     sorter: Optional[_ArrayLikeIntOrBool] = ...,  # 1D int array
 ) -> integer: ...
 @overload
 def searchsorted(
     a: ArrayLike,
     v: ArrayLike,
-    side: _Side = ...,
+    side: _SortSide = ...,
     sorter: Optional[_ArrayLikeIntOrBool] = ...,  # 1D int array
 ) -> ndarray: ...
 def resize(a: ArrayLike, new_shape: _ShapeLike) -> ndarray: ...
diff --git a/numpy/typing/tests/data/fail/ndarray_misc.py b/numpy/typing/tests/data/fail/ndarray_misc.py
new file mode 100644
index 000000000..1e1496bfe
--- /dev/null
+++ b/numpy/typing/tests/data/fail/ndarray_misc.py
@@ -0,0 +1,21 @@
+"""
+Tests for miscellaneous (non-magic) ``np.ndarray``/``np.generic`` methods.
+
+More extensive tests are performed for the methods'
+function-based counterpart in `../from_numeric.py`.
+
+"""
+
+import numpy as np
+
+f8: np.float64
+
+f8.argpartition(0)  # E: has no attribute
+f8.diagonal()  # E: has no attribute
+f8.dot(1)  # E: has no attribute
+f8.nonzero()  # E: has no attribute
+f8.partition(0)  # E: has no attribute
+f8.put(0, 2)  # E: has no attribute
+f8.setfield(2, np.float64)  # E: has no attribute
+f8.sort()  # E: has no attribute
+f8.trace()  # E: has no attribute
diff --git a/numpy/typing/tests/data/pass/ndarray_misc.py b/numpy/typing/tests/data/pass/ndarray_misc.py
new file mode 100644
index 000000000..6c6f5d50b
--- /dev/null
+++ b/numpy/typing/tests/data/pass/ndarray_misc.py
@@ -0,0 +1,159 @@
+"""
+Tests for miscellaneous (non-magic) ``np.ndarray``/``np.generic`` methods.
+
+More extensive tests are performed for the methods'
+function-based counterpart in `../from_numeric.py`.
+
+"""
+
+from typing import cast
+import numpy as np
+
+class SubClass(np.ndarray): ...
+
+i4 = np.int32(1)
+A = np.array([[1]], dtype=np.int32)
+B0 = np.empty((), dtype=np.int32).view(SubClass)
+B1 = np.empty((1,), dtype=np.int32).view(SubClass)
+B2 = np.empty((1, 1), dtype=np.int32).view(SubClass)
+C = np.array([0, 1, 2], dtype=np.int32)
+D = np.empty(3).view(SubClass)
+
+i4.all()
+A.all()
+A.all(axis=0)
+A.all(keepdims=True)
+A.all(out=B0)
+
+i4.any()
+A.any()
+A.any(axis=0)
+A.any(keepdims=True)
+A.any(out=B0)
+
+i4.argmax()
+A.argmax()
+A.argmax(axis=0)
+A.argmax(out=B0)
+
+i4.argmin()
+A.argmin()
+A.argmin(axis=0)
+A.argmin(out=B0)
+
+i4.argsort()
+A.argsort()
+
+i4.choose([()])
+_choices = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int32)
+C.choose(_choices)
+C.choose(_choices, out=D)
+
+i4.clip(1)
+A.clip(1)
+A.clip(None, 1)
+A.clip(1, out=B2)
+A.clip(None, 1, out=B2)
+
+i4.compress([1])
+A.compress([1])
+A.compress([1], out=B1)
+
+i4.conj()
+A.conj()
+B0.conj()
+
+i4.conjugate()
+A.conjugate()
+B0.conjugate()
+
+i4.cumprod()
+A.cumprod()
+A.cumprod(out=B1)
+
+i4.cumsum()
+A.cumsum()
+A.cumsum(out=B1)
+
+i4.max()
+A.max()
+A.max(axis=0)
+A.max(keepdims=True)
+A.max(out=B0)
+
+i4.mean()
+A.mean()
+A.mean(axis=0)
+A.mean(keepdims=True)
+A.mean(out=B0)
+
+i4.min()
+A.min()
+A.min(axis=0)
+A.min(keepdims=True)
+A.min(out=B0)
+
+i4.newbyteorder()
+A.newbyteorder()
+B0.newbyteorder('|')
+
+i4.prod()
+A.prod()
+A.prod(axis=0)
+A.prod(keepdims=True)
+A.prod(out=B0)
+
+i4.ptp()
+A.ptp()
+A.ptp(axis=0)
+A.ptp(keepdims=True)
+A.astype(int).ptp(out=B0)
+
+i4.round()
+A.round()
+A.round(out=B2)
+
+i4.repeat(1)
+A.repeat(1)
+B0.repeat(1)
+
+i4.std()
+A.std()
+A.std(axis=0)
+A.std(keepdims=True)
+A.std(out=B0.astype(np.float64))
+
+i4.sum()
+A.sum()
+A.sum(axis=0)
+A.sum(keepdims=True)
+A.sum(out=B0)
+
+i4.take(0)
+A.take(0)
+A.take([0])
+A.take(0, out=B0)
+A.take([0], out=B1)
+
+i4.var()
+A.var()
+A.var(axis=0)
+A.var(keepdims=True)
+A.var(out=B0)
+
+A.argpartition([0])
+
+A.diagonal()
+
+A.dot(1)
+A.dot(1, out=B0)
+
+A.nonzero()
+
+C.searchsorted(1)
+
+A.trace()
+A.trace(out=B0)
+
+void = cast(np.void, np.array(1, dtype=[("f", np.float64)]).take(0))
+void.setfield(10, np.float64)
diff --git a/numpy/typing/tests/data/reveal/ndarray_misc.py b/numpy/typing/tests/data/reveal/ndarray_misc.py
new file mode 100644
index 000000000..22a4564df
--- /dev/null
+++ b/numpy/typing/tests/data/reveal/ndarray_misc.py
@@ -0,0 +1,150 @@
+"""
+Tests for miscellaneous (non-magic) ``np.ndarray``/``np.generic`` methods.
+
+More extensive tests are performed for the methods'
+function-based counterpart in `../from_numeric.py`.
+
+"""
+
+import numpy as np
+
+class SubClass(np.ndarray): ...
+
+f8: np.float64
+A: np.ndarray
+B: SubClass
+
+reveal_type(f8.all())  # E: numpy.bool_
+reveal_type(A.all())  # E: numpy.bool_
+reveal_type(A.all(axis=0))  # E: Union[numpy.bool_, numpy.ndarray]
+reveal_type(A.all(keepdims=True))  # E: Union[numpy.bool_, numpy.ndarray]
+reveal_type(A.all(out=B))  # E: SubClass
+
+reveal_type(f8.any())  # E: numpy.bool_
+reveal_type(A.any())  # E: numpy.bool_
+reveal_type(A.any(axis=0))  # E: Union[numpy.bool_, numpy.ndarray]
+reveal_type(A.any(keepdims=True))  # E: Union[numpy.bool_, numpy.ndarray]
+reveal_type(A.any(out=B))  # E: SubClass
+
+reveal_type(f8.argmax())  # E: numpy.signedinteger
+reveal_type(A.argmax())  # E: numpy.signedinteger
+reveal_type(A.argmax(axis=0))  # E: Union[numpy.signedinteger, numpy.ndarray]
+reveal_type(A.argmax(out=B))  # E: SubClass
+
+reveal_type(f8.argmin())  # E: numpy.signedinteger
+reveal_type(A.argmin())  # E: numpy.signedinteger
+reveal_type(A.argmin(axis=0))  # E: Union[numpy.signedinteger, numpy.ndarray]
+reveal_type(A.argmin(out=B))  # E: SubClass
+
+reveal_type(f8.argsort())  # E: numpy.ndarray
+reveal_type(A.argsort())  # E: numpy.ndarray
+
+reveal_type(f8.astype(np.int64).choose([()]))  # E: numpy.ndarray
+reveal_type(A.choose([0]))  # E: numpy.ndarray
+reveal_type(A.choose([0], out=B))  # E: SubClass
+
+reveal_type(f8.clip(1))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.clip(1))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.clip(None, 1))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.clip(1, out=B))  # E: SubClass
+reveal_type(A.clip(None, 1, out=B))  # E: SubClass
+
+reveal_type(f8.compress([0]))  # E: numpy.ndarray
+reveal_type(A.compress([0]))  # E: numpy.ndarray
+reveal_type(A.compress([0], out=B))  # E: SubClass
+
+reveal_type(f8.conj())  # E: numpy.float64
+reveal_type(A.conj())  # E: numpy.ndarray
+reveal_type(B.conj())  # E: SubClass
+
+reveal_type(f8.conjugate())  # E: numpy.float64
+reveal_type(A.conjugate())  # E: numpy.ndarray
+reveal_type(B.conjugate())  # E: SubClass
+
+reveal_type(f8.cumprod())  # E: numpy.ndarray
+reveal_type(A.cumprod())  # E: numpy.ndarray
+reveal_type(A.cumprod(out=B))  # E: SubClass
+
+reveal_type(f8.cumsum())  # E: numpy.ndarray
+reveal_type(A.cumsum())  # E: numpy.ndarray
+reveal_type(A.cumsum(out=B))  # E: SubClass
+
+reveal_type(f8.max())  # E: numpy.number
+reveal_type(A.max())  # E: numpy.number
+reveal_type(A.max(axis=0))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.max(keepdims=True))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.max(out=B))  # E: SubClass
+
+reveal_type(f8.mean())  # E: numpy.number
+reveal_type(A.mean())  # E: numpy.number
+reveal_type(A.mean(axis=0))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.mean(keepdims=True))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.mean(out=B))  # E: SubClass
+
+reveal_type(f8.min())  # E: numpy.number
+reveal_type(A.min())  # E: numpy.number
+reveal_type(A.min(axis=0))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.min(keepdims=True))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.min(out=B))  # E: SubClass
+
+reveal_type(f8.newbyteorder())  # E: numpy.float64
+reveal_type(A.newbyteorder())  # E: numpy.ndarray
+reveal_type(B.newbyteorder('|'))  # E: SubClass
+
+reveal_type(f8.prod())  # E: numpy.number
+reveal_type(A.prod())  # E: numpy.number
+reveal_type(A.prod(axis=0))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.prod(keepdims=True))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.prod(out=B))  # E: SubClass
+
+reveal_type(f8.ptp())  # E: numpy.number
+reveal_type(A.ptp())  # E: numpy.number
+reveal_type(A.ptp(axis=0))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.ptp(keepdims=True))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.ptp(out=B))  # E: SubClass
+
+reveal_type(f8.round())  # E: numpy.float64
+reveal_type(A.round())  # E: numpy.ndarray
+reveal_type(A.round(out=B))  # E: SubClass
+
+reveal_type(f8.repeat(1))  # E: numpy.ndarray
+reveal_type(A.repeat(1))  # E: numpy.ndarray
+reveal_type(B.repeat(1))  # E: numpy.ndarray
+
+reveal_type(f8.std())  # E: numpy.number
+reveal_type(A.std())  # E: numpy.number
+reveal_type(A.std(axis=0))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.std(keepdims=True))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.std(out=B))  # E: SubClass
+
+reveal_type(f8.sum())  # E: numpy.number
+reveal_type(A.sum())  # E: numpy.number
+reveal_type(A.sum(axis=0))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.sum(keepdims=True))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.sum(out=B))  # E: SubClass
+
+reveal_type(f8.take(0))  # E: numpy.generic
+reveal_type(A.take(0))  # E: numpy.generic
+reveal_type(A.take([0]))  # E: numpy.ndarray
+reveal_type(A.take(0, out=B))  # E: SubClass
+reveal_type(A.take([0], out=B))  # E: SubClass
+
+reveal_type(f8.var())  # E: numpy.number
+reveal_type(A.var())  # E: numpy.number
+reveal_type(A.var(axis=0))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.var(keepdims=True))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.var(out=B))  # E: SubClass
+
+reveal_type(A.argpartition([0]))  # E: numpy.ndarray
+
+reveal_type(A.diagonal())  # E: numpy.ndarray
+
+reveal_type(A.dot(1))  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.dot(1, out=B))  # E: SubClass
+
+reveal_type(A.nonzero())  # E: tuple[numpy.ndarray]
+
+reveal_type(A.searchsorted([1]))  # E: numpy.ndarray
+
+reveal_type(A.trace())  # E: Union[numpy.number, numpy.ndarray]
+reveal_type(A.trace(out=B))  # E: SubClass