From 1b2cbd0287dfabe27a7d99d4149f238a74398c42 Mon Sep 17 00:00:00 2001 From: jorenham Date: Wed, 19 Feb 2025 22:13:31 +0100 Subject: [PATCH 1/2] =?UTF-8?q?=F0=9F=90=9B=20fix=20typing=20errors=20in?= =?UTF-8?q?=20`numpy.=5Fcore.numeric`?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/numpy-stubs/__init__.pyi | 14 +- src/numpy-stubs/_core/numeric.pyi | 670 ++++++++++++++++-------------- test/static/accept/numeric.pyi | 133 +++--- 3 files changed, 442 insertions(+), 375 deletions(-) diff --git a/src/numpy-stubs/__init__.pyi b/src/numpy-stubs/__init__.pyi index c2475ea6..add1c8eb 100644 --- a/src/numpy-stubs/__init__.pyi +++ b/src/numpy-stubs/__init__.pyi @@ -142,6 +142,8 @@ from numpy._core.multiarray import ( zeros, ) from numpy._core.numeric import ( + False_, + True_, allclose, argwhere, array_equal, @@ -159,10 +161,14 @@ from numpy._core.numeric import ( full_like, identity, indices, + inf, isclose, isfortran, isscalar, + little_endian, moveaxis, + nan, + newaxis, ones, ones_like, outer, @@ -1043,18 +1049,10 @@ class _IntegralMixin(_RealMixin): __version__: Final = "2.2.2" -newaxis: Final = None -inf: Final[float] = ... -nan: Final[float] = ... pi: Final[float] = ... e: Final[float] = ... euler_gamma: Final[float] = ... -False_: Final[np.bool[L[False]]] = ... -True_: Final[np.bool[L[True]]] = ... - -little_endian: Final[builtins.bool] = ... - # not in __all__ __NUMPY_SETUP__: Final = False __numpy_submodules__: Final[set[_SubModule]] = ... diff --git a/src/numpy-stubs/_core/numeric.pyi b/src/numpy-stubs/_core/numeric.pyi index 3c96246f..a8774aea 100644 --- a/src/numpy-stubs/_core/numeric.pyi +++ b/src/numpy-stubs/_core/numeric.pyi @@ -1,50 +1,58 @@ from collections.abc import Callable, Sequence -from typing import Any, Literal as L, NoReturn, SupportsAbs, SupportsIndex, TypeAlias, overload +from typing import Any, Final, Literal as L, NoReturn, SupportsAbs, SupportsIndex, TypeAlias, overload from typing_extensions import TypeIs, TypeVar, Unpack import numpy as np import numpy.typing as npt -from numpy import ( # noqa: ICN003 - False_, - True_, - _AnyShapeT, - _OrderCF, - _OrderKACF, - bitwise_not, - broadcast, - dtype, - flatiter, - from_dlpack, - inf, - little_endian, - matmul, - nan, - ndarray, - nditer, - newaxis, - ufunc, - vecdot, -) -from numpy._typing import ( - ArrayLike, - DTypeLike, - NDArray, - _ArrayLike, - _ArrayLikeBool_co, - _ArrayLikeComplex_co, - _ArrayLikeFloat_co, - _ArrayLikeInt_co, - _ArrayLikeObject_co, - _ArrayLikeTD64_co, - _ArrayLikeUInt_co, - _ArrayLikeUnknown, - _DTypeLike, - _ScalarLike_co, - _ShapeLike, - _SupportsArrayFunc, +from _numtype import ( + Array, + Array_1d, + Array_2d, + CoComplex_1d, + CoComplex_1nd, + CoComplex_nd, + CoFloating_1d, + CoFloating_1nd, + CoFloating_nd, + CoSInteger_1d, + CoSInteger_1nd, + CoSInteger_nd, + CoTimeDelta_1d, + CoTimeDelta_1nd, + CoTimeDelta_nd, + CoUInteger_1d, + CoUInteger_1nd, + CoUInteger_nd, + Is, + ToBool_1d, + ToBool_1nd, + ToBool_nd, + ToComplex_1d, + ToComplex_1nd, + ToComplex_nd, + ToFloating_1d, + ToFloating_1nd, + ToFloating_nd, + ToInteger_1d, + ToObject_1d, + ToObject_1nd, + ToObject_nd, + ToSInteger_1d, + ToSInteger_1nd, + ToSInteger_nd, + ToTimeDelta_1d, + ToTimeDelta_1nd, + ToTimeDelta_nd, + ToUInteger_1d, + ToUInteger_1nd, + ToUInteger_nd, + _ToArray_1nd, + _ToArray_nd, ) +from numpy import _AnyShapeT, _OrderCF, _OrderKACF, bitwise_not, dtype, matmul, ndarray, ufunc, vecdot # noqa: ICN003 +from numpy._typing import ArrayLike, DTypeLike, _ArrayLike, _DTypeLike, _ScalarLike_co, _ShapeLike, _SupportsArrayFunc -from ._multiarray_umath import _Array, _Array1D, _FloatType, _KwargsD, _KwargsDL +from ._multiarray_umath import _KwargsD, _KwargsDL from .multiarray import ( arange, array, @@ -52,12 +60,15 @@ from .multiarray import ( asarray, ascontiguousarray, asfortranarray, + broadcast, can_cast, concatenate, copyto, dot, empty, empty_like, + flatiter, + from_dlpack, frombuffer, fromfile, fromiter, @@ -66,6 +77,7 @@ from .multiarray import ( lexsort, may_share_memory, min_scalar_type, + nditer, nested_iters, promote_types, putmask, @@ -156,7 +168,20 @@ _ScalarT = TypeVar("_ScalarT", bound=np.generic) _ArrayT = TypeVar("_ArrayT", bound=np.ndarray[Any, Any]) _ShapeT = TypeVar("_ShapeT", bound=tuple[int, ...]) -_CorrelateMode: TypeAlias = L["valid", "same", "full"] +_PyScalar: TypeAlias = complex | str | bytes +_Mode: TypeAlias = L["valid", "same", "full"] +_Axes: TypeAlias = int | tuple[_ShapeLike, _ShapeLike] + +### + +newaxis: Final[None] = None + +little_endian: Final[bool] = ... + +inf: Final[float] = ... +nan: Final[float] = ... +False_: Final[np.bool[L[False]]] = ... +True_: Final[np.bool[L[True]]] = ... ### @@ -164,66 +189,66 @@ _CorrelateMode: TypeAlias = L["valid", "same", "full"] @overload # 1d def ones( shape: int | tuple[int], - dtype: _FloatType | None = ..., + dtype: type[Is[float]] | None = None, order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array1D[np.float64]: ... +) -> Array_1d[np.float64]: ... @overload def ones( shape: int | tuple[int], dtype: _DTypeLike[_ScalarT], order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array1D[_ScalarT]: ... +) -> Array_1d[_ScalarT]: ... @overload def ones( shape: int | tuple[int], - dtype: npt.DTypeLike = ..., + dtype: npt.DTypeLike | None = None, order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array1D: ... +) -> Array_1d: ... @overload # known shape def ones( shape: _AnyShapeT, - dtype: _FloatType | None = ..., + dtype: type[Is[float]] | None = None, order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array[np.float64, _AnyShapeT]: ... +) -> Array[np.float64, _AnyShapeT]: ... @overload def ones( shape: _AnyShapeT, dtype: _DTypeLike[_ScalarT], order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array[_ScalarT, _AnyShapeT]: ... +) -> Array[_ScalarT, _AnyShapeT]: ... @overload def ones( shape: _AnyShapeT, - dtype: npt.DTypeLike = ..., + dtype: npt.DTypeLike = None, order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array[Any, _AnyShapeT]: ... +) -> Array[Any, _AnyShapeT]: ... @overload # unknown shape def ones( shape: _ShapeLike, - dtype: _FloatType | None = ..., + dtype: type[Is[float]] | None = None, order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array[np.float64]: ... +) -> Array[np.float64]: ... @overload def ones( shape: _ShapeLike, dtype: _DTypeLike[_ScalarT], order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array[_ScalarT]: ... +) -> Array[_ScalarT]: ... @overload def ones( shape: _ShapeLike, - dtype: npt.DTypeLike = ..., + dtype: npt.DTypeLike | None = None, order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array: ... +) -> Array: ... # keep in sync with `ones` @overload @@ -233,7 +258,7 @@ def full( dtype: None = None, order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array1D[_ScalarT]: ... +) -> Array_1d[_ScalarT]: ... @overload def full( shape: int | tuple[int], @@ -241,7 +266,7 @@ def full( dtype: _DTypeLike[_ScalarT], order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array1D[_ScalarT]: ... +) -> Array_1d[_ScalarT]: ... @overload def full( shape: int | tuple[int], @@ -249,7 +274,7 @@ def full( dtype: DTypeLike | None = None, order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array1D: ... +) -> Array_1d: ... @overload def full( shape: _ShapeT, @@ -257,7 +282,7 @@ def full( dtype: None = None, order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array[_ScalarT, _ShapeT]: ... +) -> Array[_ScalarT, _ShapeT]: ... @overload def full( shape: _ShapeT, @@ -265,7 +290,7 @@ def full( dtype: _DTypeLike[_ScalarT], order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array[_ScalarT, _ShapeT]: ... +) -> Array[_ScalarT, _ShapeT]: ... @overload def full( shape: _ShapeT, @@ -273,7 +298,7 @@ def full( dtype: DTypeLike | None = None, order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array[Any, _ShapeT]: ... +) -> Array[Any, _ShapeT]: ... @overload def full( shape: _ShapeLike, @@ -281,7 +306,7 @@ def full( dtype: None = None, order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> NDArray[_ScalarT]: ... +) -> Array[_ScalarT]: ... @overload def full( shape: _ShapeLike, @@ -289,7 +314,7 @@ def full( dtype: _DTypeLike[_ScalarT], order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> NDArray[_ScalarT]: ... +) -> Array[_ScalarT]: ... @overload def full( shape: _ShapeLike, @@ -297,387 +322,416 @@ def full( dtype: DTypeLike | None = None, order: _OrderCF = "C", **kwargs: Unpack[_KwargsDL], -) -> _Array: ... +) -> Array: ... # @overload def zeros_like( a: _ArrayT, - dtype: None = ..., - order: _OrderKACF = ..., - subok: L[True] = ..., - shape: None = ..., + dtype: None = None, + order: _OrderKACF = "K", + subok: L[True] = True, + shape: None = None, **kwargs: Unpack[_KwargsD], ) -> _ArrayT: ... @overload def zeros_like( a: _ArrayLike[_ScalarT], - dtype: None = ..., - order: _OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., + dtype: None = None, + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, **kwargs: Unpack[_KwargsD], -) -> NDArray[_ScalarT]: ... +) -> Array[_ScalarT]: ... @overload def zeros_like( a: object, - dtype: None = ..., - order: _OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., + dtype: None = None, + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, **kwargs: Unpack[_KwargsD], -) -> _Array: ... +) -> Array: ... @overload def zeros_like( a: Any, dtype: _DTypeLike[_ScalarT], - order: _OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, **kwargs: Unpack[_KwargsD], -) -> NDArray[_ScalarT]: ... +) -> Array[_ScalarT]: ... @overload def zeros_like( a: Any, dtype: DTypeLike, - order: _OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, **kwargs: Unpack[_KwargsD], -) -> _Array: ... +) -> Array: ... # @overload def ones_like( a: _ArrayT, - dtype: None = ..., - order: _OrderKACF = ..., - subok: L[True] = ..., - shape: None = ..., + dtype: None = None, + order: _OrderKACF = "K", + subok: L[True] = True, + shape: None = None, **kwargs: Unpack[_KwargsD], ) -> _ArrayT: ... @overload def ones_like( a: _ArrayLike[_ScalarT], - dtype: None = ..., - order: _OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., + dtype: None = None, + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, **kwargs: Unpack[_KwargsD], -) -> NDArray[_ScalarT]: ... +) -> Array[_ScalarT]: ... @overload def ones_like( a: object, - dtype: None = ..., - order: _OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., + dtype: None = None, + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, **kwargs: Unpack[_KwargsD], -) -> _Array: ... +) -> Array: ... @overload def ones_like( a: Any, dtype: _DTypeLike[_ScalarT], - order: _OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, **kwargs: Unpack[_KwargsD], -) -> NDArray[_ScalarT]: ... +) -> Array[_ScalarT]: ... @overload def ones_like( a: Any, dtype: DTypeLike, - order: _OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, **kwargs: Unpack[_KwargsD], -) -> _Array: ... +) -> Array: ... # @overload def full_like( a: _ArrayT, fill_value: Any, - dtype: None = ..., - order: _OrderKACF = ..., - subok: L[True] = ..., - shape: None = ..., + dtype: None = None, + order: _OrderKACF = "K", + subok: L[True] = True, + shape: None = None, **kwargs: Unpack[_KwargsD], ) -> _ArrayT: ... @overload def full_like( a: _ArrayLike[_ScalarT], fill_value: Any, - dtype: None = ..., - order: _OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., + dtype: None = None, + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, **kwargs: Unpack[_KwargsD], -) -> NDArray[_ScalarT]: ... +) -> Array[_ScalarT]: ... @overload def full_like( a: object, fill_value: Any, - dtype: None = ..., - order: _OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., + dtype: None = None, + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, **kwargs: Unpack[_KwargsD], -) -> _Array: ... +) -> Array: ... @overload def full_like( a: Any, fill_value: Any, dtype: _DTypeLike[_ScalarT], - order: _OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, **kwargs: Unpack[_KwargsD], -) -> NDArray[_ScalarT]: ... +) -> Array[_ScalarT]: ... @overload def full_like( a: Any, fill_value: Any, dtype: DTypeLike, - order: _OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, **kwargs: Unpack[_KwargsD], -) -> _Array: ... +) -> Array: ... # @overload -def count_nonzero(a: ArrayLike, axis: None = ..., *, keepdims: L[False] = ...) -> int: ... +def count_nonzero(a: ArrayLike, axis: None = None, *, keepdims: L[False] = False) -> int: ... @overload -def count_nonzero(a: ArrayLike, axis: _ShapeLike = ..., *, keepdims: bool = ...) -> Any: ... +def count_nonzero(a: ArrayLike, axis: _ShapeLike | None = None, *, keepdims: bool = False) -> Any: ... + +# +def flatnonzero(a: ArrayLike) -> Array_1d[np.intp]: ... # -def isfortran(a: _Array | np.generic) -> bool: ... -def argwhere(a: ArrayLike) -> NDArray[np.int_]: ... -def flatnonzero(a: ArrayLike) -> NDArray[np.int_]: ... +def argwhere(a: ArrayLike) -> Array[np.intp]: ... # +def isfortran(a: Array | np.generic) -> bool: ... + +# +@overload +def correlate(a: ToBool_1d, v: ToBool_1d, mode: _Mode = "valid") -> Array_1d[np.bool]: ... # type: ignore[overload-overlap] +@overload +def correlate(a: ToUInteger_1d, v: CoUInteger_1d, mode: _Mode = "valid") -> Array_1d[np.unsignedinteger]: ... # type: ignore[overload-overlap] +@overload +def correlate(a: CoUInteger_1d, v: ToUInteger_1d, mode: _Mode = "valid") -> Array_1d[np.unsignedinteger]: ... # type: ignore[overload-overlap] @overload -def correlate(a: _ArrayLikeUnknown, v: _ArrayLikeUnknown, mode: _CorrelateMode = ...) -> _Array: ... +def correlate(a: ToSInteger_1d, v: CoSInteger_1d, mode: _Mode = "valid") -> Array_1d[np.signedinteger]: ... # type: ignore[overload-overlap] @overload -def correlate(a: _ArrayLikeBool_co, v: _ArrayLikeBool_co, mode: _CorrelateMode = ...) -> NDArray[np.bool]: ... +def correlate(a: CoSInteger_1d, v: ToSInteger_1d, mode: _Mode = "valid") -> Array_1d[np.signedinteger]: ... # type: ignore[overload-overlap] @overload -def correlate(a: _ArrayLikeUInt_co, v: _ArrayLikeUInt_co, mode: _CorrelateMode = ...) -> NDArray[np.unsignedinteger]: ... +def correlate(a: ToFloating_1d, v: CoFloating_1d, mode: _Mode = "valid") -> Array_1d[np.floating]: ... # type: ignore[overload-overlap] @overload -def correlate(a: _ArrayLikeInt_co, v: _ArrayLikeInt_co, mode: _CorrelateMode = ...) -> NDArray[np.signedinteger]: ... +def correlate(a: CoFloating_1d, v: ToFloating_1d, mode: _Mode = "valid") -> Array_1d[np.floating]: ... # type: ignore[overload-overlap] @overload -def correlate(a: _ArrayLikeFloat_co, v: _ArrayLikeFloat_co, mode: _CorrelateMode = ...) -> NDArray[np.floating]: ... +def correlate(a: ToComplex_1d, v: CoComplex_1d, mode: _Mode = "valid") -> Array_1d[np.complexfloating]: ... # type: ignore[overload-overlap] @overload -def correlate(a: _ArrayLikeComplex_co, v: _ArrayLikeComplex_co, mode: _CorrelateMode = ...) -> NDArray[np.complexfloating]: ... +def correlate(a: CoComplex_1d, v: ToComplex_1d, mode: _Mode = "valid") -> Array_1d[np.complexfloating]: ... # type: ignore[overload-overlap] @overload -def correlate(a: _ArrayLikeTD64_co, v: _ArrayLikeTD64_co, mode: _CorrelateMode = ...) -> NDArray[np.timedelta64]: ... +def correlate(a: ToTimeDelta_1d, v: CoTimeDelta_1d, mode: _Mode = "valid") -> Array_1d[np.timedelta64]: ... @overload -def correlate(a: _ArrayLikeObject_co, v: _ArrayLikeObject_co, mode: _CorrelateMode = ...) -> NDArray[np.object_]: ... +def correlate(a: CoTimeDelta_1d, v: ToTimeDelta_1d, mode: _Mode = "valid") -> Array_1d[np.timedelta64]: ... +@overload +def correlate(a: ToObject_1d, v: ToObject_1d, mode: _Mode = "valid") -> Array_1d[np.object_]: ... +@overload +def correlate( + a: CoComplex_1d | CoTimeDelta_1d | ToObject_1d, + v: CoComplex_1d | CoTimeDelta_1d | ToObject_1d, + mode: _Mode = "valid", +) -> Array_1d[Any]: ... # @overload -def convolve(a: _ArrayLikeUnknown, v: _ArrayLikeUnknown, mode: _CorrelateMode = ...) -> _Array: ... +def convolve(a: ToBool_1d, v: ToBool_1d, mode: _Mode = "valid") -> Array_1d[np.bool]: ... # type: ignore[overload-overlap] +@overload +def convolve(a: ToUInteger_1d, v: CoUInteger_1d, mode: _Mode = "valid") -> Array_1d[np.unsignedinteger]: ... # type: ignore[overload-overlap] +@overload +def convolve(a: CoUInteger_1d, v: ToUInteger_1d, mode: _Mode = "valid") -> Array_1d[np.unsignedinteger]: ... # type: ignore[overload-overlap] @overload -def convolve(a: _ArrayLikeBool_co, v: _ArrayLikeBool_co, mode: _CorrelateMode = ...) -> NDArray[np.bool]: ... +def convolve(a: ToSInteger_1d, v: CoSInteger_1d, mode: _Mode = "valid") -> Array_1d[np.signedinteger]: ... # type: ignore[overload-overlap] @overload -def convolve(a: _ArrayLikeUInt_co, v: _ArrayLikeUInt_co, mode: _CorrelateMode = ...) -> NDArray[np.unsignedinteger]: ... +def convolve(a: CoSInteger_1d, v: ToSInteger_1d, mode: _Mode = "valid") -> Array_1d[np.signedinteger]: ... # type: ignore[overload-overlap] @overload -def convolve(a: _ArrayLikeInt_co, v: _ArrayLikeInt_co, mode: _CorrelateMode = ...) -> NDArray[np.signedinteger]: ... +def convolve(a: ToFloating_1d, v: CoFloating_1d, mode: _Mode = "valid") -> Array_1d[np.floating]: ... # type: ignore[overload-overlap] @overload -def convolve(a: _ArrayLikeFloat_co, v: _ArrayLikeFloat_co, mode: _CorrelateMode = ...) -> NDArray[np.floating]: ... +def convolve(a: CoFloating_1d, v: ToFloating_1d, mode: _Mode = "valid") -> Array_1d[np.floating]: ... # type: ignore[overload-overlap] @overload -def convolve(a: _ArrayLikeComplex_co, v: _ArrayLikeComplex_co, mode: _CorrelateMode = ...) -> NDArray[np.complexfloating]: ... +def convolve(a: ToComplex_1d, v: CoComplex_1d, mode: _Mode = "valid") -> Array_1d[np.complexfloating]: ... # type: ignore[overload-overlap] @overload -def convolve(a: _ArrayLikeTD64_co, v: _ArrayLikeTD64_co, mode: _CorrelateMode = ...) -> NDArray[np.timedelta64]: ... +def convolve(a: CoComplex_1d, v: ToComplex_1d, mode: _Mode = "valid") -> Array_1d[np.complexfloating]: ... # type: ignore[overload-overlap] @overload -def convolve(a: _ArrayLikeObject_co, v: _ArrayLikeObject_co, mode: _CorrelateMode = ...) -> NDArray[np.object_]: ... +def convolve(a: ToTimeDelta_1d, v: CoTimeDelta_1d, mode: _Mode = "valid") -> Array_1d[np.timedelta64]: ... +@overload +def convolve(a: CoTimeDelta_1d, v: ToTimeDelta_1d, mode: _Mode = "valid") -> Array_1d[np.timedelta64]: ... +@overload +def convolve(a: ToObject_1d, v: ToObject_1d, mode: _Mode = "valid") -> Array_1d[np.object_]: ... +@overload +def convolve( + a: CoComplex_1d | CoTimeDelta_1d | ToObject_1d, + v: CoComplex_1d | CoTimeDelta_1d | ToObject_1d, + mode: _Mode = "valid", +) -> Array_1d[Any]: ... # @overload -def outer(a: _ArrayLikeUnknown, b: _ArrayLikeUnknown, out: None = ...) -> _Array: ... +def outer(a: ToBool_nd, b: ToBool_nd, out: None = None) -> Array_2d[np.bool]: ... # type: ignore[overload-overlap] +@overload +def outer(a: ToUInteger_nd, b: CoUInteger_nd, out: None = None) -> Array_2d[np.unsignedinteger]: ... # type: ignore[overload-overlap] +@overload +def outer(a: CoUInteger_nd, b: ToUInteger_nd, out: None = None) -> Array_2d[np.unsignedinteger]: ... # type: ignore[overload-overlap] @overload -def outer(a: _ArrayLikeBool_co, b: _ArrayLikeBool_co, out: None = ...) -> NDArray[np.bool]: ... +def outer(a: ToSInteger_nd, b: CoSInteger_nd, out: None = None) -> Array_2d[np.signedinteger]: ... # type: ignore[overload-overlap] @overload -def outer(a: _ArrayLikeUInt_co, b: _ArrayLikeUInt_co, out: None = ...) -> NDArray[np.unsignedinteger]: ... +def outer(a: CoSInteger_nd, b: ToSInteger_nd, out: None = None) -> Array_2d[np.signedinteger]: ... # type: ignore[overload-overlap] @overload -def outer(a: _ArrayLikeInt_co, b: _ArrayLikeInt_co, out: None = ...) -> NDArray[np.signedinteger]: ... +def outer(a: ToFloating_nd, b: CoFloating_nd, out: None = None) -> Array_2d[np.floating]: ... # type: ignore[overload-overlap] @overload -def outer(a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, out: None = ...) -> NDArray[np.floating]: ... +def outer(a: CoFloating_nd, b: ToFloating_nd, out: None = None) -> Array_2d[np.floating]: ... # type: ignore[overload-overlap] @overload -def outer(a: _ArrayLikeComplex_co, b: _ArrayLikeComplex_co, out: None = ...) -> NDArray[np.complexfloating]: ... +def outer(a: ToComplex_nd, b: CoComplex_nd, out: None = None) -> Array_2d[np.complexfloating]: ... # type: ignore[overload-overlap] @overload -def outer(a: _ArrayLikeTD64_co, b: _ArrayLikeTD64_co, out: None = ...) -> NDArray[np.timedelta64]: ... +def outer(a: CoComplex_nd, b: ToComplex_nd, out: None = None) -> Array_2d[np.complexfloating]: ... # type: ignore[overload-overlap] @overload -def outer(a: _ArrayLikeObject_co, b: _ArrayLikeObject_co, out: None = ...) -> NDArray[np.object_]: ... +def outer(a: ToTimeDelta_nd, b: CoTimeDelta_nd, out: None = None) -> Array_2d[np.timedelta64]: ... +@overload +def outer(a: CoTimeDelta_nd, b: ToTimeDelta_nd, out: None = None) -> Array_2d[np.timedelta64]: ... +@overload +def outer(a: ToObject_nd, b: ToObject_nd, out: None = None) -> Array_2d[np.object_]: ... @overload def outer( - a: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co, - b: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co, + a: CoComplex_nd | CoTimeDelta_nd | ToObject_nd, + b: CoComplex_nd | CoTimeDelta_nd | ToObject_nd, out: _ArrayT, ) -> _ArrayT: ... # @overload -def tensordot( - a: _ArrayLikeUnknown, - b: _ArrayLikeUnknown, - axes: int | tuple[_ShapeLike, _ShapeLike] = ..., -) -> _Array: ... +def tensordot(a: ToBool_1nd, b: ToBool_1nd, axes: _Axes = 2) -> Array[np.bool]: ... # type: ignore[overload-overlap] @overload -def tensordot( - a: _ArrayLikeBool_co, - b: _ArrayLikeBool_co, - axes: int | tuple[_ShapeLike, _ShapeLike] = ..., -) -> NDArray[np.bool]: ... +def tensordot(a: ToUInteger_1nd, b: CoUInteger_1nd, axes: _Axes = 2) -> Array[np.unsignedinteger]: ... # type: ignore[overload-overlap] @overload -def tensordot( - a: _ArrayLikeUInt_co, - b: _ArrayLikeUInt_co, - axes: int | tuple[_ShapeLike, _ShapeLike] = ..., -) -> NDArray[np.unsignedinteger]: ... +def tensordot(a: CoUInteger_1nd, b: ToUInteger_1nd, axes: _Axes = 2) -> Array[np.unsignedinteger]: ... # type: ignore[overload-overlap] @overload -def tensordot( - a: _ArrayLikeInt_co, - b: _ArrayLikeInt_co, - axes: int | tuple[_ShapeLike, _ShapeLike] = ..., -) -> NDArray[np.signedinteger]: ... +def tensordot(a: ToSInteger_1nd, b: CoSInteger_1nd, axes: _Axes = 2) -> Array[np.signedinteger]: ... # type: ignore[overload-overlap] @overload -def tensordot( - a: _ArrayLikeFloat_co, - b: _ArrayLikeFloat_co, - axes: int | tuple[_ShapeLike, _ShapeLike] = ..., -) -> NDArray[np.floating]: ... +def tensordot(a: CoSInteger_1nd, b: ToSInteger_1nd, axes: _Axes = 2) -> Array[np.signedinteger]: ... # type: ignore[overload-overlap] @overload -def tensordot( - a: _ArrayLikeComplex_co, - b: _ArrayLikeComplex_co, - axes: int | tuple[_ShapeLike, _ShapeLike] = ..., -) -> NDArray[np.complexfloating]: ... +def tensordot(a: ToFloating_1nd, b: CoFloating_1nd, axes: _Axes = 2) -> Array[np.floating]: ... # type: ignore[overload-overlap] @overload -def tensordot( - a: _ArrayLikeTD64_co, - b: _ArrayLikeTD64_co, - axes: int | tuple[_ShapeLike, _ShapeLike] = ..., -) -> NDArray[np.timedelta64]: ... +def tensordot(a: CoFloating_1nd, b: ToFloating_1nd, axes: _Axes = 2) -> Array[np.floating]: ... # type: ignore[overload-overlap] +@overload +def tensordot(a: ToComplex_1nd, b: CoComplex_1nd, axes: _Axes = 2) -> Array[np.complexfloating]: ... # type: ignore[overload-overlap] +@overload +def tensordot(a: CoComplex_1nd, b: ToComplex_1nd, axes: _Axes = 2) -> Array[np.complexfloating]: ... # type: ignore[overload-overlap] +@overload +def tensordot(a: ToTimeDelta_1nd, b: CoTimeDelta_1nd, axes: _Axes = 2) -> Array[np.timedelta64]: ... +@overload +def tensordot(a: CoTimeDelta_1nd, b: ToTimeDelta_1nd, axes: _Axes = 2) -> Array[np.timedelta64]: ... +@overload +def tensordot(a: ToObject_1nd, b: ToObject_1nd, axes: _Axes = 2) -> Array[np.object_]: ... @overload def tensordot( - a: _ArrayLikeObject_co, - b: _ArrayLikeObject_co, - axes: int | tuple[_ShapeLike, _ShapeLike] = ..., -) -> NDArray[np.object_]: ... + a: CoComplex_1nd | CoTimeDelta_1nd | ToObject_1nd, + b: CoComplex_1nd | CoTimeDelta_1nd | ToObject_1nd, + axes: _Axes = 2, +) -> Array[Any]: ... # @overload -def roll(a: _ArrayLike[_ScalarT], shift: _ShapeLike, axis: _ShapeLike | None = ...) -> NDArray[_ScalarT]: ... +def roll(a: _ArrayLike[_ScalarT], shift: _ShapeLike, axis: _ShapeLike | None = None) -> Array[_ScalarT]: ... @overload -def roll(a: ArrayLike, shift: _ShapeLike, axis: _ShapeLike | None = ...) -> _Array: ... +def roll(a: ArrayLike, shift: _ShapeLike, axis: _ShapeLike | None = None) -> Array: ... # -def rollaxis(a: NDArray[_ScalarT], axis: int, start: int = ...) -> NDArray[_ScalarT]: ... -def moveaxis(a: NDArray[_ScalarT], source: _ShapeLike, destination: _ShapeLike) -> NDArray[_ScalarT]: ... +def rollaxis(a: Array[_ScalarT], axis: int, start: int = ...) -> Array[_ScalarT]: ... +def moveaxis(a: Array[_ScalarT], source: _ShapeLike, destination: _ShapeLike) -> Array[_ScalarT]: ... # @overload def cross( - x1: _ArrayLikeUnknown, - x2: _ArrayLikeUnknown, - axisa: int = ..., - axisb: int = ..., - axisc: int = ..., - axis: int | None = ..., -) -> _Array: ... + x1: ToBool_1nd, + x2: ToBool_1nd, + axisa: int = -1, + axisb: int = -1, + axisc: int = -1, + axis: int | None = None, +) -> NoReturn: ... +@overload +def cross( # type: ignore[overload-overlap] + x1: ToUInteger_1nd, + x2: CoUInteger_1nd, + axisa: int = -1, + axisb: int = -1, + axisc: int = -1, + axis: int | None = None, +) -> Array[np.unsignedinteger]: ... +@overload +def cross( # type: ignore[overload-overlap] + x1: CoUInteger_1nd, + x2: ToUInteger_1nd, + axisa: int = -1, + axisb: int = -1, + axisc: int = -1, + axis: int | None = None, +) -> Array[np.unsignedinteger]: ... @overload def cross( - x1: _ArrayLikeBool_co, - x2: _ArrayLikeBool_co, - axisa: int = ..., - axisb: int = ..., - axisc: int = ..., - axis: int | None = ..., -) -> NoReturn: ... + x1: ToSInteger_1nd, + x2: CoSInteger_1nd, + axisa: int = -1, + axisb: int = -1, + axisc: int = -1, + axis: int | None = None, +) -> Array[np.signedinteger]: ... @overload def cross( - x1: _ArrayLikeUInt_co, - x2: _ArrayLikeUInt_co, - axisa: int = ..., - axisb: int = ..., - axisc: int = ..., - axis: int | None = ..., -) -> NDArray[np.unsignedinteger]: ... + x1: CoSInteger_1nd, + x2: ToSInteger_1nd, + axisa: int = -1, + axisb: int = -1, + axisc: int = -1, + axis: int | None = None, +) -> Array[np.signedinteger]: ... @overload def cross( - x1: _ArrayLikeInt_co, - x2: _ArrayLikeInt_co, - axisa: int = ..., - axisb: int = ..., - axisc: int = ..., - axis: int | None = ..., -) -> NDArray[np.signedinteger]: ... + x1: ToFloating_1nd, + x2: CoFloating_1nd, + axisa: int = -1, + axisb: int = -1, + axisc: int = -1, + axis: int | None = None, +) -> Array[np.floating]: ... @overload def cross( - x1: _ArrayLikeFloat_co, - x2: _ArrayLikeFloat_co, - axisa: int = ..., - axisb: int = ..., - axisc: int = ..., - axis: int | None = ..., -) -> NDArray[np.floating]: ... + x1: CoFloating_1nd, + x2: ToFloating_1nd, + axisa: int = -1, + axisb: int = -1, + axisc: int = -1, + axis: int | None = None, +) -> Array[np.floating]: ... @overload def cross( - x1: _ArrayLikeComplex_co, - x2: _ArrayLikeComplex_co, - axisa: int = ..., - axisb: int = ..., - axisc: int = ..., - axis: int | None = ..., -) -> NDArray[np.complexfloating]: ... + x1: ToComplex_1nd, + x2: CoComplex_1nd, + axisa: int = -1, + axisb: int = -1, + axisc: int = -1, + axis: int | None = None, +) -> Array[np.complexfloating]: ... @overload def cross( - x1: _ArrayLikeObject_co, - x2: _ArrayLikeObject_co, - axisa: int = ..., - axisb: int = ..., - axisc: int = ..., - axis: int | None = ..., -) -> NDArray[np.object_]: ... + x1: CoComplex_1nd, + x2: ToComplex_1nd, + axisa: int = -1, + axisb: int = -1, + axisc: int = -1, + axis: int | None = None, +) -> Array[np.complexfloating]: ... +@overload +def cross( + x1: CoComplex_1nd, + x2: CoComplex_1nd, + axisa: int = -1, + axisb: int = -1, + axisc: int = -1, + axis: int | None = None, +) -> Array[Any]: ... # @overload -def indices( - dimensions: Sequence[int], - dtype: type[int] = ..., - sparse: L[False] = ..., -) -> NDArray[np.int_]: ... +def indices(dimensions: ToInteger_1d, dtype: type[Is[int]] = ..., sparse: L[False] = False) -> Array[np.intp]: ... @overload -def indices( - dimensions: Sequence[int], - dtype: type[int] = ..., - sparse: L[True] = ..., -) -> tuple[NDArray[np.int_], ...]: ... +def indices(dimensions: ToInteger_1d, dtype: type[Is[int]], sparse: L[True]) -> tuple[Array[np.intp], ...]: ... @overload -def indices( - dimensions: Sequence[int], - dtype: _DTypeLike[_ScalarT], - sparse: L[False] = ..., -) -> NDArray[_ScalarT]: ... +def indices(dimensions: ToInteger_1d, dtype: type[Is[int]] = ..., *, sparse: L[True]) -> tuple[Array[np.intp], ...]: ... @overload -def indices( - dimensions: Sequence[int], - dtype: _DTypeLike[_ScalarT], - sparse: L[True], -) -> tuple[NDArray[_ScalarT], ...]: ... +def indices(dimensions: ToInteger_1d, dtype: _DTypeLike[_ScalarT], sparse: L[False] = False) -> Array[_ScalarT]: ... @overload -def indices( - dimensions: Sequence[int], - dtype: DTypeLike, - sparse: L[False] = ..., -) -> _Array: ... +def indices(dimensions: ToInteger_1d, dtype: _DTypeLike[_ScalarT], sparse: L[True]) -> tuple[Array[_ScalarT], ...]: ... @overload -def indices( - dimensions: Sequence[int], - dtype: DTypeLike, - sparse: L[True], -) -> tuple[_Array, ...]: ... +def indices(dimensions: ToInteger_1d, dtype: DTypeLike = ..., sparse: L[False] = False) -> Array: ... +@overload +def indices(dimensions: ToInteger_1d, dtype: DTypeLike, sparse: L[True]) -> tuple[Array, ...]: ... +@overload +def indices(dimensions: ToInteger_1d, dtype: DTypeLike = ..., *, sparse: L[True]) -> tuple[Array, ...]: ... # def fromfunction( @@ -685,26 +739,24 @@ def fromfunction( shape: Sequence[int], *, dtype: DTypeLike = ..., - like: _SupportsArrayFunc = ..., + like: _SupportsArrayFunc | None = None, **kwargs: object, ) -> _T: ... # -def isscalar(element: object) -> TypeIs[np.generic | int | float | complex | str | bytes]: ... +def isscalar(element: object) -> TypeIs[np.generic | _PyScalar]: ... # -def binary_repr(num: SupportsIndex, width: int | None = ...) -> str: ... - -# -def base_repr(number: SupportsAbs[float], base: float = ..., padding: SupportsIndex = ...) -> str: ... +def binary_repr(num: SupportsIndex, width: int | None = None) -> str: ... +def base_repr(number: SupportsAbs[float], base: float = 2, padding: SupportsIndex = 0) -> str: ... # @overload -def identity(n: int, dtype: None = ..., *, like: _SupportsArrayFunc = ...) -> NDArray[np.float64]: ... +def identity(n: int, dtype: None = None, *, like: _SupportsArrayFunc = ...) -> Array[np.float64]: ... @overload -def identity(n: int, dtype: _DTypeLike[_ScalarT], *, like: _SupportsArrayFunc = ...) -> NDArray[_ScalarT]: ... +def identity(n: int, dtype: _DTypeLike[_ScalarT], *, like: _SupportsArrayFunc = ...) -> Array[_ScalarT]: ... @overload -def identity(n: int, dtype: DTypeLike, *, like: _SupportsArrayFunc = ...) -> _Array: ... +def identity(n: int, dtype: DTypeLike, *, like: _SupportsArrayFunc = ...) -> Array: ... # def allclose(a: ArrayLike, b: ArrayLike, rtol: ArrayLike = ..., atol: ArrayLike = ..., equal_nan: bool = ...) -> bool: ... @@ -714,27 +766,35 @@ def allclose(a: ArrayLike, b: ArrayLike, rtol: ArrayLike = ..., atol: ArrayLike def isclose( a: _ScalarLike_co, b: _ScalarLike_co, - rtol: ArrayLike = ..., - atol: ArrayLike = ..., - equal_nan: bool = ..., + rtol: ArrayLike = 1e-5, + atol: ArrayLike = 1e-8, + equal_nan: bool = False, ) -> np.bool: ... @overload def isclose( - a: ArrayLike, - b: ArrayLike, - rtol: ArrayLike = ..., - atol: ArrayLike = ..., - equal_nan: bool = ..., -) -> NDArray[np.bool]: ... + a: _ToArray_1nd[np.generic, _PyScalar], + b: _ToArray_nd[np.generic, _PyScalar], + rtol: ArrayLike = 1e-5, + atol: ArrayLike = 1e-8, + equal_nan: bool = False, +) -> Array[np.bool]: ... +@overload +def isclose( + a: _ToArray_nd[np.generic, _PyScalar], + b: _ToArray_1nd[np.generic, _PyScalar], + rtol: ArrayLike = 1e-5, + atol: ArrayLike = 1e-8, + equal_nan: bool = False, +) -> Array[np.bool]: ... # -def array_equal(a1: ArrayLike, a2: ArrayLike, equal_nan: bool = ...) -> bool: ... +def array_equal(a1: ArrayLike, a2: ArrayLike, equal_nan: bool = False) -> bool: ... def array_equiv(a1: ArrayLike, a2: ArrayLike) -> bool: ... # @overload def astype( - x: ndarray[_ShapeT, dtype[Any]], + x: Array[Any, _ShapeT], dtype: _DTypeLike[_ScalarT], /, *, @@ -743,7 +803,7 @@ def astype( ) -> ndarray[_ShapeT, dtype[_ScalarT]]: ... @overload def astype( - x: ndarray[_ShapeT, dtype[Any]], + x: Array[Any, _ShapeT], dtype: DTypeLike, /, *, diff --git a/test/static/accept/numeric.pyi b/test/static/accept/numeric.pyi index 6388286b..b789302f 100644 --- a/test/static/accept/numeric.pyi +++ b/test/static/accept/numeric.pyi @@ -1,27 +1,37 @@ -from typing import Any -from typing_extensions import assert_type +from typing import Any, TypeAlias, type_check_only +from typing_extensions import TypeVar, assert_type import numpy as np import numpy.typing as npt -class SubClass(npt.NDArray[np.int64]): ... +### +_ScalarT = TypeVar("_ScalarT", bound=np.generic) +_Array1D: TypeAlias = np.ndarray[tuple[int], np.dtype[_ScalarT]] +_Array2D: TypeAlias = np.ndarray[tuple[int, int], np.dtype[_ScalarT]] + +### + +@type_check_only +class SubArray(npt.NDArray[np.int64]): ... + +ints: list[int] i8: np.int64 AR_b: npt.NDArray[np.bool] AR_u8: npt.NDArray[np.uint64] AR_i8: npt.NDArray[np.int64] +AR_i8_sub: SubArray AR_f8: npt.NDArray[np.float64] AR_c16: npt.NDArray[np.complex128] AR_m: npt.NDArray[np.timedelta64] AR_O: npt.NDArray[np.object_] -B: list[int] -C: SubClass +### assert_type(np.count_nonzero(i8), int) assert_type(np.count_nonzero(AR_i8), int) -assert_type(np.count_nonzero(B), int) +assert_type(np.count_nonzero(ints), int) assert_type(np.count_nonzero(AR_i8, keepdims=True), Any) assert_type(np.count_nonzero(AR_i8, axis=0), Any) @@ -31,73 +41,72 @@ assert_type(np.isfortran(AR_i8), bool) assert_type(np.argwhere(i8), npt.NDArray[np.intp]) assert_type(np.argwhere(AR_i8), npt.NDArray[np.intp]) -assert_type(np.flatnonzero(i8), npt.NDArray[np.intp]) -assert_type(np.flatnonzero(AR_i8), npt.NDArray[np.intp]) - -assert_type(np.correlate(B, AR_i8, mode="valid"), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.correlate(AR_i8, AR_i8, mode="same"), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.correlate(AR_b, AR_b), npt.NDArray[np.bool]) -assert_type(np.correlate(AR_b, AR_u8), npt.NDArray[np.unsignedinteger[Any]]) -assert_type(np.correlate(AR_i8, AR_b), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.correlate(AR_i8, AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.correlate(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) -assert_type(np.correlate(AR_i8, AR_m), npt.NDArray[np.timedelta64]) -assert_type(np.correlate(AR_O, AR_O), npt.NDArray[np.object_]) - -assert_type(np.convolve(B, AR_i8, mode="valid"), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.convolve(AR_i8, AR_i8, mode="same"), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.convolve(AR_b, AR_b), npt.NDArray[np.bool]) -assert_type(np.convolve(AR_b, AR_u8), npt.NDArray[np.unsignedinteger[Any]]) -assert_type(np.convolve(AR_i8, AR_b), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.convolve(AR_i8, AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.convolve(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) -assert_type(np.convolve(AR_i8, AR_m), npt.NDArray[np.timedelta64]) -assert_type(np.convolve(AR_O, AR_O), npt.NDArray[np.object_]) - -assert_type(np.outer(i8, AR_i8), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.outer(B, AR_i8), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.outer(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.outer(AR_i8, AR_i8, out=C), SubClass) -assert_type(np.outer(AR_b, AR_b), npt.NDArray[np.bool]) -assert_type(np.outer(AR_b, AR_u8), npt.NDArray[np.unsignedinteger[Any]]) -assert_type(np.outer(AR_i8, AR_b), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.convolve(AR_i8, AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.outer(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) -assert_type(np.outer(AR_i8, AR_m), npt.NDArray[np.timedelta64]) -assert_type(np.outer(AR_O, AR_O), npt.NDArray[np.object_]) - -assert_type(np.tensordot(B, AR_i8), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.tensordot(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.tensordot(AR_i8, AR_i8, axes=0), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.tensordot(AR_i8, AR_i8, axes=(0, 1)), npt.NDArray[np.signedinteger[Any]]) +assert_type(np.flatnonzero(i8), _Array1D[np.intp]) +assert_type(np.flatnonzero(AR_i8), _Array1D[np.intp]) + +assert_type(np.correlate(ints, AR_i8, mode="valid"), _Array1D[np.signedinteger]) +assert_type(np.correlate(AR_i8, AR_i8, mode="same"), _Array1D[np.signedinteger]) +assert_type(np.correlate(AR_b, AR_b), _Array1D[np.bool]) +assert_type(np.correlate(AR_b, AR_u8), _Array1D[np.unsignedinteger]) +assert_type(np.correlate(AR_i8, AR_b), _Array1D[np.signedinteger]) +assert_type(np.correlate(AR_i8, AR_f8), _Array1D[np.floating]) +assert_type(np.correlate(AR_i8, AR_c16), _Array1D[np.complexfloating]) +assert_type(np.correlate(AR_i8, AR_m), _Array1D[np.timedelta64]) +assert_type(np.correlate(AR_O, AR_O), _Array1D[np.object_]) + +assert_type(np.convolve(ints, AR_i8, mode="valid"), _Array1D[np.signedinteger]) +assert_type(np.convolve(AR_i8, AR_i8, mode="same"), _Array1D[np.signedinteger]) +assert_type(np.convolve(AR_b, AR_b), _Array1D[np.bool]) +assert_type(np.convolve(AR_b, AR_u8), _Array1D[np.unsignedinteger]) +assert_type(np.convolve(AR_i8, AR_b), _Array1D[np.signedinteger]) +assert_type(np.convolve(AR_i8, AR_f8), _Array1D[np.floating]) +assert_type(np.convolve(AR_i8, AR_c16), _Array1D[np.complexfloating]) +assert_type(np.convolve(AR_i8, AR_m), _Array1D[np.timedelta64]) +assert_type(np.convolve(AR_O, AR_O), _Array1D[np.object_]) + +assert_type(np.outer(i8, AR_i8), _Array2D[np.signedinteger]) +assert_type(np.outer(ints, AR_i8), _Array2D[np.signedinteger]) +assert_type(np.outer(AR_i8, AR_i8), _Array2D[np.signedinteger]) +assert_type(np.outer(AR_i8, AR_i8, out=AR_i8_sub), SubArray) +assert_type(np.outer(AR_b, AR_b), _Array2D[np.bool]) +assert_type(np.outer(AR_b, AR_u8), _Array2D[np.unsignedinteger]) +assert_type(np.outer(AR_i8, AR_b), _Array2D[np.signedinteger]) +assert_type(np.outer(AR_i8, AR_f8), _Array2D[np.floating]) +assert_type(np.outer(AR_i8, AR_c16), _Array2D[np.complexfloating]) +assert_type(np.outer(AR_i8, AR_m), _Array2D[np.timedelta64]) +assert_type(np.outer(AR_O, AR_O), _Array2D[np.object_]) + +assert_type(np.tensordot(ints, AR_i8), npt.NDArray[np.signedinteger]) +assert_type(np.tensordot(AR_i8, AR_i8), npt.NDArray[np.signedinteger]) +assert_type(np.tensordot(AR_i8, AR_i8, axes=0), npt.NDArray[np.signedinteger]) +assert_type(np.tensordot(AR_i8, AR_i8, axes=(0, 1)), npt.NDArray[np.signedinteger]) assert_type(np.tensordot(AR_b, AR_b), npt.NDArray[np.bool]) -assert_type(np.tensordot(AR_b, AR_u8), npt.NDArray[np.unsignedinteger[Any]]) -assert_type(np.tensordot(AR_i8, AR_b), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.tensordot(AR_i8, AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.tensordot(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.tensordot(AR_b, AR_u8), npt.NDArray[np.unsignedinteger]) +assert_type(np.tensordot(AR_i8, AR_b), npt.NDArray[np.signedinteger]) +assert_type(np.tensordot(AR_i8, AR_f8), npt.NDArray[np.floating]) +assert_type(np.tensordot(AR_i8, AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.tensordot(AR_i8, AR_m), npt.NDArray[np.timedelta64]) assert_type(np.tensordot(AR_O, AR_O), npt.NDArray[np.object_]) assert_type(np.isscalar(i8), bool) assert_type(np.isscalar(AR_i8), bool) -assert_type(np.isscalar(B), bool) +assert_type(np.isscalar(ints), bool) assert_type(np.roll(AR_i8, 1), npt.NDArray[np.int64]) assert_type(np.roll(AR_i8, (1, 2)), npt.NDArray[np.int64]) -assert_type(np.roll(B, 1), npt.NDArray[Any]) +assert_type(np.roll(ints, 1), npt.NDArray[Any]) assert_type(np.rollaxis(AR_i8, 0, 1), npt.NDArray[np.int64]) assert_type(np.moveaxis(AR_i8, 0, 1), npt.NDArray[np.int64]) assert_type(np.moveaxis(AR_i8, (0, 1), (1, 2)), npt.NDArray[np.int64]) -assert_type(np.cross(B, AR_i8), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.cross(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.cross(AR_b, AR_u8), npt.NDArray[np.unsignedinteger[Any]]) -assert_type(np.cross(AR_i8, AR_b), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.cross(AR_i8, AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.cross(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) -assert_type(np.cross(AR_O, AR_O), npt.NDArray[np.object_]) +assert_type(np.cross(ints, AR_i8), npt.NDArray[np.signedinteger]) +assert_type(np.cross(AR_i8, AR_i8), npt.NDArray[np.signedinteger]) +assert_type(np.cross(AR_b, AR_u8), npt.NDArray[np.unsignedinteger]) +assert_type(np.cross(AR_i8, AR_b), npt.NDArray[np.signedinteger]) +assert_type(np.cross(AR_i8, AR_f8), npt.NDArray[np.floating]) +assert_type(np.cross(AR_i8, AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.indices([0, 1, 2]), npt.NDArray[np.int_]) assert_type(np.indices([0, 1, 2], sparse=True), tuple[npt.NDArray[np.int_], ...]) @@ -111,18 +120,18 @@ assert_type(np.binary_repr(1), str) assert_type(np.base_repr(1), str) assert_type(np.allclose(i8, AR_i8), bool) -assert_type(np.allclose(B, AR_i8), bool) +assert_type(np.allclose(ints, AR_i8), bool) assert_type(np.allclose(AR_i8, AR_i8), bool) assert_type(np.isclose(i8, i8), np.bool) assert_type(np.isclose(i8, AR_i8), npt.NDArray[np.bool]) -assert_type(np.isclose(B, AR_i8), npt.NDArray[np.bool]) +assert_type(np.isclose(ints, AR_i8), npt.NDArray[np.bool]) assert_type(np.isclose(AR_i8, AR_i8), npt.NDArray[np.bool]) assert_type(np.array_equal(i8, AR_i8), bool) -assert_type(np.array_equal(B, AR_i8), bool) +assert_type(np.array_equal(ints, AR_i8), bool) assert_type(np.array_equal(AR_i8, AR_i8), bool) assert_type(np.array_equiv(i8, AR_i8), bool) -assert_type(np.array_equiv(B, AR_i8), bool) +assert_type(np.array_equiv(ints, AR_i8), bool) assert_type(np.array_equiv(AR_i8, AR_i8), bool) From 16617542bc1443ded7d31b8b1c0792967e12d8e1 Mon Sep 17 00:00:00 2001 From: jorenham Date: Wed, 19 Feb 2025 22:13:57 +0100 Subject: [PATCH 2/2] =?UTF-8?q?=F0=9F=91=B7=20typecheck=20all=20of=20`nump?= =?UTF-8?q?y.=5Fcore`?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .github/workflows/ci.yml | 30 ++---------------------------- 1 file changed, 2 insertions(+), 28 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index dfc4dd66..1b39e5fb 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -46,20 +46,7 @@ jobs: tool/ src/_numtype/ src/numtype/ - src/numpy-stubs/_core/__init__.pyi - src/numpy-stubs/_core/_asarray.pyi - src/numpy-stubs/_core/_internal.pyi - src/numpy-stubs/_core/_multiarray_umath.pyi - src/numpy-stubs/_core/_type_aliases.pyi - src/numpy-stubs/_core/_ufunc_config.pyi - src/numpy-stubs/_core/arrayprint.pyi - src/numpy-stubs/_core/getlimits.pyi - src/numpy-stubs/_core/multiarray.pyi - src/numpy-stubs/_core/numerictypes.pyi - src/numpy-stubs/_core/records.pyi - src/numpy-stubs/_core/shape_base.pyi - src/numpy-stubs/_core/strings.pyi - src/numpy-stubs/_core/umath.pyi + src/numpy-stubs/_core/ src/numpy-stubs/_typing/ src/numpy-stubs/char/ src/numpy-stubs/core/ @@ -110,20 +97,7 @@ jobs: uv run test/mypy.py src/_numtype/ src/numtype/ - src/numpy-stubs/_core/__init__.pyi - src/numpy-stubs/_core/_asarray.pyi - src/numpy-stubs/_core/_internal.pyi - src/numpy-stubs/_core/_multiarray_umath.pyi - src/numpy-stubs/_core/_type_aliases.pyi - src/numpy-stubs/_core/_ufunc_config.pyi - src/numpy-stubs/_core/arrayprint.pyi - src/numpy-stubs/_core/getlimits.pyi - src/numpy-stubs/_core/multiarray.pyi - src/numpy-stubs/_core/numerictypes.pyi - src/numpy-stubs/_core/records.pyi - src/numpy-stubs/_core/shape_base.pyi - src/numpy-stubs/_core/strings.pyi - src/numpy-stubs/_core/umath.pyi + src/numpy-stubs/_core/ src/numpy-stubs/_typing/ src/numpy-stubs/char/ src/numpy-stubs/core/