From 620dc2370856358cdcaeef3d3efefd7699965c2e Mon Sep 17 00:00:00 2001 From: jorenham Date: Thu, 20 Feb 2025 01:00:09 +0100 Subject: [PATCH] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20remove=20redundant=20`Any`?= =?UTF-8?q?=20type=20arguments?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/numpy-stubs/_core/_type_aliases.pyi | 10 +-- src/numpy-stubs/_core/einsumfunc.pyi | 2 +- src/numpy-stubs/ctypeslib/_ctypeslib.pyi | 5 +- src/numpy-stubs/polynomial/chebyshev.pyi | 4 +- src/numpy-stubs/polynomial/polyutils.pyi | 72 +++++++++----------- src/numpy-stubs/testing/_private/utils.pyi | 2 +- test/static/accept/arraypad.pyi | 2 +- test/static/accept/arrayprint.pyi | 5 +- test/static/accept/ctypeslib.pyi | 5 +- test/static/accept/dtype.pyi | 8 +-- test/static/accept/emath.pyi | 36 +++++----- test/static/accept/fromnumeric.pyi | 40 +++++------ test/static/accept/lib_function_base.pyi | 66 +++++++++--------- test/static/accept/lib_polynomial.pyi | 58 ++++++++-------- test/static/accept/polynomial_polyutils.pyi | 34 +++++----- test/static/accept/polynomial_series.pyi | 74 ++++++++++----------- test/static/accept/shape_base.pyi | 4 +- test/static/accept/twodim_base.pyi | 12 ++-- test/static/accept/ufunclike.pyi | 9 ++- 19 files changed, 217 insertions(+), 231 deletions(-) diff --git a/src/numpy-stubs/_core/_type_aliases.pyi b/src/numpy-stubs/_core/_type_aliases.pyi index f92958a6..3d57e813 100644 --- a/src/numpy-stubs/_core/_type_aliases.pyi +++ b/src/numpy-stubs/_core/_type_aliases.pyi @@ -1,5 +1,5 @@ from collections.abc import Collection -from typing import Any, Final, Literal as L, TypeAlias, TypedDict, type_check_only +from typing import Final, Literal as L, TypeAlias, TypedDict, type_check_only import numpy as np @@ -87,10 +87,10 @@ _extra_aliases: Final[_ExtraAliasesType] @type_check_only class _SCTypes(TypedDict): - int: Collection[type[np.signedinteger[Any]]] - uint: Collection[type[np.unsignedinteger[Any]]] - float: Collection[type[np.floating[Any]]] - complex: Collection[type[np.complexfloating[Any, Any]]] + int: Collection[type[np.signedinteger]] + uint: Collection[type[np.unsignedinteger]] + float: Collection[type[np.floating]] + complex: Collection[type[np.complexfloating]] others: Collection[type[np.flexible | np.bool | np.object_]] sctypes: Final[_SCTypes] diff --git a/src/numpy-stubs/_core/einsumfunc.pyi b/src/numpy-stubs/_core/einsumfunc.pyi index ecdce320..e97b5648 100644 --- a/src/numpy-stubs/_core/einsumfunc.pyi +++ b/src/numpy-stubs/_core/einsumfunc.pyi @@ -22,7 +22,7 @@ from numpy._typing import ( __all__ = ["einsum", "einsum_path"] -_ArrayT = TypeVar("_ArrayT", bound=NDArray[np.bool | np.number[Any]]) +_ArrayT = TypeVar("_ArrayT", bound=NDArray[np.bool | np.number]) _OptimizeKind: TypeAlias = bool | Literal["greedy", "optimal"] | Sequence[Any] | None _CastingSafe: TypeAlias = Literal["no", "equiv", "safe", "same_kind"] diff --git a/src/numpy-stubs/ctypeslib/_ctypeslib.pyi b/src/numpy-stubs/ctypeslib/_ctypeslib.pyi index 1ad19c01..8cf53c2d 100644 --- a/src/numpy-stubs/ctypeslib/_ctypeslib.pyi +++ b/src/numpy-stubs/ctypeslib/_ctypeslib.pyi @@ -1,3 +1,4 @@ +import _ctypes as _ct import ctypes as ct from _typeshed import StrOrBytesPath from collections.abc import Iterable, Sequence @@ -151,9 +152,9 @@ def as_ctypes_type(dtype: _DoubleCodes | _DTypeLike[np.double] | type[float | ct @overload def as_ctypes_type(dtype: _LongDoubleCodes | _DTypeLike[np.longdouble] | type[ct.c_longdouble]) -> type[ct.c_longdouble]: ... @overload -def as_ctypes_type(dtype: _VoidDTypeLike) -> type[Any]: ... # `ctypes.Union` or `ctypes.Structure` +def as_ctypes_type(dtype: _VoidDTypeLike) -> _ct._UnionType | _ct._PyCStructType: ... @overload -def as_ctypes_type(dtype: str) -> type[Any]: ... +def as_ctypes_type(dtype: str) -> type: ... @overload def as_array(obj: ct._PointerLike, shape: Sequence[int]) -> NDArray[Any]: ... @overload diff --git a/src/numpy-stubs/polynomial/chebyshev.pyi b/src/numpy-stubs/polynomial/chebyshev.pyi index a00bd49d..a940f9ba 100644 --- a/src/numpy-stubs/polynomial/chebyshev.pyi +++ b/src/numpy-stubs/polynomial/chebyshev.pyi @@ -80,7 +80,7 @@ __all__ = [ "poly2cheb", ] -_SCT = TypeVar("_SCT", bound=np.number[Any] | np.object_) +_SCT = TypeVar("_SCT", bound=np.number | np.object_) def _cseries_to_zseries(c: npt.NDArray[_SCT]) -> _Series[_SCT]: ... def _zseries_to_cseries(zs: npt.NDArray[_SCT]) -> _Series[_SCT]: ... @@ -131,7 +131,7 @@ chebpts1: _FuncPts[L["chebpts1"]] chebpts2: _FuncPts[L["chebpts2"]] # keep in sync with `Chebyshev.interpolate` -_RT = TypeVar("_RT", bound=np.number[Any] | np.bool | np.object_) +_RT = TypeVar("_RT", bound=np.number | np.bool | np.object_) @overload def chebinterpolate( diff --git a/src/numpy-stubs/polynomial/polyutils.pyi b/src/numpy-stubs/polynomial/polyutils.pyi index 2140fafa..59490f4f 100644 --- a/src/numpy-stubs/polynomial/polyutils.pyi +++ b/src/numpy-stubs/polynomial/polyutils.pyi @@ -1,22 +1,10 @@ from collections.abc import Callable, Iterable, Sequence -from typing import ( - Any, - Final, - Literal, - SupportsIndex, - TypeAlias, - overload, -) +from typing import Final, Literal, SupportsIndex, TypeAlias, overload from typing_extensions import TypeVar import numpy as np import numpy.typing as npt -from numpy._typing import ( - _ArrayLikeComplex_co, - _ArrayLikeFloat_co, - _FloatLike_co, - _NumberLike_co, -) +from numpy._typing import _ArrayLikeComplex_co, _ArrayLikeFloat_co, _FloatLike_co, _NumberLike_co from ._polytypes import ( _AnyInt, @@ -41,7 +29,7 @@ from ._polytypes import ( _Tuple2, ) -__all__: Final[Sequence[str]] = [ +__all__ = [ "as_series", "format_float", "getdomain", @@ -66,7 +54,7 @@ _AnyVanderF: TypeAlias = Callable[ @overload def as_series( - alist: npt.NDArray[np.integer[Any]] | _FloatArray, + alist: npt.NDArray[np.integer] | _FloatArray, trim: bool = ..., ) -> list[_FloatSeries]: ... @overload @@ -81,7 +69,7 @@ def as_series( ) -> list[_ObjectSeries]: ... @overload def as_series( # type: ignore[overload-overlap] - alist: Iterable[_FloatArray | npt.NDArray[np.integer[Any]]], + alist: Iterable[_FloatArray | npt.NDArray[np.integer]], trim: bool = ..., ) -> list[_FloatSeries]: ... @overload @@ -115,7 +103,7 @@ _T_seq = TypeVar("_T_seq", bound=_CoefArray | Sequence[_CoefLike_co]) def trimseq(seq: _T_seq) -> _T_seq: ... @overload def trimcoef( # type: ignore[overload-overlap] - c: npt.NDArray[np.integer[Any]] | _FloatArray, + c: npt.NDArray[np.integer] | _FloatArray, tol: _FloatLike_co = ..., ) -> _FloatSeries: ... @overload @@ -145,7 +133,7 @@ def trimcoef( ) -> _ObjectSeries: ... @overload def getdomain( # type: ignore[overload-overlap] - x: _FloatArray | npt.NDArray[np.integer[Any]], + x: _FloatArray | npt.NDArray[np.integer], ) -> _Array2[np.float64]: ... @overload def getdomain( @@ -169,18 +157,18 @@ def getdomain( ) -> _Array2[np.object_]: ... @overload def mapparms( # type: ignore[overload-overlap] - old: npt.NDArray[np.floating[Any] | np.integer[Any]], - new: npt.NDArray[np.floating[Any] | np.integer[Any]], -) -> _Tuple2[np.floating[Any]]: ... + old: npt.NDArray[np.floating | np.integer], + new: npt.NDArray[np.floating | np.integer], +) -> _Tuple2[np.floating]: ... @overload def mapparms( - old: npt.NDArray[np.number[Any]], - new: npt.NDArray[np.number[Any]], -) -> _Tuple2[np.complexfloating[Any, Any]]: ... + old: npt.NDArray[np.number], + new: npt.NDArray[np.number], +) -> _Tuple2[np.complexfloating]: ... @overload def mapparms( - old: npt.NDArray[np.object_ | np.number[Any]], - new: npt.NDArray[np.object_ | np.number[Any]], + old: npt.NDArray[np.object_ | np.number], + new: npt.NDArray[np.object_ | np.number], ) -> _Tuple2[object]: ... @overload def mapparms( # type: ignore[overload-overlap] @@ -196,12 +184,12 @@ def mapparms( def mapparms( old: _SeriesLikeFloat_co, new: _SeriesLikeFloat_co, -) -> _Tuple2[np.floating[Any]]: ... +) -> _Tuple2[np.floating]: ... @overload def mapparms( old: _SeriesLikeComplex_co, new: _SeriesLikeComplex_co, -) -> _Tuple2[np.complexfloating[Any, Any]]: ... +) -> _Tuple2[np.complexfloating]: ... @overload def mapparms( old: _SeriesLikeCoef_co, @@ -212,30 +200,30 @@ def mapdomain( # type: ignore[overload-overlap] x: _FloatLike_co, old: _SeriesLikeFloat_co, new: _SeriesLikeFloat_co, -) -> np.floating[Any]: ... +) -> np.floating: ... @overload def mapdomain( x: _NumberLike_co, old: _SeriesLikeComplex_co, new: _SeriesLikeComplex_co, -) -> np.complexfloating[Any, Any]: ... +) -> np.complexfloating: ... @overload def mapdomain( # type: ignore[overload-overlap] - x: npt.NDArray[np.floating[Any] | np.integer[Any]], - old: npt.NDArray[np.floating[Any] | np.integer[Any]], - new: npt.NDArray[np.floating[Any] | np.integer[Any]], + x: npt.NDArray[np.floating | np.integer], + old: npt.NDArray[np.floating | np.integer], + new: npt.NDArray[np.floating | np.integer], ) -> _FloatSeries: ... @overload def mapdomain( - x: npt.NDArray[np.number[Any]], - old: npt.NDArray[np.number[Any]], - new: npt.NDArray[np.number[Any]], + x: npt.NDArray[np.number], + old: npt.NDArray[np.number], + new: npt.NDArray[np.number], ) -> _ComplexSeries: ... @overload def mapdomain( - x: npt.NDArray[np.object_ | np.number[Any]], - old: npt.NDArray[np.object_ | np.number[Any]], - new: npt.NDArray[np.object_ | np.number[Any]], + x: npt.NDArray[np.object_ | np.number], + old: npt.NDArray[np.object_ | np.number], + new: npt.NDArray[np.object_ | np.number], ) -> _ObjectSeries: ... @overload def mapdomain( # type: ignore[overload-overlap] @@ -402,7 +390,7 @@ def _fit( full: Literal[True], /, w: _SeriesLikeCoef_co | None = ..., -) -> tuple[_CoefSeries, Sequence[np.inexact[Any] | np.int32]]: ... +) -> tuple[_CoefSeries, Sequence[np.inexact | np.int32]]: ... @overload def _fit( vander_f: _AnyVanderF, @@ -414,6 +402,6 @@ def _fit( *, full: Literal[True], w: _SeriesLikeCoef_co | None = ..., -) -> tuple[_CoefSeries, Sequence[np.inexact[Any] | np.int32]]: ... +) -> tuple[_CoefSeries, Sequence[np.inexact | np.int32]]: ... def _as_int(x: SupportsIndex, desc: str) -> int: ... def format_float(x: _FloatLike_co, parens: bool = ...) -> str: ... diff --git a/src/numpy-stubs/testing/_private/utils.pyi b/src/numpy-stubs/testing/_private/utils.pyi index 96555029..2ae2a364 100644 --- a/src/numpy-stubs/testing/_private/utils.pyi +++ b/src/numpy-stubs/testing/_private/utils.pyi @@ -405,7 +405,7 @@ def raises(*args: type[BaseException]) -> Callable[[_FT], _FT]: ... # def decorate_methods( - cls: type[Any], + cls: type, decorator: Callable[[Callable[..., Any]], Any], testmatch: str | bytes | Pattern[Any] | None = None, ) -> None: ... diff --git a/test/static/accept/arraypad.pyi b/test/static/accept/arraypad.pyi index bfc292c8..ddafa08d 100644 --- a/test/static/accept/arraypad.pyi +++ b/test/static/accept/arraypad.pyi @@ -6,7 +6,7 @@ import numpy as np import numpy.typing as npt def mode_func( - ar: npt.NDArray[np.number[Any]], + ar: npt.NDArray[np.number], width: tuple[int, int], iaxis: SupportsIndex, kwargs: Mapping[str, Any], diff --git a/test/static/accept/arrayprint.pyi b/test/static/accept/arrayprint.pyi index c0ea7680..0703e4ca 100644 --- a/test/static/accept/arrayprint.pyi +++ b/test/static/accept/arrayprint.pyi @@ -1,6 +1,5 @@ import contextlib from collections.abc import Callable -from typing import Any from typing_extensions import assert_type import numpy as np @@ -8,8 +7,8 @@ import numpy.typing as npt from numpy._core.arrayprint import _FormatOptions AR: npt.NDArray[np.int64] -func_float: Callable[[np.floating[Any]], str] -func_int: Callable[[np.integer[Any]], str] +func_float: Callable[[np.floating], str] +func_int: Callable[[np.integer], str] assert_type(np.get_printoptions(), _FormatOptions) assert_type( diff --git a/test/static/accept/ctypeslib.pyi b/test/static/accept/ctypeslib.pyi index 87c3fc31..fa01d97f 100644 --- a/test/static/accept/ctypeslib.pyi +++ b/test/static/accept/ctypeslib.pyi @@ -1,3 +1,4 @@ +import _ctypes as _ct import ctypes as ct from typing import Any from typing_extensions import assert_type @@ -43,8 +44,8 @@ assert_type(np.ctypeslib.as_ctypes_type(np.single), type[ct.c_float]) assert_type(np.ctypeslib.as_ctypes_type(np.double), type[ct.c_double]) assert_type(np.ctypeslib.as_ctypes_type(ct.c_double), type[ct.c_double]) assert_type(np.ctypeslib.as_ctypes_type("q"), type[ct.c_longlong]) -assert_type(np.ctypeslib.as_ctypes_type([("i8", np.int64), ("f8", np.float64)]), type[Any]) -assert_type(np.ctypeslib.as_ctypes_type("i8"), type[Any]) +assert_type(np.ctypeslib.as_ctypes_type([("i8", np.int64), ("f8", np.float64)]), _ct._UnionType | _ct._PyCStructType) +assert_type(np.ctypeslib.as_ctypes_type("i8"), type) assert_type(np.ctypeslib.as_ctypes_type("f8"), type[ct.c_double]) assert_type(np.ctypeslib.as_ctypes(AR_bool.take(0)), ct.c_bool) diff --git a/test/static/accept/dtype.pyi b/test/static/accept/dtype.pyi index 499a5dee..c4f66ae7 100644 --- a/test/static/accept/dtype.pyi +++ b/test/static/accept/dtype.pyi @@ -31,7 +31,7 @@ cs_number: Literal["=L", "i", "c16"] cs_flex: Literal[">V", "S"] cs_generic: Literal["H", "U", "h", "|M8[Y]", "?"] -dt_inexact: np.dtype[np.inexact[Any]] +dt_inexact: np.dtype[np.inexact] dt_string: StringDType assert_type(np.dtype(np.float64), np.dtype[np.float64]) @@ -73,8 +73,8 @@ assert_type(np.dtype("u1"), np.dtype[np.uint8]) assert_type(np.dtype("l"), np.dtype[np.long]) assert_type(np.dtype("longlong"), np.dtype[np.longlong]) assert_type(np.dtype(">g"), np.dtype[np.longdouble]) -assert_type(np.dtype(cs_integer), np.dtype[np.integer[Any]]) -assert_type(np.dtype(cs_number), np.dtype[np.number[Any]]) +assert_type(np.dtype(cs_integer), np.dtype[np.integer]) +assert_type(np.dtype(cs_number), np.dtype[np.number]) assert_type(np.dtype(cs_flex), np.dtype[np.flexible]) assert_type(np.dtype(cs_generic), np.dtype[np.generic]) @@ -91,7 +91,7 @@ assert_type(np.dtype(None), np.dtype[np.float64]) # Dypes of dtypes assert_type(np.dtype(np.dtype(np.float64)), np.dtype[np.float64]) -assert_type(np.dtype(dt_inexact), np.dtype[np.inexact[Any]]) +assert_type(np.dtype(dt_inexact), np.dtype[np.inexact]) # Parameterized dtypes assert_type(np.dtype("S8"), np.dtype[Any]) diff --git a/test/static/accept/emath.pyi b/test/static/accept/emath.pyi index df4e66b8..21046af2 100644 --- a/test/static/accept/emath.pyi +++ b/test/static/accept/emath.pyi @@ -11,45 +11,45 @@ c16: np.complex128 assert_type(np.emath.sqrt(f8), Any) assert_type(np.emath.sqrt(AR_f8), npt.NDArray[Any]) -assert_type(np.emath.sqrt(c16), np.complexfloating[Any, Any]) -assert_type(np.emath.sqrt(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.emath.sqrt(c16), np.complexfloating) +assert_type(np.emath.sqrt(AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.emath.log(f8), Any) assert_type(np.emath.log(AR_f8), npt.NDArray[Any]) -assert_type(np.emath.log(c16), np.complexfloating[Any, Any]) -assert_type(np.emath.log(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.emath.log(c16), np.complexfloating) +assert_type(np.emath.log(AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.emath.log10(f8), Any) assert_type(np.emath.log10(AR_f8), npt.NDArray[Any]) -assert_type(np.emath.log10(c16), np.complexfloating[Any, Any]) -assert_type(np.emath.log10(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.emath.log10(c16), np.complexfloating) +assert_type(np.emath.log10(AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.emath.log2(f8), Any) assert_type(np.emath.log2(AR_f8), npt.NDArray[Any]) -assert_type(np.emath.log2(c16), np.complexfloating[Any, Any]) -assert_type(np.emath.log2(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.emath.log2(c16), np.complexfloating) +assert_type(np.emath.log2(AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.emath.logn(f8, 2), Any) assert_type(np.emath.logn(AR_f8, 4), npt.NDArray[Any]) -assert_type(np.emath.logn(f8, 1j), np.complexfloating[Any, Any]) -assert_type(np.emath.logn(AR_c16, 1.5), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.emath.logn(f8, 1j), np.complexfloating) +assert_type(np.emath.logn(AR_c16, 1.5), npt.NDArray[np.complexfloating]) assert_type(np.emath.power(f8, 2), Any) assert_type(np.emath.power(AR_f8, 4), npt.NDArray[Any]) -assert_type(np.emath.power(f8, 2j), np.complexfloating[Any, Any]) -assert_type(np.emath.power(AR_c16, 1.5), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.emath.power(f8, 2j), np.complexfloating) +assert_type(np.emath.power(AR_c16, 1.5), npt.NDArray[np.complexfloating]) assert_type(np.emath.arccos(f8), Any) assert_type(np.emath.arccos(AR_f8), npt.NDArray[Any]) -assert_type(np.emath.arccos(c16), np.complexfloating[Any, Any]) -assert_type(np.emath.arccos(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.emath.arccos(c16), np.complexfloating) +assert_type(np.emath.arccos(AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.emath.arcsin(f8), Any) assert_type(np.emath.arcsin(AR_f8), npt.NDArray[Any]) -assert_type(np.emath.arcsin(c16), np.complexfloating[Any, Any]) -assert_type(np.emath.arcsin(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.emath.arcsin(c16), np.complexfloating) +assert_type(np.emath.arcsin(AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.emath.arctanh(f8), Any) assert_type(np.emath.arctanh(AR_f8), npt.NDArray[Any]) -assert_type(np.emath.arctanh(c16), np.complexfloating[Any, Any]) -assert_type(np.emath.arctanh(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.emath.arctanh(c16), np.complexfloating) +assert_type(np.emath.arctanh(AR_c16), npt.NDArray[np.complexfloating]) diff --git a/test/static/accept/fromnumeric.pyi b/test/static/accept/fromnumeric.pyi index 251a9c7b..13bc19e3 100644 --- a/test/static/accept/fromnumeric.pyi +++ b/test/static/accept/fromnumeric.pyi @@ -246,8 +246,8 @@ assert_type(np.amin(AR_f4, out=AR_subclass), NDArraySubclass) assert_type(np.prod(AR_b), np.int_) assert_type(np.prod(AR_u8), np.uint64) assert_type(np.prod(AR_i8), np.int64) -assert_type(np.prod(AR_f4), np.floating[Any]) -assert_type(np.prod(AR_c16), np.complexfloating[Any, Any]) +assert_type(np.prod(AR_f4), np.floating) +assert_type(np.prod(AR_c16), np.complexfloating) assert_type(np.prod(AR_O), Any) assert_type(np.prod(AR_f4, axis=0), Any) assert_type(np.prod(AR_f4, keepdims=True), Any) @@ -258,10 +258,10 @@ assert_type(np.prod(AR_f4, out=AR_subclass), NDArraySubclass) assert_type(np.cumprod(AR_b), npt.NDArray[np.int_]) assert_type(np.cumprod(AR_u8), npt.NDArray[np.uint64]) assert_type(np.cumprod(AR_i8), npt.NDArray[np.int64]) -assert_type(np.cumprod(AR_f4), npt.NDArray[np.floating[Any]]) -assert_type(np.cumprod(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.cumprod(AR_f4), npt.NDArray[np.floating]) +assert_type(np.cumprod(AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.cumprod(AR_O), npt.NDArray[np.object_]) -assert_type(np.cumprod(AR_f4, axis=0), npt.NDArray[np.floating[Any]]) +assert_type(np.cumprod(AR_f4, axis=0), npt.NDArray[np.floating]) assert_type(np.cumprod(AR_f4, dtype=np.float64), npt.NDArray[np.float64]) assert_type(np.cumprod(AR_f4, dtype=float), npt.NDArray[Any]) assert_type(np.cumprod(AR_f4, out=AR_subclass), NDArraySubclass) @@ -269,10 +269,10 @@ assert_type(np.cumprod(AR_f4, out=AR_subclass), NDArraySubclass) assert_type(np.cumulative_prod(AR_b), npt.NDArray[np.int_]) assert_type(np.cumulative_prod(AR_u8), npt.NDArray[np.uint64]) assert_type(np.cumulative_prod(AR_i8), npt.NDArray[np.int64]) -assert_type(np.cumulative_prod(AR_f4), npt.NDArray[np.floating[Any]]) -assert_type(np.cumulative_prod(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.cumulative_prod(AR_f4), npt.NDArray[np.floating]) +assert_type(np.cumulative_prod(AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.cumulative_prod(AR_O), npt.NDArray[np.object_]) -assert_type(np.cumulative_prod(AR_f4, axis=0), npt.NDArray[np.floating[Any]]) +assert_type(np.cumulative_prod(AR_f4, axis=0), npt.NDArray[np.floating]) assert_type(np.cumulative_prod(AR_f4, dtype=np.float64), npt.NDArray[np.float64]) assert_type(np.cumulative_prod(AR_f4, dtype=float), npt.NDArray[Any]) assert_type(np.cumulative_prod(AR_f4, out=AR_subclass), NDArraySubclass) @@ -299,11 +299,11 @@ assert_type(np.around(AR_f4), npt.NDArray[np.float32]) assert_type(np.around([1.5]), npt.NDArray[Any]) assert_type(np.around(AR_f4, out=AR_subclass), NDArraySubclass) -assert_type(np.mean(AR_b), np.floating[Any]) -assert_type(np.mean(AR_i8), np.floating[Any]) -assert_type(np.mean(AR_f4), np.floating[Any]) +assert_type(np.mean(AR_b), np.floating) +assert_type(np.mean(AR_i8), np.floating) +assert_type(np.mean(AR_f4), np.floating) assert_type(np.mean(AR_m), np.timedelta64) -assert_type(np.mean(AR_c16), np.complexfloating[Any, Any]) +assert_type(np.mean(AR_c16), np.complexfloating) assert_type(np.mean(AR_O), Any) assert_type(np.mean(AR_f4, axis=0), Any) assert_type(np.mean(AR_f4, keepdims=True), Any) @@ -317,10 +317,10 @@ assert_type(np.mean(AR_f4, None, np.float64, keepdims=False), np.float64) assert_type(np.mean(AR_f4, dtype=np.float64, keepdims=True), np.float64 | npt.NDArray[np.float64]) assert_type(np.mean(AR_f4, None, np.float64, keepdims=True), np.float64 | npt.NDArray[np.float64]) -assert_type(np.std(AR_b), np.floating[Any]) -assert_type(np.std(AR_i8), np.floating[Any]) -assert_type(np.std(AR_f4), np.floating[Any]) -assert_type(np.std(AR_c16), np.floating[Any]) +assert_type(np.std(AR_b), np.floating) +assert_type(np.std(AR_i8), np.floating) +assert_type(np.std(AR_f4), np.floating) +assert_type(np.std(AR_c16), np.floating) assert_type(np.std(AR_O), Any) assert_type(np.std(AR_f4, axis=0), Any) assert_type(np.std(AR_f4, keepdims=True), Any) @@ -328,10 +328,10 @@ assert_type(np.std(AR_f4, dtype=float), Any) assert_type(np.std(AR_f4, dtype=np.float64), np.float64) assert_type(np.std(AR_f4, out=AR_subclass), NDArraySubclass) -assert_type(np.var(AR_b), np.floating[Any]) -assert_type(np.var(AR_i8), np.floating[Any]) -assert_type(np.var(AR_f4), np.floating[Any]) -assert_type(np.var(AR_c16), np.floating[Any]) +assert_type(np.var(AR_b), np.floating) +assert_type(np.var(AR_i8), np.floating) +assert_type(np.var(AR_f4), np.floating) +assert_type(np.var(AR_c16), np.floating) assert_type(np.var(AR_O), Any) assert_type(np.var(AR_f4, axis=0), Any) assert_type(np.var(AR_f4, keepdims=True), Any) diff --git a/test/static/accept/lib_function_base.pyi b/test/static/accept/lib_function_base.pyi index 01e147d6..f2276303 100644 --- a/test/static/accept/lib_function_base.pyi +++ b/test/static/accept/lib_function_base.pyi @@ -51,11 +51,11 @@ assert_type(np.flip(AR_LIKE_f8, axis=0), npt.NDArray[Any]) assert_type(np.iterable(1), bool) assert_type(np.iterable([1]), bool) -assert_type(np.average(AR_f8), np.floating[Any]) -assert_type(np.average(AR_f8, weights=AR_c16), np.complexfloating[Any, Any]) +assert_type(np.average(AR_f8), np.floating) +assert_type(np.average(AR_f8, weights=AR_c16), np.complexfloating) assert_type(np.average(AR_O), Any) -assert_type(np.average(AR_f8, returned=True), tuple[np.floating[Any], np.floating[Any]]) -assert_type(np.average(AR_f8, weights=AR_c16, returned=True), tuple[np.complexfloating[Any, Any], np.complexfloating[Any, Any]]) +assert_type(np.average(AR_f8, returned=True), tuple[np.floating, np.floating]) +assert_type(np.average(AR_f8, weights=AR_c16, returned=True), tuple[np.complexfloating, np.complexfloating]) assert_type(np.average(AR_O, returned=True), tuple[Any, Any]) assert_type(np.average(AR_f8, axis=0), Any) assert_type(np.average(AR_f8, axis=0, returned=True), tuple[Any, Any]) @@ -96,15 +96,15 @@ assert_type(np.interp([1], [1], AR_c16), npt.NDArray[np.complex128]) assert_type(np.interp(1, [1], [1j]), np.float64 | np.complex128) # type: ignore[assert-type] assert_type(np.interp([1], [1], [1j]), npt.NDArray[np.float64 | np.complex128]) # type: ignore[assert-type] -assert_type(np.angle(f8), np.floating[Any]) -assert_type(np.angle(AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.angle(AR_c16, deg=True), npt.NDArray[np.floating[Any]]) +assert_type(np.angle(f8), np.floating) +assert_type(np.angle(AR_f8), npt.NDArray[np.floating]) +assert_type(np.angle(AR_c16, deg=True), npt.NDArray[np.floating]) assert_type(np.angle(AR_O), npt.NDArray[np.object_]) -assert_type(np.unwrap(AR_f8), npt.NDArray[np.floating[Any]]) +assert_type(np.unwrap(AR_f8), npt.NDArray[np.floating]) assert_type(np.unwrap(AR_O), npt.NDArray[np.object_]) -assert_type(np.sort_complex(AR_f8), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.sort_complex(AR_f8), npt.NDArray[np.complexfloating]) assert_type(np.trim_zeros(AR_f8), npt.NDArray[np.float64]) assert_type(np.trim_zeros(AR_LIKE_f8), list[float]) @@ -114,43 +114,43 @@ assert_type(np.extract(AR_i8, AR_LIKE_f8), npt.NDArray[Any]) assert_type(np.place(AR_f8, mask=AR_i8, vals=5.0), None) -assert_type(np.cov(AR_f8, bias=True), npt.NDArray[np.floating[Any]]) -assert_type(np.cov(AR_f8, AR_c16, ddof=1), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.cov(AR_f8, bias=True), npt.NDArray[np.floating]) +assert_type(np.cov(AR_f8, AR_c16, ddof=1), npt.NDArray[np.complexfloating]) assert_type(np.cov(AR_f8, aweights=AR_f8, dtype=np.float32), npt.NDArray[np.float32]) assert_type(np.cov(AR_f8, fweights=AR_f8, dtype=float), npt.NDArray[Any]) -assert_type(np.corrcoef(AR_f8, rowvar=True), npt.NDArray[np.floating[Any]]) -assert_type(np.corrcoef(AR_f8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.corrcoef(AR_f8, rowvar=True), npt.NDArray[np.floating]) +assert_type(np.corrcoef(AR_f8, AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.corrcoef(AR_f8, dtype=np.float32), npt.NDArray[np.float32]) assert_type(np.corrcoef(AR_f8, dtype=float), npt.NDArray[Any]) -assert_type(np.blackman(5), npt.NDArray[np.floating[Any]]) -assert_type(np.bartlett(6), npt.NDArray[np.floating[Any]]) -assert_type(np.hanning(4.5), npt.NDArray[np.floating[Any]]) -assert_type(np.hamming(0), npt.NDArray[np.floating[Any]]) -assert_type(np.i0(AR_i8), npt.NDArray[np.floating[Any]]) -assert_type(np.kaiser(4, 5.9), npt.NDArray[np.floating[Any]]) +assert_type(np.blackman(5), npt.NDArray[np.floating]) +assert_type(np.bartlett(6), npt.NDArray[np.floating]) +assert_type(np.hanning(4.5), npt.NDArray[np.floating]) +assert_type(np.hamming(0), npt.NDArray[np.floating]) +assert_type(np.i0(AR_i8), npt.NDArray[np.floating]) +assert_type(np.kaiser(4, 5.9), npt.NDArray[np.floating]) -assert_type(np.sinc(1.0), np.floating[Any]) -assert_type(np.sinc(1j), np.complexfloating[Any, Any]) -assert_type(np.sinc(AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.sinc(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.sinc(1.0), np.floating) +assert_type(np.sinc(1j), np.complexfloating) +assert_type(np.sinc(AR_f8), npt.NDArray[np.floating]) +assert_type(np.sinc(AR_c16), npt.NDArray[np.complexfloating]) -assert_type(np.median(AR_f8, keepdims=False), np.floating[Any]) -assert_type(np.median(AR_c16, overwrite_input=True), np.complexfloating[Any, Any]) +assert_type(np.median(AR_f8, keepdims=False), np.floating) +assert_type(np.median(AR_c16, overwrite_input=True), np.complexfloating) assert_type(np.median(AR_m), np.timedelta64) assert_type(np.median(AR_O), Any) assert_type(np.median(AR_f8, keepdims=True), Any) assert_type(np.median(AR_c16, axis=0), Any) assert_type(np.median(AR_LIKE_f8, out=AR_c16), npt.NDArray[np.complex128]) -assert_type(np.percentile(AR_f8, 50), np.floating[Any]) -assert_type(np.percentile(AR_c16, 50), np.complexfloating[Any, Any]) +assert_type(np.percentile(AR_f8, 50), np.floating) +assert_type(np.percentile(AR_c16, 50), np.complexfloating) assert_type(np.percentile(AR_m, 50), np.timedelta64) assert_type(np.percentile(AR_M, 50, overwrite_input=True), np.datetime64) assert_type(np.percentile(AR_O, 50), Any) -assert_type(np.percentile(AR_f8, [50]), npt.NDArray[np.floating[Any]]) -assert_type(np.percentile(AR_c16, [50]), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.percentile(AR_f8, [50]), npt.NDArray[np.floating]) +assert_type(np.percentile(AR_c16, [50]), npt.NDArray[np.complexfloating]) assert_type(np.percentile(AR_m, [50]), npt.NDArray[np.timedelta64]) assert_type(np.percentile(AR_M, [50], method="nearest"), npt.NDArray[np.datetime64]) assert_type(np.percentile(AR_O, [50]), npt.NDArray[np.object_]) @@ -158,13 +158,13 @@ assert_type(np.percentile(AR_f8, [50], keepdims=True), Any) assert_type(np.percentile(AR_f8, [50], axis=[1]), Any) assert_type(np.percentile(AR_f8, [50], out=AR_c16), npt.NDArray[np.complex128]) -assert_type(np.quantile(AR_f8, 0.5), np.floating[Any]) -assert_type(np.quantile(AR_c16, 0.5), np.complexfloating[Any, Any]) +assert_type(np.quantile(AR_f8, 0.5), np.floating) +assert_type(np.quantile(AR_c16, 0.5), np.complexfloating) assert_type(np.quantile(AR_m, 0.5), np.timedelta64) assert_type(np.quantile(AR_M, 0.5, overwrite_input=True), np.datetime64) assert_type(np.quantile(AR_O, 0.5), Any) -assert_type(np.quantile(AR_f8, [0.5]), npt.NDArray[np.floating[Any]]) -assert_type(np.quantile(AR_c16, [0.5]), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.quantile(AR_f8, [0.5]), npt.NDArray[np.floating]) +assert_type(np.quantile(AR_c16, [0.5]), npt.NDArray[np.complexfloating]) assert_type(np.quantile(AR_m, [0.5]), npt.NDArray[np.timedelta64]) assert_type(np.quantile(AR_M, [0.5], method="nearest"), npt.NDArray[np.datetime64]) assert_type(np.quantile(AR_O, [0.5]), npt.NDArray[np.object_]) diff --git a/test/static/accept/lib_polynomial.pyi b/test/static/accept/lib_polynomial.pyi index f0cdca2b..b36ec4a3 100644 --- a/test/static/accept/lib_polynomial.pyi +++ b/test/static/accept/lib_polynomial.pyi @@ -50,18 +50,18 @@ assert_type(iter(poly_obj), Iterator[Any]) assert_type(poly_obj.deriv(), np.poly1d) assert_type(poly_obj.integ(), np.poly1d) -assert_type(np.poly(poly_obj), npt.NDArray[np.floating[Any]]) -assert_type(np.poly(AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.poly(AR_c16), npt.NDArray[np.floating[Any]]) +assert_type(np.poly(poly_obj), npt.NDArray[np.floating]) +assert_type(np.poly(AR_f8), npt.NDArray[np.floating]) +assert_type(np.poly(AR_c16), npt.NDArray[np.floating]) assert_type(np.polyint(poly_obj), np.poly1d) -assert_type(np.polyint(AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.polyint(AR_f8, k=AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.polyint(AR_f8), npt.NDArray[np.floating]) +assert_type(np.polyint(AR_f8, k=AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.polyint(AR_O, m=2), npt.NDArray[np.object_]) assert_type(np.polyder(poly_obj), np.poly1d) -assert_type(np.polyder(AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.polyder(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.polyder(AR_f8), npt.NDArray[np.floating]) +assert_type(np.polyder(AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.polyder(AR_O, m=2), npt.NDArray[np.object_]) assert_type(np.polyfit(AR_f8, AR_f8, 2), npt.NDArray[np.float64]) @@ -102,46 +102,44 @@ assert_type( ) assert_type(np.polyval(AR_b, AR_b), npt.NDArray[np.int64]) -assert_type(np.polyval(AR_u4, AR_b), npt.NDArray[np.unsignedinteger[Any]]) -assert_type(np.polyval(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.polyval(AR_f8, AR_i8), npt.NDArray[np.floating[Any]]) -assert_type(np.polyval(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.polyval(AR_u4, AR_b), npt.NDArray[np.unsignedinteger]) +assert_type(np.polyval(AR_i8, AR_i8), npt.NDArray[np.signedinteger]) +assert_type(np.polyval(AR_f8, AR_i8), npt.NDArray[np.floating]) +assert_type(np.polyval(AR_i8, AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.polyval(AR_O, AR_O), npt.NDArray[np.object_]) assert_type(np.polyadd(poly_obj, AR_i8), np.poly1d) assert_type(np.polyadd(AR_f8, poly_obj), np.poly1d) assert_type(np.polyadd(AR_b, AR_b), npt.NDArray[np.bool]) -assert_type(np.polyadd(AR_u4, AR_b), npt.NDArray[np.unsignedinteger[Any]]) -assert_type(np.polyadd(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.polyadd(AR_f8, AR_i8), npt.NDArray[np.floating[Any]]) -assert_type(np.polyadd(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.polyadd(AR_u4, AR_b), npt.NDArray[np.unsignedinteger]) +assert_type(np.polyadd(AR_i8, AR_i8), npt.NDArray[np.signedinteger]) +assert_type(np.polyadd(AR_f8, AR_i8), npt.NDArray[np.floating]) +assert_type(np.polyadd(AR_i8, AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.polyadd(AR_O, AR_O), npt.NDArray[np.object_]) assert_type(np.polysub(poly_obj, AR_i8), np.poly1d) assert_type(np.polysub(AR_f8, poly_obj), np.poly1d) assert_type(np.polysub(AR_b, AR_b), NoReturn) -assert_type(np.polysub(AR_u4, AR_b), npt.NDArray[np.unsignedinteger[Any]]) -assert_type(np.polysub(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.polysub(AR_f8, AR_i8), npt.NDArray[np.floating[Any]]) -assert_type(np.polysub(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.polysub(AR_u4, AR_b), npt.NDArray[np.unsignedinteger]) +assert_type(np.polysub(AR_i8, AR_i8), npt.NDArray[np.signedinteger]) +assert_type(np.polysub(AR_f8, AR_i8), npt.NDArray[np.floating]) +assert_type(np.polysub(AR_i8, AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.polysub(AR_O, AR_O), npt.NDArray[np.object_]) assert_type(np.polymul(poly_obj, AR_i8), np.poly1d) assert_type(np.polymul(AR_f8, poly_obj), np.poly1d) assert_type(np.polymul(AR_b, AR_b), npt.NDArray[np.bool]) -assert_type(np.polymul(AR_u4, AR_b), npt.NDArray[np.unsignedinteger[Any]]) -assert_type(np.polymul(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.polymul(AR_f8, AR_i8), npt.NDArray[np.floating[Any]]) -assert_type(np.polymul(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.polymul(AR_u4, AR_b), npt.NDArray[np.unsignedinteger]) +assert_type(np.polymul(AR_i8, AR_i8), npt.NDArray[np.signedinteger]) +assert_type(np.polymul(AR_f8, AR_i8), npt.NDArray[np.floating]) +assert_type(np.polymul(AR_i8, AR_c16), npt.NDArray[np.complexfloating]) assert_type(np.polymul(AR_O, AR_O), npt.NDArray[np.object_]) assert_type(np.polydiv(poly_obj, AR_i8), tuple[np.poly1d, np.poly1d]) assert_type(np.polydiv(AR_f8, poly_obj), tuple[np.poly1d, np.poly1d]) -assert_type(np.polydiv(AR_b, AR_b), tuple[npt.NDArray[np.floating[Any]], npt.NDArray[np.floating[Any]]]) -assert_type(np.polydiv(AR_u4, AR_b), tuple[npt.NDArray[np.floating[Any]], npt.NDArray[np.floating[Any]]]) -assert_type(np.polydiv(AR_i8, AR_i8), tuple[npt.NDArray[np.floating[Any]], npt.NDArray[np.floating[Any]]]) -assert_type(np.polydiv(AR_f8, AR_i8), tuple[npt.NDArray[np.floating[Any]], npt.NDArray[np.floating[Any]]]) -assert_type( - np.polydiv(AR_i8, AR_c16), tuple[npt.NDArray[np.complexfloating[Any, Any]], npt.NDArray[np.complexfloating[Any, Any]]] -) +assert_type(np.polydiv(AR_b, AR_b), tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]) +assert_type(np.polydiv(AR_u4, AR_b), tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]) +assert_type(np.polydiv(AR_i8, AR_i8), tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]) +assert_type(np.polydiv(AR_f8, AR_i8), tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]) +assert_type(np.polydiv(AR_i8, AR_c16), tuple[npt.NDArray[np.complexfloating], npt.NDArray[np.complexfloating]]) assert_type(np.polydiv(AR_O, AR_O), tuple[npt.NDArray[Any], npt.NDArray[Any]]) diff --git a/test/static/accept/polynomial_polyutils.pyi b/test/static/accept/polynomial_polyutils.pyi index 058020a0..983d0361 100644 --- a/test/static/accept/polynomial_polyutils.pyi +++ b/test/static/accept/polynomial_polyutils.pyi @@ -1,7 +1,7 @@ from collections.abc import Sequence from decimal import Decimal from fractions import Fraction -from typing import Any, Literal as L, TypeAlias +from typing import Literal as L, TypeAlias from typing_extensions import assert_type import numpy as np @@ -9,8 +9,8 @@ import numpy.polynomial.polyutils as pu import numpy.typing as npt from numpy.polynomial._polytypes import _Tuple2 -_ArrFloat1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.floating[Any]]] -_ArrComplex1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.complexfloating[Any, Any]]] +_ArrFloat1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.floating]] +_ArrComplex1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.complexfloating]] _ArrObject1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.object_]] _ArrFloat1D_2: TypeAlias = np.ndarray[tuple[L[2]], np.dtype[np.float64]] @@ -156,31 +156,31 @@ assert_type(pu.mapparms(seq_num_complex, seq_num_complex), _Tuple2[complex]) assert_type(pu.mapparms(seq_num_complex, seq_num_object), _Tuple2[object]) assert_type(pu.mapparms(seq_num_object, seq_num_object), _Tuple2[object]) -assert_type(pu.mapparms(seq_sct_int, seq_sct_int), _Tuple2[np.floating[Any]]) -assert_type(pu.mapparms(seq_sct_int, seq_sct_float), _Tuple2[np.floating[Any]]) +assert_type(pu.mapparms(seq_sct_int, seq_sct_int), _Tuple2[np.floating]) +assert_type(pu.mapparms(seq_sct_int, seq_sct_float), _Tuple2[np.floating]) assert_type(pu.mapparms(seq_sct_float, seq_sct_float), _Tuple2[float]) assert_type(pu.mapparms(seq_sct_float, seq_sct_complex), _Tuple2[complex]) assert_type(pu.mapparms(seq_sct_complex, seq_sct_complex), _Tuple2[complex]) assert_type(pu.mapparms(seq_sct_complex, seq_sct_object), _Tuple2[object]) assert_type(pu.mapparms(seq_sct_object, seq_sct_object), _Tuple2[object]) -assert_type(pu.mapparms(arr_int, arr_int), _Tuple2[np.floating[Any]]) -assert_type(pu.mapparms(arr_int, arr_float), _Tuple2[np.floating[Any]]) -assert_type(pu.mapparms(arr_float, arr_float), _Tuple2[np.floating[Any]]) -assert_type(pu.mapparms(arr_float, arr_complex), _Tuple2[np.complexfloating[Any, Any]]) -assert_type(pu.mapparms(arr_complex, arr_complex), _Tuple2[np.complexfloating[Any, Any]]) +assert_type(pu.mapparms(arr_int, arr_int), _Tuple2[np.floating]) +assert_type(pu.mapparms(arr_int, arr_float), _Tuple2[np.floating]) +assert_type(pu.mapparms(arr_float, arr_float), _Tuple2[np.floating]) +assert_type(pu.mapparms(arr_float, arr_complex), _Tuple2[np.complexfloating]) +assert_type(pu.mapparms(arr_complex, arr_complex), _Tuple2[np.complexfloating]) assert_type(pu.mapparms(arr_complex, arr_object), _Tuple2[object]) assert_type(pu.mapparms(arr_object, arr_object), _Tuple2[object]) # mapdomain -assert_type(pu.mapdomain(num_int, seq_num_int, seq_num_int), np.floating[Any]) -assert_type(pu.mapdomain(num_int, seq_num_int, seq_num_float), np.floating[Any]) -assert_type(pu.mapdomain(num_int, seq_num_float, seq_num_float), np.floating[Any]) -assert_type(pu.mapdomain(num_float, seq_num_float, seq_num_float), np.floating[Any]) -assert_type(pu.mapdomain(num_float, seq_num_float, seq_num_complex), np.complexfloating[Any, Any]) -assert_type(pu.mapdomain(num_float, seq_num_complex, seq_num_complex), np.complexfloating[Any, Any]) -assert_type(pu.mapdomain(num_complex, seq_num_complex, seq_num_complex), np.complexfloating[Any, Any]) +assert_type(pu.mapdomain(num_int, seq_num_int, seq_num_int), np.floating) +assert_type(pu.mapdomain(num_int, seq_num_int, seq_num_float), np.floating) +assert_type(pu.mapdomain(num_int, seq_num_float, seq_num_float), np.floating) +assert_type(pu.mapdomain(num_float, seq_num_float, seq_num_float), np.floating) +assert_type(pu.mapdomain(num_float, seq_num_float, seq_num_complex), np.complexfloating) +assert_type(pu.mapdomain(num_float, seq_num_complex, seq_num_complex), np.complexfloating) +assert_type(pu.mapdomain(num_complex, seq_num_complex, seq_num_complex), np.complexfloating) assert_type(pu.mapdomain(num_complex, seq_num_complex, seq_num_object), object) assert_type(pu.mapdomain(num_complex, seq_num_object, seq_num_object), object) assert_type(pu.mapdomain(num_object, seq_num_object, seq_num_object), object) diff --git a/test/static/accept/polynomial_series.pyi b/test/static/accept/polynomial_series.pyi index 438d3323..7b6b8e88 100644 --- a/test/static/accept/polynomial_series.pyi +++ b/test/static/accept/polynomial_series.pyi @@ -1,14 +1,14 @@ from collections.abc import Sequence -from typing import Any, TypeAlias +from typing import TypeAlias from typing_extensions import assert_type import numpy as np import numpy.polynomial as npp import numpy.typing as npt -_ArrFloat1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.floating[Any]]] +_ArrFloat1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.floating]] _ArrFloat1D64: TypeAlias = np.ndarray[tuple[int], np.dtype[np.float64]] -_ArrComplex1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.complexfloating[Any, Any]]] +_ArrComplex1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.complexfloating]] _ArrComplex1D128: TypeAlias = np.ndarray[tuple[int], np.dtype[np.complex128]] _ArrObject1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.object_]] @@ -50,70 +50,70 @@ assert_type(npp.polynomial.polypow(AR_c16, 2), _ArrComplex1D) assert_type(npp.polynomial.polypow(AR_O, 2), _ArrObject1D) # assert_type(npp.polynomial.polyder(PS_poly), npt.NDArray[np.object_]) -assert_type(npp.polynomial.polyder(AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyder(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(npp.polynomial.polyder(AR_f8), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyder(AR_c16), npt.NDArray[np.complexfloating]) assert_type(npp.polynomial.polyder(AR_O, m=2), npt.NDArray[np.object_]) # assert_type(npp.polynomial.polyint(PS_poly), npt.NDArray[np.object_]) -assert_type(npp.polynomial.polyint(AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyint(AR_f8, k=AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(npp.polynomial.polyint(AR_f8), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyint(AR_f8, k=AR_c16), npt.NDArray[np.complexfloating]) assert_type(npp.polynomial.polyint(AR_O, m=2), npt.NDArray[np.object_]) -assert_type(npp.polynomial.polyval(AR_b, AR_b), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyval(AR_u4, AR_b), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyval(AR_i8, AR_i8), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyval(AR_f8, AR_i8), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyval(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(npp.polynomial.polyval(AR_b, AR_b), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyval(AR_u4, AR_b), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyval(AR_i8, AR_i8), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyval(AR_f8, AR_i8), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyval(AR_i8, AR_c16), npt.NDArray[np.complexfloating]) assert_type(npp.polynomial.polyval(AR_O, AR_O), npt.NDArray[np.object_]) -assert_type(npp.polynomial.polyval2d(AR_b, AR_b, AR_b), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyval2d(AR_u4, AR_u4, AR_b), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyval2d(AR_i8, AR_i8, AR_i8), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyval2d(AR_f8, AR_f8, AR_i8), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyval2d(AR_i8, AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(npp.polynomial.polyval2d(AR_b, AR_b, AR_b), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyval2d(AR_u4, AR_u4, AR_b), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyval2d(AR_i8, AR_i8, AR_i8), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyval2d(AR_f8, AR_f8, AR_i8), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyval2d(AR_i8, AR_i8, AR_c16), npt.NDArray[np.complexfloating]) assert_type(npp.polynomial.polyval2d(AR_O, AR_O, AR_O), npt.NDArray[np.object_]) -assert_type(npp.polynomial.polyval3d(AR_b, AR_b, AR_b, AR_b), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyval3d(AR_u4, AR_u4, AR_u4, AR_b), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyval3d(AR_i8, AR_i8, AR_i8, AR_i8), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyval3d(AR_f8, AR_f8, AR_f8, AR_i8), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyval3d(AR_i8, AR_i8, AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(npp.polynomial.polyval3d(AR_b, AR_b, AR_b, AR_b), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyval3d(AR_u4, AR_u4, AR_u4, AR_b), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyval3d(AR_i8, AR_i8, AR_i8, AR_i8), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyval3d(AR_f8, AR_f8, AR_f8, AR_i8), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyval3d(AR_i8, AR_i8, AR_i8, AR_c16), npt.NDArray[np.complexfloating]) assert_type(npp.polynomial.polyval3d(AR_O, AR_O, AR_O, AR_O), npt.NDArray[np.object_]) -assert_type(npp.polynomial.polyvalfromroots(AR_b, AR_b), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyvalfromroots(AR_u4, AR_b), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyvalfromroots(AR_i8, AR_i8), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyvalfromroots(AR_f8, AR_i8), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyvalfromroots(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(npp.polynomial.polyvalfromroots(AR_b, AR_b), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyvalfromroots(AR_u4, AR_b), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyvalfromroots(AR_i8, AR_i8), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyvalfromroots(AR_f8, AR_i8), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyvalfromroots(AR_i8, AR_c16), npt.NDArray[np.complexfloating]) assert_type(npp.polynomial.polyvalfromroots(AR_O, AR_O), npt.NDArray[np.object_]) -assert_type(npp.polynomial.polyvander(AR_f8, 3), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyvander(AR_c16, 3), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(npp.polynomial.polyvander(AR_f8, 3), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyvander(AR_c16, 3), npt.NDArray[np.complexfloating]) assert_type(npp.polynomial.polyvander(AR_O, 3), npt.NDArray[np.object_]) -assert_type(npp.polynomial.polyvander2d(AR_f8, AR_f8, [4, 2]), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyvander2d(AR_c16, AR_c16, [4, 2]), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(npp.polynomial.polyvander2d(AR_f8, AR_f8, [4, 2]), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyvander2d(AR_c16, AR_c16, [4, 2]), npt.NDArray[np.complexfloating]) assert_type(npp.polynomial.polyvander2d(AR_O, AR_O, [4, 2]), npt.NDArray[np.object_]) -assert_type(npp.polynomial.polyvander3d(AR_f8, AR_f8, AR_f8, [4, 3, 2]), npt.NDArray[np.floating[Any]]) -assert_type(npp.polynomial.polyvander3d(AR_c16, AR_c16, AR_c16, [4, 3, 2]), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(npp.polynomial.polyvander3d(AR_f8, AR_f8, AR_f8, [4, 3, 2]), npt.NDArray[np.floating]) +assert_type(npp.polynomial.polyvander3d(AR_c16, AR_c16, AR_c16, [4, 3, 2]), npt.NDArray[np.complexfloating]) assert_type(npp.polynomial.polyvander3d(AR_O, AR_O, AR_O, [4, 3, 2]), npt.NDArray[np.object_]) assert_type( npp.polynomial.polyfit(AR_f8, AR_f8, 2), - npt.NDArray[np.floating[Any]], + npt.NDArray[np.floating], ) assert_type( npp.polynomial.polyfit(AR_f8, AR_i8, 1, full=True), - tuple[npt.NDArray[np.floating[Any]], Sequence[np.inexact[Any] | np.int32]], + tuple[npt.NDArray[np.floating], Sequence[np.inexact | np.int32]], ) assert_type( npp.polynomial.polyfit(AR_c16, AR_f8, 2), - npt.NDArray[np.complexfloating[Any, Any]], + npt.NDArray[np.complexfloating], ) assert_type( npp.polynomial.polyfit(AR_f8, AR_c16, 1, full=True)[0], - npt.NDArray[np.complexfloating[Any, Any]], + npt.NDArray[np.complexfloating], ) assert_type(npp.chebyshev.chebgauss(2), tuple[_ArrFloat1D64, _ArrFloat1D64]) diff --git a/test/static/accept/shape_base.pyi b/test/static/accept/shape_base.pyi index 6c52b9f8..dbe01082 100644 --- a/test/static/accept/shape_base.pyi +++ b/test/static/accept/shape_base.pyi @@ -43,8 +43,8 @@ assert_type(np.dsplit(AR_i8, [3, 5, 6, 10]), list[npt.NDArray[np.int64]]) assert_type(np.dsplit(AR_LIKE_f8, [3, 5, 6, 10]), list[npt.NDArray[Any]]) assert_type(np.kron(AR_b, AR_b), npt.NDArray[np.bool]) -assert_type(np.kron(AR_b, AR_i8), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.kron(AR_f8, AR_f8), npt.NDArray[np.floating[Any]]) +assert_type(np.kron(AR_b, AR_i8), npt.NDArray[np.signedinteger]) +assert_type(np.kron(AR_f8, AR_f8), npt.NDArray[np.floating]) assert_type(np.tile(AR_i8, 5), npt.NDArray[np.int64]) assert_type(np.tile(AR_LIKE_f8, [2, 2]), npt.NDArray[Any]) diff --git a/test/static/accept/twodim_base.pyi b/test/static/accept/twodim_base.pyi index 2524b2b7..f84daab1 100644 --- a/test/static/accept/twodim_base.pyi +++ b/test/static/accept/twodim_base.pyi @@ -7,7 +7,7 @@ import numpy.typing as npt _SCT = TypeVar("_SCT", bound=np.generic) def func1(ar: npt.NDArray[_SCT], a: int) -> npt.NDArray[_SCT]: ... -def func2(ar: npt.NDArray[np.number[Any]], a: str) -> npt.NDArray[np.float64]: ... +def func2(ar: npt.NDArray[np.number], a: str) -> npt.NDArray[np.float64]: ... AR_b: npt.NDArray[np.bool] AR_u: npt.NDArray[np.uint64] @@ -45,11 +45,11 @@ assert_type(np.tril(AR_LIKE_b, k=0), npt.NDArray[Any]) assert_type(np.triu(AR_b), npt.NDArray[np.bool]) assert_type(np.triu(AR_LIKE_b, k=0), npt.NDArray[Any]) -assert_type(np.vander(AR_b), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.vander(AR_u), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.vander(AR_i, N=2), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.vander(AR_f, increasing=True), npt.NDArray[np.floating[Any]]) -assert_type(np.vander(AR_c), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.vander(AR_b), npt.NDArray[np.signedinteger]) +assert_type(np.vander(AR_u), npt.NDArray[np.signedinteger]) +assert_type(np.vander(AR_i, N=2), npt.NDArray[np.signedinteger]) +assert_type(np.vander(AR_f, increasing=True), npt.NDArray[np.floating]) +assert_type(np.vander(AR_c), npt.NDArray[np.complexfloating]) assert_type(np.vander(AR_O), npt.NDArray[np.object_]) assert_type( diff --git a/test/static/accept/ufunclike.pyi b/test/static/accept/ufunclike.pyi index f0432b1f..fdee886a 100644 --- a/test/static/accept/ufunclike.pyi +++ b/test/static/accept/ufunclike.pyi @@ -1,4 +1,3 @@ -from typing import Any from typing_extensions import assert_type import numpy as np @@ -12,10 +11,10 @@ AR_LIKE_O: list[np.object_] AR_U: npt.NDArray[np.str_] -assert_type(np.fix(AR_LIKE_b), npt.NDArray[np.floating[Any]]) -assert_type(np.fix(AR_LIKE_u), npt.NDArray[np.floating[Any]]) -assert_type(np.fix(AR_LIKE_i), npt.NDArray[np.floating[Any]]) -assert_type(np.fix(AR_LIKE_f), npt.NDArray[np.floating[Any]]) +assert_type(np.fix(AR_LIKE_b), npt.NDArray[np.floating]) +assert_type(np.fix(AR_LIKE_u), npt.NDArray[np.floating]) +assert_type(np.fix(AR_LIKE_i), npt.NDArray[np.floating]) +assert_type(np.fix(AR_LIKE_f), npt.NDArray[np.floating]) assert_type(np.fix(AR_LIKE_O), npt.NDArray[np.object_]) assert_type(np.fix(AR_LIKE_f, out=AR_U), npt.NDArray[np.str_])