From f38ef869839cd6dae8981c4264dd9d07bb3690e3 Mon Sep 17 00:00:00 2001 From: jorenham Date: Fri, 14 Mar 2025 16:27:37 +0100 Subject: [PATCH 1/7] TYP: stub ``numpy._core.umath`` Backport of numpy/numtype#123 --- numpy/_core/meson.build | 1 + numpy/_core/umath.pyi | 197 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 198 insertions(+) create mode 100644 numpy/_core/umath.pyi diff --git a/numpy/_core/meson.build b/numpy/_core/meson.build index d32d71adc5dd..ec40c290f59a 100644 --- a/numpy/_core/meson.build +++ b/numpy/_core/meson.build @@ -1335,6 +1335,7 @@ python_sources = [ 'strings.py', 'strings.pyi', 'umath.py', + 'umath.pyi', ] py.install_sources( diff --git a/numpy/_core/umath.pyi b/numpy/_core/umath.pyi new file mode 100644 index 000000000000..d9f0d384cf6d --- /dev/null +++ b/numpy/_core/umath.pyi @@ -0,0 +1,197 @@ +from numpy import ( + absolute, + add, + arccos, + arccosh, + arcsin, + arcsinh, + arctan, + arctan2, + arctanh, + bitwise_and, + bitwise_count, + bitwise_or, + bitwise_xor, + cbrt, + ceil, + conj, + conjugate, + copysign, + cos, + cosh, + deg2rad, + degrees, + divide, + divmod, + e, + equal, + euler_gamma, + exp, + exp2, + expm1, + fabs, + float_power, + floor, + floor_divide, + fmax, + fmin, + fmod, + frexp, + frompyfunc, + gcd, + greater, + greater_equal, + heaviside, + hypot, + invert, + isfinite, + isinf, + isnan, + isnat, + lcm, + ldexp, + left_shift, + less, + less_equal, + log, + log1p, + log2, + log10, + logaddexp, + logaddexp2, + logical_and, + logical_not, + logical_or, + logical_xor, + matvec, + maximum, + minimum, + mod, + modf, + multiply, + negative, + nextafter, + not_equal, + pi, + positive, + power, + rad2deg, + radians, + reciprocal, + remainder, + right_shift, + rint, + sign, + signbit, + sin, + sinh, + spacing, + sqrt, + square, + subtract, + tan, + tanh, + true_divide, + trunc, + vecdot, + vecmat, +) + +__all__ = [ + "absolute", + "add", + "arccos", + "arccosh", + "arcsin", + "arcsinh", + "arctan", + "arctan2", + "arctanh", + "bitwise_and", + "bitwise_count", + "bitwise_or", + "bitwise_xor", + "cbrt", + "ceil", + "conj", + "conjugate", + "copysign", + "cos", + "cosh", + "deg2rad", + "degrees", + "divide", + "divmod", + "e", + "equal", + "euler_gamma", + "exp", + "exp2", + "expm1", + "fabs", + "float_power", + "floor", + "floor_divide", + "fmax", + "fmin", + "fmod", + "frexp", + "frompyfunc", + "gcd", + "greater", + "greater_equal", + "heaviside", + "hypot", + "invert", + "isfinite", + "isinf", + "isnan", + "isnat", + "lcm", + "ldexp", + "left_shift", + "less", + "less_equal", + "log", + "log1p", + "log2", + "log10", + "logaddexp", + "logaddexp2", + "logical_and", + "logical_not", + "logical_or", + "logical_xor", + "matvec", + "maximum", + "minimum", + "mod", + "modf", + "multiply", + "negative", + "nextafter", + "not_equal", + "pi", + "positive", + "power", + "rad2deg", + "radians", + "reciprocal", + "remainder", + "right_shift", + "rint", + "sign", + "signbit", + "sin", + "sinh", + "spacing", + "sqrt", + "square", + "subtract", + "tan", + "tanh", + "true_divide", + "trunc", + "vecdot", + "vecmat", +] From 6b50f1b0cd7ada671613230f560c208a4da36836 Mon Sep 17 00:00:00 2001 From: jorenham Date: Fri, 14 Mar 2025 16:43:22 +0100 Subject: [PATCH 2/7] TYP: fix typing errors in ``numpy.lib._arrayterator_impl`` Ported from numpy/numtype#165 --- numpy/lib/_arrayterator_impl.pyi | 63 +++++++++++++++----------------- 1 file changed, 29 insertions(+), 34 deletions(-) diff --git a/numpy/lib/_arrayterator_impl.pyi b/numpy/lib/_arrayterator_impl.pyi index 58875b3c9301..c24fe56ac8a9 100644 --- a/numpy/lib/_arrayterator_impl.pyi +++ b/numpy/lib/_arrayterator_impl.pyi @@ -1,51 +1,46 @@ +# pyright: reportIncompatibleMethodOverride=false + from collections.abc import Generator from types import EllipsisType -from typing import ( - Any, - TypeAlias, - TypeVar, - overload, -) +from typing import Any, Final, TypeAlias, overload + +from typing_extensions import TypeVar -from numpy import ndarray, dtype, generic -from numpy._typing import DTypeLike, NDArray, _Shape as _AnyShape +import numpy as np __all__ = ["Arrayterator"] -# TODO: Rename to ``_ShapeType`` -_Shape = TypeVar("_Shape", bound=_AnyShape) -_DType = TypeVar("_DType", bound=dtype[Any]) -_ScalarType = TypeVar("_ScalarType", bound=generic) +_ShapeT_co = TypeVar("_ShapeT_co", bound=tuple[int, ...], covariant=True) +_DTypeT = TypeVar("_DTypeT", bound=np.dtype[Any]) +_DTypeT_co = TypeVar("_DTypeT_co", bound=np.dtype[Any], covariant=True) +_ScalarT = TypeVar("_ScalarT", bound=np.generic) -_Index: TypeAlias = ( - EllipsisType - | int - | slice - | tuple[EllipsisType | int | slice, ...] -) +_AnyIndex: TypeAlias = EllipsisType | int | slice | tuple[EllipsisType | int | slice, ...] # NOTE: In reality `Arrayterator` does not actually inherit from `ndarray`, # but its ``__getattr__` method does wrap around the former and thus has # access to all its methods -class Arrayterator(ndarray[_Shape, _DType]): - var: ndarray[_Shape, _DType] # type: ignore[assignment] - buf_size: None | int - start: list[int] - stop: list[int] - step: list[int] +class Arrayterator(np.ndarray[_ShapeT_co, _DTypeT_co]): + var: np.ndarray[_ShapeT_co, _DTypeT_co] # type: ignore[assignment] + buf_size: Final[int | None] + start: Final[list[int]] + stop: Final[list[int]] + step: Final[list[int]] @property # type: ignore[misc] - def shape(self) -> tuple[int, ...]: ... + def shape(self) -> _ShapeT_co: ... @property - def flat(self: NDArray[_ScalarType]) -> Generator[_ScalarType, None, None]: ... - def __init__( - self, var: ndarray[_Shape, _DType], buf_size: None | int = ... - ) -> None: ... - @overload - def __array__(self, dtype: None = ..., copy: None | bool = ...) -> ndarray[_AnyShape, _DType]: ... + def flat(self: Arrayterator[Any, np.dtype[_ScalarT]]) -> Generator[_ScalarT]: ... # type: ignore[override] + + # + def __init__(self, /, var: np.ndarray[_ShapeT_co, _DTypeT_co], buf_size: int | None = None) -> None: ... + def __getitem__(self, index: _AnyIndex, /) -> Arrayterator[tuple[int, ...], _DTypeT_co]: ... # type: ignore[override] + def __iter__(self) -> Generator[np.ndarray[tuple[int, ...], _DTypeT_co]]: ... + + # + @overload # type: ignore[override] + def __array__(self, /, dtype: None = None, copy: bool | None = None) -> np.ndarray[_ShapeT_co, _DTypeT_co]: ... @overload - def __array__(self, dtype: DTypeLike, copy: None | bool = ...) -> NDArray[Any]: ... - def __getitem__(self, index: _Index) -> Arrayterator[_AnyShape, _DType]: ... - def __iter__(self) -> Generator[ndarray[_AnyShape, _DType], None, None]: ... + def __array__(self, /, dtype: _DTypeT, copy: bool | None = None) -> np.ndarray[_ShapeT_co, _DTypeT]: ... From 348f680c01ce327d9754f61c62b1d3c5d7fa6388 Mon Sep 17 00:00:00 2001 From: jorenham Date: Fri, 14 Mar 2025 17:37:24 +0100 Subject: [PATCH 3/7] TYP: fix signatures of ``ndarray.put`` and ``ndarray.view`` partial port of numpy/numtype#200 --- numpy/__init__.pyi | 44 ++++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/numpy/__init__.pyi b/numpy/__init__.pyi index 1a2d6a08bbb1..7f6bd9db55a4 100644 --- a/numpy/__init__.pyi +++ b/numpy/__init__.pyi @@ -1097,8 +1097,12 @@ class _HasShape(Protocol[_ShapeT_co]): def shape(self, /) -> _ShapeT_co: ... @type_check_only -class _HasShapeAndSupportsItem(_HasShape[_ShapeT_co], _SupportsItem[_T_co], Protocol[_ShapeT_co, _T_co]): - pass +class _HasDType(Protocol[_T_co]): + @property + def dtype(self, /) -> _T_co: ... + +@type_check_only +class _HasShapeAndSupportsItem(_HasShape[_ShapeT_co], _SupportsItem[_T_co], Protocol[_ShapeT_co, _T_co]): ... # matches any `x` on `x.type.item() -> _T_co`, e.g. `dtype[np.int8]` gives `_T_co: int` @type_check_only @@ -2345,12 +2349,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DType_co]): # `put` is technically available to `generic`, # but is pointless as `generic`s are immutable - def put( - self, - ind: _ArrayLikeInt_co, - v: ArrayLike, - mode: _ModeKind = ..., - ) -> None: ... + def put(self, /, indices: _ArrayLikeInt_co, values: ArrayLike, mode: _ModeKind = "raise") -> None: ... @overload def searchsorted( # type: ignore[misc] @@ -2537,20 +2536,21 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DType_co]): copy: builtins.bool | _CopyMode = ..., ) -> ndarray[_ShapeT_co, dtype[Any]]: ... - @overload - def view(self) -> Self: ... - @overload - def view(self, type: type[_ArrayT]) -> _ArrayT: ... - @overload - def view(self, dtype: _DTypeLike[_SCT]) -> NDArray[_SCT]: ... - @overload - def view(self, dtype: DTypeLike) -> NDArray[Any]: ... - @overload - def view( - self, - dtype: DTypeLike, - type: type[_ArrayT], - ) -> _ArrayT: ... + # + @overload # () + def view(self, /) -> Self: ... + @overload # (dtype: T) + def view(self, /, dtype: _DType | _HasDType[_DType]) -> ndarray[_ShapeT_co, _DType]: ... + @overload # (dtype: dtype[T]) + def view(self, /, dtype: _DTypeLike[_SCT]) -> NDArray[_SCT]: ... + @overload # (type: T) + def view(self, /, *, type: type[_ArrayT]) -> _ArrayT: ... + @overload # (_: T) + def view(self, /, dtype: type[_ArrayT]) -> _ArrayT: ... + @overload # (dtype: ?) + def view(self, /, dtype: DTypeLike) -> ndarray[_ShapeT_co, dtype[Any]]: ... + @overload # (dtype: ?, type: type[T]) + def view(self, /, dtype: DTypeLike, type: type[_ArrayT]) -> _ArrayT: ... @overload def getfield( From 2016e63d69f7b1dae0c5ff24eafb0feab7f898c4 Mon Sep 17 00:00:00 2001 From: jorenham Date: Fri, 14 Mar 2025 19:23:47 +0100 Subject: [PATCH 4/7] TYP: fix typing errors in ``_core.fromnumeric`` Partial port of numpy/numtype#221 --- numpy/_core/fromnumeric.pyi | 767 +++++++++++++++++++++++------------- 1 file changed, 487 insertions(+), 280 deletions(-) diff --git a/numpy/_core/fromnumeric.pyi b/numpy/_core/fromnumeric.pyi index 0465cc5aaa54..69705687ec02 100644 --- a/numpy/_core/fromnumeric.pyi +++ b/numpy/_core/fromnumeric.pyi @@ -1,3 +1,4 @@ +# ruff: noqa: ANN401 from collections.abc import Sequence from typing import ( Any, @@ -34,6 +35,7 @@ from numpy import ( _SortSide, _CastingKind, ) +from numpy._globals import _NoValueType from numpy._typing import ( DTypeLike, _DTypeLike, @@ -105,7 +107,7 @@ __all__ = [ _SCT = TypeVar("_SCT", bound=generic) _SCT_uifcO = TypeVar("_SCT_uifcO", bound=number[Any] | object_) -_ArrayType = TypeVar("_ArrayType", bound=np.ndarray[Any, Any]) +_ArrayT = TypeVar("_ArrayT", bound=np.ndarray[Any, Any]) _SizeType = TypeVar("_SizeType", bound=int) _ShapeType = TypeVar("_ShapeType", bound=tuple[int, ...]) _ShapeType_co = TypeVar("_ShapeType_co", bound=tuple[int, ...], covariant=True) @@ -120,7 +122,7 @@ class _SupportsShape(Protocol[_ShapeType_co]): _T = TypeVar("_T") _PyArray: TypeAlias = list[_T] | tuple[_T, ...] # `int` also covers `bool` -_PyScalar: TypeAlias = int | float | complex | bytes | str +_PyScalar: TypeAlias = float | complex | bytes | str @overload def take( @@ -134,7 +136,7 @@ def take( def take( a: ArrayLike, indices: _IntLike_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., out: None = ..., mode: _ModeKind = ..., ) -> Any: ... @@ -142,7 +144,7 @@ def take( def take( a: _ArrayLike[_SCT], indices: _ArrayLikeInt_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., out: None = ..., mode: _ModeKind = ..., ) -> NDArray[_SCT]: ... @@ -150,7 +152,7 @@ def take( def take( a: ArrayLike, indices: _ArrayLikeInt_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., out: None = ..., mode: _ModeKind = ..., ) -> NDArray[Any]: ... @@ -158,10 +160,19 @@ def take( def take( a: ArrayLike, indices: _ArrayLikeInt_co, - axis: None | SupportsIndex = ..., - out: _ArrayType = ..., + axis: SupportsIndex | None, + out: _ArrayT, mode: _ModeKind = ..., -) -> _ArrayType: ... +) -> _ArrayT: ... +@overload +def take( + a: ArrayLike, + indices: _ArrayLikeInt_co, + axis: SupportsIndex | None = ..., + *, + out: _ArrayT, + mode: _ModeKind = ..., +) -> _ArrayT: ... @overload def reshape( # shape: index @@ -258,21 +269,21 @@ def choose( def choose( a: _ArrayLikeInt_co, choices: ArrayLike, - out: _ArrayType = ..., + out: _ArrayT, mode: _ModeKind = ..., -) -> _ArrayType: ... +) -> _ArrayT: ... @overload def repeat( a: _ArrayLike[_SCT], repeats: _ArrayLikeInt_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., ) -> NDArray[_SCT]: ... @overload def repeat( a: ArrayLike, repeats: _ArrayLikeInt_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., ) -> NDArray[Any]: ... def put( @@ -298,70 +309,70 @@ def swapaxes( @overload def transpose( a: _ArrayLike[_SCT], - axes: None | _ShapeLike = ... + axes: _ShapeLike | None = ... ) -> NDArray[_SCT]: ... @overload def transpose( a: ArrayLike, - axes: None | _ShapeLike = ... + axes: _ShapeLike | None = ... ) -> NDArray[Any]: ... @overload -def matrix_transpose(x: _ArrayLike[_SCT]) -> NDArray[_SCT]: ... +def matrix_transpose(x: _ArrayLike[_SCT], /) -> NDArray[_SCT]: ... @overload -def matrix_transpose(x: ArrayLike) -> NDArray[Any]: ... +def matrix_transpose(x: ArrayLike, /) -> NDArray[Any]: ... @overload def partition( a: _ArrayLike[_SCT], kth: _ArrayLikeInt_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., kind: _PartitionKind = ..., - order: None | str | Sequence[str] = ..., + order: str | Sequence[str] | None = ..., ) -> NDArray[_SCT]: ... @overload def partition( a: ArrayLike, kth: _ArrayLikeInt_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., kind: _PartitionKind = ..., - order: None | str | Sequence[str] = ..., + order: str | Sequence[str] | None = ..., ) -> NDArray[Any]: ... def argpartition( a: ArrayLike, kth: _ArrayLikeInt_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = -1, kind: _PartitionKind = ..., - order: None | str | Sequence[str] = ..., + order: str | Sequence[str] | None = ..., ) -> NDArray[intp]: ... @overload def sort( a: _ArrayLike[_SCT], - axis: None | SupportsIndex = ..., - kind: None | _SortKind = ..., - order: None | str | Sequence[str] = ..., + axis: SupportsIndex | None = ..., + kind: _SortKind | None = ..., + order: str | Sequence[str] | None = ..., *, - stable: None | bool = ..., + stable: bool | None = ..., ) -> NDArray[_SCT]: ... @overload def sort( a: ArrayLike, - axis: None | SupportsIndex = ..., - kind: None | _SortKind = ..., - order: None | str | Sequence[str] = ..., + axis: SupportsIndex | None = ..., + kind: _SortKind | None = ..., + order: str | Sequence[str] | None = ..., *, - stable: None | bool = ..., + stable: bool | None = ..., ) -> NDArray[Any]: ... def argsort( a: ArrayLike, - axis: None | SupportsIndex = ..., - kind: None | _SortKind = ..., - order: None | str | Sequence[str] = ..., + axis: SupportsIndex | None = ..., + kind: _SortKind | None = ..., + order: str | Sequence[str] | None = ..., *, - stable: None | bool = ..., + stable: bool | None = ..., ) -> NDArray[intp]: ... @overload @@ -375,7 +386,7 @@ def argmax( @overload def argmax( a: ArrayLike, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., out: None = ..., *, keepdims: bool = ..., @@ -383,11 +394,19 @@ def argmax( @overload def argmax( a: ArrayLike, - axis: None | SupportsIndex = ..., - out: _ArrayType = ..., + axis: SupportsIndex | None , + out: _ArrayT, *, keepdims: bool = ..., -) -> _ArrayType: ... +) -> _ArrayT: ... +@overload +def argmax( + a: ArrayLike, + axis: SupportsIndex | None = ..., + *, + out: _ArrayT, + keepdims: bool = ..., +) -> _ArrayT: ... @overload def argmin( @@ -400,7 +419,7 @@ def argmin( @overload def argmin( a: ArrayLike, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., out: None = ..., *, keepdims: bool = ..., @@ -408,25 +427,33 @@ def argmin( @overload def argmin( a: ArrayLike, - axis: None | SupportsIndex = ..., - out: _ArrayType = ..., + axis: SupportsIndex | None, + out: _ArrayT, *, keepdims: bool = ..., -) -> _ArrayType: ... +) -> _ArrayT: ... +@overload +def argmin( + a: ArrayLike, + axis: SupportsIndex | None = ..., + *, + out: _ArrayT, + keepdims: bool = ..., +) -> _ArrayT: ... @overload def searchsorted( a: ArrayLike, v: _ScalarLike_co, side: _SortSide = ..., - sorter: None | _ArrayLikeInt_co = ..., # 1D int array + sorter: _ArrayLikeInt_co | None = ..., # 1D int array ) -> intp: ... @overload def searchsorted( a: ArrayLike, v: ArrayLike, side: _SortSide = ..., - sorter: None | _ArrayLikeInt_co = ..., # 1D int array + sorter: _ArrayLikeInt_co | None = ..., # 1D int array ) -> NDArray[intp]: ... # unlike `reshape`, `resize` only accepts positive integers, so literal ints can be used @@ -450,17 +477,17 @@ def resize(a: ArrayLike, new_shape: Sequence[SupportsIndex]) -> NDArray[Any]: .. @overload def squeeze( a: _SCT, - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None = ..., ) -> _SCT: ... @overload def squeeze( a: _ArrayLike[_SCT], - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None = ..., ) -> NDArray[_SCT]: ... @overload def squeeze( a: ArrayLike, - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None = ..., ) -> NDArray[Any]: ... @overload @@ -488,14 +515,24 @@ def trace( out: None = ..., ) -> Any: ... @overload +def trace( + a: ArrayLike, # >= 2D array + offset: SupportsIndex, + axis1: SupportsIndex, + axis2: SupportsIndex, + dtype: DTypeLike, + out: _ArrayT, +) -> _ArrayT: ... +@overload def trace( a: ArrayLike, # >= 2D array offset: SupportsIndex = ..., axis1: SupportsIndex = ..., axis2: SupportsIndex = ..., dtype: DTypeLike = ..., - out: _ArrayType = ..., -) -> _ArrayType: ... + *, + out: _ArrayT, +) -> _ArrayT: ... _Array1D: TypeAlias = np.ndarray[tuple[int], np.dtype[_SCT]] @@ -547,120 +584,128 @@ def shape(a: ArrayLike) -> tuple[int, ...]: ... def compress( condition: _ArrayLikeBool_co, # 1D bool array a: _ArrayLike[_SCT], - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., out: None = ..., ) -> NDArray[_SCT]: ... @overload def compress( condition: _ArrayLikeBool_co, # 1D bool array a: ArrayLike, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., out: None = ..., ) -> NDArray[Any]: ... @overload def compress( condition: _ArrayLikeBool_co, # 1D bool array a: ArrayLike, - axis: None | SupportsIndex = ..., - out: _ArrayType = ..., -) -> _ArrayType: ... + axis: SupportsIndex | None, + out: _ArrayT, +) -> _ArrayT: ... +@overload +def compress( + condition: _ArrayLikeBool_co, # 1D bool array + a: ArrayLike, + axis: SupportsIndex | None = ..., + *, + out: _ArrayT, +) -> _ArrayT: ... @overload def clip( a: _SCT, - a_min: None | ArrayLike, - a_max: None | ArrayLike, + a_min: ArrayLike | None, + a_max: ArrayLike | None, out: None = ..., *, - min: None | ArrayLike = ..., - max: None | ArrayLike = ..., + min: ArrayLike | None = ..., + max: ArrayLike | None = ..., dtype: None = ..., - where: None | _ArrayLikeBool_co = ..., + where: _ArrayLikeBool_co | None = ..., order: _OrderKACF = ..., subok: bool = ..., - signature: str | tuple[None | str, ...] = ..., + signature: str | tuple[str | None, ...] = ..., casting: _CastingKind = ..., ) -> _SCT: ... @overload def clip( a: _ScalarLike_co, - a_min: None | ArrayLike, - a_max: None | ArrayLike, + a_min: ArrayLike | None, + a_max: ArrayLike | None, out: None = ..., *, - min: None | ArrayLike = ..., - max: None | ArrayLike = ..., + min: ArrayLike | None = ..., + max: ArrayLike | None = ..., dtype: None = ..., - where: None | _ArrayLikeBool_co = ..., + where: _ArrayLikeBool_co | None = ..., order: _OrderKACF = ..., subok: bool = ..., - signature: str | tuple[None | str, ...] = ..., + signature: str | tuple[str | None, ...] = ..., casting: _CastingKind = ..., ) -> Any: ... @overload def clip( a: _ArrayLike[_SCT], - a_min: None | ArrayLike, - a_max: None | ArrayLike, + a_min: ArrayLike | None, + a_max: ArrayLike | None, out: None = ..., *, - min: None | ArrayLike = ..., - max: None | ArrayLike = ..., + min: ArrayLike | None = ..., + max: ArrayLike | None = ..., dtype: None = ..., - where: None | _ArrayLikeBool_co = ..., + where: _ArrayLikeBool_co | None = ..., order: _OrderKACF = ..., subok: bool = ..., - signature: str | tuple[None | str, ...] = ..., + signature: str | tuple[str | None, ...] = ..., casting: _CastingKind = ..., ) -> NDArray[_SCT]: ... @overload def clip( a: ArrayLike, - a_min: None | ArrayLike, - a_max: None | ArrayLike, + a_min: ArrayLike | None, + a_max: ArrayLike | None, out: None = ..., *, - min: None | ArrayLike = ..., - max: None | ArrayLike = ..., + min: ArrayLike | None = ..., + max: ArrayLike | None = ..., dtype: None = ..., - where: None | _ArrayLikeBool_co = ..., + where: _ArrayLikeBool_co | None = ..., order: _OrderKACF = ..., subok: bool = ..., - signature: str | tuple[None | str, ...] = ..., + signature: str | tuple[str | None, ...] = ..., casting: _CastingKind = ..., ) -> NDArray[Any]: ... @overload def clip( a: ArrayLike, - a_min: None | ArrayLike, - a_max: None | ArrayLike, - out: _ArrayType = ..., + a_min: ArrayLike | None, + a_max: ArrayLike | None, + out: _ArrayT, *, - min: None | ArrayLike = ..., - max: None | ArrayLike = ..., - dtype: DTypeLike, - where: None | _ArrayLikeBool_co = ..., + min: ArrayLike | None = ..., + max: ArrayLike | None = ..., + dtype: DTypeLike = ..., + where: _ArrayLikeBool_co | None = ..., order: _OrderKACF = ..., subok: bool = ..., - signature: str | tuple[None | str, ...] = ..., + signature: str | tuple[str | None, ...] = ..., casting: _CastingKind = ..., -) -> Any: ... +) -> _ArrayT: ... @overload def clip( a: ArrayLike, - a_min: None | ArrayLike, - a_max: None | ArrayLike, - out: _ArrayType, + a_min: ArrayLike | None, + a_max: ArrayLike | None, + out: ArrayLike = ..., *, - min: None | ArrayLike = ..., - max: None | ArrayLike = ..., - dtype: DTypeLike = ..., - where: None | _ArrayLikeBool_co = ..., + min: ArrayLike | None = ..., + max: ArrayLike | None = ..., + dtype: DTypeLike, + where: _ArrayLikeBool_co | None = ..., order: _OrderKACF = ..., subok: bool = ..., - signature: str | tuple[None | str, ...] = ..., + signature: str | tuple[str | None, ...] = ..., casting: _CastingKind = ..., -) -> _ArrayType: ... +) -> Any: ... @overload def sum( @@ -706,7 +751,7 @@ def sum( @overload def sum( a: ArrayLike, - axis: None | _ShapeLike, + axis: _ShapeLike | None, dtype: _DTypeLike[_SCT], out: None = ..., keepdims: bool = ..., @@ -716,7 +761,7 @@ def sum( @overload def sum( a: ArrayLike, - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None = ..., *, dtype: _DTypeLike[_SCT], out: None = ..., @@ -727,7 +772,7 @@ def sum( @overload def sum( a: ArrayLike, - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None = ..., dtype: DTypeLike = ..., out: None = ..., keepdims: bool = ..., @@ -737,130 +782,157 @@ def sum( @overload def sum( a: ArrayLike, - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None, + dtype: DTypeLike, + out: _ArrayT, + keepdims: bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> _ArrayT: ... +@overload +def sum( + a: ArrayLike, + axis: _ShapeLike | None = ..., dtype: DTypeLike = ..., - out: _ArrayType = ..., + *, + out: _ArrayT, keepdims: bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., -) -> _ArrayType: ... +) -> _ArrayT: ... @overload def all( a: ArrayLike, axis: None = None, out: None = None, - keepdims: Literal[False, 0] = False, + keepdims: Literal[False, 0] | _NoValueType = ..., *, - where: _ArrayLikeBool_co = True, + where: _ArrayLikeBool_co | _NoValueType = ..., ) -> np.bool: ... @overload def all( a: ArrayLike, - axis: None | int | tuple[int, ...] = None, + axis: int | tuple[int, ...] | None = None, out: None = None, - keepdims: SupportsIndex = False, + keepdims: _BoolLike_co | _NoValueType = ..., *, - where: _ArrayLikeBool_co = True, + where: _ArrayLikeBool_co | _NoValueType = ..., ) -> np.bool | NDArray[np.bool]: ... @overload def all( a: ArrayLike, - axis: None | int | tuple[int, ...], - out: _ArrayType, - keepdims: SupportsIndex = False, + axis: int | tuple[int, ...] | None, + out: _ArrayT, + keepdims: _BoolLike_co | _NoValueType = ..., *, - where: _ArrayLikeBool_co = True, -) -> _ArrayType: ... + where: _ArrayLikeBool_co | _NoValueType = ..., +) -> _ArrayT: ... @overload def all( a: ArrayLike, - axis: None | int | tuple[int, ...] = None, + axis: int | tuple[int, ...] | None = None, *, - out: _ArrayType, - keepdims: SupportsIndex = False, - where: _ArrayLikeBool_co = True, -) -> _ArrayType: ... + out: _ArrayT, + keepdims: _BoolLike_co | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., +) -> _ArrayT: ... @overload def any( a: ArrayLike, axis: None = None, out: None = None, - keepdims: Literal[False, 0] = False, + keepdims: Literal[False, 0] | _NoValueType = ..., *, - where: _ArrayLikeBool_co = True, + where: _ArrayLikeBool_co | _NoValueType = ..., ) -> np.bool: ... @overload def any( a: ArrayLike, - axis: None | int | tuple[int, ...] = None, + axis: int | tuple[int, ...] | None = None, out: None = None, - keepdims: SupportsIndex = False, + keepdims: _BoolLike_co | _NoValueType = ..., *, - where: _ArrayLikeBool_co = True, + where: _ArrayLikeBool_co | _NoValueType = ..., ) -> np.bool | NDArray[np.bool]: ... @overload def any( a: ArrayLike, - axis: None | int | tuple[int, ...], - out: _ArrayType, - keepdims: SupportsIndex = False, + axis: int | tuple[int, ...] | None, + out: _ArrayT, + keepdims: _BoolLike_co | _NoValueType = ..., *, - where: _ArrayLikeBool_co = True, -) -> _ArrayType: ... + where: _ArrayLikeBool_co | _NoValueType = ..., +) -> _ArrayT: ... @overload def any( a: ArrayLike, - axis: None | int | tuple[int, ...] = None, + axis: int | tuple[int, ...] | None = None, *, - out: _ArrayType, - keepdims: SupportsIndex = False, - where: _ArrayLikeBool_co = True, -) -> _ArrayType: ... + out: _ArrayT, + keepdims: _BoolLike_co | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., +) -> _ArrayT: ... @overload def cumsum( a: _ArrayLike[_SCT], - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., ) -> NDArray[_SCT]: ... @overload def cumsum( a: ArrayLike, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., ) -> NDArray[Any]: ... @overload def cumsum( a: ArrayLike, - axis: None | SupportsIndex = ..., - dtype: _DTypeLike[_SCT] = ..., + axis: SupportsIndex | None, + dtype: _DTypeLike[_SCT], + out: None = ..., +) -> NDArray[_SCT]: ... +@overload +def cumsum( + a: ArrayLike, + axis: SupportsIndex | None = ..., + *, + dtype: _DTypeLike[_SCT], out: None = ..., ) -> NDArray[_SCT]: ... @overload def cumsum( a: ArrayLike, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: DTypeLike = ..., out: None = ..., ) -> NDArray[Any]: ... @overload def cumsum( a: ArrayLike, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None, + dtype: DTypeLike, + out: _ArrayT, +) -> _ArrayT: ... +@overload +def cumsum( + a: ArrayLike, + axis: SupportsIndex | None = ..., dtype: DTypeLike = ..., - out: _ArrayType = ..., -) -> _ArrayType: ... + *, + out: _ArrayT, +) -> _ArrayT: ... @overload def cumulative_sum( x: _ArrayLike[_SCT], /, *, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., include_initial: bool = ..., @@ -870,7 +942,7 @@ def cumulative_sum( x: ArrayLike, /, *, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., include_initial: bool = ..., @@ -880,8 +952,8 @@ def cumulative_sum( x: ArrayLike, /, *, - axis: None | SupportsIndex = ..., - dtype: _DTypeLike[_SCT] = ..., + axis: SupportsIndex | None = ..., + dtype: _DTypeLike[_SCT], out: None = ..., include_initial: bool = ..., ) -> NDArray[_SCT]: ... @@ -890,7 +962,7 @@ def cumulative_sum( x: ArrayLike, /, *, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: DTypeLike = ..., out: None = ..., include_initial: bool = ..., @@ -900,11 +972,11 @@ def cumulative_sum( x: ArrayLike, /, *, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: DTypeLike = ..., - out: _ArrayType = ..., + out: _ArrayT, include_initial: bool = ..., -) -> _ArrayType: ... +) -> _ArrayT: ... @overload def ptp( @@ -916,17 +988,25 @@ def ptp( @overload def ptp( a: ArrayLike, - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None = ..., out: None = ..., keepdims: bool = ..., ) -> Any: ... @overload def ptp( a: ArrayLike, - axis: None | _ShapeLike = ..., - out: _ArrayType = ..., + axis: _ShapeLike | None, + out: _ArrayT, keepdims: bool = ..., -) -> _ArrayType: ... +) -> _ArrayT: ... +@overload +def ptp( + a: ArrayLike, + axis: _ShapeLike | None = ..., + *, + out: _ArrayT, + keepdims: bool = ..., +) -> _ArrayT: ... @overload def amax( @@ -940,7 +1020,7 @@ def amax( @overload def amax( a: ArrayLike, - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None = ..., out: None = ..., keepdims: bool = ..., initial: _NumberLike_co = ..., @@ -949,12 +1029,22 @@ def amax( @overload def amax( a: ArrayLike, - axis: None | _ShapeLike = ..., - out: _ArrayType = ..., + axis: _ShapeLike | None, + out: _ArrayT, keepdims: bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., -) -> _ArrayType: ... +) -> _ArrayT: ... +@overload +def amax( + a: ArrayLike, + axis: _ShapeLike | None = ..., + *, + out: _ArrayT, + keepdims: bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> _ArrayT: ... @overload def amin( @@ -968,7 +1058,7 @@ def amin( @overload def amin( a: ArrayLike, - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None = ..., out: None = ..., keepdims: bool = ..., initial: _NumberLike_co = ..., @@ -977,12 +1067,22 @@ def amin( @overload def amin( a: ArrayLike, - axis: None | _ShapeLike = ..., - out: _ArrayType = ..., + axis: _ShapeLike | None, + out: _ArrayT, keepdims: bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., -) -> _ArrayType: ... +) -> _ArrayT: ... +@overload +def amin( + a: ArrayLike, + axis: _ShapeLike | None = ..., + *, + out: _ArrayT, + keepdims: bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> _ArrayT: ... # TODO: `np.prod()``: For object arrays `initial` does not necessarily # have to be a numerical scalar. @@ -1044,7 +1144,7 @@ def prod( @overload def prod( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None = ..., dtype: None = ..., out: None = ..., keepdims: bool = ..., @@ -1052,10 +1152,21 @@ def prod( where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload +def prod( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None, + dtype: _DTypeLike[_SCT], + out: None = ..., + keepdims: Literal[False] = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> _SCT: ... +@overload def prod( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, axis: None = ..., - dtype: _DTypeLike[_SCT] = ..., + *, + dtype: _DTypeLike[_SCT], out: None = ..., keepdims: Literal[False] = ..., initial: _NumberLike_co = ..., @@ -1064,8 +1175,8 @@ def prod( @overload def prod( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None | _ShapeLike = ..., - dtype: None | DTypeLike = ..., + axis: _ShapeLike | None = ..., + dtype: DTypeLike | None = ..., out: None = ..., keepdims: bool = ..., initial: _NumberLike_co = ..., @@ -1074,84 +1185,111 @@ def prod( @overload def prod( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None | _ShapeLike = ..., - dtype: None | DTypeLike = ..., - out: _ArrayType = ..., + axis: _ShapeLike | None, + dtype: DTypeLike | None, + out: _ArrayT, + keepdims: bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> _ArrayT: ... +@overload +def prod( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: _ShapeLike | None = ..., + dtype: DTypeLike | None = ..., + *, + out: _ArrayT, keepdims: bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., -) -> _ArrayType: ... +) -> _ArrayT: ... @overload def cumprod( a: _ArrayLikeBool_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., ) -> NDArray[int_]: ... @overload def cumprod( a: _ArrayLikeUInt_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., ) -> NDArray[uint64]: ... @overload def cumprod( a: _ArrayLikeInt_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., ) -> NDArray[int64]: ... @overload def cumprod( a: _ArrayLikeFloat_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., ) -> NDArray[floating[Any]]: ... @overload def cumprod( a: _ArrayLikeComplex_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., ) -> NDArray[complexfloating[Any, Any]]: ... @overload def cumprod( a: _ArrayLikeObject_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., ) -> NDArray[object_]: ... @overload def cumprod( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None | SupportsIndex = ..., - dtype: _DTypeLike[_SCT] = ..., + axis: SupportsIndex | None, + dtype: _DTypeLike[_SCT], + out: None = ..., +) -> NDArray[_SCT]: ... +@overload +def cumprod( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: SupportsIndex | None = ..., + *, + dtype: _DTypeLike[_SCT], out: None = ..., ) -> NDArray[_SCT]: ... @overload def cumprod( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: DTypeLike = ..., out: None = ..., ) -> NDArray[Any]: ... @overload def cumprod( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None, + dtype: DTypeLike, + out: _ArrayT, +) -> _ArrayT: ... +@overload +def cumprod( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: SupportsIndex | None = ..., dtype: DTypeLike = ..., - out: _ArrayType = ..., -) -> _ArrayType: ... + *, + out: _ArrayT, +) -> _ArrayT: ... @overload def cumulative_prod( x: _ArrayLikeBool_co, /, *, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., include_initial: bool = ..., @@ -1161,7 +1299,7 @@ def cumulative_prod( x: _ArrayLikeUInt_co, /, *, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., include_initial: bool = ..., @@ -1171,7 +1309,7 @@ def cumulative_prod( x: _ArrayLikeInt_co, /, *, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., include_initial: bool = ..., @@ -1181,7 +1319,7 @@ def cumulative_prod( x: _ArrayLikeFloat_co, /, *, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., include_initial: bool = ..., @@ -1191,7 +1329,7 @@ def cumulative_prod( x: _ArrayLikeComplex_co, /, *, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., include_initial: bool = ..., @@ -1201,7 +1339,7 @@ def cumulative_prod( x: _ArrayLikeObject_co, /, *, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: None = ..., out: None = ..., include_initial: bool = ..., @@ -1211,8 +1349,8 @@ def cumulative_prod( x: _ArrayLikeComplex_co | _ArrayLikeObject_co, /, *, - axis: None | SupportsIndex = ..., - dtype: _DTypeLike[_SCT] = ..., + axis: SupportsIndex | None = ..., + dtype: _DTypeLike[_SCT], out: None = ..., include_initial: bool = ..., ) -> NDArray[_SCT]: ... @@ -1221,7 +1359,7 @@ def cumulative_prod( x: _ArrayLikeComplex_co | _ArrayLikeObject_co, /, *, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: DTypeLike = ..., out: None = ..., include_initial: bool = ..., @@ -1231,15 +1369,15 @@ def cumulative_prod( x: _ArrayLikeComplex_co | _ArrayLikeObject_co, /, *, - axis: None | SupportsIndex = ..., + axis: SupportsIndex | None = ..., dtype: DTypeLike = ..., - out: _ArrayType = ..., + out: _ArrayT, include_initial: bool = ..., -) -> _ArrayType: ... +) -> _ArrayT: ... def ndim(a: ArrayLike) -> int: ... -def size(a: ArrayLike, axis: None | int = ...) -> int: ... +def size(a: ArrayLike, axis: int | None = ...) -> int: ... @overload def around( @@ -1278,11 +1416,18 @@ def around( out: None = ..., ) -> NDArray[Any]: ... @overload +def around( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + decimals: SupportsIndex, + out: _ArrayT, +) -> _ArrayT: ... +@overload def around( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, decimals: SupportsIndex = ..., - out: _ArrayType = ..., -) -> _ArrayType: ... + *, + out: _ArrayT, +) -> _ArrayT: ... @overload def mean( @@ -1290,9 +1435,9 @@ def mean( axis: None = ..., dtype: None = ..., out: None = ..., - keepdims: Literal[False] = ..., + keepdims: Literal[False] | _NoValueType = ..., *, - where: _ArrayLikeBool_co = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., ) -> floating[Any]: ... @overload def mean( @@ -1300,9 +1445,9 @@ def mean( axis: None = ..., dtype: None = ..., out: None = ..., - keepdims: Literal[False] = ..., + keepdims: Literal[False] | _NoValueType = ..., *, - where: _ArrayLikeBool_co = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., ) -> complexfloating[Any, Any]: ... @overload def mean( @@ -1310,40 +1455,40 @@ def mean( axis: None = ..., dtype: None = ..., out: None = ..., - keepdims: Literal[False] = ..., + keepdims: Literal[False] | _NoValueType = ..., *, - where: _ArrayLikeBool_co = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., ) -> timedelta64: ... @overload def mean( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None = ..., dtype: None = ..., out: None = ..., - keepdims: bool = ..., + keepdims: bool | _NoValueType = ..., *, - where: _ArrayLikeBool_co = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., ) -> Any: ... @overload def mean( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None = ..., - dtype: _DTypeLike[_SCT] = ..., + axis: None, + dtype: _DTypeLike[_SCT], out: None = ..., - keepdims: Literal[False] = ..., + keepdims: bool | _NoValueType = ..., *, - where: _ArrayLikeBool_co = ..., -) -> _SCT: ... + where: _ArrayLikeBool_co | _NoValueType = ..., +) -> _SCT | NDArray[_SCT]: ... @overload def mean( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None, + axis: None = ..., + *, dtype: _DTypeLike[_SCT], out: None = ..., - keepdims: bool = ..., - *, - where: _ArrayLikeBool_co = ..., -) -> _SCT | NDArray[_SCT]: ... + keepdims: Literal[False] | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., +) -> _SCT: ... @overload def mean( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, @@ -1351,29 +1496,39 @@ def mean( *, dtype: _DTypeLike[_SCT], out: None = ..., - keepdims: bool = ..., - where: _ArrayLikeBool_co = ..., + keepdims: bool | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., ) -> _SCT | NDArray[_SCT]: ... @overload def mean( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None = ..., dtype: DTypeLike = ..., out: None = ..., - keepdims: bool = ..., + keepdims: bool | _NoValueType = ..., *, - where: _ArrayLikeBool_co = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., ) -> Any: ... @overload def mean( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None, + dtype: DTypeLike, + out: _ArrayT, + keepdims: bool | _NoValueType = ..., + *, + where: _ArrayLikeBool_co | _NoValueType = ..., +) -> _ArrayT: ... +@overload +def mean( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: _ShapeLike | None = ..., dtype: DTypeLike = ..., - out: _ArrayType = ..., - keepdims: bool = ..., *, - where: _ArrayLikeBool_co = ..., -) -> _ArrayType: ... + out: _ArrayT, + keepdims: bool | _NoValueType = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., +) -> _ArrayT: ... @overload def std( @@ -1381,65 +1536,91 @@ def std( axis: None = ..., dtype: None = ..., out: None = ..., - ddof: int | float = ..., + ddof: float = ..., keepdims: Literal[False] = ..., *, - where: _ArrayLikeBool_co = ..., - mean: _ArrayLikeComplex_co = ..., - correction: int | float = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., ) -> floating[Any]: ... @overload def std( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None = ..., dtype: None = ..., out: None = ..., - ddof: int | float = ..., + ddof: float = ..., keepdims: bool = ..., *, - where: _ArrayLikeBool_co = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., - correction: int | float = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + correction: float | _NoValueType = ..., ) -> Any: ... @overload def std( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None = ..., - dtype: _DTypeLike[_SCT] = ..., + axis: None, + dtype: _DTypeLike[_SCT], out: None = ..., - ddof: int | float = ..., + ddof: float = ..., keepdims: Literal[False] = ..., *, - where: _ArrayLikeBool_co = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., - correction: int | float = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + correction: float | _NoValueType = ..., ) -> _SCT: ... @overload def std( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None | _ShapeLike = ..., + axis: None = ..., + *, + dtype: _DTypeLike[_SCT], + out: None = ..., + ddof: float = ..., + keepdims: Literal[False] = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> _SCT: ... +@overload +def std( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: _ShapeLike | None = ..., dtype: DTypeLike = ..., out: None = ..., - ddof: int | float = ..., + ddof: float = ..., keepdims: bool = ..., *, - where: _ArrayLikeBool_co = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., - correction: int | float = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + correction: float | _NoValueType = ..., ) -> Any: ... @overload def std( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None | _ShapeLike = ..., - dtype: DTypeLike = ..., - out: _ArrayType = ..., - ddof: int | float = ..., + axis: _ShapeLike | None, + dtype: DTypeLike, + out: _ArrayT, + ddof: float = ..., keepdims: bool = ..., *, - where: _ArrayLikeBool_co = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., - correction: int | float = ..., -) -> _ArrayType: ... + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> _ArrayT: ... +@overload +def std( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: _ShapeLike | None = ..., + dtype: DTypeLike = ..., + *, + out: _ArrayT, + ddof: float = ..., + keepdims: bool = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> _ArrayT: ... @overload def var( @@ -1447,65 +1628,91 @@ def var( axis: None = ..., dtype: None = ..., out: None = ..., - ddof: int | float = ..., + ddof: float = ..., keepdims: Literal[False] = ..., *, - where: _ArrayLikeBool_co = ..., - mean: _ArrayLikeComplex_co = ..., - correction: int | float = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _NoValueType = ..., + correction: float | _NoValueType = ..., ) -> floating[Any]: ... @overload def var( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None = ..., dtype: None = ..., out: None = ..., - ddof: int | float = ..., + ddof: float = ..., keepdims: bool = ..., *, - where: _ArrayLikeBool_co = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., - correction: int | float = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + correction: float | _NoValueType = ..., ) -> Any: ... @overload def var( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None = ..., - dtype: _DTypeLike[_SCT] = ..., + axis: None, + dtype: _DTypeLike[_SCT], out: None = ..., - ddof: int | float = ..., + ddof: float = ..., keepdims: Literal[False] = ..., *, - where: _ArrayLikeBool_co = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., - correction: int | float = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> _SCT: ... +@overload +def var( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None = ..., + *, + dtype: _DTypeLike[_SCT], + out: None = ..., + ddof: float = ..., + keepdims: Literal[False] = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + correction: float | _NoValueType = ..., ) -> _SCT: ... @overload def var( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None | _ShapeLike = ..., + axis: _ShapeLike | None = ..., dtype: DTypeLike = ..., out: None = ..., - ddof: int | float = ..., + ddof: float = ..., keepdims: bool = ..., *, - where: _ArrayLikeBool_co = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., - correction: int | float = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + correction: float | _NoValueType = ..., ) -> Any: ... @overload def var( a: _ArrayLikeComplex_co | _ArrayLikeObject_co, - axis: None | _ShapeLike = ..., - dtype: DTypeLike = ..., - out: _ArrayType = ..., - ddof: int | float = ..., + axis: _ShapeLike | None, + dtype: DTypeLike, + out: _ArrayT, + ddof: float = ..., keepdims: bool = ..., *, - where: _ArrayLikeBool_co = ..., - mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., - correction: int | float = ..., -) -> _ArrayType: ... + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> _ArrayT: ... +@overload +def var( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: _ShapeLike | None = ..., + dtype: DTypeLike = ..., + *, + out: _ArrayT, + ddof: float = ..., + keepdims: bool = ..., + where: _ArrayLikeBool_co | _NoValueType = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co | _NoValueType = ..., + correction: float | _NoValueType = ..., +) -> _ArrayT: ... max = amax min = amin From 42e5140a1b644cf57bcb146cfc018bfad1dc2176 Mon Sep 17 00:00:00 2001 From: jorenham Date: Fri, 14 Mar 2025 19:33:43 +0100 Subject: [PATCH 5/7] TYP: fix typing errors in ``_core.function_base`` Partial port of numpy/numtype#221 --- numpy/_core/function_base.pyi | 91 ++++++++++++++++++++++++----------- 1 file changed, 62 insertions(+), 29 deletions(-) diff --git a/numpy/_core/function_base.pyi b/numpy/_core/function_base.pyi index 1d7ea3a2792e..12fdf677d0f5 100644 --- a/numpy/_core/function_base.pyi +++ b/numpy/_core/function_base.pyi @@ -29,8 +29,8 @@ def linspace( dtype: None = ..., axis: SupportsIndex = ..., *, - device: None | L["cpu"] = ..., -) -> NDArray[floating[Any]]: ... + device: L["cpu"] | None = ..., +) -> NDArray[floating]: ... @overload def linspace( start: _ArrayLikeComplex_co, @@ -41,8 +41,20 @@ def linspace( dtype: None = ..., axis: SupportsIndex = ..., *, - device: None | L["cpu"] = ..., -) -> NDArray[complexfloating[Any, Any]]: ... + device: L["cpu"] | None = ..., +) -> NDArray[complexfloating]: ... +@overload +def linspace( + start: _ArrayLikeComplex_co, + stop: _ArrayLikeComplex_co, + num: SupportsIndex, + endpoint: bool, + retstep: L[False], + dtype: _DTypeLike[_SCT], + axis: SupportsIndex = ..., + *, + device: L["cpu"] | None = ..., +) -> NDArray[_SCT]: ... @overload def linspace( start: _ArrayLikeComplex_co, @@ -50,10 +62,10 @@ def linspace( num: SupportsIndex = ..., endpoint: bool = ..., retstep: L[False] = ..., - dtype: _DTypeLike[_SCT] = ..., - axis: SupportsIndex = ..., *, - device: None | L["cpu"] = ..., + dtype: _DTypeLike[_SCT], + axis: SupportsIndex = ..., + device: L["cpu"] | None = ..., ) -> NDArray[_SCT]: ... @overload def linspace( @@ -65,7 +77,7 @@ def linspace( dtype: DTypeLike = ..., axis: SupportsIndex = ..., *, - device: None | L["cpu"] = ..., + device: L["cpu"] | None = ..., ) -> NDArray[Any]: ... @overload def linspace( @@ -73,35 +85,35 @@ def linspace( stop: _ArrayLikeFloat_co, num: SupportsIndex = ..., endpoint: bool = ..., - retstep: L[True] = ..., + *, + retstep: L[True], dtype: None = ..., axis: SupportsIndex = ..., - *, - device: None | L["cpu"] = ..., -) -> tuple[NDArray[floating[Any]], floating[Any]]: ... + device: L["cpu"] | None = ..., +) -> tuple[NDArray[floating], floating]: ... @overload def linspace( start: _ArrayLikeComplex_co, stop: _ArrayLikeComplex_co, num: SupportsIndex = ..., endpoint: bool = ..., - retstep: L[True] = ..., + *, + retstep: L[True], dtype: None = ..., axis: SupportsIndex = ..., - *, - device: None | L["cpu"] = ..., -) -> tuple[NDArray[complexfloating[Any, Any]], complexfloating[Any, Any]]: ... + device: L["cpu"] | None = ..., +) -> tuple[NDArray[complexfloating], complexfloating]: ... @overload def linspace( start: _ArrayLikeComplex_co, stop: _ArrayLikeComplex_co, num: SupportsIndex = ..., endpoint: bool = ..., - retstep: L[True] = ..., - dtype: _DTypeLike[_SCT] = ..., - axis: SupportsIndex = ..., *, - device: None | L["cpu"] = ..., + retstep: L[True], + dtype: _DTypeLike[_SCT], + axis: SupportsIndex = ..., + device: L["cpu"] | None = ..., ) -> tuple[NDArray[_SCT], _SCT]: ... @overload def linspace( @@ -109,11 +121,11 @@ def linspace( stop: _ArrayLikeComplex_co, num: SupportsIndex = ..., endpoint: bool = ..., - retstep: L[True] = ..., + *, + retstep: L[True], dtype: DTypeLike = ..., axis: SupportsIndex = ..., - *, - device: None | L["cpu"] = ..., + device: L["cpu"] | None = ..., ) -> tuple[NDArray[Any], Any]: ... @overload @@ -125,7 +137,7 @@ def logspace( base: _ArrayLikeFloat_co = ..., dtype: None = ..., axis: SupportsIndex = ..., -) -> NDArray[floating[Any]]: ... +) -> NDArray[floating]: ... @overload def logspace( start: _ArrayLikeComplex_co, @@ -135,7 +147,17 @@ def logspace( base: _ArrayLikeComplex_co = ..., dtype: None = ..., axis: SupportsIndex = ..., -) -> NDArray[complexfloating[Any, Any]]: ... +) -> NDArray[complexfloating]: ... +@overload +def logspace( + start: _ArrayLikeComplex_co, + stop: _ArrayLikeComplex_co, + num: SupportsIndex, + endpoint: bool, + base: _ArrayLikeComplex_co, + dtype: _DTypeLike[_SCT], + axis: SupportsIndex = ..., +) -> NDArray[_SCT]: ... @overload def logspace( start: _ArrayLikeComplex_co, @@ -143,7 +165,8 @@ def logspace( num: SupportsIndex = ..., endpoint: bool = ..., base: _ArrayLikeComplex_co = ..., - dtype: _DTypeLike[_SCT] = ..., + *, + dtype: _DTypeLike[_SCT], axis: SupportsIndex = ..., ) -> NDArray[_SCT]: ... @overload @@ -165,7 +188,7 @@ def geomspace( endpoint: bool = ..., dtype: None = ..., axis: SupportsIndex = ..., -) -> NDArray[floating[Any]]: ... +) -> NDArray[floating]: ... @overload def geomspace( start: _ArrayLikeComplex_co, @@ -174,14 +197,24 @@ def geomspace( endpoint: bool = ..., dtype: None = ..., axis: SupportsIndex = ..., -) -> NDArray[complexfloating[Any, Any]]: ... +) -> NDArray[complexfloating]: ... +@overload +def geomspace( + start: _ArrayLikeComplex_co, + stop: _ArrayLikeComplex_co, + num: SupportsIndex, + endpoint: bool, + dtype: _DTypeLike[_SCT], + axis: SupportsIndex = ..., +) -> NDArray[_SCT]: ... @overload def geomspace( start: _ArrayLikeComplex_co, stop: _ArrayLikeComplex_co, num: SupportsIndex = ..., endpoint: bool = ..., - dtype: _DTypeLike[_SCT] = ..., + *, + dtype: _DTypeLike[_SCT], axis: SupportsIndex = ..., ) -> NDArray[_SCT]: ... @overload From 50a4fb1acc09b8d49e0eb119a945b8a0ad04280c Mon Sep 17 00:00:00 2001 From: jorenham Date: Fri, 14 Mar 2025 19:36:50 +0100 Subject: [PATCH 6/7] TYP: add missing implicit re-exports in ``_core.numeric`` Partial port of numpy/numtype#221 --- numpy/_core/numeric.pyi | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/numpy/_core/numeric.pyi b/numpy/_core/numeric.pyi index d97ee6e4f649..7966d9ac118b 100644 --- a/numpy/_core/numeric.pyi +++ b/numpy/_core/numeric.pyi @@ -47,6 +47,13 @@ from numpy import ( _OrderKACF, _OrderCF, ) +from .fromnumeric import ( + all as all, + any as any, + argpartition as argpartition, + matrix_transpose as matrix_transpose, + mean as mean, +) from .multiarray import ( # re-exports arange, From a5044ed9f7d775d8f32660a90e536511fd92bf3a Mon Sep 17 00:00:00 2001 From: jorenham Date: Fri, 14 Mar 2025 19:41:20 +0100 Subject: [PATCH 7/7] STY: fix `E203` flake8 error --- numpy/_core/fromnumeric.pyi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/numpy/_core/fromnumeric.pyi b/numpy/_core/fromnumeric.pyi index 69705687ec02..f7207db17b0c 100644 --- a/numpy/_core/fromnumeric.pyi +++ b/numpy/_core/fromnumeric.pyi @@ -394,7 +394,7 @@ def argmax( @overload def argmax( a: ArrayLike, - axis: SupportsIndex | None , + axis: SupportsIndex | None, out: _ArrayT, *, keepdims: bool = ...,