diff --git a/src/numpy-stubs/__init__.pyi b/src/numpy-stubs/__init__.pyi index 77f31333..03ab55d9 100644 --- a/src/numpy-stubs/__init__.pyi +++ b/src/numpy-stubs/__init__.pyi @@ -102,8 +102,10 @@ from numpy._core.multiarray import ( ascontiguousarray, asfortranarray, bincount, + broadcast, busday_count, busday_offset, + busdaycalendar, can_cast, concatenate, copyto, @@ -113,6 +115,8 @@ from numpy._core.multiarray import ( empty, empty_like, flagsobj, + flatiter, + from_dlpack, frombuffer, fromfile, fromiter, @@ -123,6 +127,7 @@ from numpy._core.multiarray import ( lexsort, may_share_memory, min_scalar_type, + nditer, nested_iters, packbits, promote_types, @@ -289,9 +294,6 @@ from numpy._typing._callable import ( _UnsignedIntMod, _UnsignedIntOp, ) - -# NOTE: Numpy's mypy plugin is used for removing the types unavailable -# to the specific platform from numpy._typing._extended_precision import ( complex160, complex192, @@ -446,6 +448,10 @@ from numpy.matrixlib import asmatrix, bmat from . import ( __config__ as __config__, + _array_api_info as _array_api_info, + _core as _core, + _globals as _globals, + _typing as _typing, char, core, ctypeslib, @@ -632,7 +638,6 @@ _AnyDateOrTime = TypeVar("_AnyDateOrTime", dt.date, dt.datetime, dt.timedelta) _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) -_T_contra = TypeVar("_T_contra", contravariant=True) _RealT_co = TypeVar("_RealT_co", covariant=True) _ImagT_co = TypeVar("_ImagT_co", covariant=True) @@ -643,14 +648,12 @@ _DType_co = TypeVar("_DType_co", bound=dtype[Any], covariant=True) _FlexDType = TypeVar("_FlexDType", bound=dtype[flexible]) _ArrayT = TypeVar("_ArrayT", bound=NDArray[Any]) -_ArrayT_co = TypeVar("_ArrayT_co", bound=NDArray[Any], covariant=True) _IntegralArrayT = TypeVar("_IntegralArrayT", bound=NDArray[integer | np.bool | object_]) _RealArrayT = TypeVar("_RealArrayT", bound=NDArray[floating | integer | timedelta64 | np.bool | object_]) _NumericArrayT = TypeVar("_NumericArrayT", bound=NDArray[number | timedelta64 | object_]) _ShapeT = TypeVar("_ShapeT", bound=_Shape) _ShapeT_co = TypeVar("_ShapeT_co", bound=_Shape, covariant=True) -_1DShapeT = TypeVar("_1DShapeT", bound=_1D) _2DShapeT_co = TypeVar("_2DShapeT_co", bound=_2D, covariant=True) _1NShapeT = TypeVar("_1NShapeT", bound=tuple[L[1], Unpack[tuple[L[1], ...]]]) # (1,) | (1, 1) | (1, 1, 1) | ... @@ -673,7 +676,7 @@ _NumberItemT_co = TypeVar("_NumberItemT_co", bound=int | float | complex, defaul _InexactItemT_co = TypeVar("_InexactItemT_co", bound=float | complex, default=float | complex, covariant=True) _FlexibleItemT_co = TypeVar( "_FlexibleItemT_co", - bound=_CharLike_co | tuple[Any, ...], + bound=_CharLike_co | tuple[object, ...], default=_CharLike_co | tuple[Any, ...], covariant=True, ) @@ -761,7 +764,6 @@ _ExpiredAttribute: TypeAlias = L[ "unicode_", "who", ] -_FutureScalar: TypeAlias = L["bytes", "str", "object"] _Falsy: TypeAlias = L[False, 0] | np.bool[L[False]] _Truthy: TypeAlias = L[True, 1] | np.bool[L[True]] @@ -813,7 +815,6 @@ _BuiltinObjectLike: TypeAlias = ( # Introduce an alias for `dtype` to avoid naming conflicts. _dtype: TypeAlias = dtype[_SCT] -_ByteOrderChar: TypeAlias = L["<", ">", "=", "|"] # can be anything, is case-insensitive, and only the first character matters _ByteOrder: TypeAlias = L[ "S", # swap the current order (default) @@ -898,30 +899,22 @@ _DTypeBuiltinKind: TypeAlias = L[0, 1, 2] _ArrayAPIVersion: TypeAlias = L["2021.12", "2022.12", "2023.12"] -_CastingKind: TypeAlias = L["no", "equiv", "safe", "same_kind", "unsafe"] - -_OrderKACF: TypeAlias = L["K", "A", "C", "F"] | None -_OrderACF: TypeAlias = L["A", "C", "F"] | None _OrderCF: TypeAlias = L["C", "F"] | None +_OrderACF: TypeAlias = L["A", "C", "F"] | None +_OrderKACF: TypeAlias = L["K", "A", "C", "F"] | None +_FutureScalar: TypeAlias = L["bytes", "str", "object"] +_ByteOrderChar: TypeAlias = L["<", ">", "=", "|"] +_CastingKind: TypeAlias = L["no", "equiv", "safe", "same_kind", "unsafe"] _ModeKind: TypeAlias = L["raise", "wrap", "clip"] +_ModeKindMM: TypeAlias = L["readonly", "r", "copyonwrite", "c", "readwrite", "r+", "write", "w+"] _PartitionKind: TypeAlias = L["introselect"] -# in practice, only the first case-insensitive character is considered (so e.g. -# "QuantumSort3000" will be interpreted as quicksort). _SortKind: TypeAlias = L[ - "Q", - "quick", - "quicksort", - "M", - "merge", - "mergesort", - "H", - "heap", - "heapsort", - "S", - "stable", - "stablesort", -] + "Q", "quick", "quicksort", + "M", "merge", "mergesort", + "H", "heap", "heapsort", + "S", "stable", "stablesort", +] # fmt: skip _SortSide: TypeAlias = L["left", "right"] _ConvertibleToInt: TypeAlias = SupportsInt | SupportsIndex | _CharLike_co @@ -930,51 +923,6 @@ _ConvertibleToComplex: TypeAlias = SupportsComplex | SupportsFloat | SupportsInd _ConvertibleToTD64: TypeAlias = dt.timedelta | int | _CharLike_co | character | number | timedelta64 | np.bool | None _ConvertibleToDT64: TypeAlias = dt.date | int | _CharLike_co | character | number | datetime64 | np.bool | None -_NDIterFlagsKind: TypeAlias = L[ - "buffered", - "c_index", - "copy_if_overlap", - "common_dtype", - "delay_bufalloc", - "external_loop", - "f_index", - "grow_inner", - "growinner", - "multi_index", - "ranged", - "refs_ok", - "reduce_ok", - "zerosize_ok", -] -_NDIterFlagsOp: TypeAlias = L[ - "aligned", - "allocate", - "arraymask", - "copy", - "config", - "nbo", - "no_subtype", - "no_broadcast", - "overlap_assume_elementwise", - "readonly", - "readwrite", - "updateifcopy", - "virtual", - "writeonly", - "writemasked", -] - -_MemMapModeKind: TypeAlias = L[ - "readonly", - "r", - "copyonwrite", - "c", - "readwrite", - "r+", - "write", - "w+", -] - _DT64Date: TypeAlias = _HasDateAttributes | L["TODAY", "today", b"TODAY", b"today"] _DT64Now: TypeAlias = L["NOW", "now", b"NOW", b"now"] _NaTValue: TypeAlias = L["NAT", "NaT", "nat", b"NAT", b"NaT", b"nat"] @@ -1016,10 +964,6 @@ class _SupportsFileMethodsRW(SupportsWrite[bytes], _SupportsFileMethods, Protoco class _SupportsItem(Protocol[_T_co]): def item(self, /) -> _T_co: ... -@type_check_only -class _SupportsDLPack(Protocol[_T_contra]): - def __dlpack__(self, /, *, stream: _T_contra | None = None) -> CapsuleType: ... - @type_check_only class _HasShape(Protocol[_ShapeT_co]): @property @@ -1115,7 +1059,6 @@ little_endian: Final[builtins.bool] = ... # not in __all__ __NUMPY_SETUP__: Final = False __numpy_submodules__: Final[set[_SubModule]] = ... -__expired_attributes__: Final[dict[_ExpiredAttribute, LiteralString]] __former_attrs__: Final[_FormerAttrsDict] = ... __future_scalars__: Final[set[_FutureScalar]] = ... __array_api_version__: Final = "2023.12" @@ -1778,46 +1721,6 @@ class dtype(Generic[_SCT_co]): @property def type(self) -> type[_SCT_co]: ... -@final -class flatiter(Generic[_ArrayT_co]): - __hash__: ClassVar[None] = None # type: ignore[assignment] # pyright: ignore[reportIncompatibleMethodOverride] - @property - def base(self) -> _ArrayT_co: ... - @property - def coords(self) -> _Shape: ... - @property - def index(self) -> int: ... - def copy(self) -> _ArrayT_co: ... - def __iter__(self) -> Self: ... - def __next__(self: flatiter[NDArray[_SCT]]) -> _SCT: ... - def __len__(self) -> int: ... - @overload - def __getitem__(self: flatiter[NDArray[_SCT]], key: int | integer | tuple[int | integer], /) -> _SCT: ... - @overload - def __getitem__( - self, - key: _ArrayLikeInt | slice | EllipsisType | tuple[_ArrayLikeInt | slice | EllipsisType], - /, - ) -> _ArrayT_co: ... - # TODO: `__setitem__` operates via `unsafe` casting rules, and can - # thus accept any type accepted by the relevant underlying `np.generic` - # constructor. - # This means that `value` must in reality be a supertype of `npt.ArrayLike`. - def __setitem__( - self, - key: _ArrayLikeInt | slice | EllipsisType | tuple[_ArrayLikeInt | slice | EllipsisType], - value: Any, - /, - ) -> None: ... - @overload - def __array__(self: flatiter[ndarray[_1DShapeT, _DType]], dtype: None = ..., /) -> ndarray[_1DShapeT, _DType]: ... - @overload - def __array__(self: flatiter[ndarray[_1DShapeT, Any]], dtype: _DType, /) -> ndarray[_1DShapeT, _DType]: ... - @overload - def __array__(self: flatiter[ndarray[_Shape, _DType]], dtype: None = ..., /) -> ndarray[_Shape, _DType]: ... - @overload - def __array__(self, dtype: _DType, /) -> ndarray[_Shape, _DType]: ... - @type_check_only class _ArrayOrScalarCommon: @property @@ -5155,113 +5058,112 @@ class ufunc: def signature(self) -> LiteralString | None: ... # - def __call__(self, *args: Any, **kwargs: Any) -> Any: ... - - # + def __call__(self, /, *args: Any, **kwargs: Any) -> Any: ... def reduce(self, /, *args: Any, **kwargs: Any) -> Any: ... def accumulate(self, /, *args: Any, **kwargs: Any) -> NDArray[Any]: ... def reduceat(self, /, *args: Any, **kwargs: Any) -> NDArray[Any]: ... def outer(self, *args: Any, **kwargs: Any) -> Any: ... - - # def at(self, /, *args: Any, **kwargs: Any) -> None: ... -# Parameters: `__name__`, `ntypes` and `identity` -absolute: Final[_UFunc_Nin1_Nout1[L["absolute"], L[20], None]] = ... +absolute: Final[_UFunc_Nin1_Nout1[L["absolute"], L[20]]] = ... +arccos: Final[_UFunc_Nin1_Nout1[L["arccos"], L[8]]] = ... +arccosh: Final[_UFunc_Nin1_Nout1[L["arccosh"], L[8]]] = ... +arcsin: Final[_UFunc_Nin1_Nout1[L["arcsin"], L[8]]] = ... +arcsinh: Final[_UFunc_Nin1_Nout1[L["arcsinh"], L[8]]] = ... +arctan: Final[_UFunc_Nin1_Nout1[L["arctan"], L[8]]] = ... +arctanh: Final[_UFunc_Nin1_Nout1[L["arctanh"], L[8]]] = ... +bitwise_count: Final[_UFunc_Nin1_Nout1[L["bitwise_count"], L[11]]] = ... +bitwise_not: Final[_UFunc_Nin1_Nout1[L["invert"], L[12]]] = ... +cbrt: Final[_UFunc_Nin1_Nout1[L["cbrt"], L[5]]] = ... +ceil: Final[_UFunc_Nin1_Nout1[L["ceil"], L[7]]] = ... +conj: Final[_UFunc_Nin1_Nout1[L["conjugate"], L[18]]] = ... +conjugate: Final[_UFunc_Nin1_Nout1[L["conjugate"], L[18]]] = ... +cos: Final[_UFunc_Nin1_Nout1[L["cos"], L[9]]] = ... +cosh: Final[_UFunc_Nin1_Nout1[L["cosh"], L[8]]] = ... +deg2rad: Final[_UFunc_Nin1_Nout1[L["deg2rad"], L[5]]] = ... +degrees: Final[_UFunc_Nin1_Nout1[L["degrees"], L[5]]] = ... +exp2: Final[_UFunc_Nin1_Nout1[L["exp2"], L[8]]] = ... +exp: Final[_UFunc_Nin1_Nout1[L["exp"], L[10]]] = ... +expm1: Final[_UFunc_Nin1_Nout1[L["expm1"], L[8]]] = ... +fabs: Final[_UFunc_Nin1_Nout1[L["fabs"], L[5]]] = ... +floor: Final[_UFunc_Nin1_Nout1[L["floor"], L[7]]] = ... +invert: Final[_UFunc_Nin1_Nout1[L["invert"], L[12]]] = ... +isfinite: Final[_UFunc_Nin1_Nout1[L["isfinite"], L[20]]] = ... +isinf: Final[_UFunc_Nin1_Nout1[L["isinf"], L[20]]] = ... +isnan: Final[_UFunc_Nin1_Nout1[L["isnan"], L[20]]] = ... +isnat: Final[_UFunc_Nin1_Nout1[L["isnat"], L[2]]] = ... +log10: Final[_UFunc_Nin1_Nout1[L["log10"], L[8]]] = ... +log1p: Final[_UFunc_Nin1_Nout1[L["log1p"], L[8]]] = ... +log2: Final[_UFunc_Nin1_Nout1[L["log2"], L[8]]] = ... +log: Final[_UFunc_Nin1_Nout1[L["log"], L[10]]] = ... +logical_not: Final[_UFunc_Nin1_Nout1[L["logical_not"], L[20]]] = ... +negative: Final[_UFunc_Nin1_Nout1[L["negative"], L[19]]] = ... +positive: Final[_UFunc_Nin1_Nout1[L["positive"], L[19]]] = ... +rad2deg: Final[_UFunc_Nin1_Nout1[L["rad2deg"], L[5]]] = ... +radians: Final[_UFunc_Nin1_Nout1[L["radians"], L[5]]] = ... +reciprocal: Final[_UFunc_Nin1_Nout1[L["reciprocal"], L[18]]] = ... +rint: Final[_UFunc_Nin1_Nout1[L["rint"], L[10]]] = ... +sign: Final[_UFunc_Nin1_Nout1[L["sign"], L[19]]] = ... +signbit: Final[_UFunc_Nin1_Nout1[L["signbit"], L[4]]] = ... +sin: Final[_UFunc_Nin1_Nout1[L["sin"], L[9]]] = ... +sinh: Final[_UFunc_Nin1_Nout1[L["sinh"], L[8]]] = ... +spacing: Final[_UFunc_Nin1_Nout1[L["spacing"], L[4]]] = ... +sqrt: Final[_UFunc_Nin1_Nout1[L["sqrt"], L[10]]] = ... +square: Final[_UFunc_Nin1_Nout1[L["square"], L[18]]] = ... +tan: Final[_UFunc_Nin1_Nout1[L["tan"], L[8]]] = ... +tanh: Final[_UFunc_Nin1_Nout1[L["tanh"], L[8]]] = ... +trunc: Final[_UFunc_Nin1_Nout1[L["trunc"], L[7]]] = ... + add: Final[_UFunc_Nin2_Nout1[L["add"], L[22], L[0]]] = ... -arccos: Final[_UFunc_Nin1_Nout1[L["arccos"], L[8], None]] = ... -arccosh: Final[_UFunc_Nin1_Nout1[L["arccosh"], L[8], None]] = ... -arcsin: Final[_UFunc_Nin1_Nout1[L["arcsin"], L[8], None]] = ... -arcsinh: Final[_UFunc_Nin1_Nout1[L["arcsinh"], L[8], None]] = ... -arctan2: Final[_UFunc_Nin2_Nout1[L["arctan2"], L[5], None]] = ... -arctan: Final[_UFunc_Nin1_Nout1[L["arctan"], L[8], None]] = ... -arctanh: Final[_UFunc_Nin1_Nout1[L["arctanh"], L[8], None]] = ... +arctan2: Final[_UFunc_Nin2_Nout1[L["arctan2"], L[5]]] = ... bitwise_and: Final[_UFunc_Nin2_Nout1[L["bitwise_and"], L[12], L[-1]]] = ... -bitwise_count: Final[_UFunc_Nin1_Nout1[L["bitwise_count"], L[11], None]] = ... -bitwise_not: Final[_UFunc_Nin1_Nout1[L["invert"], L[12], None]] = ... bitwise_or: Final[_UFunc_Nin2_Nout1[L["bitwise_or"], L[12], L[0]]] = ... bitwise_xor: Final[_UFunc_Nin2_Nout1[L["bitwise_xor"], L[12], L[0]]] = ... -cbrt: Final[_UFunc_Nin1_Nout1[L["cbrt"], L[5], None]] = ... -ceil: Final[_UFunc_Nin1_Nout1[L["ceil"], L[7], None]] = ... -conj: Final[_UFunc_Nin1_Nout1[L["conjugate"], L[18], None]] = ... -conjugate: Final[_UFunc_Nin1_Nout1[L["conjugate"], L[18], None]] = ... -copysign: Final[_UFunc_Nin2_Nout1[L["copysign"], L[4], None]] = ... -cos: Final[_UFunc_Nin1_Nout1[L["cos"], L[9], None]] = ... -cosh: Final[_UFunc_Nin1_Nout1[L["cosh"], L[8], None]] = ... -deg2rad: Final[_UFunc_Nin1_Nout1[L["deg2rad"], L[5], None]] = ... -degrees: Final[_UFunc_Nin1_Nout1[L["degrees"], L[5], None]] = ... -divide: Final[_UFunc_Nin2_Nout1[L["true_divide"], L[11], None]] = ... -divmod: Final[_UFunc_Nin2_Nout2[L["divmod"], L[15], None]] = ... -equal: Final[_UFunc_Nin2_Nout1[L["equal"], L[23], None]] = ... -exp2: Final[_UFunc_Nin1_Nout1[L["exp2"], L[8], None]] = ... -exp: Final[_UFunc_Nin1_Nout1[L["exp"], L[10], None]] = ... -expm1: Final[_UFunc_Nin1_Nout1[L["expm1"], L[8], None]] = ... -fabs: Final[_UFunc_Nin1_Nout1[L["fabs"], L[5], None]] = ... -float_power: Final[_UFunc_Nin2_Nout1[L["float_power"], L[4], None]] = ... -floor: Final[_UFunc_Nin1_Nout1[L["floor"], L[7], None]] = ... -floor_divide: Final[_UFunc_Nin2_Nout1[L["floor_divide"], L[21], None]] = ... -fmax: Final[_UFunc_Nin2_Nout1[L["fmax"], L[21], None]] = ... -fmin: Final[_UFunc_Nin2_Nout1[L["fmin"], L[21], None]] = ... -fmod: Final[_UFunc_Nin2_Nout1[L["fmod"], L[15], None]] = ... -frexp: Final[_UFunc_Nin1_Nout2[L["frexp"], L[4], None]] = ... +copysign: Final[_UFunc_Nin2_Nout1[L["copysign"], L[4]]] = ... +divide: Final[_UFunc_Nin2_Nout1[L["true_divide"], L[11]]] = ... +equal: Final[_UFunc_Nin2_Nout1[L["equal"], L[23]]] = ... +float_power: Final[_UFunc_Nin2_Nout1[L["float_power"], L[4]]] = ... +floor_divide: Final[_UFunc_Nin2_Nout1[L["floor_divide"], L[21]]] = ... +fmax: Final[_UFunc_Nin2_Nout1[L["fmax"], L[21]]] = ... +fmin: Final[_UFunc_Nin2_Nout1[L["fmin"], L[21]]] = ... +fmod: Final[_UFunc_Nin2_Nout1[L["fmod"], L[15]]] = ... gcd: Final[_UFunc_Nin2_Nout1[L["gcd"], L[11], L[0]]] = ... -greater: Final[_UFunc_Nin2_Nout1[L["greater"], L[23], None]] = ... -greater_equal: Final[_UFunc_Nin2_Nout1[L["greater_equal"], L[23], None]] = ... -heaviside: Final[_UFunc_Nin2_Nout1[L["heaviside"], L[4], None]] = ... +greater: Final[_UFunc_Nin2_Nout1[L["greater"], L[23]]] = ... +greater_equal: Final[_UFunc_Nin2_Nout1[L["greater_equal"], L[23]]] = ... +heaviside: Final[_UFunc_Nin2_Nout1[L["heaviside"], L[4]]] = ... hypot: Final[_UFunc_Nin2_Nout1[L["hypot"], L[5], L[0]]] = ... -invert: Final[_UFunc_Nin1_Nout1[L["invert"], L[12], None]] = ... -isfinite: Final[_UFunc_Nin1_Nout1[L["isfinite"], L[20], None]] = ... -isinf: Final[_UFunc_Nin1_Nout1[L["isinf"], L[20], None]] = ... -isnan: Final[_UFunc_Nin1_Nout1[L["isnan"], L[20], None]] = ... -isnat: Final[_UFunc_Nin1_Nout1[L["isnat"], L[2], None]] = ... -lcm: Final[_UFunc_Nin2_Nout1[L["lcm"], L[11], None]] = ... -ldexp: Final[_UFunc_Nin2_Nout1[L["ldexp"], L[8], None]] = ... -left_shift: Final[_UFunc_Nin2_Nout1[L["left_shift"], L[11], None]] = ... -less: Final[_UFunc_Nin2_Nout1[L["less"], L[23], None]] = ... -less_equal: Final[_UFunc_Nin2_Nout1[L["less_equal"], L[23], None]] = ... -log10: Final[_UFunc_Nin1_Nout1[L["log10"], L[8], None]] = ... -log1p: Final[_UFunc_Nin1_Nout1[L["log1p"], L[8], None]] = ... -log2: Final[_UFunc_Nin1_Nout1[L["log2"], L[8], None]] = ... -log: Final[_UFunc_Nin1_Nout1[L["log"], L[10], None]] = ... +lcm: Final[_UFunc_Nin2_Nout1[L["lcm"], L[11]]] = ... +ldexp: Final[_UFunc_Nin2_Nout1[L["ldexp"], L[8]]] = ... +left_shift: Final[_UFunc_Nin2_Nout1[L["left_shift"], L[11]]] = ... +less: Final[_UFunc_Nin2_Nout1[L["less"], L[23]]] = ... +less_equal: Final[_UFunc_Nin2_Nout1[L["less_equal"], L[23]]] = ... logaddexp2: Final[_UFunc_Nin2_Nout1[L["logaddexp2"], L[4], float]] = ... logaddexp: Final[_UFunc_Nin2_Nout1[L["logaddexp"], L[4], float]] = ... logical_and: Final[_UFunc_Nin2_Nout1[L["logical_and"], L[20], L[True]]] = ... -logical_not: Final[_UFunc_Nin1_Nout1[L["logical_not"], L[20], None]] = ... logical_or: Final[_UFunc_Nin2_Nout1[L["logical_or"], L[20], L[False]]] = ... logical_xor: Final[_UFunc_Nin2_Nout1[L["logical_xor"], L[19], L[False]]] = ... +maximum: Final[_UFunc_Nin2_Nout1[L["maximum"], L[21]]] = ... +minimum: Final[_UFunc_Nin2_Nout1[L["minimum"], L[21]]] = ... +mod: Final[_UFunc_Nin2_Nout1[L["remainder"], L[16]]] = ... +multiply: Final[_UFunc_Nin2_Nout1[L["multiply"], L[23], L[1]]] = ... +nextafter: Final[_UFunc_Nin2_Nout1[L["nextafter"], L[4]]] = ... +not_equal: Final[_UFunc_Nin2_Nout1[L["not_equal"], L[23]]] = ... +power: Final[_UFunc_Nin2_Nout1[L["power"], L[18]]] = ... +remainder: Final[_UFunc_Nin2_Nout1[L["remainder"], L[16]]] = ... +right_shift: Final[_UFunc_Nin2_Nout1[L["right_shift"], L[11]]] = ... +subtract: Final[_UFunc_Nin2_Nout1[L["subtract"], L[21]]] = ... +true_divide: Final[_UFunc_Nin2_Nout1[L["true_divide"], L[11]]] = ... + matmul: Final[_GUFunc_Nin2_Nout1[L["matmul"], L[19], None, L["(n?,k),(k,m?)->(n?,m?)"]]] = ... matvec: Final[_GUFunc_Nin2_Nout1[L["matvec"], L[19], None, L["(m,n),(n)->(m)"]]] = ... -maximum: Final[_UFunc_Nin2_Nout1[L["maximum"], L[21], None]] = ... -minimum: Final[_UFunc_Nin2_Nout1[L["minimum"], L[21], None]] = ... -mod: Final[_UFunc_Nin2_Nout1[L["remainder"], L[16], None]] = ... -modf: Final[_UFunc_Nin1_Nout2[L["modf"], L[4], None]] = ... -multiply: Final[_UFunc_Nin2_Nout1[L["multiply"], L[23], L[1]]] = ... -negative: Final[_UFunc_Nin1_Nout1[L["negative"], L[19], None]] = ... -nextafter: Final[_UFunc_Nin2_Nout1[L["nextafter"], L[4], None]] = ... -not_equal: Final[_UFunc_Nin2_Nout1[L["not_equal"], L[23], None]] = ... -positive: Final[_UFunc_Nin1_Nout1[L["positive"], L[19], None]] = ... -power: Final[_UFunc_Nin2_Nout1[L["power"], L[18], None]] = ... -rad2deg: Final[_UFunc_Nin1_Nout1[L["rad2deg"], L[5], None]] = ... -radians: Final[_UFunc_Nin1_Nout1[L["radians"], L[5], None]] = ... -reciprocal: Final[_UFunc_Nin1_Nout1[L["reciprocal"], L[18], None]] = ... -remainder: Final[_UFunc_Nin2_Nout1[L["remainder"], L[16], None]] = ... -right_shift: Final[_UFunc_Nin2_Nout1[L["right_shift"], L[11], None]] = ... -rint: Final[_UFunc_Nin1_Nout1[L["rint"], L[10], None]] = ... -sign: Final[_UFunc_Nin1_Nout1[L["sign"], L[19], None]] = ... -signbit: Final[_UFunc_Nin1_Nout1[L["signbit"], L[4], None]] = ... -sin: Final[_UFunc_Nin1_Nout1[L["sin"], L[9], None]] = ... -sinh: Final[_UFunc_Nin1_Nout1[L["sinh"], L[8], None]] = ... -spacing: Final[_UFunc_Nin1_Nout1[L["spacing"], L[4], None]] = ... -sqrt: Final[_UFunc_Nin1_Nout1[L["sqrt"], L[10], None]] = ... -square: Final[_UFunc_Nin1_Nout1[L["square"], L[18], None]] = ... -subtract: Final[_UFunc_Nin2_Nout1[L["subtract"], L[21], None]] = ... -tan: Final[_UFunc_Nin1_Nout1[L["tan"], L[8], None]] = ... -tanh: Final[_UFunc_Nin1_Nout1[L["tanh"], L[8], None]] = ... -true_divide: Final[_UFunc_Nin2_Nout1[L["true_divide"], L[11], None]] = ... -trunc: Final[_UFunc_Nin1_Nout1[L["trunc"], L[7], None]] = ... vecdot: Final[_GUFunc_Nin2_Nout1[L["vecdot"], L[19], None, L["(n),(n)->()"]]] = ... vecmat: Final[_GUFunc_Nin2_Nout1[L["vecmat"], L[19], None, L["(n),(n,m)->(m)"]]] = ... +frexp: Final[_UFunc_Nin1_Nout2[L["frexp"], L[4]]] = ... +modf: Final[_UFunc_Nin1_Nout2[L["modf"], L[4]]] = ... + +divmod: Final[_UFunc_Nin2_Nout2[L["divmod"], L[15]]] = ... + abs: Final = absolute acos: Final = arccos acosh: Final = arccosh @@ -5339,47 +5241,6 @@ class ndindex: def __iter__(self) -> Self: ... def __next__(self) -> _Shape: ... -@final -class broadcast: - @property - def iters(self) -> tuple[flatiter[Any], ...]: ... - @property - def index(self) -> int: ... - @property - def nd(self) -> int: ... - @property - def ndim(self) -> int: ... - @property - def numiter(self) -> int: ... - @property - def size(self) -> int: ... - @property - def shape(self) -> _Shape: ... - - # - def __new__(cls, *args: ArrayLike) -> Self: ... - - # - def __next__(self) -> tuple[Any, ...]: ... - def __iter__(self) -> Self: ... - - # - def reset(self) -> None: ... - -@final -class busdaycalendar: - @property - def weekmask(self) -> NDArray[np.bool]: ... - @property - def holidays(self) -> NDArray[datetime64]: ... - - # - def __new__( - cls, - weekmask: ArrayLike = ..., - holidays: ArrayLike | dt.date | _NestedSequence[dt.date] = ..., - ) -> busdaycalendar: ... - class finfo(Generic[_FloatingT_co]): dtype: Final[dtype[_FloatingT_co]] bits: Final[int] @@ -5431,94 +5292,6 @@ class iinfo(Generic[_IntegerT_co]): @overload def __new__(cls, dtype: str) -> iinfo[Any]: ... -@final -class nditer: - @property - def dtypes(self) -> tuple[dtype[Any], ...]: ... - @property - def shape(self) -> tuple[int, ...]: ... - @property - def ndim(self) -> int: ... - - # - @property - def finished(self) -> builtins.bool: ... - @property - def has_delayed_bufalloc(self) -> builtins.bool: ... - @property - def has_index(self) -> builtins.bool: ... - @property - def has_multi_index(self) -> builtins.bool: ... - @property - def iterationneedsapi(self) -> builtins.bool: ... - - # - @property - def nop(self) -> int: ... - @property - def index(self) -> int: ... - @property - def multi_index(self) -> tuple[int, ...]: ... - @property - def iterindex(self) -> int: ... - @property - def itersize(self) -> int: ... - @property - def iterrange(self) -> tuple[int, ...]: ... - @property - def itviews(self) -> tuple[NDArray[Any], ...]: ... - @property - def operands(self) -> tuple[NDArray[Any], ...]: ... - @property - def value(self) -> tuple[NDArray[Any], ...]: ... - - # - def __new__( - cls, - op: ArrayLike | Sequence[ArrayLike | None], - flags: Sequence[_NDIterFlagsKind] | None = ..., - op_flags: Sequence[Sequence[_NDIterFlagsOp]] | None = ..., - op_dtypes: DTypeLike | Sequence[DTypeLike] = ..., - order: _OrderKACF = ..., - casting: _CastingKind = ..., - op_axes: Sequence[Sequence[SupportsIndex]] | None = ..., - itershape: _ShapeLike | None = ..., - buffersize: SupportsIndex = ..., - ) -> nditer: ... - - # - def __enter__(self) -> Self: ... - def __exit__(self, cls: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None, /) -> None: ... - def close(self) -> None: ... - def reset(self) -> None: ... - - # - def __len__(self) -> int: ... - def __iter__(self) -> nditer: ... - def __next__(self) -> tuple[NDArray[Any], ...]: ... - def iternext(self) -> builtins.bool: ... - - # - @overload - def __getitem__(self, index: SupportsIndex, /) -> NDArray[Any]: ... - @overload - def __getitem__(self, index: slice, /) -> tuple[NDArray[Any], ...]: ... - - # - def __setitem__(self, index: slice | SupportsIndex, value: ArrayLike, /) -> None: ... - - # - def __copy__(self) -> Self: ... - def copy(self) -> nditer: ... - - # . - def debug_print(self) -> None: ... - def enable_external_loop(self) -> None: ... - - # - def remove_axis(self, i: SupportsIndex, /) -> None: ... - def remove_multi_index(self) -> None: ... - class memmap(ndarray[_ShapeT_co, _DType_co]): __array_priority__: ClassVar[float] # pyright: ignore[reportIncompatibleMethodOverride] @@ -5531,7 +5304,7 @@ class memmap(ndarray[_ShapeT_co, _DType_co]): cls, filename: StrOrBytesPath | _SupportsFileMethodsRW, dtype: type[uint8] = ..., - mode: _MemMapModeKind = ..., + mode: _ModeKindMM = ..., offset: int = ..., shape: int | tuple[int, ...] | None = ..., order: _OrderKACF = ..., @@ -5541,7 +5314,7 @@ class memmap(ndarray[_ShapeT_co, _DType_co]): cls, filename: StrOrBytesPath | _SupportsFileMethodsRW, dtype: _DTypeLike[_SCT], - mode: _MemMapModeKind = ..., + mode: _ModeKindMM = ..., offset: int = ..., shape: int | tuple[int, ...] | None = ..., order: _OrderKACF = ..., @@ -5551,7 +5324,7 @@ class memmap(ndarray[_ShapeT_co, _DType_co]): cls, filename: StrOrBytesPath | _SupportsFileMethodsRW, dtype: DTypeLike, - mode: _MemMapModeKind = ..., + mode: _ModeKindMM = ..., offset: int = ..., shape: int | tuple[int, ...] | None = ..., order: _OrderKACF = ..., @@ -5846,11 +5619,3 @@ class matrix(ndarray[_2DShapeT_co, _DType_co]): @property def H(self) -> matrix[_2D, _DType_co]: ... def getH(self) -> matrix[_2D, _DType_co]: ... - -def from_dlpack( - x: _SupportsDLPack[None], - /, - *, - device: L["cpu"] | None = None, - copy: builtins.bool | None = None, -) -> NDArray[number | np.bool]: ... diff --git a/src/numpy-stubs/_core/_multiarray_umath.pyi b/src/numpy-stubs/_core/_multiarray_umath.pyi new file mode 100644 index 00000000..5cc19cec --- /dev/null +++ b/src/numpy-stubs/_core/_multiarray_umath.pyi @@ -0,0 +1,1686 @@ +import datetime as dt +from _typeshed import Incomplete, StrOrBytesPath, SupportsLenAndGetItem +from builtins import bool as py_bool +from collections.abc import Callable, Iterable, Mapping, Sequence +from types import EllipsisType, TracebackType +from typing import ( + Any, + ClassVar, + Final, + Generic, + Literal as L, + Protocol, + SupportsIndex, + SupportsInt, + TypeAlias, + TypedDict, + final, + overload, + type_check_only, +) +from typing_extensions import CapsuleType, Self, TypeAliasType, TypeVar, Unpack + +import numpy as np +import numpy.typing as npt +from numpy import _AnyShapeT, _CastingKind, _ModeKind, _OrderCF, _OrderKACF, _SupportsBuffer, _SupportsFileMethods # noqa: ICN003 +from numpy._globals import _CopyMode +from numpy._typing import ( + _ArrayLike, + _ArrayLikeAnyString_co, + _ArrayLikeBool_co, + _ArrayLikeBytes_co, + _ArrayLikeFloat_co, + _ArrayLikeInt, + _ArrayLikeInt_co, + _ArrayLikeNumber_co, + _ArrayLikeStr_co, + _DTypeLike, + _NestedSequence, + _ScalarLike_co, + _ShapeLike, + _SupportsArrayFunc, +) +from numpy._typing._ufunc import ( + _PyFunc_Nin1P_Nout2 as _PyFunc1P2, + _PyFunc_Nin1P_Nout2P as _PyFunc1P2P, + _PyFunc_Nin1_Nout1 as _PyFunc11, + _PyFunc_Nin2_Nout1 as _PyFunc21, + _PyFunc_Nin3P_Nout1 as _PyFunc3P1, +) + +### + +_T = TypeVar("_T") +_T_contra = TypeVar("_T_contra", default=None, contravariant=True) +_T1 = TypeVar("_T1") +_T2 = TypeVar("_T2") +_IdT = TypeVar("_IdT", default=None) + +_ShapeT = TypeVar("_ShapeT", bound=tuple[int, ...]) +_ShapeT0 = TypeVar("_ShapeT0", bound=tuple[int, ...], default=tuple[int, ...]) + +_ScalarT = TypeVar("_ScalarT", bound=np.generic) +_ScalarT0 = TypeVar("_ScalarT0", bound=np.generic, default=Any) +_NumericT = TypeVar("_NumericT", bound=np.bool | np.number | np.timedelta64 | np.object_) +_SafeScalarT = TypeVar("_SafeScalarT", bound=np.bool | np.number | np.flexible | np.timedelta64 | np.datetime64) # not `object_` + +_DTypeT = TypeVar("_DTypeT", bound=np.dtype[Any]) + +_ArrayT = TypeVar("_ArrayT", bound=_Array) +_Array1T = TypeVar("_Array1T", bound=_Array[Any, tuple[int, Unpack[tuple[int, ...]]]]) +_Array2T = TypeVar("_Array2T", bound=_Array[Any, tuple[int, int, Unpack[tuple[int, ...]]]]) +_ArrayT_co = TypeVar("_ArrayT_co", bound=_Array, default=_Array, covariant=True) + +### + +_FlagWrite: TypeAlias = L[ + "A", "ALIGNED", + "W", "WRITEABLE", + "X", "WRITEBACKIFCOPY", +] # fmt: skip +_FlagRead: TypeAlias = L[ + "C", "CONTIGUOUS", "C_CONTIGUOUS", + "F", "FORTRAN", "F_CONTIGUOUS", + "B", "BEHAVED", + "O", "OWNDATA", + "CA", "CARRAY", + "FA", "FARRAY", + "FNC", "FORC", + _FlagWrite, +] # fmt: skip + +_IterFlag: TypeAlias = L[ + "buffered", + "c_index", + "f_index", + "multi_index", + "common_dtype", + "copy_if_overlap", + "delay_bufalloc", + "external_loop", + "grow_inner", + "growinner", + "ranged", + "refs_ok", + "reduce_ok", + "zerosize_ok", +] +_IterFlagOp: TypeAlias = L[ + "readonly", "writeonly", "readwrite", + "no_broadcast", + "config", + "aligned", + "nbo", + "copy", "updateifcopy", + "allocate", + "no_subtype", + "arraymask", "writemasked", + "overlap_assume_elementwise", + "virtual", # undocumented +] # fmt: skip + +_Array = TypeAliasType("_Array", np.ndarray[_ShapeT0, np.dtype[_ScalarT0]], type_params=(_ScalarT0, _ShapeT0)) +_Array1D = TypeAliasType("_Array1D", np.ndarray[tuple[int], np.dtype[_ScalarT0]], type_params=(_ScalarT0,)) + +_FloatType: TypeAlias = type[_HasClass[float]] + +_FlatIterIndex0: TypeAlias = int | np.integer +_FlatIterIndex: TypeAlias = _FlatIterIndex0 | tuple[_FlatIterIndex0] +_FlatIterSlice0: TypeAlias = slice | EllipsisType | _ArrayLikeInt +_FlatIterSlice: TypeAlias = _FlatIterSlice0 | tuple[_FlatIterSlice0] + +_Device: TypeAlias = L["cpu"] +_Roll = TypeAliasType( + "_Roll", + L["raise", "nat", "forward", "backward", "preceding", "following", "modifiedfollowing", "modifiedpreceding"], +) +_TimeUnit: TypeAlias = L["Y", "M", "D", "h", "m", "s", "ms", "us", "μs", "ns", "ps", "fs", "as"] +_TimeZone: TypeAlias = L["naive", "UTC", "local"] | dt.tzinfo +_CorrMode: TypeAlias = L[0, "valid", 1, "same", 2, "full"] + +_Copy: TypeAlias = py_bool | L[2] | _CopyMode +_WeekMask: TypeAlias = str | Sequence[L[0, 1] | py_bool | np.bool] + +_ToInt: TypeAlias = int | np.integer | np.bool +_ToDT64: TypeAlias = np.datetime64[Any] | _ToInt +_ToTD64: TypeAlias = np.timedelta64[Any] | _ToInt +_ToFloat: TypeAlias = float | np.floating | np.integer | np.bool +_ToComplex: TypeAlias = complex | np.number | np.bool + +_ToDate: TypeAlias = _ToDT64 | dt.date | str # accepts strings like "1993-06-29" +_ToDelta: TypeAlias = ( + np.timedelta64[Any] | SupportsIndex | SupportsInt | dt.timedelta | str +) # accepts same strings as `builtins.int` +_ToDateArray = TypeAliasType( + "_ToDateArray", + _ArrayLike[np.datetime64[Any] | np.floating | np.integer | np.character] + | _NestedSequence[_ToDT64 | dt.date] + | _NestedSequence[str], +) +_ToDeltaArray = TypeAliasType( + "_ToDeltaArray", + _ArrayLike[np.timedelta64[Any] | np.integer] | _NestedSequence[_ToDelta], +) + +_ToFile: TypeAlias = StrOrBytesPath | _SupportsFileMethods + +_3P = TypeAliasType("_3P", L[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]) +_2: TypeAlias = L[2] +_2P: TypeAlias = _2 | _3P +_1: TypeAlias = L[True, 1] +_1P: TypeAlias = _1 | _2P + +### + +@type_check_only +class _CanArray(Protocol[_ArrayT_co]): + def __array__(self, /) -> _ArrayT_co: ... + +@type_check_only +class _CanDLPack(Protocol[_T_contra]): + def __dlpack__(self, /, *, stream: _T_contra | None = None) -> CapsuleType: ... + +@type_check_only +class _HasDoc(Protocol): + __doc__: str | None + +@type_check_only +@final +class _HasClass(Protocol[_T]): + @property # type: ignore[override] + def __class__(self, /) -> type[_T]: ... # pyright: ignore[reportIncompatibleMethodOverride] + @__class__.setter + def __class__(self, t: type[_T], /) -> None: ... + +### + +@type_check_only +class _KwargsD(TypedDict, total=False): + device: _Device | None + +@type_check_only +class _KwargsL(TypedDict, total=False): + like: _SupportsArrayFunc | None + +@type_check_only +class _KwargsCL(TypedDict, total=False): + copy: _Copy | None + like: _SupportsArrayFunc | None + +@type_check_only +class _KwargsDL(TypedDict, total=False): + device: _Device | None + like: _SupportsArrayFunc | None + +@type_check_only +class _KwargsDCL(TypedDict, total=False): + device: _Device | None + copy: _Copy | None + like: _SupportsArrayFunc | None + +### + +__version__: Final[str] = ... + +DATETIMEUNITS: Final[CapsuleType] = ... +_ARRAY_API: Final[CapsuleType] = ... +_UFUNC_API: Final[CapsuleType] = ... + +ALLOW_THREADS: Final = 1 +BUFSIZE: Final = 8_192 + +CLIP: Final = 0 +ITEM_HASOBJECT: Final = 1 +LIST_PICKLE: Final = 2 +ITEM_IS_POINTER: Final = 4 +NEEDS_INIT: Final = 8 +NEEDS_PYAPI: Final = 16 +USE_GETITEM: Final = 32 +USE_SETITEM: Final = 64 + +RAISE: Final = 2 +WRAP: Final = 1 + +MAXDIMS: Final = 64 + +MAY_SHARE_BOUNDS: Final = 0 +MAY_SHARE_EXACT: Final = -1 + +FPE_DIVIDEBYZERO: Final = 1 +FPE_OVERFLOW: Final = 2 +FPE_UNDERFLOW: Final = 4 +FPE_INVALID: Final = 8 + +FLOATING_POINT_SUPPORT: Final = 1 + +UFUNC_PYVALS_NAME: Final = "UFUNC_PYVALS" +UFUNC_BUFSIZE_DEFAULT: Final = 8192 + +PINF: Final[float] = ... +NINF: Final[float] = ... +PZERO: Final = 0.0 +NZERO: Final = -0.0 +NAN: Final[float] = ... + +### + +error: Final = Exception + +tracemalloc_domain: Final[int] = ... + +__cpu_baseline__: Final[list[str]] = ... +__cpu_dispatch__: Final[list[str]] = ... +__cpu_features__: Final[dict[str, bool]] = ... +__cpu_targets_info__: Final[dict[str, dict[str, dict[str, str]]]] = ... + +_flagdict: Final[dict[str, int]] = ... +typeinfo: Final[dict[str, np.dtype[Any]]] = ... + +e: Final[float] = ... +euler_gamma: Final[float] = ... +pi: Final[float] = ... + +# +_arg: np.ufunc +_center: np.ufunc +_expandtabs: np.ufunc +_expandtabs_length: np.ufunc +_ljust: np.ufunc +_lstrip_chars: np.ufunc +_lstrip_whitespace: np.ufunc +_ones_like: np.ufunc +_partition: np.ufunc +_partition_index: np.ufunc +_replace: np.ufunc +_rjust: np.ufunc +_rpartition: np.ufunc +_rpartition_index: np.ufunc +_rstrip_chars: np.ufunc +_rstrip_whitespace: np.ufunc +_strip_chars: np.ufunc +_strip_whitespace: np.ufunc +_zfill: np.ufunc +# +clip: np.ufunc +count: np.ufunc +endswith: np.ufunc +find: np.ufunc +index: np.ufunc +isalnum: np.ufunc +isalpha: np.ufunc +isdecimal: np.ufunc +isdigit: np.ufunc +islower: np.ufunc +isnumeric: np.ufunc +isspace: np.ufunc +istitle: np.ufunc +isupper: np.ufunc +rfind: np.ufunc +rindex: np.ufunc +startswith: np.ufunc +str_len: np.ufunc + +@final +class flagsobj: + __hash__: ClassVar[None] # type: ignore[assignment] # pyright: ignore[reportIncompatibleMethodOverride] + aligned: bool + writeable: bool + writebackifcopy: bool + @property + def behaved(self) -> bool: ... + @property + def c_contiguous(self) -> bool: ... + @property + def carray(self) -> bool: ... + @property + def contiguous(self) -> bool: ... + @property + def f_contiguous(self) -> bool: ... + @property + def farray(self) -> bool: ... + @property + def fnc(self) -> bool: ... + @property + def forc(self) -> bool: ... + @property + def fortran(self) -> bool: ... + @property + def num(self) -> int: ... + @property + def owndata(self) -> bool: ... + def __getitem__(self, key: _FlagRead, /) -> bool: ... + def __setitem__(self, key: _FlagWrite, value: bool, /) -> None: ... + +### + +@final +class broadcast: + @property + def iters(self) -> tuple[flatiter[Any], ...]: ... + @property + def index(self) -> int: ... + @property + def nd(self) -> int: ... + @property + def ndim(self) -> int: ... + @property + def numiter(self) -> int: ... + @property + def size(self) -> int: ... + @property + def shape(self) -> tuple[int, ...]: ... + + # + def __new__(cls, *args: npt.ArrayLike) -> Self: ... + + # + def __next__(self) -> tuple[Any, ...]: ... + def __iter__(self) -> Self: ... + + # + def reset(self) -> None: ... + +@final +class flatiter(Generic[_ArrayT_co]): + __hash__: ClassVar[None] = None # type: ignore[assignment] # pyright: ignore[reportIncompatibleMethodOverride] + + @property + def base(self) -> _ArrayT_co: ... + @property + def coords(self) -> tuple[int, ...]: ... + @property + def index(self) -> int: ... + + # + def copy(self) -> _ArrayT_co: ... + + # + def __len__(self) -> int: ... + def __iter__(self) -> Self: ... + def __next__(self: flatiter[_Array[_ScalarT]]) -> _ScalarT: ... + + # + @overload + def __getitem__(self: flatiter[_Array[_SafeScalarT]], i: _FlatIterIndex, /) -> _SafeScalarT: ... + @overload + def __getitem__(self: flatiter[_Array[np.object_]], i: _FlatIterIndex, /) -> Any: ... + @overload + def __getitem__(self, i: _FlatIterSlice, /) -> _ArrayT_co: ... + def __setitem__(self, i: _FlatIterIndex | _FlatIterSlice, value: object, /) -> None: ... + + # + @overload + def __array__(self: flatiter[_Array[_ScalarT]], dtype: None = None, /) -> _Array1D[_ScalarT]: ... + @overload + def __array__(self, dtype: _DTypeLike[_ScalarT], /) -> _Array1D[_ScalarT]: ... + @overload + def __array__(self, dtype: npt.DTypeLike | None = None, /) -> _Array1D: ... + +@final +class nditer: + @property + def dtypes(self) -> tuple[np.dtype[Any], ...]: ... + @property + def shape(self) -> tuple[int, ...]: ... + @property + def ndim(self) -> int: ... + + # + @property + def finished(self) -> py_bool: ... + @property + def has_delayed_bufalloc(self) -> py_bool: ... + @property + def has_index(self) -> py_bool: ... + @property + def has_multi_index(self) -> py_bool: ... + @property + def iterationneedsapi(self) -> py_bool: ... + + # + @property + def nop(self) -> int: ... + @property + def index(self) -> int: ... + @property + def multi_index(self) -> tuple[int, ...]: ... + @property + def iterindex(self) -> int: ... + @property + def itersize(self) -> int: ... + @property + def iterrange(self) -> tuple[int, ...]: ... + @property + def itviews(self) -> tuple[_Array, ...]: ... + @property + def operands(self) -> tuple[_Array, ...]: ... + @property + def value(self) -> tuple[_Array, ...]: ... + + # + def __init__( + self, + /, + op: Sequence[npt.ArrayLike | None] | npt.ArrayLike, + flags: Sequence[_IterFlag] | None = None, + op_flags: Sequence[Sequence[_IterFlagOp]] | None = None, + op_dtypes: Sequence[npt.DTypeLike] | npt.DTypeLike = None, + order: _OrderKACF = "K", + casting: _CastingKind = "safe", + op_axes: Sequence[Sequence[SupportsIndex]] | None = None, + itershape: _ShapeLike | None = None, + buffersize: SupportsIndex = 0, + ) -> None: ... + + # + def __enter__(self) -> Self: ... + def __exit__(self, cls: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None, /) -> None: ... + def close(self) -> None: ... + def reset(self) -> None: ... + + # + def __len__(self) -> int: ... + def __iter__(self) -> Self: ... + def __next__(self) -> tuple[_Array, ...]: ... + def iternext(self) -> py_bool: ... + + # + @overload + def __getitem__(self, index: SupportsIndex, /) -> _Array: ... + @overload + def __getitem__(self, index: slice, /) -> tuple[_Array, ...]: ... + def __setitem__(self, index: slice | SupportsIndex, value: npt.ArrayLike, /) -> None: ... + + # + def __copy__(self) -> Self: ... + def copy(self) -> nditer: ... + + # . + def debug_print(self) -> None: ... + def enable_external_loop(self) -> None: ... + + # + def remove_axis(self, i: SupportsIndex, /) -> None: ... + def remove_multi_index(self) -> None: ... + +def nested_iters( + op: Sequence[npt.ArrayLike] | npt.ArrayLike, + axes: Sequence[Sequence[SupportsIndex]], + flags: Sequence[_IterFlag] | None = None, + op_flags: Sequence[Sequence[_IterFlagOp]] | None = None, + op_dtypes: Sequence[npt.DTypeLike] | npt.DTypeLike = None, + order: _OrderKACF = "K", + casting: _CastingKind = "safe", + buffersize: SupportsIndex = 0, +) -> tuple[nditer, ...]: ... + +### + +# +def set_datetimeparse_function(*args: Incomplete, **kwargs: Incomplete) -> None: ... +def set_typeDict(dict: Mapping[str, np.dtype[Any]]) -> None: ... + +# +def get_handler_name(a: _Array = ..., /) -> str | None: ... +def get_handler_version(a: _Array = ..., /) -> int | None: ... + +### + +# keep in sync with `zeros` and `numpy._core.numeric.ones` +@overload # 1d +def empty( + shape: int | tuple[int], + dtype: _FloatType | None = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[np.float64]: ... +@overload +def empty( + shape: int | tuple[int], + dtype: _DTypeLike[_ScalarT], + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[_ScalarT]: ... +@overload +def empty( + shape: int | tuple[int], + dtype: npt.DTypeLike = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array1D: ... +@overload # known shape +def empty( + shape: _AnyShapeT, + dtype: _FloatType | None = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[np.float64, _AnyShapeT]: ... +@overload +def empty( + shape: _AnyShapeT, + dtype: _DTypeLike[_ScalarT], + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[_ScalarT, _AnyShapeT]: ... +@overload +def empty( + shape: _AnyShapeT, + dtype: npt.DTypeLike = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[Any, _AnyShapeT]: ... +@overload # unknown shape +def empty( + shape: _ShapeLike, + dtype: _FloatType | None = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[np.float64]: ... +@overload +def empty( + shape: _ShapeLike, + dtype: _DTypeLike[_ScalarT], + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[_ScalarT]: ... +@overload +def empty( + shape: _ShapeLike, + dtype: npt.DTypeLike = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array: ... + +# keep in sync with `empty` (below) and `numpy._core.numeric.ones` +@overload # 1d +def zeros( + shape: int | tuple[int], + dtype: _FloatType | None = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[np.float64]: ... +@overload +def zeros( + shape: int | tuple[int], + dtype: _DTypeLike[_ScalarT], + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[_ScalarT]: ... +@overload +def zeros( + shape: int | tuple[int], + dtype: npt.DTypeLike = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array1D: ... +@overload # known shape +def zeros( + shape: _AnyShapeT, + dtype: _FloatType | None = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[np.float64, _AnyShapeT]: ... +@overload +def zeros( + shape: _AnyShapeT, + dtype: _DTypeLike[_ScalarT], + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[_ScalarT, _AnyShapeT]: ... +@overload +def zeros( + shape: _AnyShapeT, + dtype: npt.DTypeLike = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[Any, _AnyShapeT]: ... +@overload # unknown shape +def zeros( + shape: _ShapeLike, + dtype: _FloatType | None = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[np.float64]: ... +@overload +def zeros( + shape: _ShapeLike, + dtype: _DTypeLike[_ScalarT], + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[_ScalarT]: ... +@overload +def zeros( + shape: _ShapeLike, + dtype: npt.DTypeLike = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array: ... + +# +@overload +def empty_like( + prototype: _ArrayT, + dtype: None = None, + order: _OrderKACF = "K", + subok: L[True] = True, + shape: _ShapeLike | None = None, + **kwargs: Unpack[_KwargsD], +) -> _ArrayT: ... +@overload +def empty_like( + prototype: _CanArray[np.ndarray[_ShapeT, _DTypeT]], + dtype: None = None, + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, + **kwargs: Unpack[_KwargsD], +) -> np.ndarray[_ShapeT, _DTypeT]: ... +@overload +def empty_like( + prototype: _ArrayLike[_ScalarT], + dtype: None = None, + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, + **kwargs: Unpack[_KwargsD], +) -> _Array[_ScalarT]: ... +@overload +def empty_like( + prototype: object, + dtype: _DTypeLike[_ScalarT], + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, + **kwargs: Unpack[_KwargsD], +) -> _Array[_ScalarT]: ... +@overload +def empty_like( + prototype: object, + dtype: npt.DTypeLike | None = None, + order: _OrderKACF = "K", + subok: bool = True, + shape: _ShapeLike | None = None, + **kwargs: Unpack[_KwargsD], +) -> _Array: ... + +# +@overload +def array( + object: _ArrayT, + dtype: None = None, + *, + order: _OrderKACF = "K", + subok: L[True], + ndmin: L[0] = 0, + **kwargs: Unpack[_KwargsCL], +) -> _ArrayT: ... +@overload +def array( + object: _Array1T, + dtype: None = None, + *, + order: _OrderKACF = "K", + subok: L[True], + ndmin: L[0, 1] = 0, + **kwargs: Unpack[_KwargsCL], +) -> _Array1T: ... +@overload +def array( + object: _Array2T, + dtype: None = None, + *, + order: _OrderKACF = "K", + subok: L[True], + ndmin: L[0, 1, 2] = 0, + **kwargs: Unpack[_KwargsCL], +) -> _Array2T: ... +@overload +def array( + object: _CanArray[np.ndarray[_ShapeT, _DTypeT]], + dtype: None = None, + *, + order: _OrderKACF = "K", + subok: bool = False, + ndmin: L[0] = 0, + **kwargs: Unpack[_KwargsCL], +) -> np.ndarray[_ShapeT, _DTypeT]: ... +@overload +def array( + object: _ArrayLike[_ScalarT], + dtype: None = None, + *, + order: _OrderKACF = "K", + subok: bool = False, + ndmin: int = 0, + **kwargs: Unpack[_KwargsCL], +) -> _Array[_ScalarT]: ... +@overload +def array( + object: _ScalarLike_co, + dtype: _DTypeLike[_ScalarT], + *, + order: _OrderKACF = "K", + subok: bool = False, + ndmin: L[0] = 0, + **kwargs: Unpack[_KwargsCL], +) -> _Array[_ScalarT, tuple[()]]: ... +@overload +def array( + object: _ScalarLike_co, + dtype: npt.DTypeLike | None, + *, + order: _OrderKACF = "K", + subok: bool = False, + ndmin: L[0] = 0, + **kwargs: Unpack[_KwargsCL], +) -> _Array[Any, tuple[()]]: ... +@overload +def array( + object: object, + dtype: _DTypeLike[_ScalarT], + *, + order: _OrderKACF = "K", + subok: bool = False, + ndmin: int = 0, + **kwargs: Unpack[_KwargsCL], +) -> _Array[_ScalarT]: ... +@overload +def array( + object: object, + dtype: npt.DTypeLike | None = None, + *, + order: _OrderKACF = "K", + subok: bool = False, + ndmin: int = 0, + **kwargs: Unpack[_KwargsCL], +) -> _Array: ... + +# +@overload +def asarray( + a: _CanArray[np.ndarray[_ShapeT, _DTypeT]], + dtype: None = None, + order: _OrderKACF = None, + **kwargs: Unpack[_KwargsDCL], +) -> np.ndarray[_ShapeT, _DTypeT]: ... +@overload +def asarray( + a: _ArrayLike[_ScalarT], + dtype: None = None, + order: _OrderKACF = None, + **kwargs: Unpack[_KwargsDCL], +) -> _Array[_ScalarT]: ... +@overload +def asarray( + a: _ScalarLike_co, + dtype: _DTypeLike[_ScalarT], + order: _OrderKACF = None, + **kwargs: Unpack[_KwargsDCL], +) -> _Array[_ScalarT, tuple[()]]: ... +@overload +def asarray( + a: _ScalarLike_co, + dtype: npt.DTypeLike | None = None, + order: _OrderKACF = None, + **kwargs: Unpack[_KwargsDCL], +) -> _Array[Any, tuple[()]]: ... +@overload +def asarray( + a: object, + dtype: _DTypeLike[_ScalarT], + order: _OrderKACF = None, + **kwargs: Unpack[_KwargsDCL], +) -> _Array[_ScalarT]: ... +@overload +def asarray( + a: object, + dtype: npt.DTypeLike | None = None, + order: _OrderKACF = None, + **kwargs: Unpack[_KwargsDCL], +) -> _Array: ... + +# +@overload +def asanyarray( + a: _ArrayT, + dtype: None = None, + order: _OrderKACF = None, + **kwargs: Unpack[_KwargsDCL], +) -> _ArrayT: ... +@overload +def asanyarray( + a: _CanArray[_ArrayT], + dtype: None = None, + order: _OrderKACF = None, + **kwargs: Unpack[_KwargsDCL], +) -> _ArrayT: ... +@overload +def asanyarray( + a: _ArrayLike[_ScalarT], + dtype: None = None, + order: _OrderKACF = None, + **kwargs: Unpack[_KwargsDCL], +) -> _Array[_ScalarT]: ... +@overload +def asanyarray( + a: object, + dtype: _DTypeLike[_ScalarT], + order: _OrderKACF = None, + **kwargs: Unpack[_KwargsDCL], +) -> _Array[_ScalarT]: ... +@overload +def asanyarray( + a: object, + dtype: npt.DTypeLike | None = None, + order: _OrderKACF = None, + **kwargs: Unpack[_KwargsDCL], +) -> _Array: ... + +# keep in sync with asfortranarray +@overload +def ascontiguousarray( + a: _CanArray[_Array[_ScalarT, _ShapeT]], + dtype: None = None, + **kwargs: Unpack[_KwargsL], +) -> _Array[_ScalarT, _ShapeT]: ... +@overload +def ascontiguousarray(a: _ArrayLike[_ScalarT], dtype: None = None, **kwargs: Unpack[_KwargsL]) -> _Array[_ScalarT]: ... +@overload +def ascontiguousarray(a: object, dtype: None = None, *, like: _Array[_ScalarT]) -> _Array[_ScalarT]: ... +@overload +def ascontiguousarray(a: object, dtype: _DTypeLike[_ScalarT], **kwargs: Unpack[_KwargsL]) -> _Array[_ScalarT]: ... +@overload +def ascontiguousarray(a: object, dtype: npt.DTypeLike | None = None, **kwargs: Unpack[_KwargsL]) -> _Array: ... + +# keep in sync with ascontiguousarray +@overload +def asfortranarray( + a: _CanArray[_Array[_ScalarT, _ShapeT]], + dtype: None = None, + **kwargs: Unpack[_KwargsL], +) -> _Array[_ScalarT, _ShapeT]: ... +@overload +def asfortranarray(a: _ArrayLike[_ScalarT], dtype: None = None, **kwargs: Unpack[_KwargsL]) -> _Array[_ScalarT]: ... +@overload +def asfortranarray(a: object, dtype: None = None, *, like: _Array[_ScalarT]) -> _Array[_ScalarT]: ... +@overload +def asfortranarray(a: object, dtype: _DTypeLike[_ScalarT], **kwargs: Unpack[_KwargsL]) -> _Array[_ScalarT]: ... +@overload +def asfortranarray(a: object, dtype: npt.DTypeLike | None = None, **kwargs: Unpack[_KwargsL]) -> _Array: ... + +# `sep` is a de facto mandatory argument, as its default value is deprecated +@overload +def fromstring( + string: str | bytes, + dtype: _FloatType | None = ..., + count: SupportsIndex = -1, + *, + sep: str, + **kwargs: Unpack[_KwargsL], +) -> _Array[np.float64]: ... +@overload +def fromstring( + string: str | bytes, + dtype: _DTypeLike[_ScalarT], + count: SupportsIndex = -1, + *, + sep: str, + **kwargs: Unpack[_KwargsL], +) -> _Array[_ScalarT]: ... +@overload +def fromstring( + string: str | bytes, + dtype: npt.DTypeLike = ..., + count: SupportsIndex = -1, + *, + sep: str, + like: _Array[_ScalarT], +) -> _Array[_ScalarT]: ... +@overload +def fromstring( + string: str | bytes, + dtype: npt.DTypeLike, + count: SupportsIndex = -1, + *, + sep: str, + **kwargs: Unpack[_KwargsL], +) -> _Array: ... + +# +@overload +def fromfile( + file: _ToFile, + *, + count: SupportsIndex = -1, + sep: str = "", + offset: SupportsIndex = 0, + **kwargs: Unpack[_KwargsL], +) -> _Array[np.float64]: ... +@overload +def fromfile( + file: _ToFile, + dtype: _DTypeLike[_ScalarT], + count: SupportsIndex = -1, + sep: str = "", + offset: SupportsIndex = 0, + **kwargs: Unpack[_KwargsL], +) -> _Array[_ScalarT]: ... +@overload +def fromfile( + file: _ToFile, + dtype: npt.DTypeLike, + count: SupportsIndex = -1, + sep: str = "", + offset: SupportsIndex = 0, + **kwargs: Unpack[_KwargsL], +) -> _Array: ... + +# +@overload +def fromiter( + iter: Iterable[object], + dtype: _DTypeLike[_ScalarT], + count: SupportsIndex = -1, + **kwargs: Unpack[_KwargsL], +) -> _Array[_ScalarT]: ... +@overload +def fromiter( + iter: Iterable[object], + dtype: npt.DTypeLike, + count: SupportsIndex = -1, + **kwargs: Unpack[_KwargsL], +) -> _Array: ... + +# +@overload +def frombuffer( + buffer: _SupportsBuffer, + *, + count: SupportsIndex = -1, + offset: SupportsIndex = 0, + **kwargs: Unpack[_KwargsL], +) -> _Array[np.float64]: ... +@overload +def frombuffer( + buffer: _SupportsBuffer, + dtype: _DTypeLike[_ScalarT], + count: SupportsIndex = -1, + offset: SupportsIndex = 0, + **kwargs: Unpack[_KwargsL], +) -> _Array[_ScalarT]: ... +@overload +def frombuffer( + buffer: _SupportsBuffer, + dtype: npt.DTypeLike, + count: SupportsIndex = -1, + offset: SupportsIndex = 0, + **kwargs: Unpack[_KwargsL], +) -> _Array: ... + +# +def from_dlpack(x: _CanDLPack, /, *, copy: py_bool | None = None, **kwargs: Unpack[_KwargsD]) -> _Array: ... + +### + +# +@overload # (stop, dtype=_) +def arange(stop: object, *, dtype: _DTypeLike[_ScalarT], **kwargs: Unpack[_KwargsDL]) -> _Array1D[_ScalarT]: ... +@overload # (start, stop step, dtype) +def arange( + start: object, + stop: object, + step: object, + dtype: _DTypeLike[_ScalarT], + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[_ScalarT]: ... +@overload # (start, stop, step?, dtype=) +def arange( + start: object, + stop: object, + step: object = ..., + *, + dtype: _DTypeLike[_ScalarT], + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[_ScalarT]: ... +@overload # (stop: int) +def arange( + stop: int | np.int_, + *, + dtype: _DTypeLike[np.int_] | type[int] | None = None, + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[np.int_]: ... +@overload # (start: int, stop: int, step?: int) +def arange( + start: int | np.int_, + stop: int | np.int_, + step: int | np.int_ = ..., + dtype: _DTypeLike[np.int_] | type[int] | None = None, + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[np.int_]: ... +@overload # (stop: float) +def arange( + stop: float | np.float64, + *, + dtype: _DTypeLike[np.float64] | type[float] | None = None, + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[np.float64 | np.int_]: ... +@overload # (start: float, stop: float, step?: float) +def arange( + start: float | np.float64, + stop: float | np.float64, + step: float | np.float64 = ..., + dtype: _DTypeLike[np.float64] | type[float] | None = None, + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[np.float64 | np.int_]: ... +@overload # int-like +def arange( + stop: _ToInt, + *, + dtype: None = None, + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[np.signedinteger]: ... +@overload # int-like +def arange( + start: _ToInt, + stop: _ToInt, + step: _ToInt = ..., + dtype: None = None, + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[np.signedinteger]: ... +@overload # float-like +def arange( + stop: _ToFloat, + *, + dtype: None = None, + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[np.floating | np.signedinteger]: ... +@overload # float-like +def arange( + start: _ToFloat, + stop: _ToFloat, + step: _ToFloat = ..., + dtype: None = None, + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[np.floating | np.signedinteger]: ... +@overload # timedelta64 +def arange( + stop: np.timedelta64, + *, + dtype: None = None, + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[np.timedelta64]: ... +@overload # timedelta64 +def arange( + start: _ToTD64, + stop: np.timedelta64, + step: _ToTD64 = ..., + dtype: None = None, + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[np.timedelta64]: ... +@overload # timedelta64 +def arange( + start: np.timedelta64, + stop: _ToTD64, + step: _ToTD64 = ..., + dtype: None = None, + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[np.timedelta64]: ... +@overload # datetime64 (requires both start and stop) +def arange( + start: np.datetime64, + stop: np.datetime64, + step: _ToDT64 = ..., + dtype: None = None, + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[np.datetime64]: ... +@overload # fallback +def arange( + stop: object, + *, + dtype: npt.DTypeLike, + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[Any]: ... +@overload # fallback +def arange( + start: object, + stop: object, + step: object = ..., + dtype: npt.DTypeLike | None = None, + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[Any]: ... + +### + +# +@overload +def concatenate( + arrays: _ArrayLike[_ScalarT], + /, + axis: SupportsIndex | None = 0, + out: None = None, + *, + dtype: None = None, + casting: _CastingKind = "same_kind", +) -> _Array[_ScalarT]: ... +@overload +def concatenate( + arrays: SupportsLenAndGetItem[_ArrayLike[_ScalarT]], + /, + axis: SupportsIndex | None = 0, + out: None = None, + *, + dtype: None = None, + casting: _CastingKind = "same_kind", +) -> _Array[_ScalarT]: ... +@overload +def concatenate( + arrays: SupportsLenAndGetItem[npt.ArrayLike], + /, + axis: SupportsIndex | None, + out: _ArrayT, + *, + dtype: None = None, + casting: _CastingKind = "same_kind", +) -> _ArrayT: ... +@overload +def concatenate( + arrays: SupportsLenAndGetItem[npt.ArrayLike], + /, + axis: SupportsIndex | None = 0, + *, + out: _ArrayT, + dtype: None = None, + casting: _CastingKind = "same_kind", +) -> _ArrayT: ... +@overload +def concatenate( + arrays: SupportsLenAndGetItem[npt.ArrayLike], + /, + axis: SupportsIndex | None = 0, + out: None = None, + *, + dtype: _DTypeLike[_ScalarT], + casting: _CastingKind = "same_kind", +) -> _Array[_ScalarT]: ... +@overload +def concatenate( + arrays: SupportsLenAndGetItem[npt.ArrayLike], + /, + axis: SupportsIndex | None = 0, + out: None = None, + *, + dtype: npt.DTypeLike | None = None, + casting: _CastingKind = "same_kind", +) -> _Array: ... + +# +def unpackbits( + a: _Array[np.uint8], + /, + axis: SupportsIndex | None = None, + count: SupportsIndex | None = None, + bitorder: L["big", "little"] = "big", +) -> _Array[np.uint8]: ... + +# +def packbits( + a: _ArrayLikeInt_co, + /, + axis: SupportsIndex | None = None, + bitorder: L["big", "little"] = "big", +) -> _Array[np.uint8]: ... + +# +def copyto( + dst: _Array, + src: npt.ArrayLike, + casting: _CastingKind = "same_kind", + where: _ArrayLikeBool_co | None = True, +) -> None: ... + +# +@overload +def where(condition: npt.ArrayLike, /) -> tuple[_Array[np.int_], ...]: ... +@overload +def where(condition: npt.ArrayLike, x: _ArrayLike[_ScalarT], y: _ArrayLike[_ScalarT], /) -> _Array[_ScalarT]: ... +@overload +def where(condition: npt.ArrayLike, x: npt.ArrayLike, y: npt.ArrayLike, /) -> _Array: ... + +# +def putmask(a: _Array, /, mask: _ArrayLikeBool_co, values: npt.ArrayLike) -> None: ... + +# +@overload +def unravel_index(indices: _ToInt, shape: _ShapeLike, order: _OrderCF = "C") -> tuple[np.intp, ...]: ... +@overload +def unravel_index( + indices: _ArrayLike[np.integer] | _NestedSequence[_ToInt] | _NestedSequence[_ArrayLike[np.integer]], + shape: _ShapeLike, + order: _OrderCF = "C", +) -> tuple[_Array[np.intp], ...]: ... + +# +@overload +def ravel_multi_index( + multi_index: Sequence[_ToInt], + dims: _ShapeLike, + mode: _ModeKind | tuple[_ModeKind, ...] = "raise", + order: _OrderCF = "C", +) -> np.intp: ... +@overload +def ravel_multi_index( + multi_index: Sequence[_ArrayLike[np.integer] | _NestedSequence[np.integer | int]], + dims: _ShapeLike, + mode: _ModeKind | tuple[_ModeKind, ...] = "raise", + order: _OrderCF = "C", +) -> _Array[np.intp]: ... + +### + +# +def shares_memory(a: object, b: object, /, max_work: L[0, 1] | None = None) -> bool: ... +def may_share_memory(a: object, b: object, /, max_work: L[0, 1] | None = None) -> bool: ... +def can_cast(from_: npt.ArrayLike | npt.DTypeLike, to: npt.DTypeLike, casting: _CastingKind = "safe") -> bool: ... + +# +def min_scalar_type(a: npt.ArrayLike, /) -> np.dtype[Any]: ... +def result_type(*arrays_and_dtypes: npt.ArrayLike | npt.DTypeLike) -> np.dtype[Any]: ... +def promote_types(type1: npt.DTypeLike, type2: npt.DTypeLike, /) -> np.dtype[Any]: ... + +# +@overload +def dot(a: npt.ArrayLike, b: npt.ArrayLike, out: None = None) -> Any: ... +@overload +def dot(a: npt.ArrayLike, b: npt.ArrayLike, out: _ArrayT) -> _ArrayT: ... + +# +@overload +def vdot(a: _ArrayLike[_NumericT], b: _ArrayLike[_NumericT], /) -> _NumericT: ... # type: ignore[overload-overlap] # false positive +@overload +def vdot(a: _ArrayLikeInt_co, b: _ArrayLikeInt_co, /) -> np.signedinteger: ... +@overload +def vdot(a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, /) -> np.floating | np.signedinteger: ... +@overload +def vdot(a: _ArrayLikeNumber_co, b: _ArrayLikeNumber_co, /) -> np.inexact | np.signedinteger: ... + +# TODO(jorenham): https://github.com/numpy/numtype/issues/117 +def inner(a: npt.ArrayLike, b: npt.ArrayLike, /) -> Incomplete: ... + +# +@overload +def interp( + x: _ToFloat, + xp: _ArrayLikeFloat_co, + fp: _ArrayLikeFloat_co, + left: _ToFloat | None = None, + right: _ToFloat | None = None, +) -> np.float64: ... +@overload +def interp( + x: _Array[np.floating | np.integer, _ShapeT], + xp: _ArrayLikeFloat_co, + fp: _ArrayLikeFloat_co, + left: _ToFloat | None = None, + right: _ToFloat | None = None, +) -> _Array[np.float64, _ShapeT]: ... +@overload +def interp( + x: _NestedSequence[_ToFloat], + xp: _ArrayLikeFloat_co, + fp: _ArrayLikeFloat_co, + left: _ToFloat | None = None, + right: _ToFloat | None = None, +) -> _Array[np.float64]: ... +@overload +def interp( + x: _ArrayLikeFloat_co, + xp: _ArrayLikeFloat_co, + fp: _ArrayLikeFloat_co, + left: _ToFloat | None = None, + right: _ToFloat | None = None, +) -> np.float64 | _Array[np.float64]: ... + +# +@overload +def interp_complex( + x: _ToFloat, + xp: _ArrayLikeFloat_co, + fp: _ArrayLikeNumber_co, + left: _ToComplex | None = None, + right: _ToComplex | None = None, +) -> np.complex128: ... +@overload +def interp_complex( + x: _Array[np.floating | np.integer, _ShapeT], + xp: _ArrayLikeFloat_co, + fp: _ArrayLikeNumber_co, + left: _ToComplex | None = None, + right: _ToComplex | None = None, +) -> _Array[np.complex128, _ShapeT]: ... +@overload +def interp_complex( + x: _NestedSequence[_ToFloat], + xp: _ArrayLikeFloat_co, + fp: _ArrayLikeNumber_co, + left: _ToComplex | None = None, + right: _ToComplex | None = None, +) -> _Array[np.complex128]: ... +@overload +def interp_complex( + x: _ArrayLikeFloat_co, + xp: _ArrayLikeFloat_co, + fp: _ArrayLikeNumber_co, + left: _ToComplex | None = None, + right: _ToComplex | None = None, +) -> np.complex128 | _Array[np.complex128]: ... + +# +def count_nonzero(a: object, /) -> int: ... +def bincount( + x: _ArrayLikeInt_co, + /, + weights: _ArrayLikeFloat_co | None = None, + minlength: SupportsIndex = 0, +) -> _Array[np.intp]: ... + +# +@overload # 2d -> 1d +def lexsort( + keys: _Array[Any, tuple[int, int]] | Sequence[Sequence[np.generic | complex | float | int]], + axis: SupportsIndex = -1, +) -> _Array1D[np.intp]: ... +@overload # 1d -> 0d +def lexsort(keys: _Array1D | Sequence[np.generic | complex | float | int], axis: SupportsIndex = -1) -> np.intp: ... +@overload # TODO(jorenham) +def lexsort(keys: npt.ArrayLike, axis: SupportsIndex = -1) -> Incomplete: ... + +### + +# +@final +class busdaycalendar: + @property + def weekmask(self) -> _Array1D[np.bool]: ... + @property + def holidays(self) -> _Array1D[np.datetime64[dt.datetime]]: ... + def __init__(self, /, weekmask: _WeekMask = "1111100", holidays: _ToDateArray | None = None) -> None: ... + +# +@overload +def is_busday( + dates: _ToDate, + weekmask: _WeekMask = "1111100", + holidays: _ToDateArray | None = None, + busdaycal: busdaycalendar | None = None, + out: None = None, +) -> np.bool: ... +@overload +def is_busday( + dates: _ToDateArray, + weekmask: _WeekMask = "1111100", + holidays: _ToDateArray | None = None, + busdaycal: busdaycalendar | None = None, + out: None = None, +) -> _Array[np.bool]: ... +@overload +def is_busday( + dates: _ToDateArray, + weekmask: _WeekMask, + holidays: _ToDateArray | None, + busdaycal: busdaycalendar | None, + out: _ArrayT, +) -> _ArrayT: ... +@overload +def is_busday( + dates: _ToDateArray, + weekmask: _WeekMask = "1111100", + holidays: _ToDateArray | None = None, + busdaycal: busdaycalendar | None = None, + *, + out: _ArrayT, +) -> _ArrayT: ... + +# +@overload +def busday_count( + begindates: _ToDate, + enddates: _ToDate, + weekmask: _WeekMask = "1111100", + holidays: _ToDateArray | None = None, + busdaycal: busdaycalendar | None = None, + out: None = None, +) -> np.int_: ... +@overload +def busday_count( + begindates: _ToDate | _ToDateArray, + enddates: _ToDateArray, + weekmask: _WeekMask = "1111100", + holidays: _ToDateArray | None = None, + busdaycal: busdaycalendar | None = None, + out: None = None, +) -> _Array[np.int_]: ... +@overload +def busday_count( + begindates: _ToDateArray, + enddates: _ToDate | _ToDateArray, + weekmask: _WeekMask = "1111100", + holidays: _ToDateArray | None = None, + busdaycal: busdaycalendar | None = None, + out: None = None, +) -> _Array[np.int_]: ... +@overload +def busday_count( + begindates: _ToDate | _ToDateArray, + enddates: _ToDate | _ToDateArray, + weekmask: _WeekMask, + holidays: _ToDateArray | None, + busdaycal: busdaycalendar | None, + out: _ArrayT, +) -> _ArrayT: ... +@overload +def busday_count( + begindates: _ToDate | _ToDateArray, + enddates: _ToDate | _ToDateArray, + weekmask: _WeekMask = "1111100", + holidays: _ToDateArray | None = None, + busdaycal: busdaycalendar | None = None, + *, + out: _ArrayT, +) -> _ArrayT: ... + +# +@overload +def busday_offset( + dates: _ToDate, + offsets: _ToDelta, + roll: _Roll = "raise", + weekmask: _WeekMask = "1111100", + holidays: _ToDateArray | None = None, + busdaycal: busdaycalendar | None = None, + out: None = None, +) -> np.datetime64[dt.datetime]: ... +@overload +def busday_offset( + dates: _ToDate | _ToDateArray, + offsets: _ToDeltaArray, + roll: _Roll = "raise", + weekmask: _WeekMask = "1111100", + holidays: _ToDateArray | None = None, + busdaycal: busdaycalendar | None = None, + out: None = None, +) -> _Array[np.datetime64[dt.datetime]]: ... +@overload +def busday_offset( + dates: _ToDateArray, + offsets: _ToDelta | _ToDeltaArray, + roll: _Roll = "raise", + weekmask: _WeekMask = "1111100", + holidays: _ToDateArray | None = None, + busdaycal: busdaycalendar | None = None, + out: None = None, +) -> _Array[np.datetime64[dt.datetime]]: ... +@overload +def busday_offset( + dates: _ToDate | _ToDateArray, + offsets: _ToDelta | _ToDeltaArray, + roll: _Roll, + weekmask: _WeekMask, + holidays: _ToDateArray | None, + busdaycal: busdaycalendar | None, + out: _ArrayT, +) -> _ArrayT: ... +@overload +def busday_offset( + dates: _ToDate | _ToDateArray, + offsets: _ToDelta | _ToDeltaArray, + roll: _Roll = "raise", + weekmask: _WeekMask = "1111100", + holidays: _ToDateArray | None = None, + busdaycal: busdaycalendar | None = None, + *, + out: _ArrayT, +) -> _ArrayT: ... + +# +@overload +def datetime_as_string( + arr: np.datetime64, + unit: L["auto"] | _TimeUnit | None = None, + timezone: _TimeZone = "naive", + casting: _CastingKind = "same_kind", +) -> np.str_: ... +@overload +def datetime_as_string( + arr: npt.NDArray[np.datetime64], + unit: L["auto"] | _TimeUnit | None = None, + timezone: _TimeZone = "naive", + casting: _CastingKind = "same_kind", +) -> _Array[np.str_]: ... + +# +def datetime_data(dtype: str | _DTypeLike[np.datetime64 | np.timedelta64], /) -> tuple[str, int]: ... + +### + +# keep in sync with correlate2 +@overload +def correlate(a: _ArrayLike[_NumericT], v: _ArrayLike[_NumericT], mode: _CorrMode = 0) -> _Array1D[_NumericT]: ... +@overload +def correlate(a: npt.ArrayLike, v: npt.ArrayLike, mode: _CorrMode = 0) -> _Array1D: ... + +# keep in sync with correlate +@overload +def correlate2(a: _ArrayLike[_NumericT], v: _ArrayLike[_NumericT], mode: _CorrMode = 0) -> _Array1D[_NumericT]: ... +@overload +def correlate2(a: npt.ArrayLike, v: npt.ArrayLike, mode: _CorrMode = 0) -> _Array1D: ... + +# +@overload +def c_einsum( + subscripts: str, + *operands: npt.ArrayLike, + out: _ArrayT, + dtype: None = None, + order: _OrderKACF = "K", + casting: _CastingKind = "safe", +) -> _ArrayT: ... +@overload +def c_einsum( + subscripts: str, + *operands: npt.ArrayLike, + out: None = None, + dtype: npt.DTypeLike | None = None, + order: _OrderKACF = "K", + casting: _CastingKind = "safe", +) -> Any: ... + +### + +# +@overload +def scalar(dtype: np.dtype[np.object_], obj: object) -> Any: ... +@overload +def scalar(dtype: np.dtypes.StringDType, obj: np.ndarray[Any, np.dtypes.StringDType]) -> str: ... +@overload +def scalar(dtype: np.dtype[_SafeScalarT]) -> _SafeScalarT: ... +@overload +def scalar(dtype: np.dtype[_SafeScalarT], obj: bytes) -> _SafeScalarT: ... + +# +@overload +def compare_chararrays( + a1: _ArrayLikeStr_co, + a2: _ArrayLikeStr_co, + cmp: L["<", "<=", "==", ">=", ">", "!="], + rstrip: bool, +) -> _Array[np.bool]: ... +@overload +def compare_chararrays( + a1: _ArrayLikeBytes_co, + a2: _ArrayLikeBytes_co, + cmp: L["<", "<=", "==", ">=", ">", "!="], + rstrip: bool, +) -> _Array[np.bool]: ... + +# +def add_docstring(obj: Callable[..., object] | _HasDoc, docstring: str, /) -> None: ... + +# +def dragon4_positional(*args: Incomplete, **kwargs: Incomplete) -> Incomplete: ... +def dragon4_scientific(*args: Incomplete, **kwargs: Incomplete) -> Incomplete: ... +def format_longfloat(*args: Incomplete, **kwargs: Incomplete) -> Incomplete: ... + +# +def _get_madvise_hugepage() -> bool: ... +def _set_madvise_hugepage(enabled: bool, /) -> bool: ... +def _get_ndarray_c_version() -> int: ... + +# +def _monotonicity(x: _ArrayLikeFloat_co) -> L[0, 1]: ... +def _place(input: npt.ArrayLike, mask: _ArrayLikeBool_co, vals: npt.ArrayLike) -> None: ... +def _reconstruct( + subtype: type[_Array], + shape: _AnyShapeT, + dtype: _DTypeT, +) -> np.ndarray[_AnyShapeT, _DTypeT]: ... +def _vec_string(a: _ArrayLikeAnyString_co, dtype: npt.DTypeLike, attr: str, /) -> _Array: ... + +### + +# NOTE: We can't use e.g. `Concatenate[Any, ...]`, as that causes mypy to reject every function... +@overload # (a) -> T +def frompyfunc(f: Callable[[Any], _T], /, nin: _1, nout: _1, *, identity: _IdT | None = None) -> _PyFunc11[_T, _IdT]: ... +@overload # (a, b) -> T +def frompyfunc(f: Callable[[Any, Any], _T], /, nin: _2, nout: _1, *, identity: _IdT | None = None) -> _PyFunc21[_T, _IdT]: ... +@overload # (a, b, c, ...) -> T +def frompyfunc( + # f: Callable[Concatenate[Any, Any, Any, ...], _T], + f: Callable[..., _T], + /, + nin: _3P, + nout: _1, + *, + identity: _IdT | None = None, +) -> _PyFunc3P1[_T, _IdT]: ... +@overload # (a, ...) -> (T1, T2) +def frompyfunc( # type: ignore[overload-overlap] # mypy-only false positive + f: Callable[..., tuple[_T1, _T2]], + /, + nin: _1P, + nout: _2, + *, + identity: _IdT | None = None, +) -> _PyFunc1P2[_T1, _T2, _IdT]: ... +@overload # (a, ...) -> (T1, T2, *(T, ...)) +def frompyfunc( + f: Callable[..., tuple[_T1, _T2, Unpack[tuple[_T, ...]]]], + /, + nin: _1P, + nout: _2P, + *, + identity: _IdT | None = None, +) -> _PyFunc1P2P[_T1 | _T2 | _T, _IdT]: ... +@overload +def frompyfunc(f: Callable[..., Any], /, nin: SupportsIndex, nout: SupportsIndex, *, identity: object = None) -> np.ufunc: ... + +### diff --git a/src/numpy-stubs/_core/multiarray.pyi b/src/numpy-stubs/_core/multiarray.pyi index feff09d2..ef18a791 100644 --- a/src/numpy-stubs/_core/multiarray.pyi +++ b/src/numpy-stubs/_core/multiarray.pyi @@ -1,65 +1,190 @@ -import datetime as dt -from _typeshed import StrOrBytesPath, SupportsLenAndGetItem -from collections.abc import Callable, Iterable, Sequence -from typing import ( - Any, - ClassVar, - Final, - Literal as L, - Protocol, - SupportsIndex, - TypeAlias, - TypedDict, - final, - overload, - type_check_only, +from numpy import ( # noqa: ICN003 + absolute as absolute, + add as add, + arccos as arccos, + arccosh as arccosh, + arcsin as arcsin, + arcsinh as arcsinh, + arctan as arctan, + arctan2 as arctan2, + arctanh as arctanh, + bitwise_and as bitwise_and, + bitwise_count as bitwise_count, + bitwise_or as bitwise_or, + bitwise_xor as bitwise_xor, + cbrt as cbrt, + ceil as ceil, + conjugate as conjugate, + copysign as copysign, + cos as cos, + cosh as cosh, + deg2rad as deg2rad, + degrees as degrees, + divide as divide, + divmod as divmod, + dtype, + equal as equal, + exp as exp, + exp2 as exp2, + expm1 as expm1, + fabs as fabs, + float_power as float_power, + floor as floor, + floor_divide as floor_divide, + fmax as fmax, + fmin as fmin, + fmod as fmod, + frexp as frexp, + gcd as gcd, + greater as greater, + greater_equal as greater_equal, + heaviside as heaviside, + hypot as hypot, + invert as invert, + isfinite as isfinite, + isinf as isinf, + isnan as isnan, + isnat as isnat, + lcm as lcm, + ldexp as ldexp, + left_shift as left_shift, + less as less, + less_equal as less_equal, + log as log, + log1p as log1p, + log2 as log2, + log10 as log10, + logaddexp as logaddexp, + logaddexp2 as logaddexp2, + logical_and as logical_and, + logical_not as logical_not, + logical_or as logical_or, + logical_xor as logical_xor, + matmul, + matvec as matvec, + maximum as maximum, + minimum as minimum, + modf as modf, + multiply as multiply, + ndarray, + negative as negative, + nextafter as nextafter, + not_equal as not_equal, + positive as positive, + power as power, + rad2deg as rad2deg, + radians as radians, + reciprocal as reciprocal, + remainder as remainder, + right_shift as right_shift, + rint as rint, + sign as sign, + signbit as signbit, + sin as sin, + sinh as sinh, + spacing as spacing, + sqrt as sqrt, + square as square, + subtract as subtract, + tan as tan, + tanh as tanh, + trunc as trunc, + vecdot, + vecmat as vecmat, ) -from typing_extensions import CapsuleType, TypeVar, Unpack +from numpy.lib._array_utils_impl import normalize_axis_index -import numpy as np -from numpy import ( # noqa: ICN003 +from ._multiarray_umath import ( + ALLOW_THREADS, + BUFSIZE, + CLIP, + DATETIMEUNITS, + ITEM_HASOBJECT, + ITEM_IS_POINTER, + LIST_PICKLE, + MAXDIMS, + MAY_SHARE_BOUNDS, + MAY_SHARE_EXACT, + NEEDS_INIT, + NEEDS_PYAPI, + RAISE, + USE_GETITEM, + USE_SETITEM, + WRAP, + _ARRAY_API, + _flagdict, + _get_madvise_hugepage as _get_madvise_hugepage, + _get_ndarray_c_version as _get_ndarray_c_version, + _monotonicity, + _place, + _reconstruct, + _set_madvise_hugepage as _set_madvise_hugepage, + _vec_string, + add_docstring, + arange, + array, + asanyarray, + asarray, + ascontiguousarray, + asfortranarray, + bincount, broadcast, + busday_count, + busday_offset, busdaycalendar, + c_einsum, + can_cast, + compare_chararrays, + concatenate, + copyto, correlate, + correlate2, count_nonzero, - dtype, - einsum as c_einsum, + datetime_as_string, + datetime_data, + dot, + dragon4_positional, + dragon4_scientific, + empty, + empty_like, + error, + flagsobj, flatiter, + format_longfloat, from_dlpack, + frombuffer, + fromfile, + fromiter, + frompyfunc as frompyfunc, + fromstring, + get_handler_name, + get_handler_version, + inner, interp, - matmul, - ndarray, + interp_complex, + is_busday, + lexsort, + may_share_memory, + min_scalar_type, nditer, - ufunc, - vecdot, + nested_iters, + packbits, + promote_types, + putmask, + ravel_multi_index, + result_type, + scalar, + set_datetimeparse_function, + set_typeDict, + shares_memory, + tracemalloc_domain as tracemalloc_domain, + typeinfo, + unpackbits, + unravel_index, + vdot, + where, + zeros, ) -from numpy._typing import ( - ArrayLike, - DTypeLike, - NDArray, - _ArrayLike, - _ArrayLikeBool_co, - _ArrayLikeBytes_co, - _ArrayLikeComplex_co, - _ArrayLikeDT64_co, - _ArrayLikeFloat_co, - _ArrayLikeInt_co, - _ArrayLikeObject_co, - _ArrayLikeStr_co, - _ArrayLikeTD64_co, - _ArrayLikeUInt_co, - _DTypeLike, - _FloatLike_co, - _IntLike_co, - _NestedSequence, - _ScalarLike_co, - _ShapeLike, - _SupportsArrayFunc, - _SupportsDType, - _TD64Like_co, -) -from numpy._typing._ufunc import _PyFunc_Nin1P_Nout2P, _PyFunc_Nin1_Nout1, _PyFunc_Nin2_Nout1, _PyFunc_Nin3P_Nout1 -from numpy.lib._array_utils_impl import normalize_axis_index __all__ = [ "ALLOW_THREADS", @@ -152,1129 +277,3 @@ __all__ = [ "where", "zeros", ] - -_ReturnT = TypeVar("_ReturnT") -_ReturnT1 = TypeVar("_ReturnT1") -_ReturnT2 = TypeVar("_ReturnT2") -_IdentityT = TypeVar("_IdentityT") - -_SCT = TypeVar("_SCT", bound=np.generic) -_DTypeT = TypeVar("_DTypeT", bound=np.dtype[Any]) -_ArrayT = TypeVar("_ArrayT", bound=ndarray[Any, Any]) -_ArrayT_co = TypeVar("_ArrayT_co", bound=ndarray[Any, Any], covariant=True) - -_ShapeT = TypeVar("_ShapeT", bound=tuple[int, ...]) - -_Array1D: TypeAlias = ndarray[tuple[int], dtype[_SCT]] -_Array: TypeAlias = ndarray[_ShapeT, dtype[_SCT]] - -# Valid time units -_UnitKind: TypeAlias = L["Y", "M", "D", "h", "m", "s", "ms", "us", "μs", "ns", "ps", "fs", "as"] - -# `raise` is deliberately excluded -_RollKind: TypeAlias = L["nat", "forward", "following", "backward", "preceding", "modifiedfollowing", "modifiedpreceding"] - -@type_check_only -class _SupportsArray(Protocol[_ArrayT_co]): - def __array__(self, /) -> _ArrayT_co: ... - -@type_check_only -class _KwargsEmpty(TypedDict, total=False): - device: L["cpu"] | None - like: _SupportsArrayFunc | None - -@type_check_only -class _ConstructorEmpty(Protocol): - # 1-D shape - @overload - def __call__( - self, - /, - shape: int, - dtype: None = ..., - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], - ) -> _Array[tuple[int], np.float64]: ... - @overload - def __call__( - self, - /, - shape: int, - dtype: _DTypeT | _SupportsDType[_DTypeT], - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], - ) -> ndarray[tuple[int], _DTypeT]: ... - @overload - def __call__( - self, - /, - shape: int, - dtype: type[_SCT], - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], - ) -> _Array[tuple[int], _SCT]: ... - @overload - def __call__( - self, - /, - shape: int, - dtype: DTypeLike, - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], - ) -> _Array[tuple[int], Any]: ... - - # known shape - @overload - def __call__( - self, - /, - shape: _ShapeT, - dtype: None = ..., - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], - ) -> _Array[_ShapeT, np.float64]: ... - @overload - def __call__( - self, - /, - shape: _ShapeT, - dtype: _DTypeT | _SupportsDType[_DTypeT], - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], - ) -> ndarray[_ShapeT, _DTypeT]: ... - @overload - def __call__( - self, - /, - shape: _ShapeT, - dtype: type[_SCT], - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], - ) -> _Array[_ShapeT, _SCT]: ... - @overload - def __call__( - self, - /, - shape: _ShapeT, - dtype: DTypeLike, - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], - ) -> _Array[_ShapeT, Any]: ... - - # unknown shape - @overload - def __call__( - self, - /, - shape: _ShapeLike, - dtype: None = ..., - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], - ) -> NDArray[np.float64]: ... - @overload - def __call__( - self, - /, - shape: _ShapeLike, - dtype: _DTypeT | _SupportsDType[_DTypeT], - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], - ) -> ndarray[Any, _DTypeT]: ... - @overload - def __call__( - self, - /, - shape: _ShapeLike, - dtype: type[_SCT], - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], - ) -> NDArray[_SCT]: ... - @overload - def __call__( - self, - /, - shape: _ShapeLike, - dtype: DTypeLike, - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], - ) -> NDArray[Any]: ... - -error: Final = Exception - -# from ._multiarray_umath -ITEM_HASOBJECT: Final = 1 -LIST_PICKLE: Final = 2 -ITEM_IS_POINTER: Final = 4 -NEEDS_INIT: Final = 8 -NEEDS_PYAPI: Final = 16 -USE_GETITEM: Final = 32 -USE_SETITEM: Final = 64 -DATETIMEUNITS: Final[CapsuleType] -_ARRAY_API: Final[CapsuleType] -_flagdict: Final[dict[str, int]] -_monotonicity: Final[Callable[..., object]] -_place: Final[Callable[..., object]] -_reconstruct: Final[Callable[..., object]] -_vec_string: Final[Callable[..., object]] -correlate2: Final[Callable[..., object]] -dragon4_positional: Final[Callable[..., object]] -dragon4_scientific: Final[Callable[..., object]] -interp_complex: Final[Callable[..., object]] -set_datetimeparse_function: Final[Callable[..., object]] - -def get_handler_name(a: NDArray[Any] = ..., /) -> str | None: ... -def get_handler_version(a: NDArray[Any] = ..., /) -> int | None: ... -def format_longfloat(x: np.longdouble, precision: int) -> str: ... -def scalar(dtype: _DTypeT, object: bytes | object = ...) -> ndarray[tuple[()], _DTypeT]: ... -def set_typeDict(dict_: dict[str, np.dtype[Any]], /) -> None: ... - -typeinfo: Final[dict[str, np.dtype[np.generic]]] - -ALLOW_THREADS: Final[int] # 0 or 1 (system-specific) -BUFSIZE: L[8192] -CLIP: L[0] -WRAP: L[1] -RAISE: L[2] -MAXDIMS: L[32] -MAY_SHARE_BOUNDS: L[0] -MAY_SHARE_EXACT: L[-1] -tracemalloc_domain: L[389047] - -zeros: Final[_ConstructorEmpty] -empty: Final[_ConstructorEmpty] - -@overload -def empty_like( - prototype: _ArrayT, - dtype: None = ..., - order: np._OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> _ArrayT: ... -@overload -def empty_like( - prototype: _ArrayLike[_SCT], - dtype: None = ..., - order: np._OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[_SCT]: ... -@overload -def empty_like( - prototype: object, - dtype: None = ..., - order: np._OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[Any]: ... -@overload -def empty_like( - prototype: Any, - dtype: _DTypeLike[_SCT], - order: np._OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[_SCT]: ... -@overload -def empty_like( - prototype: Any, - dtype: DTypeLike, - order: np._OrderKACF = ..., - subok: bool = ..., - shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[Any]: ... - -# -@overload -def array( - object: _ArrayT, - dtype: None = ..., - *, - copy: bool | np._CopyMode | None = ..., - order: np._OrderKACF = ..., - subok: L[True], - ndmin: int = ..., - like: _SupportsArrayFunc | None = ..., -) -> _ArrayT: ... -@overload -def array( - object: _SupportsArray[_ArrayT], - dtype: None = ..., - *, - copy: bool | np._CopyMode | None = ..., - order: np._OrderKACF = ..., - subok: L[True], - ndmin: L[0] = ..., - like: _SupportsArrayFunc | None = ..., -) -> _ArrayT: ... -@overload -def array( - object: _ArrayLike[_SCT], - dtype: None = ..., - *, - copy: bool | np._CopyMode | None = ..., - order: np._OrderKACF = ..., - subok: bool = ..., - ndmin: int = ..., - like: _SupportsArrayFunc | None = ..., -) -> NDArray[_SCT]: ... -@overload -def array( - object: object, - dtype: None = ..., - *, - copy: bool | np._CopyMode | None = ..., - order: np._OrderKACF = ..., - subok: bool = ..., - ndmin: int = ..., - like: _SupportsArrayFunc | None = ..., -) -> NDArray[Any]: ... -@overload -def array( - object: Any, - dtype: _DTypeLike[_SCT], - *, - copy: bool | np._CopyMode | None = ..., - order: np._OrderKACF = ..., - subok: bool = ..., - ndmin: int = ..., - like: _SupportsArrayFunc | None = ..., -) -> NDArray[_SCT]: ... -@overload -def array( - object: Any, - dtype: DTypeLike, - *, - copy: bool | np._CopyMode | None = ..., - order: np._OrderKACF = ..., - subok: bool = ..., - ndmin: int = ..., - like: _SupportsArrayFunc | None = ..., -) -> NDArray[Any]: ... - -# -@overload -def unravel_index( - indices: _IntLike_co, - shape: _ShapeLike, - order: np._OrderCF = ..., -) -> tuple[np.int_, ...]: ... -@overload -def unravel_index( - indices: _ArrayLikeInt_co, - shape: _ShapeLike, - order: np._OrderCF = ..., -) -> tuple[NDArray[np.int_], ...]: ... - -# -@overload -def ravel_multi_index( - multi_index: Sequence[_IntLike_co], - dims: Sequence[SupportsIndex], - mode: np._ModeKind | tuple[np._ModeKind, ...] = ..., - order: np._OrderCF = ..., -) -> np.int_: ... -@overload -def ravel_multi_index( - multi_index: Sequence[_ArrayLikeInt_co], - dims: Sequence[SupportsIndex], - mode: np._ModeKind | tuple[np._ModeKind, ...] = ..., - order: np._OrderCF = ..., -) -> NDArray[np.int_]: ... - -# NOTE: Allow any sequence of array-like objects -@overload -def concatenate( - arrays: _ArrayLike[_SCT], - /, - axis: SupportsIndex | None = ..., - out: None = ..., - *, - dtype: None = ..., - casting: np._CastingKind | None = ..., -) -> NDArray[_SCT]: ... -@overload -def concatenate( - arrays: SupportsLenAndGetItem[ArrayLike], - /, - axis: SupportsIndex | None = ..., - out: None = ..., - *, - dtype: None = ..., - casting: np._CastingKind | None = ..., -) -> NDArray[Any]: ... -@overload -def concatenate( - arrays: SupportsLenAndGetItem[ArrayLike], - /, - axis: SupportsIndex | None = ..., - out: None = ..., - *, - dtype: _DTypeLike[_SCT], - casting: np._CastingKind | None = ..., -) -> NDArray[_SCT]: ... -@overload -def concatenate( - arrays: SupportsLenAndGetItem[ArrayLike], - /, - axis: SupportsIndex | None = ..., - out: None = ..., - *, - dtype: DTypeLike, - casting: np._CastingKind | None = ..., -) -> NDArray[Any]: ... -@overload -def concatenate( - arrays: SupportsLenAndGetItem[ArrayLike], - /, - axis: SupportsIndex | None = ..., - out: _ArrayT = ..., - *, - dtype: DTypeLike = ..., - casting: np._CastingKind | None = ..., -) -> _ArrayT: ... - -# -def inner(a: ArrayLike, b: ArrayLike, /) -> Any: ... - -# -@overload -def where(condition: ArrayLike, /) -> tuple[NDArray[np.int_], ...]: ... -@overload -def where(condition: ArrayLike, x: ArrayLike, y: ArrayLike, /) -> NDArray[Any]: ... - -# -def lexsort(keys: ArrayLike, axis: SupportsIndex | None = ...) -> Any: ... -def can_cast(from_: ArrayLike | DTypeLike, to: DTypeLike, casting: np._CastingKind | None = ...) -> bool: ... -def min_scalar_type(a: ArrayLike, /) -> dtype[Any]: ... -def result_type(*arrays_and_dtypes: ArrayLike | DTypeLike) -> dtype[Any]: ... - -# -@overload -def dot(a: ArrayLike, b: ArrayLike, out: None = ...) -> Any: ... -@overload -def dot(a: ArrayLike, b: ArrayLike, out: _ArrayT) -> _ArrayT: ... - -# -@overload -def vdot(a: _ArrayLikeBool_co, b: _ArrayLikeBool_co, /) -> np.bool: ... -@overload -def vdot(a: _ArrayLikeUInt_co, b: _ArrayLikeUInt_co, /) -> np.unsignedinteger: ... -@overload -def vdot(a: _ArrayLikeInt_co, b: _ArrayLikeInt_co, /) -> np.signedinteger: ... -@overload -def vdot(a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, /) -> np.floating: ... -@overload -def vdot(a: _ArrayLikeComplex_co, b: _ArrayLikeComplex_co, /) -> np.complexfloating: ... -@overload -def vdot(a: _ArrayLikeTD64_co, b: _ArrayLikeTD64_co, /) -> np.timedelta64: ... -@overload -def vdot(a: _ArrayLikeObject_co, b: Any, /) -> Any: ... -@overload -def vdot(a: Any, b: _ArrayLikeObject_co, /) -> Any: ... - -# -def bincount(x: ArrayLike, /, weights: ArrayLike | None = ..., minlength: SupportsIndex = ...) -> NDArray[np.int_]: ... - -# -def copyto( - dst: NDArray[Any], - src: ArrayLike, - casting: np._CastingKind | None = ..., - where: _ArrayLikeBool_co | None = ..., -) -> None: ... - -# -def putmask(a: NDArray[Any], /, mask: _ArrayLikeBool_co, values: ArrayLike) -> None: ... - -# -def packbits( - a: _ArrayLikeInt_co, - /, - axis: SupportsIndex | None = ..., - bitorder: L["big", "little"] = ..., -) -> NDArray[np.uint8]: ... - -# -def unpackbits( - a: _ArrayLike[np.uint8], - /, - axis: SupportsIndex | None = ..., - count: SupportsIndex | None = ..., - bitorder: L["big", "little"] = ..., -) -> NDArray[np.uint8]: ... - -# -def shares_memory(a: object, b: object, /, max_work: int | None = ...) -> bool: ... -def may_share_memory(a: object, b: object, /, max_work: int | None = ...) -> bool: ... - -# -@overload -def asarray( - a: _ArrayLike[_SCT], - dtype: None = ..., - order: np._OrderKACF = ..., - *, - device: L["cpu"] | None = ..., - copy: bool | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> NDArray[_SCT]: ... -@overload -def asarray( - a: object, - dtype: None = ..., - order: np._OrderKACF = ..., - *, - device: L["cpu"] | None = ..., - copy: bool | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> NDArray[Any]: ... -@overload -def asarray( - a: Any, - dtype: _DTypeLike[_SCT], - order: np._OrderKACF = ..., - *, - device: L["cpu"] | None = ..., - copy: bool | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> NDArray[_SCT]: ... -@overload -def asarray( - a: Any, - dtype: DTypeLike, - order: np._OrderKACF = ..., - *, - device: L["cpu"] | None = ..., - copy: bool | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> NDArray[Any]: ... - -# -@overload -def asanyarray( - a: _ArrayT, # Preserve subclass-information - dtype: None = ..., - order: np._OrderKACF = ..., - *, - device: L["cpu"] | None = ..., - copy: bool | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> _ArrayT: ... -@overload -def asanyarray( - a: _ArrayLike[_SCT], - dtype: None = ..., - order: np._OrderKACF = ..., - *, - device: L["cpu"] | None = ..., - copy: bool | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> NDArray[_SCT]: ... -@overload -def asanyarray( - a: object, - dtype: None = ..., - order: np._OrderKACF = ..., - *, - device: L["cpu"] | None = ..., - copy: bool | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> NDArray[Any]: ... -@overload -def asanyarray( - a: Any, - dtype: _DTypeLike[_SCT], - order: np._OrderKACF = ..., - *, - device: L["cpu"] | None = ..., - copy: bool | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> NDArray[_SCT]: ... -@overload -def asanyarray( - a: Any, - dtype: DTypeLike, - order: np._OrderKACF = ..., - *, - device: L["cpu"] | None = ..., - copy: bool | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> NDArray[Any]: ... - -# -@overload -def ascontiguousarray(a: _ArrayLike[_SCT], dtype: None = ..., *, like: _SupportsArrayFunc | None = ...) -> NDArray[_SCT]: ... -@overload -def ascontiguousarray(a: object, dtype: None = ..., *, like: _SupportsArrayFunc | None = ...) -> NDArray[Any]: ... -@overload -def ascontiguousarray(a: Any, dtype: _DTypeLike[_SCT], *, like: _SupportsArrayFunc | None = ...) -> NDArray[_SCT]: ... -@overload -def ascontiguousarray(a: Any, dtype: DTypeLike, *, like: _SupportsArrayFunc | None = ...) -> NDArray[Any]: ... - -# -@overload -def asfortranarray(a: _ArrayLike[_SCT], dtype: None = ..., *, like: _SupportsArrayFunc | None = ...) -> NDArray[_SCT]: ... -@overload -def asfortranarray(a: object, dtype: None = ..., *, like: _SupportsArrayFunc | None = ...) -> NDArray[Any]: ... -@overload -def asfortranarray(a: Any, dtype: _DTypeLike[_SCT], *, like: _SupportsArrayFunc | None = ...) -> NDArray[_SCT]: ... -@overload -def asfortranarray(a: Any, dtype: DTypeLike, *, like: _SupportsArrayFunc | None = ...) -> NDArray[Any]: ... - -# -def promote_types(type1: DTypeLike, type2: DTypeLike, /) -> dtype[Any]: ... - -# `sep` is a de facto mandatory argument, as its default value is deprecated -@overload -def fromstring( - string: str | bytes, - dtype: None = ..., - count: SupportsIndex = ..., - *, - sep: str, - like: _SupportsArrayFunc | None = ..., -) -> NDArray[np.float64]: ... -@overload -def fromstring( - string: str | bytes, - dtype: _DTypeLike[_SCT], - count: SupportsIndex = ..., - *, - sep: str, - like: _SupportsArrayFunc | None = ..., -) -> NDArray[_SCT]: ... -@overload -def fromstring( - string: str | bytes, - dtype: DTypeLike, - count: SupportsIndex = ..., - *, - sep: str, - like: _SupportsArrayFunc | None = ..., -) -> NDArray[Any]: ... - -_3P: TypeAlias = L[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] -_2P: TypeAlias = L[2] | _3P -_1P: TypeAlias = L[1, 2] | _3P - -# -@overload -def frompyfunc( - func: Callable[[Any], _ReturnT], - /, - nin: L[1], - nout: L[1], - *, - identity: None = None, -) -> _PyFunc_Nin1_Nout1[_ReturnT, None]: ... -@overload -def frompyfunc( - func: Callable[[Any], _ReturnT], - /, - nin: L[1], - nout: L[1], - *, - identity: _IdentityT, -) -> _PyFunc_Nin1_Nout1[_ReturnT, _IdentityT]: ... -@overload -def frompyfunc( - func: Callable[[Any, Any], _ReturnT], - /, - nin: L[2], - nout: L[1], - *, - identity: None = None, -) -> _PyFunc_Nin2_Nout1[_ReturnT, None]: ... -@overload -def frompyfunc( - func: Callable[[Any, Any], _ReturnT], - /, - nin: L[2], - nout: L[1], - *, - identity: _IdentityT, -) -> _PyFunc_Nin2_Nout1[_ReturnT, _IdentityT]: ... -@overload -def frompyfunc( - func: Callable[..., _ReturnT], - /, - nin: _3P, - nout: L[1], - *, - identity: None = None, -) -> _PyFunc_Nin3P_Nout1[_ReturnT, None, int]: ... -@overload -def frompyfunc( - func: Callable[..., _ReturnT], - /, - nin: _3P, - nout: L[1], - *, - identity: _IdentityT, -) -> _PyFunc_Nin3P_Nout1[_ReturnT, _IdentityT, int]: ... -@overload -def frompyfunc( - func: Callable[..., tuple[_ReturnT1, _ReturnT2]], - /, - nin: _1P, - nout: _2P, - *, - identity: None = None, -) -> _PyFunc_Nin1P_Nout2P[_ReturnT1 | _ReturnT2, None, int, int]: ... -@overload -def frompyfunc( - func: Callable[..., tuple[_ReturnT1, _ReturnT2]], - /, - nin: _1P, - nout: _2P, - *, - identity: _IdentityT, -) -> _PyFunc_Nin1P_Nout2P[_ReturnT1 | _ReturnT2, _IdentityT, int, int]: ... -@overload -def frompyfunc( - func: Callable[..., tuple[_ReturnT1, _ReturnT2, Unpack[tuple[_ReturnT, ...]]]], - /, - nin: _1P, - nout: _2P, - *, - identity: None = None, -) -> _PyFunc_Nin1P_Nout2P[_ReturnT1 | _ReturnT2 | _ReturnT, None, int, int]: ... -@overload -def frompyfunc( - func: Callable[..., tuple[_ReturnT1, _ReturnT2, Unpack[tuple[_ReturnT, ...]]]], - /, - nin: _1P, - nout: _2P, - *, - identity: _IdentityT, -) -> _PyFunc_Nin1P_Nout2P[_ReturnT1 | _ReturnT2 | _ReturnT, _IdentityT, int, int]: ... -@overload -def frompyfunc( - func: Callable[..., Any], - /, - nin: SupportsIndex, - nout: SupportsIndex, - *, - identity: object | None = ..., -) -> ufunc: ... - -# -@overload -def fromfile( - file: StrOrBytesPath | np._SupportsFileMethods, - dtype: None = ..., - count: SupportsIndex = ..., - sep: str = ..., - offset: SupportsIndex = ..., - *, - like: _SupportsArrayFunc | None = ..., -) -> NDArray[np.float64]: ... -@overload -def fromfile( - file: StrOrBytesPath | np._SupportsFileMethods, - dtype: _DTypeLike[_SCT], - count: SupportsIndex = ..., - sep: str = ..., - offset: SupportsIndex = ..., - *, - like: _SupportsArrayFunc | None = ..., -) -> NDArray[_SCT]: ... -@overload -def fromfile( - file: StrOrBytesPath | np._SupportsFileMethods, - dtype: DTypeLike, - count: SupportsIndex = ..., - sep: str = ..., - offset: SupportsIndex = ..., - *, - like: _SupportsArrayFunc | None = ..., -) -> NDArray[Any]: ... - -# -@overload -def fromiter( - iter: Iterable[Any], - dtype: _DTypeLike[_SCT], - count: SupportsIndex = ..., - *, - like: _SupportsArrayFunc | None = ..., -) -> NDArray[_SCT]: ... -@overload -def fromiter( - iter: Iterable[Any], - dtype: DTypeLike, - count: SupportsIndex = ..., - *, - like: _SupportsArrayFunc | None = ..., -) -> NDArray[Any]: ... - -# -@overload -def frombuffer( - buffer: np._SupportsBuffer, - dtype: None = ..., - count: SupportsIndex = ..., - offset: SupportsIndex = ..., - *, - like: _SupportsArrayFunc | None = ..., -) -> NDArray[np.float64]: ... -@overload -def frombuffer( - buffer: np._SupportsBuffer, - dtype: _DTypeLike[_SCT], - count: SupportsIndex = ..., - offset: SupportsIndex = ..., - *, - like: _SupportsArrayFunc | None = ..., -) -> NDArray[_SCT]: ... -@overload -def frombuffer( - buffer: np._SupportsBuffer, - dtype: DTypeLike, - count: SupportsIndex = ..., - offset: SupportsIndex = ..., - *, - like: _SupportsArrayFunc | None = ..., -) -> NDArray[Any]: ... - -# -@overload -def arange( - stop: _IntLike_co, - /, - *, - dtype: None = ..., - device: L["cpu"] | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> _Array1D[np.signedinteger]: ... -@overload -def arange( - start: _IntLike_co, - stop: _IntLike_co, - step: _IntLike_co = ..., - dtype: None = ..., - *, - device: L["cpu"] | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> _Array1D[np.signedinteger]: ... -@overload -def arange( - stop: _FloatLike_co, - /, - *, - dtype: None = ..., - device: L["cpu"] | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> _Array1D[np.floating]: ... -@overload -def arange( - start: _FloatLike_co, - stop: _FloatLike_co, - step: _FloatLike_co = ..., - dtype: None = ..., - *, - device: L["cpu"] | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> _Array1D[np.floating]: ... -@overload -def arange( - stop: _TD64Like_co, - /, - *, - dtype: None = ..., - device: L["cpu"] | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> _Array1D[np.timedelta64]: ... -@overload -def arange( - start: _TD64Like_co, - stop: _TD64Like_co, - step: _TD64Like_co = ..., - dtype: None = ..., - *, - device: L["cpu"] | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> _Array1D[np.timedelta64]: ... -@overload -def arange( # both start and stop must always be specified for np.datetime64 - start: np.datetime64, - stop: np.datetime64, - step: np.datetime64 = ..., - dtype: None = ..., - *, - device: L["cpu"] | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> _Array1D[np.datetime64]: ... -@overload -def arange( - stop: object, - /, - *, - dtype: _DTypeLike[_SCT], - device: L["cpu"] | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> _Array1D[_SCT]: ... -@overload -def arange( - start: object, - stop: object, - step: object = ..., - dtype: _DTypeLike[_SCT] = ..., - *, - device: L["cpu"] | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> _Array1D[_SCT]: ... -@overload -def arange( - stop: object, - /, - *, - dtype: DTypeLike, - device: L["cpu"] | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> _Array1D[Any]: ... -@overload -def arange( - start: object, - stop: object, - step: object = ..., - dtype: DTypeLike = ..., - *, - device: L["cpu"] | None = ..., - like: _SupportsArrayFunc | None = ..., -) -> _Array1D[Any]: ... - -# -def datetime_data(dtype: str | _DTypeLike[np.datetime64] | _DTypeLike[np.timedelta64], /) -> tuple[str, int]: ... - -# The datetime functions perform unsafe casts to `np.datetime64[D]`, -# so a lot of different argument types are allowed here - -@overload -def busday_count( - begindates: _ScalarLike_co | dt.date, - enddates: _ScalarLike_co | dt.date, - weekmask: ArrayLike = ..., - holidays: ArrayLike | dt.date | _NestedSequence[dt.date] | None = ..., - busdaycal: busdaycalendar | None = ..., - out: None = ..., -) -> np.int_: ... -@overload -def busday_count( - begindates: ArrayLike | dt.date | _NestedSequence[dt.date], - enddates: ArrayLike | dt.date | _NestedSequence[dt.date], - weekmask: ArrayLike = ..., - holidays: ArrayLike | dt.date | _NestedSequence[dt.date] | None = ..., - busdaycal: busdaycalendar | None = ..., - out: None = ..., -) -> NDArray[np.int_]: ... -@overload -def busday_count( - begindates: ArrayLike | dt.date | _NestedSequence[dt.date], - enddates: ArrayLike | dt.date | _NestedSequence[dt.date], - weekmask: ArrayLike = ..., - holidays: ArrayLike | dt.date | _NestedSequence[dt.date] | None = ..., - busdaycal: busdaycalendar | None = ..., - out: _ArrayT = ..., -) -> _ArrayT: ... - -# `roll="raise"` is (more or less?) equivalent to `casting="safe"` -@overload -def busday_offset( - dates: np.datetime64 | dt.date, - offsets: _TD64Like_co | dt.timedelta, - roll: L["raise"] = ..., - weekmask: ArrayLike = ..., - holidays: ArrayLike | dt.date | _NestedSequence[dt.date] | None = ..., - busdaycal: busdaycalendar | None = ..., - out: None = ..., -) -> np.datetime64: ... -@overload -def busday_offset( - dates: _ArrayLike[np.datetime64] | dt.date | _NestedSequence[dt.date], - offsets: _ArrayLikeTD64_co | dt.timedelta | _NestedSequence[dt.timedelta], - roll: L["raise"] = ..., - weekmask: ArrayLike = ..., - holidays: ArrayLike | dt.date | _NestedSequence[dt.date] | None = ..., - busdaycal: busdaycalendar | None = ..., - out: None = ..., -) -> NDArray[np.datetime64]: ... -@overload -def busday_offset( - dates: _ArrayLike[np.datetime64] | dt.date | _NestedSequence[dt.date], - offsets: _ArrayLikeTD64_co | dt.timedelta | _NestedSequence[dt.timedelta], - roll: L["raise"] = ..., - weekmask: ArrayLike = ..., - holidays: ArrayLike | dt.date | _NestedSequence[dt.date] | None = ..., - busdaycal: busdaycalendar | None = ..., - out: _ArrayT = ..., -) -> _ArrayT: ... -@overload -def busday_offset( - dates: _ScalarLike_co | dt.date, - offsets: _ScalarLike_co | dt.timedelta, - roll: _RollKind, - weekmask: ArrayLike = ..., - holidays: ArrayLike | dt.date | _NestedSequence[dt.date] | None = ..., - busdaycal: busdaycalendar | None = ..., - out: None = ..., -) -> np.datetime64: ... -@overload -def busday_offset( - dates: ArrayLike | dt.date | _NestedSequence[dt.date], - offsets: ArrayLike | dt.timedelta | _NestedSequence[dt.timedelta], - roll: _RollKind, - weekmask: ArrayLike = ..., - holidays: ArrayLike | dt.date | _NestedSequence[dt.date] | None = ..., - busdaycal: busdaycalendar | None = ..., - out: None = ..., -) -> NDArray[np.datetime64]: ... -@overload -def busday_offset( - dates: ArrayLike | dt.date | _NestedSequence[dt.date], - offsets: ArrayLike | dt.timedelta | _NestedSequence[dt.timedelta], - roll: _RollKind, - weekmask: ArrayLike = ..., - holidays: ArrayLike | dt.date | _NestedSequence[dt.date] | None = ..., - busdaycal: busdaycalendar | None = ..., - out: _ArrayT = ..., -) -> _ArrayT: ... -@overload -def is_busday( - dates: _ScalarLike_co | dt.date, - weekmask: ArrayLike = ..., - holidays: ArrayLike | dt.date | _NestedSequence[dt.date] | None = ..., - busdaycal: busdaycalendar | None = ..., - out: None = ..., -) -> np.bool: ... -@overload -def is_busday( - dates: ArrayLike | _NestedSequence[dt.date], - weekmask: ArrayLike = ..., - holidays: ArrayLike | dt.date | _NestedSequence[dt.date] | None = ..., - busdaycal: busdaycalendar | None = ..., - out: None = ..., -) -> NDArray[np.bool]: ... -@overload -def is_busday( - dates: ArrayLike | _NestedSequence[dt.date], - weekmask: ArrayLike = ..., - holidays: ArrayLike | dt.date | _NestedSequence[dt.date] | None = ..., - busdaycal: busdaycalendar | None = ..., - out: _ArrayT = ..., -) -> _ArrayT: ... -@overload -def datetime_as_string( - arr: np.datetime64 | dt.date, - unit: L["auto"] | _UnitKind | None = ..., - timezone: L["naive", "UTC", "local"] | dt.tzinfo = ..., - casting: np._CastingKind = ..., -) -> np.str_: ... -@overload -def datetime_as_string( - arr: _ArrayLikeDT64_co | _NestedSequence[dt.date], - unit: L["auto"] | _UnitKind | None = ..., - timezone: L["naive", "UTC", "local"] | dt.tzinfo = ..., - casting: np._CastingKind = ..., -) -> NDArray[np.str_]: ... -@overload -def compare_chararrays( - a1: _ArrayLikeStr_co, - a2: _ArrayLikeStr_co, - cmp: L["<", "<=", "==", ">=", ">", "!="], - rstrip: bool, -) -> NDArray[np.bool]: ... -@overload -def compare_chararrays( - a1: _ArrayLikeBytes_co, - a2: _ArrayLikeBytes_co, - cmp: L["<", "<=", "==", ">=", ">", "!="], - rstrip: bool, -) -> NDArray[np.bool]: ... -def add_docstring(obj: Callable[..., Any], docstring: str, /) -> None: ... - -_GetItemKeys: TypeAlias = L[ - "C", - "CONTIGUOUS", - "C_CONTIGUOUS", - "F", - "FORTRAN", - "F_CONTIGUOUS", - "W", - "WRITEABLE", - "B", - "BEHAVED", - "O", - "OWNDATA", - "A", - "ALIGNED", - "X", - "WRITEBACKIFCOPY", - "CA", - "CARRAY", - "FA", - "FARRAY", - "FNC", - "FORC", -] -_SetItemKeys: TypeAlias = L[ - "A", - "ALIGNED", - "W", - "WRITEABLE", - "X", - "WRITEBACKIFCOPY", -] - -@final -class flagsobj: - __hash__: ClassVar[None] # type: ignore[assignment] # pyright: ignore[reportIncompatibleMethodOverride] - aligned: bool - writeable: bool - writebackifcopy: bool - @property - def behaved(self) -> bool: ... - @property - def c_contiguous(self) -> bool: ... - @property - def carray(self) -> bool: ... - @property - def contiguous(self) -> bool: ... - @property - def f_contiguous(self) -> bool: ... - @property - def farray(self) -> bool: ... - @property - def fnc(self) -> bool: ... - @property - def forc(self) -> bool: ... - @property - def fortran(self) -> bool: ... - @property - def num(self) -> int: ... - @property - def owndata(self) -> bool: ... - def __getitem__(self, key: _GetItemKeys) -> bool: ... - def __setitem__(self, key: _SetItemKeys, value: bool) -> None: ... - -def nested_iters( - op: ArrayLike | Sequence[ArrayLike], - axes: Sequence[Sequence[SupportsIndex]], - flags: Sequence[np._NDIterFlagsKind] | None = ..., - op_flags: Sequence[Sequence[np._NDIterFlagsOp]] | None = ..., - op_dtypes: DTypeLike | Sequence[DTypeLike] = ..., - order: np._OrderKACF = ..., - casting: np._CastingKind = ..., - buffersize: SupportsIndex = ..., -) -> tuple[nditer, ...]: ... diff --git a/src/numpy-stubs/_core/numeric.pyi b/src/numpy-stubs/_core/numeric.pyi index 84f06c9b..3c96246f 100644 --- a/src/numpy-stubs/_core/numeric.pyi +++ b/src/numpy-stubs/_core/numeric.pyi @@ -1,20 +1,15 @@ from collections.abc import Callable, Sequence -from typing import ( - Any, - Final, - Literal as L, - NoReturn, - SupportsAbs, - SupportsIndex, - TypeAlias, - overload, -) +from typing import Any, 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, @@ -47,15 +42,10 @@ from numpy._typing import ( _ScalarLike_co, _ShapeLike, _SupportsArrayFunc, - _SupportsDType, ) +from ._multiarray_umath import _Array, _Array1D, _FloatType, _KwargsD, _KwargsDL from .multiarray import ( - # other - _Array, - _ConstructorEmpty, - _KwargsEmpty, - # re-exports arange, array, asanyarray, @@ -162,215 +152,246 @@ __all__ = [ ] _T = TypeVar("_T") -_SCT = TypeVar("_SCT", bound=np.generic) -_DTypeT = TypeVar("_DTypeT", bound=np.dtype[Any]) +_ScalarT = TypeVar("_ScalarT", bound=np.generic) _ArrayT = TypeVar("_ArrayT", bound=np.ndarray[Any, Any]) -_SizeT = TypeVar("_SizeT", bound=int) _ShapeT = TypeVar("_ShapeT", bound=tuple[int, ...]) _CorrelateMode: TypeAlias = L["valid", "same", "full"] +### + +# keep in sync with `empty` and `zeros` in `._multiarray_umath.ones` +@overload # 1d +def ones( + shape: int | tuple[int], + dtype: _FloatType | None = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[np.float64]: ... +@overload +def ones( + shape: int | tuple[int], + dtype: _DTypeLike[_ScalarT], + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[_ScalarT]: ... +@overload +def ones( + shape: int | tuple[int], + dtype: npt.DTypeLike = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array1D: ... +@overload # known shape +def ones( + shape: _AnyShapeT, + dtype: _FloatType | None = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[np.float64, _AnyShapeT]: ... +@overload +def ones( + shape: _AnyShapeT, + dtype: _DTypeLike[_ScalarT], + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[_ScalarT, _AnyShapeT]: ... +@overload +def ones( + shape: _AnyShapeT, + dtype: npt.DTypeLike = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[Any, _AnyShapeT]: ... +@overload # unknown shape +def ones( + shape: _ShapeLike, + dtype: _FloatType | None = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[np.float64]: ... +@overload +def ones( + shape: _ShapeLike, + dtype: _DTypeLike[_ScalarT], + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[_ScalarT]: ... +@overload +def ones( + shape: _ShapeLike, + dtype: npt.DTypeLike = ..., + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array: ... + +# keep in sync with `ones` +@overload +def full( + shape: int | tuple[int], + fill_value: _ScalarT, + dtype: None = None, + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[_ScalarT]: ... +@overload +def full( + shape: int | tuple[int], + fill_value: object, + dtype: _DTypeLike[_ScalarT], + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array1D[_ScalarT]: ... +@overload +def full( + shape: int | tuple[int], + fill_value: object, + dtype: DTypeLike | None = None, + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array1D: ... +@overload +def full( + shape: _ShapeT, + fill_value: _ScalarT, + dtype: None = None, + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[_ScalarT, _ShapeT]: ... +@overload +def full( + shape: _ShapeT, + fill_value: object, + dtype: _DTypeLike[_ScalarT], + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[_ScalarT, _ShapeT]: ... +@overload +def full( + shape: _ShapeT, + fill_value: object, + dtype: DTypeLike | None = None, + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array[Any, _ShapeT]: ... +@overload +def full( + shape: _ShapeLike, + fill_value: _ScalarT, + dtype: None = None, + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> NDArray[_ScalarT]: ... +@overload +def full( + shape: _ShapeLike, + fill_value: object, + dtype: _DTypeLike[_ScalarT], + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> NDArray[_ScalarT]: ... +@overload +def full( + shape: _ShapeLike, + fill_value: object, + dtype: DTypeLike | None = None, + order: _OrderCF = "C", + **kwargs: Unpack[_KwargsDL], +) -> _Array: ... + +# @overload def zeros_like( a: _ArrayT, dtype: None = ..., - order: np._OrderKACF = ..., + order: _OrderKACF = ..., subok: L[True] = ..., shape: None = ..., - *, - device: L["cpu"] | None = ..., + **kwargs: Unpack[_KwargsD], ) -> _ArrayT: ... @overload def zeros_like( - a: _ArrayLike[_SCT], + a: _ArrayLike[_ScalarT], dtype: None = ..., - order: np._OrderKACF = ..., + order: _OrderKACF = ..., subok: bool = ..., shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[_SCT]: ... + **kwargs: Unpack[_KwargsD], +) -> NDArray[_ScalarT]: ... @overload def zeros_like( a: object, dtype: None = ..., - order: np._OrderKACF = ..., + order: _OrderKACF = ..., subok: bool = ..., shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[Any]: ... + **kwargs: Unpack[_KwargsD], +) -> _Array: ... @overload def zeros_like( a: Any, - dtype: _DTypeLike[_SCT], - order: np._OrderKACF = ..., + dtype: _DTypeLike[_ScalarT], + order: _OrderKACF = ..., subok: bool = ..., shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[_SCT]: ... + **kwargs: Unpack[_KwargsD], +) -> NDArray[_ScalarT]: ... @overload def zeros_like( a: Any, dtype: DTypeLike, - order: np._OrderKACF = ..., + order: _OrderKACF = ..., subok: bool = ..., shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[Any]: ... - -ones: Final[_ConstructorEmpty] + **kwargs: Unpack[_KwargsD], +) -> _Array: ... +# @overload def ones_like( a: _ArrayT, dtype: None = ..., - order: np._OrderKACF = ..., + order: _OrderKACF = ..., subok: L[True] = ..., shape: None = ..., - *, - device: L["cpu"] | None = ..., + **kwargs: Unpack[_KwargsD], ) -> _ArrayT: ... @overload def ones_like( - a: _ArrayLike[_SCT], + a: _ArrayLike[_ScalarT], dtype: None = ..., - order: np._OrderKACF = ..., + order: _OrderKACF = ..., subok: bool = ..., shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[_SCT]: ... + **kwargs: Unpack[_KwargsD], +) -> NDArray[_ScalarT]: ... @overload def ones_like( a: object, dtype: None = ..., - order: np._OrderKACF = ..., + order: _OrderKACF = ..., subok: bool = ..., shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[Any]: ... + **kwargs: Unpack[_KwargsD], +) -> _Array: ... @overload def ones_like( a: Any, - dtype: _DTypeLike[_SCT], - order: np._OrderKACF = ..., + dtype: _DTypeLike[_ScalarT], + order: _OrderKACF = ..., subok: bool = ..., shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[_SCT]: ... + **kwargs: Unpack[_KwargsD], +) -> NDArray[_ScalarT]: ... @overload def ones_like( a: Any, dtype: DTypeLike, - order: np._OrderKACF = ..., + order: _OrderKACF = ..., subok: bool = ..., shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[Any]: ... - -# TODO: Add overloads for bool, int, float, complex, str, bytes, and memoryview -@overload -def full( - shape: _SizeT, - fill_value: _SCT, - dtype: None = ..., - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], -) -> _Array[tuple[_SizeT], _SCT]: ... -@overload -def full( - shape: _SizeT, - fill_value: Any, - dtype: _DTypeT | _SupportsDType[_DTypeT], - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], -) -> np.ndarray[tuple[_SizeT], _DTypeT]: ... -@overload -def full( - shape: _SizeT, - fill_value: Any, - dtype: type[_SCT], - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], -) -> _Array[tuple[_SizeT], _SCT]: ... -@overload -def full( - shape: _SizeT, - fill_value: Any, - dtype: DTypeLike | None = ..., - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], -) -> _Array[tuple[_SizeT], Any]: ... -@overload -def full( - shape: _ShapeT, - fill_value: _SCT, - dtype: None = ..., - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], -) -> _Array[_ShapeT, _SCT]: ... -@overload -def full( - shape: _ShapeT, - fill_value: Any, - dtype: _DTypeT | _SupportsDType[_DTypeT], - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], -) -> np.ndarray[_ShapeT, _DTypeT]: ... -@overload -def full( - shape: _ShapeT, - fill_value: Any, - dtype: type[_SCT], - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], -) -> _Array[_ShapeT, _SCT]: ... -@overload -def full( - shape: _ShapeT, - fill_value: Any, - dtype: DTypeLike | None = ..., - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], -) -> _Array[_ShapeT, Any]: ... -@overload -def full( - shape: _ShapeLike, - fill_value: _SCT, - dtype: None = ..., - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], -) -> NDArray[_SCT]: ... -@overload -def full( - shape: _ShapeLike, - fill_value: Any, - dtype: _DTypeT | _SupportsDType[_DTypeT], - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], -) -> np.ndarray[Any, _DTypeT]: ... -@overload -def full( - shape: _ShapeLike, - fill_value: Any, - dtype: type[_SCT], - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], -) -> NDArray[_SCT]: ... -@overload -def full( - shape: _ShapeLike, - fill_value: Any, - dtype: DTypeLike | None = ..., - order: np._OrderCF = ..., - **kwargs: Unpack[_KwargsEmpty], -) -> NDArray[Any]: ... + **kwargs: Unpack[_KwargsD], +) -> _Array: ... # @overload @@ -378,56 +399,51 @@ def full_like( a: _ArrayT, fill_value: Any, dtype: None = ..., - order: np._OrderKACF = ..., + order: _OrderKACF = ..., subok: L[True] = ..., shape: None = ..., - *, - device: L["cpu"] | None = ..., + **kwargs: Unpack[_KwargsD], ) -> _ArrayT: ... @overload def full_like( - a: _ArrayLike[_SCT], + a: _ArrayLike[_ScalarT], fill_value: Any, dtype: None = ..., - order: np._OrderKACF = ..., + order: _OrderKACF = ..., subok: bool = ..., shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[_SCT]: ... + **kwargs: Unpack[_KwargsD], +) -> NDArray[_ScalarT]: ... @overload def full_like( a: object, fill_value: Any, dtype: None = ..., - order: np._OrderKACF = ..., + order: _OrderKACF = ..., subok: bool = ..., shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[Any]: ... + **kwargs: Unpack[_KwargsD], +) -> _Array: ... @overload def full_like( a: Any, fill_value: Any, - dtype: _DTypeLike[_SCT], - order: np._OrderKACF = ..., + dtype: _DTypeLike[_ScalarT], + order: _OrderKACF = ..., subok: bool = ..., shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[_SCT]: ... + **kwargs: Unpack[_KwargsD], +) -> NDArray[_ScalarT]: ... @overload def full_like( a: Any, fill_value: Any, dtype: DTypeLike, - order: np._OrderKACF = ..., + order: _OrderKACF = ..., subok: bool = ..., shape: _ShapeLike | None = ..., - *, - device: L["cpu"] | None = ..., -) -> NDArray[Any]: ... + **kwargs: Unpack[_KwargsD], +) -> _Array: ... # @overload @@ -436,13 +452,13 @@ def count_nonzero(a: ArrayLike, axis: None = ..., *, keepdims: L[False] = ...) - def count_nonzero(a: ArrayLike, axis: _ShapeLike = ..., *, keepdims: bool = ...) -> Any: ... # -def isfortran(a: NDArray[Any] | np.generic) -> bool: ... +def isfortran(a: _Array | np.generic) -> bool: ... def argwhere(a: ArrayLike) -> NDArray[np.int_]: ... def flatnonzero(a: ArrayLike) -> NDArray[np.int_]: ... # @overload -def correlate(a: _ArrayLikeUnknown, v: _ArrayLikeUnknown, mode: _CorrelateMode = ...) -> NDArray[Any]: ... +def correlate(a: _ArrayLikeUnknown, v: _ArrayLikeUnknown, mode: _CorrelateMode = ...) -> _Array: ... @overload def correlate(a: _ArrayLikeBool_co, v: _ArrayLikeBool_co, mode: _CorrelateMode = ...) -> NDArray[np.bool]: ... @overload @@ -460,7 +476,7 @@ def correlate(a: _ArrayLikeObject_co, v: _ArrayLikeObject_co, mode: _CorrelateMo # @overload -def convolve(a: _ArrayLikeUnknown, v: _ArrayLikeUnknown, mode: _CorrelateMode = ...) -> NDArray[Any]: ... +def convolve(a: _ArrayLikeUnknown, v: _ArrayLikeUnknown, mode: _CorrelateMode = ...) -> _Array: ... @overload def convolve(a: _ArrayLikeBool_co, v: _ArrayLikeBool_co, mode: _CorrelateMode = ...) -> NDArray[np.bool]: ... @overload @@ -478,7 +494,7 @@ def convolve(a: _ArrayLikeObject_co, v: _ArrayLikeObject_co, mode: _CorrelateMod # @overload -def outer(a: _ArrayLikeUnknown, b: _ArrayLikeUnknown, out: None = ...) -> NDArray[Any]: ... +def outer(a: _ArrayLikeUnknown, b: _ArrayLikeUnknown, out: None = ...) -> _Array: ... @overload def outer(a: _ArrayLikeBool_co, b: _ArrayLikeBool_co, out: None = ...) -> NDArray[np.bool]: ... @overload @@ -506,7 +522,7 @@ def tensordot( a: _ArrayLikeUnknown, b: _ArrayLikeUnknown, axes: int | tuple[_ShapeLike, _ShapeLike] = ..., -) -> NDArray[Any]: ... +) -> _Array: ... @overload def tensordot( a: _ArrayLikeBool_co, @@ -552,13 +568,13 @@ def tensordot( # @overload -def roll(a: _ArrayLike[_SCT], shift: _ShapeLike, axis: _ShapeLike | None = ...) -> NDArray[_SCT]: ... +def roll(a: _ArrayLike[_ScalarT], shift: _ShapeLike, axis: _ShapeLike | None = ...) -> NDArray[_ScalarT]: ... @overload -def roll(a: ArrayLike, shift: _ShapeLike, axis: _ShapeLike | None = ...) -> NDArray[Any]: ... +def roll(a: ArrayLike, shift: _ShapeLike, axis: _ShapeLike | None = ...) -> _Array: ... # -def rollaxis(a: NDArray[_SCT], axis: int, start: int = ...) -> NDArray[_SCT]: ... -def moveaxis(a: NDArray[_SCT], source: _ShapeLike, destination: _ShapeLike) -> NDArray[_SCT]: ... +def rollaxis(a: NDArray[_ScalarT], axis: int, start: int = ...) -> NDArray[_ScalarT]: ... +def moveaxis(a: NDArray[_ScalarT], source: _ShapeLike, destination: _ShapeLike) -> NDArray[_ScalarT]: ... # @overload @@ -569,7 +585,7 @@ def cross( axisb: int = ..., axisc: int = ..., axis: int | None = ..., -) -> NDArray[Any]: ... +) -> _Array: ... @overload def cross( x1: _ArrayLikeBool_co, @@ -641,27 +657,27 @@ def indices( @overload def indices( dimensions: Sequence[int], - dtype: _DTypeLike[_SCT], + dtype: _DTypeLike[_ScalarT], sparse: L[False] = ..., -) -> NDArray[_SCT]: ... +) -> NDArray[_ScalarT]: ... @overload def indices( dimensions: Sequence[int], - dtype: _DTypeLike[_SCT], + dtype: _DTypeLike[_ScalarT], sparse: L[True], -) -> tuple[NDArray[_SCT], ...]: ... +) -> tuple[NDArray[_ScalarT], ...]: ... @overload def indices( dimensions: Sequence[int], dtype: DTypeLike, sparse: L[False] = ..., -) -> NDArray[Any]: ... +) -> _Array: ... @overload def indices( dimensions: Sequence[int], dtype: DTypeLike, sparse: L[True], -) -> tuple[NDArray[Any], ...]: ... +) -> tuple[_Array, ...]: ... # def fromfunction( @@ -670,7 +686,7 @@ def fromfunction( *, dtype: DTypeLike = ..., like: _SupportsArrayFunc = ..., - **kwargs: Any, + **kwargs: object, ) -> _T: ... # @@ -686,9 +702,9 @@ def base_repr(number: SupportsAbs[float], base: float = ..., padding: SupportsIn @overload def identity(n: int, dtype: None = ..., *, like: _SupportsArrayFunc = ...) -> NDArray[np.float64]: ... @overload -def identity(n: int, dtype: _DTypeLike[_SCT], *, like: _SupportsArrayFunc = ...) -> NDArray[_SCT]: ... +def identity(n: int, dtype: _DTypeLike[_ScalarT], *, like: _SupportsArrayFunc = ...) -> NDArray[_ScalarT]: ... @overload -def identity(n: int, dtype: DTypeLike, *, like: _SupportsArrayFunc = ...) -> NDArray[Any]: ... +def identity(n: int, dtype: DTypeLike, *, like: _SupportsArrayFunc = ...) -> _Array: ... # def allclose(a: ArrayLike, b: ArrayLike, rtol: ArrayLike = ..., atol: ArrayLike = ..., equal_nan: bool = ...) -> bool: ... @@ -719,14 +735,18 @@ def array_equiv(a1: ArrayLike, a2: ArrayLike) -> bool: ... @overload def astype( x: ndarray[_ShapeT, dtype[Any]], - dtype: _DTypeLike[_SCT], - copy: bool = ..., - device: L["cpu"] | None = ..., -) -> ndarray[_ShapeT, dtype[_SCT]]: ... + dtype: _DTypeLike[_ScalarT], + /, + *, + copy: bool = True, + **kwargs: Unpack[_KwargsD], +) -> ndarray[_ShapeT, dtype[_ScalarT]]: ... @overload def astype( x: ndarray[_ShapeT, dtype[Any]], dtype: DTypeLike, - copy: bool = ..., - device: L["cpu"] | None = ..., + /, + *, + copy: bool = True, + **kwargs: Unpack[_KwargsD], ) -> ndarray[_ShapeT, dtype[Any]]: ... diff --git a/src/numpy-stubs/_typing/_ufunc.pyi b/src/numpy-stubs/_typing/_ufunc.pyi index 6f8af49e..d2e842b8 100644 --- a/src/numpy-stubs/_typing/_ufunc.pyi +++ b/src/numpy-stubs/_typing/_ufunc.pyi @@ -25,19 +25,20 @@ _2Tuple: TypeAlias = tuple[_T, _T] _3Tuple: TypeAlias = tuple[_T, _T, _T] _4Tuple: TypeAlias = tuple[_T, _T, _T, _T] -_2PTuple: TypeAlias = tuple[_T, _T, *tuple[_T, ...]] -_3PTuple: TypeAlias = tuple[_T, _T, _T, *tuple[_T, ...]] -_4PTuple: TypeAlias = tuple[_T, _T, _T, _T, *tuple[_T, ...]] +_2PTuple: TypeAlias = tuple[_T, _T, Unpack[tuple[_T, ...]]] +_3PTuple: TypeAlias = tuple[_T, _T, _T, Unpack[tuple[_T, ...]]] +_4PTuple: TypeAlias = tuple[_T, _T, _T, _T, Unpack[tuple[_T, ...]]] _NTypesT_co = TypeVar("_NTypesT_co", bound=int, covariant=True) -_IdentityT_co = TypeVar("_IdentityT_co", covariant=True) +_IdentityT_co = TypeVar("_IdentityT_co", default=None, covariant=True) _NameT_co = TypeVar("_NameT_co", bound=LiteralString, covariant=True) _SignatureT_co = TypeVar("_SignatureT_co", bound=LiteralString, covariant=True) - -_NInT_co = TypeVar("_NInT_co", bound=int, covariant=True) -_NOutT_co = TypeVar("_NOutT_co", bound=int, covariant=True) _OutT_co = TypeVar("_OutT_co", covariant=True) +_OutT1_co = TypeVar("_OutT1_co", covariant=True) +_OutT2_co = TypeVar("_OutT2_co", covariant=True) _ArrayT = TypeVar("_ArrayT", bound=npt.NDArray[Any]) +_ArrayT1 = TypeVar("_ArrayT1", bound=npt.NDArray[Any]) +_ArrayT2 = TypeVar("_ArrayT2", bound=npt.NDArray[Any]) @type_check_only class _SupportsArrayUFunc(Protocol): @@ -92,7 +93,7 @@ class _UFunc_Nin1_Nout1(np.ufunc, Generic[_NameT_co, _NTypesT_co, _IdentityT_co] self, x1: _ScalarLike_co, /, - out: None = ..., + out: None = None, *, where: _ArrayLikeBool_co | None = ..., casting: np._CastingKind = ..., @@ -444,7 +445,7 @@ class _GUFunc_Nin2_Nout1(np.ufunc, Generic[_NameT_co, _NTypesT_co, _IdentityT_co x1: ArrayLike, x2: ArrayLike, /, - out: None = ..., + out: None = None, *, casting: np._CastingKind = ..., order: np._OrderKACF = ..., @@ -529,7 +530,7 @@ class _PyFunc_Nin1_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co]): # type: i self, x1: _ScalarLike_co, /, - out: None = ..., + out: None = None, **kwargs: Unpack[_PyFunc_Kwargs_Nargs2], ) -> _OutT_co: ... @overload @@ -537,7 +538,7 @@ class _PyFunc_Nin1_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co]): # type: i self, x1: ArrayLike, /, - out: None = ..., + out: None = None, **kwargs: Unpack[_PyFunc_Kwargs_Nargs2], ) -> _OutT_co | npt.NDArray[np.object_]: ... @overload @@ -582,7 +583,7 @@ class _PyFunc_Nin2_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co]): # type: i x1: _ScalarLike_co, x2: _ScalarLike_co, /, - out: None = ..., + out: None = None, **kwargs: Unpack[_PyFunc_Kwargs_Nargs3], ) -> _OutT_co: ... @overload @@ -591,7 +592,7 @@ class _PyFunc_Nin2_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co]): # type: i x1: ArrayLike, x2: ArrayLike, /, - out: None = ..., + out: None = None, **kwargs: Unpack[_PyFunc_Kwargs_Nargs3], ) -> _OutT_co | npt.NDArray[np.object_]: ... @overload @@ -654,7 +655,7 @@ class _PyFunc_Nin2_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co]): # type: i array: ArrayLike, axis: _ShapeLike | None = ..., dtype: DTypeLike = ..., - out: None = ..., + out: None = None, *, keepdims: Literal[True], initial: _ScalarLike_co = ..., @@ -667,7 +668,7 @@ class _PyFunc_Nin2_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co]): # type: i array: ArrayLike, axis: _ShapeLike | None = ..., dtype: DTypeLike = ..., - out: None = ..., + out: None = None, keepdims: bool = ..., initial: _ScalarLike_co = ..., where: _ArrayLikeBool_co = ..., @@ -701,7 +702,7 @@ class _PyFunc_Nin2_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co]): # type: i indices: _ArrayLikeInt_co, axis: SupportsIndex = ..., dtype: DTypeLike = ..., - out: None = ..., + out: None = None, ) -> npt.NDArray[np.object_]: ... @overload def reduceat( @@ -738,7 +739,7 @@ class _PyFunc_Nin2_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co]): # type: i array: ArrayLike, axis: SupportsIndex = ..., dtype: DTypeLike = ..., - out: None = ..., + out: None = None, ) -> npt.NDArray[np.object_]: ... @overload def outer( @@ -747,7 +748,7 @@ class _PyFunc_Nin2_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co]): # type: i B: _ScalarLike_co, /, *, - out: None = ..., + out: None = None, **kwargs: Unpack[_PyFunc_Kwargs_Nargs3], ) -> _OutT_co: ... @overload @@ -757,7 +758,7 @@ class _PyFunc_Nin2_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co]): # type: i B: ArrayLike, /, *, - out: None = ..., + out: None = None, **kwargs: Unpack[_PyFunc_Kwargs_Nargs3], ) -> _OutT_co | npt.NDArray[np.object_]: ... @overload @@ -777,7 +778,7 @@ class _PyFunc_Nin2_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co]): # type: i B: _SupportsArrayUFunc | ArrayLike, /, *, - out: None = ..., + out: None = None, **kwargs: Unpack[_PyFunc_Kwargs_Nargs3], ) -> Any: ... @overload @@ -787,16 +788,16 @@ class _PyFunc_Nin2_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co]): # type: i B: _SupportsArrayUFunc | ArrayLike, /, *, - out: None = ..., + out: None = None, **kwargs: Unpack[_PyFunc_Kwargs_Nargs3], ) -> Any: ... @type_check_only -class _PyFunc_Nin3P_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co, _NInT_co]): # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues] +class _PyFunc_Nin3P_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co]): # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues] @property def identity(self) -> _IdentityT_co: ... @property - def nin(self) -> _NInT_co: ... + def nin(self) -> int: ... @property def nout(self) -> Literal[1]: ... @property @@ -811,7 +812,7 @@ class _PyFunc_Nin3P_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co, _NInT_co]): x3: _ScalarLike_co, /, *xs: _ScalarLike_co, - out: None = ..., + out: None = None, **kwargs: Unpack[_PyFunc_Kwargs_Nargs4P], ) -> _OutT_co: ... @overload @@ -822,7 +823,7 @@ class _PyFunc_Nin3P_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co, _NInT_co]): x3: ArrayLike, /, *xs: ArrayLike, - out: None = ..., + out: None = None, **kwargs: Unpack[_PyFunc_Kwargs_Nargs4P], ) -> _OutT_co | npt.NDArray[np.object_]: ... @overload @@ -854,13 +855,13 @@ class _PyFunc_Nin3P_Nout1(np.ufunc, Generic[_OutT_co, _IdentityT_co, _NInT_co]): def outer(self, /, *args: Any, **kwargs: Any) -> NoReturn: ... @type_check_only -class _PyFunc_Nin1P_Nout2P(np.ufunc, Generic[_OutT_co, _IdentityT_co, _NInT_co, _NOutT_co]): # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues] +class _PyFunc_Nin1P_Nout2(np.ufunc, Generic[_OutT1_co, _OutT2_co, _IdentityT_co]): # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues] @property def identity(self) -> _IdentityT_co: ... @property - def nin(self) -> _NInT_co: ... + def nin(self) -> int: ... @property - def nout(self) -> _NOutT_co: ... + def nout(self) -> Literal[2]: ... @property def ntypes(self) -> Literal[1]: ... @property @@ -871,7 +872,61 @@ class _PyFunc_Nin1P_Nout2P(np.ufunc, Generic[_OutT_co, _IdentityT_co, _NInT_co, x1: _ScalarLike_co, /, *xs: _ScalarLike_co, - out: None = ..., + out: None = None, + **kwargs: Unpack[_PyFunc_Kwargs_Nargs3P], + ) -> tuple[_OutT1_co, _OutT2_co]: ... + @overload + def __call__( + self, + x1: ArrayLike, + /, + *xs: ArrayLike, + out: None = None, + **kwargs: Unpack[_PyFunc_Kwargs_Nargs3P], + ) -> tuple[_OutT1_co | npt.NDArray[np.object_], _OutT2_co | npt.NDArray[np.object_]]: ... + @overload + def __call__( + self, + x1: ArrayLike, + /, + *xs: ArrayLike, + out: tuple[_ArrayT1, _ArrayT2], + **kwargs: Unpack[_PyFunc_Kwargs_Nargs3P], + ) -> tuple[_ArrayT1, _ArrayT2]: ... + @overload + def __call__( + self, + x1: _SupportsArrayUFunc | ArrayLike, + /, + *xs: _SupportsArrayUFunc | ArrayLike, + out: _2PTuple[npt.NDArray[Any]] | None = ..., + **kwargs: Unpack[_PyFunc_Kwargs_Nargs3P], + ) -> Any: ... + def at(self, /, *args: Any, **kwargs: Any) -> NoReturn: ... + def reduce(self, /, *args: Any, **kwargs: Any) -> NoReturn: ... + def accumulate(self, /, *args: Any, **kwargs: Any) -> NoReturn: ... + def reduceat(self, /, *args: Any, **kwargs: Any) -> NoReturn: ... + def outer(self, /, *args: Any, **kwargs: Any) -> NoReturn: ... + +@type_check_only +class _PyFunc_Nin1P_Nout2P(np.ufunc, Generic[_OutT_co, _IdentityT_co]): # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues] + @property + def identity(self) -> _IdentityT_co: ... + @property + def nin(self) -> int: ... + @property + def nout(self) -> int: ... + @property + def ntypes(self) -> Literal[1]: ... + @property + def signature(self) -> None: ... + @overload + def __call__( + self, + x1: _ScalarLike_co, + /, + *xs: _ScalarLike_co, + out: None = None, **kwargs: Unpack[_PyFunc_Kwargs_Nargs3P], ) -> _2PTuple[_OutT_co]: ... @overload @@ -880,7 +935,7 @@ class _PyFunc_Nin1P_Nout2P(np.ufunc, Generic[_OutT_co, _IdentityT_co, _NInT_co, x1: ArrayLike, /, *xs: ArrayLike, - out: None = ..., + out: None = None, **kwargs: Unpack[_PyFunc_Kwargs_Nargs3P], ) -> _2PTuple[_OutT_co | npt.NDArray[np.object_]]: ... @overload diff --git a/test/runtime/accept/literal.py b/test/runtime/accept/literal.py index c8ad2d70..db4bf607 100644 --- a/test/runtime/accept/literal.py +++ b/test/runtime/accept/literal.py @@ -26,10 +26,9 @@ (KACF, AR.flatten), (KACF, AR.ravel), (KACF, partial(np.array, 1)), - # NOTE: __call__ is needed due to mypy>=1.11 bugs (#17620, #17631) (also in 1.14) - (CF, partial(np.zeros.__call__, 1)), - (CF, partial(np.ones.__call__, 1)), - (CF, partial(np.empty.__call__, 1)), + (CF, partial(np.zeros, 1)), + (CF, partial(np.ones, 1)), + (CF, partial(np.empty, 1)), (CF, partial(np.full, 1, 1)), (KACF, partial(np.zeros_like, AR)), (KACF, partial(np.ones_like, AR)), diff --git a/test/runtime/accept/recfunctions.py b/test/runtime/accept/recfunctions.py index 03322e06..94f65660 100644 --- a/test/runtime/accept/recfunctions.py +++ b/test/runtime/accept/recfunctions.py @@ -93,7 +93,7 @@ def test_repack_fields() -> None: assert_type(rfn.repack_fields(dt), np.dtype[np.void]) assert_type(rfn.repack_fields(dt.type(0)), np.void) assert_type( - rfn.repack_fields(np.ones((int(3),), dtype=dt)), + rfn.repack_fields(np.ones((3,), dtype=dt)), np.ndarray[tuple[int], np.dtype[np.void]], ) diff --git a/test/static/accept/array_constructors.pyi b/test/static/accept/array_constructors.pyi index 126fbcc4..7db4f6b2 100644 --- a/test/static/accept/array_constructors.pyi +++ b/test/static/accept/array_constructors.pyi @@ -9,7 +9,7 @@ import numpy.typing as npt _SCT_co = TypeVar("_SCT_co", bound=np.generic, covariant=True) -class MyArray(npt.NDArray[_SCT_co]): ... +class MyArray(np.ndarray[tuple[int], np.dtype[_SCT_co]]): ... i8: np.int64 @@ -27,7 +27,8 @@ assert_type(np.empty_like(A, dtype=np.int64), npt.NDArray[np.int64]) assert_type(np.empty_like(A, dtype="c16"), npt.NDArray[Any]) assert_type(np.array(A), npt.NDArray[np.float64]) -assert_type(np.array(B), npt.NDArray[np.float64]) +assert_type(np.array(B), np.ndarray[tuple[int], np.dtype[np.float64]]) +assert_type(np.array(D), np.ndarray[tuple[int], np.dtype[np.float64 | np.int64]]) assert_type(np.array([1, 1.0]), npt.NDArray[Any]) assert_type(np.array(deque([1, 2, 3])), npt.NDArray[Any]) assert_type(np.array(A, dtype=np.int64), npt.NDArray[np.int64]) @@ -37,7 +38,6 @@ assert_type(np.array(A, subok=True), npt.NDArray[np.float64]) assert_type(np.array(B, subok=True), MyArray[np.float64]) assert_type(np.array(B, subok=True, ndmin=0), MyArray[np.float64]) assert_type(np.array(B, subok=True, ndmin=1), MyArray[np.float64]) -assert_type(np.array(D), npt.NDArray[np.float64 | np.int64]) assert_type(np.zeros([1, 5, 6]), npt.NDArray[np.float64]) assert_type(np.zeros([1, 5, 6], dtype=np.int64), npt.NDArray[np.int64]) @@ -59,7 +59,7 @@ assert_type(np.concatenate(A, dtype="c16"), npt.NDArray[Any]) assert_type(np.concatenate([1, 1.0], out=A), npt.NDArray[np.float64]) assert_type(np.asarray(A), npt.NDArray[np.float64]) -assert_type(np.asarray(B), npt.NDArray[np.float64]) +assert_type(np.asarray(B), np.ndarray[tuple[int], np.dtype[np.float64]]) assert_type(np.asarray([1, 1.0]), npt.NDArray[Any]) assert_type(np.asarray(A, dtype=np.int64), npt.NDArray[np.int64]) assert_type(np.asarray(A, dtype="c16"), npt.NDArray[Any]) @@ -71,13 +71,13 @@ assert_type(np.asanyarray(A, dtype=np.int64), npt.NDArray[np.int64]) assert_type(np.asanyarray(A, dtype="c16"), npt.NDArray[Any]) assert_type(np.ascontiguousarray(A), npt.NDArray[np.float64]) -assert_type(np.ascontiguousarray(B), npt.NDArray[np.float64]) +assert_type(np.ascontiguousarray(B), np.ndarray[tuple[int], np.dtype[np.float64]]) assert_type(np.ascontiguousarray([1, 1.0]), npt.NDArray[Any]) assert_type(np.ascontiguousarray(A, dtype=np.int64), npt.NDArray[np.int64]) assert_type(np.ascontiguousarray(A, dtype="c16"), npt.NDArray[Any]) assert_type(np.asfortranarray(A), npt.NDArray[np.float64]) -assert_type(np.asfortranarray(B), npt.NDArray[np.float64]) +assert_type(np.asfortranarray(B), np.ndarray[tuple[int], np.dtype[np.float64]]) assert_type(np.asfortranarray([1, 1.0]), npt.NDArray[Any]) assert_type(np.asfortranarray(A, dtype=np.int64), npt.NDArray[np.int64]) assert_type(np.asfortranarray(A, dtype="c16"), npt.NDArray[Any]) @@ -104,17 +104,17 @@ assert_type(np.frombuffer(A), npt.NDArray[np.float64]) assert_type(np.frombuffer(A, dtype=np.int64), npt.NDArray[np.int64]) assert_type(np.frombuffer(A, dtype="c16"), npt.NDArray[Any]) -assert_type(np.arange(False, True), np.ndarray[tuple[int], np.dtype[np.signedinteger]]) -assert_type(np.arange(10), np.ndarray[tuple[int], np.dtype[np.signedinteger]]) -assert_type(np.arange(0, 10, step=2), np.ndarray[tuple[int], np.dtype[np.signedinteger]]) -assert_type(np.arange(10.0), np.ndarray[tuple[int], np.dtype[np.floating]]) -assert_type(np.arange(start=0, stop=10.0), np.ndarray[tuple[int], np.dtype[np.floating]]) +assert_type(np.arange(False, True), np.ndarray[tuple[int], np.dtype[np.int_]]) +assert_type(np.arange(10), np.ndarray[tuple[int], np.dtype[np.int_]]) +assert_type(np.arange(0, 10, step=2), np.ndarray[tuple[int], np.dtype[np.int_]]) +assert_type(np.arange(10.0), np.ndarray[tuple[int], np.dtype[np.float64 | np.int_]]) +assert_type(np.arange(start=0, stop=10.0), np.ndarray[tuple[int], np.dtype[np.float64 | np.int_]]) assert_type(np.arange(np.timedelta64(0)), np.ndarray[tuple[int], np.dtype[np.timedelta64]]) assert_type(np.arange(0, np.timedelta64(10)), np.ndarray[tuple[int], np.dtype[np.timedelta64]]) assert_type(np.arange(np.datetime64("0"), np.datetime64("10")), np.ndarray[tuple[int], np.dtype[np.datetime64]]) assert_type(np.arange(10, dtype=np.float64), np.ndarray[tuple[int], np.dtype[np.float64]]) assert_type(np.arange(0, 10, step=2, dtype=np.int16), np.ndarray[tuple[int], np.dtype[np.int16]]) -assert_type(np.arange(10, dtype=int), np.ndarray[tuple[int], np.dtype[Any]]) +assert_type(np.arange(10, dtype=int), np.ndarray[tuple[int], np.dtype[np.int_]]) assert_type(np.arange(0, 10, dtype="f8"), np.ndarray[tuple[int], np.dtype[Any]]) assert_type(np.require(A), npt.NDArray[np.float64]) @@ -179,7 +179,7 @@ assert_type(np.ones(_shape_2d), np.ndarray[tuple[int, int], np.dtype[np.float64] assert_type(np.ones(_shape_nd), np.ndarray[tuple[int, ...], np.dtype[np.float64]]) assert_type(np.ones(_shape_1d, dtype=np.int64), np.ndarray[tuple[int], np.dtype[np.int64]]) assert_type(np.ones(_shape_like), npt.NDArray[np.float64]) -assert_type(np.ones(_shape_like, dtype=np.dtypes.Int64DType()), np.ndarray[Any, np.dtypes.Int64DType]) +assert_type(np.ones(_shape_like, dtype=np.dtypes.Int64DType()), npt.NDArray[np.int64]) assert_type(np.ones(_shape_like, dtype=int), npt.NDArray[Any]) assert_type(np.full(_size, i8), np.ndarray[tuple[int], np.dtype[np.int64]]) diff --git a/test/static/accept/flatiter.pyi b/test/static/accept/flatiter.pyi index 82526de2..5ca0bec3 100644 --- a/test/static/accept/flatiter.pyi +++ b/test/static/accept/flatiter.pyi @@ -1,4 +1,3 @@ -from typing import Literal, TypeAlias from typing_extensions import assert_type import numpy as np @@ -7,9 +6,6 @@ import numpy.typing as npt a: np.flatiter[npt.NDArray[np.str_]] a_1d: np.flatiter[np.ndarray[tuple[int], np.dtype[np.bytes_]]] -Size: TypeAlias = Literal[42] -a_1d_fixed: np.flatiter[np.ndarray[tuple[Size], np.dtype[np.object_]]] - assert_type(a.base, npt.NDArray[np.str_]) assert_type(a.copy(), npt.NDArray[np.str_]) assert_type(a.coords, tuple[int, ...]) @@ -23,23 +19,21 @@ assert_type(a[:], npt.NDArray[np.str_]) assert_type(a[...,], npt.NDArray[np.str_]) assert_type(a[0,], np.str_) -assert_type(a.__array__(), npt.NDArray[np.str_]) -assert_type(a.__array__(np.dtype(np.float64)), npt.NDArray[np.float64]) assert_type( - a_1d.__array__(), - np.ndarray[tuple[int], np.dtype[np.bytes_]], + a.__array__(), + np.ndarray[tuple[int], np.dtype[np.str_]], ) assert_type( - a_1d.__array__(np.dtype(np.float64)), + a.__array__(np.dtype(np.float64)), np.ndarray[tuple[int], np.dtype[np.float64]], ) assert_type( - a_1d_fixed.__array__(), - np.ndarray[tuple[Size], np.dtype[np.object_]], + a_1d.__array__(), + np.ndarray[tuple[int], np.dtype[np.bytes_]], ) assert_type( - a_1d_fixed.__array__(np.dtype(np.float64)), - np.ndarray[tuple[Size], np.dtype[np.float64]], + a_1d.__array__(np.dtype(np.float64)), + np.ndarray[tuple[int], np.dtype[np.float64]], ) a[0] = "a" diff --git a/test/static/accept/multiarray.pyi b/test/static/accept/multiarray.pyi index 568eceeb..ce1be79f 100644 --- a/test/static/accept/multiarray.pyi +++ b/test/static/accept/multiarray.pyi @@ -1,5 +1,5 @@ import datetime as dt -from typing import Any, Literal +from typing import Any, Literal as L from typing_extensions import TypeVar, assert_type import numpy as np @@ -34,10 +34,6 @@ date_scalar: dt.date date_seq: list[dt.date] timedelta_seq: list[dt.timedelta] -n1: Literal[1] -n2: Literal[2] -n3: Literal[3] - f8: np.float64 def func11(a: int) -> bool: ... @@ -68,10 +64,16 @@ assert_type(b_i8_f8_f8.size, int) assert_type(np.inner(AR_f8, AR_i8), Any) -assert_type(np.where([True, True, False]), tuple[npt.NDArray[np.intp], ...]) -assert_type(np.where([True, True, False], 1, 0), npt.NDArray[Any]) +assert_type( + np.where([True, True, False], 1, 0), + npt.NDArray[Any], +) +assert_type( + np.where([True, True, False]), + tuple[npt.NDArray[np.intp], ...], +) -assert_type(np.lexsort([0, 1, 2]), Any) +assert_type(np.lexsort([0, 1, 2]), np.int_) assert_type(np.can_cast(np.dtype("i8"), int), bool) assert_type(np.can_cast(AR_f8, "f8"), bool) @@ -89,9 +91,9 @@ assert_type(np.dot(AR_u1, 1), Any) assert_type(np.dot(1.5j, 1), Any) assert_type(np.dot(AR_u1, 1, out=AR_f8), npt.NDArray[np.float64]) -assert_type(np.vdot(AR_LIKE_f, AR_i8), np.floating[Any]) -assert_type(np.vdot(AR_u1, 1), np.signedinteger[Any]) -assert_type(np.vdot(1.5j, 1), np.complexfloating[Any, Any]) +assert_type(np.vdot(AR_u1, 1), np.signedinteger) +assert_type(np.vdot(AR_LIKE_f, AR_i8), np.floating | np.signedinteger) +assert_type(np.vdot(1.5j, 1), np.inexact | np.signedinteger) assert_type(np.bincount(AR_i8), npt.NDArray[np.intp]) @@ -113,54 +115,77 @@ assert_type(np.may_share_memory(AR_f8, AR_f8, max_work=1), bool) assert_type(np.promote_types(np.int32, np.int64), np.dtype[Any]) assert_type(np.promote_types("f4", float), np.dtype[Any]) -assert_type(np.frompyfunc(func11, n1, n1).nin, Literal[1]) -assert_type(np.frompyfunc(func11, n1, n1).nout, Literal[1]) -assert_type(np.frompyfunc(func11, n1, n1).nargs, Literal[2]) -assert_type(np.frompyfunc(func11, n1, n1).ntypes, Literal[1]) -assert_type(np.frompyfunc(func11, n1, n1).identity, None) -assert_type(np.frompyfunc(func11, n1, n1).signature, None) -assert_type(np.frompyfunc(func11, n1, n1)(f8), bool) -assert_type(np.frompyfunc(func11, n1, n1)(AR_f8), bool | npt.NDArray[np.object_]) -assert_type(np.frompyfunc(func11, n1, n1).at(AR_f8, AR_i8), None) - -assert_type(np.frompyfunc(func21, n2, n1).nin, Literal[2]) -assert_type(np.frompyfunc(func21, n2, n1).nout, Literal[1]) -assert_type(np.frompyfunc(func21, n2, n1).nargs, Literal[3]) -assert_type(np.frompyfunc(func21, n2, n1).ntypes, Literal[1]) -assert_type(np.frompyfunc(func21, n2, n1).identity, None) -assert_type(np.frompyfunc(func21, n2, n1).signature, None) -assert_type(np.frompyfunc(func21, n2, n1)(f8, f8), int) -assert_type(np.frompyfunc(func21, n2, n1)(AR_f8, f8), int | npt.NDArray[np.object_]) -assert_type(np.frompyfunc(func21, n2, n1)(f8, AR_f8), int | npt.NDArray[np.object_]) -assert_type(np.frompyfunc(func21, n2, n1).reduce(AR_f8, axis=0), int | npt.NDArray[np.object_]) -assert_type(np.frompyfunc(func21, n2, n1).accumulate(AR_f8), npt.NDArray[np.object_]) -assert_type(np.frompyfunc(func21, n2, n1).reduceat(AR_f8, AR_i8), npt.NDArray[np.object_]) -assert_type(np.frompyfunc(func21, n2, n1).outer(f8, f8), int) -assert_type(np.frompyfunc(func21, n2, n1).outer(AR_f8, f8), int | npt.NDArray[np.object_]) - -assert_type(np.frompyfunc(func21, n2, n1, identity=0).nin, Literal[2]) -assert_type(np.frompyfunc(func21, n2, n1, identity=0).nout, Literal[1]) -assert_type(np.frompyfunc(func21, n2, n1, identity=0).nargs, Literal[3]) -assert_type(np.frompyfunc(func21, n2, n1, identity=0).ntypes, Literal[1]) -assert_type(np.frompyfunc(func21, n2, n1, identity=0).identity, int) -assert_type(np.frompyfunc(func21, n2, n1, identity=0).signature, None) - -assert_type(np.frompyfunc(func12, n1, n2).nin, int) -assert_type(np.frompyfunc(func12, n1, n2).nout, int) -assert_type(np.frompyfunc(func12, n1, n2).nargs, int) -assert_type(np.frompyfunc(func12, n1, n2).ntypes, Literal[1]) -assert_type(np.frompyfunc(func12, n1, n2).identity, None) -assert_type(np.frompyfunc(func12, n1, n2).signature, None) -assert_type( - np.frompyfunc(func12, n2, n2)(f8, f8), - tuple[complex | str, complex | str, *tuple[complex | str, ...]], -) -assert_type( - np.frompyfunc(func12, n2, n2)(AR_f8, f8), +assert_type(np.frompyfunc(func11, 1, 1).nin, L[1]) +assert_type(np.frompyfunc(func11, 1, 1).nout, L[1]) +assert_type(np.frompyfunc(func11, 1, 1).nargs, L[2]) +assert_type(np.frompyfunc(func11, 1, 1).ntypes, L[1]) +assert_type(np.frompyfunc(func11, 1, 1).identity, None) +assert_type(np.frompyfunc(func11, 1, 1).signature, None) +assert_type(np.frompyfunc(func11, 1, 1)(f8), bool) +assert_type(np.frompyfunc(func11, 1, 1).at(AR_f8, AR_i8), None) +assert_type( + np.frompyfunc(func11, 1, 1)(AR_f8), + bool | npt.NDArray[np.object_], +) + +assert_type(np.frompyfunc(func21, 2, 1).nin, L[2]) +assert_type(np.frompyfunc(func21, 2, 1).nout, L[1]) +assert_type(np.frompyfunc(func21, 2, 1).nargs, L[3]) +assert_type(np.frompyfunc(func21, 2, 1).ntypes, L[1]) +assert_type(np.frompyfunc(func21, 2, 1).identity, None) +assert_type(np.frompyfunc(func21, 2, 1).signature, None) +assert_type(np.frompyfunc(func21, 2, 1)(f8, f8), int) +assert_type( + np.frompyfunc(func21, 2, 1)(AR_f8, f8), + int | npt.NDArray[np.object_], +) +assert_type( + np.frompyfunc(func21, 2, 1)(f8, AR_f8), + int | npt.NDArray[np.object_], +) +assert_type( + np.frompyfunc(func21, 2, 1).reduce(AR_f8, axis=0), + int | npt.NDArray[np.object_], +) +assert_type( + np.frompyfunc(func21, 2, 1).accumulate(AR_f8), + npt.NDArray[np.object_], +) +assert_type( + np.frompyfunc(func21, 2, 1).reduceat(AR_f8, AR_i8), + npt.NDArray[np.object_], +) +assert_type( + np.frompyfunc(func21, 2, 1).outer(f8, f8), + int, +) +assert_type( + np.frompyfunc(func21, 2, 1).outer(AR_f8, f8), + int | npt.NDArray[np.object_], +) + +assert_type(np.frompyfunc(func21, 2, 1, identity=0).nin, L[2]) +assert_type(np.frompyfunc(func21, 2, 1, identity=0).nout, L[1]) +assert_type(np.frompyfunc(func21, 2, 1, identity=0).nargs, L[3]) +assert_type(np.frompyfunc(func21, 2, 1, identity=0).ntypes, L[1]) +assert_type(np.frompyfunc(func21, 2, 1, identity=0).identity, int) +assert_type(np.frompyfunc(func21, 2, 1, identity=0).signature, None) + +assert_type(np.frompyfunc(func12, 1, 2).nin, int) +assert_type(np.frompyfunc(func12, 1, 2).nout, L[2]) +assert_type(np.frompyfunc(func12, 1, 2).nargs, int) +assert_type(np.frompyfunc(func12, 1, 2).ntypes, L[1]) +assert_type(np.frompyfunc(func12, 1, 2).identity, None) +assert_type(np.frompyfunc(func12, 1, 2).signature, None) +assert_type( + np.frompyfunc(func12, 1, 2)(f8, f8), + tuple[complex, str], +) +assert_type( + np.frompyfunc(func12, 1, 2)(AR_f8, f8), tuple[ - complex | str | npt.NDArray[np.object_], - complex | str | npt.NDArray[np.object_], - *tuple[complex | str | npt.NDArray[np.object_], ...], + complex | npt.NDArray[np.object_], + str | npt.NDArray[np.object_], ], ) @@ -172,13 +197,26 @@ assert_type(np.busday_count("2011-01", "2011-02"), np.int_) assert_type(np.busday_count(["2011-01"], "2011-02"), npt.NDArray[np.int_]) assert_type(np.busday_count(["2011-01"], date_scalar), npt.NDArray[np.int_]) -assert_type(np.busday_offset(M, m), np.datetime64) -assert_type(np.busday_offset(date_scalar, m), np.datetime64) -assert_type(np.busday_offset(M, 5), np.datetime64) -assert_type(np.busday_offset(AR_M, m), npt.NDArray[np.datetime64]) -assert_type(np.busday_offset(M, timedelta_seq), npt.NDArray[np.datetime64]) -assert_type(np.busday_offset("2011-01", "2011-02", roll="forward"), np.datetime64) -assert_type(np.busday_offset(["2011-01"], "2011-02", roll="forward"), npt.NDArray[np.datetime64]) +assert_type(np.busday_offset(date_scalar, m), np.datetime64[dt.datetime]) +assert_type(np.busday_offset(M, m), np.datetime64[dt.datetime]) +assert_type(np.busday_offset(M, 5), np.datetime64[dt.datetime]) +assert_type(np.busday_offset(AR_M, m), npt.NDArray[np.datetime64[dt.datetime]]) +assert_type( + np.busday_offset(M, timedelta_seq), + npt.NDArray[np.datetime64[dt.datetime]], +) +assert_type( + np.busday_offset("2011-01", 1, roll="forward"), + np.datetime64[dt.datetime], +) +assert_type( + np.busday_offset(["2011-01"], 1, roll="forward"), + npt.NDArray[np.datetime64[dt.datetime]], +) +assert_type( + np.busday_offset(["2011-01"], [1], roll="forward"), + npt.NDArray[np.datetime64[dt.datetime]], +) assert_type(np.is_busday("2012"), np.bool) assert_type(np.is_busday(date_scalar), np.bool) @@ -190,10 +228,28 @@ assert_type(np.datetime_as_string(AR_M), npt.NDArray[np.str_]) assert_type(np.busdaycalendar(holidays=date_seq), np.busdaycalendar) assert_type(np.busdaycalendar(holidays=[M]), np.busdaycalendar) -assert_type(np.char.compare_chararrays("a", "b", "!=", rstrip=False), npt.NDArray[np.bool]) -assert_type(np.char.compare_chararrays(b"a", b"a", "==", True), npt.NDArray[np.bool]) +assert_type( + np.char.compare_chararrays("a", "b", "!=", rstrip=False), + npt.NDArray[np.bool], +) +assert_type( + np.char.compare_chararrays(b"a", b"a", "==", True), + npt.NDArray[np.bool], +) -assert_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], flags=["c_index"]), tuple[np.nditer, ...]) -assert_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_flags=[["readonly", "readonly"]]), tuple[np.nditer, ...]) -assert_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_dtypes=np.int_), tuple[np.nditer, ...]) -assert_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], order="C", casting="no"), tuple[np.nditer, ...]) +assert_type( + np.nested_iters([AR_i8, AR_i8], [[0], [1]], flags=["c_index"]), + tuple[np.nditer, ...], +) +assert_type( + np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_flags=[["readonly", "readonly"]]), + tuple[np.nditer, ...], +) +assert_type( + np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_dtypes=np.int_), + tuple[np.nditer, ...], +) +assert_type( + np.nested_iters([AR_i8, AR_i8], [[0], [1]], order="C", casting="no"), + tuple[np.nditer, ...], +) diff --git a/test/static/reject/multiarray.pyi b/test/static/reject/multiarray.pyi index e71fda4b..0bbc0fac 100644 --- a/test/static/reject/multiarray.pyi +++ b/test/static/reject/multiarray.pyi @@ -20,7 +20,7 @@ np.where(AR_b, 1) # type: ignore[call-overload] # pyright: ignore[reportCallIs np.can_cast(AR_f8, 1) # type: ignore[arg-type] # pyright: ignore[reportArgumentType] -np.vdot(AR_M, AR_M) # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] +np.vdot(AR_M, AR_M) # type: ignore[type-var] # pyright: ignore[reportCallIssue,reportArgumentType] np.copyto(AR_LIKE_f, AR_f8) # type: ignore[arg-type] # pyright: ignore[reportArgumentType] @@ -36,13 +36,10 @@ np.shares_memory(1, 1, max_work=i8) # type: ignore[arg-type] # pyright: ignore np.may_share_memory(1, 1, max_work=i8) # type: ignore[arg-type] # pyright: ignore[reportArgumentType] np.arange(M) # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportArgumentType] -np.arange(stop=10) # type: ignore[call-overload] # pyright: ignore[reportCallIssue] np.datetime_data(int) # type: ignore[arg-type] # pyright: ignore[reportArgumentType] np.datetime_as_string("2012") # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportArgumentType] -np.busday_offset("2012", 10) # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportArgumentType] - np.char.compare_chararrays("a", b"a", "==", False) # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportArgumentType] np.nested_iters([AR_i8, AR_i8]) # type: ignore[call-arg] # pyright: ignore[reportCallIssue]