import builtins import sys import os import mmap import ctypes as ct import array as _array import datetime as dt import enum from abc import abstractmethod from types import TracebackType, MappingProxyType, GenericAlias from contextlib import contextmanager import numpy as np from numpy._pytesttester import PytestTester from numpy._core._internal import _ctypes from numpy._typing import ( # Arrays ArrayLike, NDArray, _ArrayLike, _SupportsArray, _NestedSequence, _FiniteNestedSequence, _SupportsArray, _ArrayLikeBool_co, _ArrayLikeUInt_co, _ArrayLikeInt_co, _ArrayLikeFloat_co, _ArrayLikeComplex_co, _ArrayLikeNumber_co, _ArrayLikeTD64_co, _ArrayLikeDT64_co, _ArrayLikeObject_co, _ArrayLikeStr_co, _ArrayLikeBytes_co, _ArrayLikeUnknown, _UnknownType, # DTypes DTypeLike, _DTypeLike, _DTypeLikeVoid, _SupportsDType, _VoidDTypeLike, # Shapes _Shape, _ShapeLike, # Scalars _CharLike_co, _IntLike_co, _FloatLike_co, _TD64Like_co, _NumberLike_co, _ScalarLike_co, # `number` precision NBitBase, # NOTE: Do not remove the extended precision bit-types even if seemingly unused; # they're used by the mypy plugin _256Bit, _128Bit, _96Bit, _80Bit, _64Bit, _32Bit, _16Bit, _8Bit, _NBitByte, _NBitShort, _NBitIntC, _NBitIntP, _NBitInt, _NBitLong, _NBitLongLong, _NBitHalf, _NBitSingle, _NBitDouble, _NBitLongDouble, # Character codes _BoolCodes, _UInt8Codes, _UInt16Codes, _UInt32Codes, _UInt64Codes, _Int8Codes, _Int16Codes, _Int32Codes, _Int64Codes, _Float16Codes, _Float32Codes, _Float64Codes, _Complex64Codes, _Complex128Codes, _ByteCodes, _ShortCodes, _IntCCodes, _IntPCodes, _LongCodes, _LongLongCodes, _UByteCodes, _UShortCodes, _UIntCCodes, _UIntPCodes, _ULongCodes, _ULongLongCodes, _HalfCodes, _SingleCodes, _DoubleCodes, _LongDoubleCodes, _CSingleCodes, _CDoubleCodes, _CLongDoubleCodes, _DT64Codes, _TD64Codes, _StrCodes, _BytesCodes, _VoidCodes, _ObjectCodes, # Ufuncs _UFunc_Nin1_Nout1, _UFunc_Nin2_Nout1, _UFunc_Nin1_Nout2, _UFunc_Nin2_Nout2, _GUFunc_Nin2_Nout1, ) from numpy._typing._callable import ( _BoolOp, _BoolBitOp, _BoolSub, _BoolTrueDiv, _BoolMod, _BoolDivMod, _TD64Div, _IntTrueDiv, _UnsignedIntOp, _UnsignedIntBitOp, _UnsignedIntMod, _UnsignedIntDivMod, _SignedIntOp, _SignedIntBitOp, _SignedIntMod, _SignedIntDivMod, _FloatOp, _FloatMod, _FloatDivMod, _ComplexOp, _NumberOp, _ComparisonOpLT, _ComparisonOpLE, _ComparisonOpGT, _ComparisonOpGE, ) # NOTE: Numpy's mypy plugin is used for removing the types unavailable # to the specific platform from numpy._typing._extended_precision import ( uint128 as uint128, uint256 as uint256, int128 as int128, int256 as int256, float80 as float80, float96 as float96, float128 as float128, float256 as float256, complex160 as complex160, complex192 as complex192, complex256 as complex256, complex512 as complex512, ) from numpy._array_api_info import __array_namespace_info__ as __array_namespace_info__ from collections.abc import ( Callable, Iterable, Iterator, Mapping, Sequence, ) from typing import ( TYPE_CHECKING, Literal as L, Any, Generator, Generic, NoReturn, overload, SupportsComplex, SupportsFloat, SupportsInt, TypeVar, Protocol, SupportsIndex, Final, final, ClassVar, TypeAlias, ) if sys.version_info >= (3, 11): from typing import LiteralString elif TYPE_CHECKING: from typing_extensions import LiteralString else: LiteralString: TypeAlias = str # Ensures that the stubs are picked up from numpy import ( ctypeslib as ctypeslib, exceptions as exceptions, fft as fft, lib as lib, linalg as linalg, ma as ma, polynomial as polynomial, random as random, testing as testing, version as version, exceptions as exceptions, dtypes as dtypes, rec as rec, char as char, strings as strings, ) from numpy._core.records import ( record as record, recarray as recarray, ) from numpy._core.defchararray import ( chararray as chararray, ) from numpy._core.function_base import ( linspace as linspace, logspace as logspace, geomspace as geomspace, ) from numpy._core.fromnumeric import ( take as take, reshape as reshape, choose as choose, repeat as repeat, put as put, swapaxes as swapaxes, transpose as transpose, matrix_transpose as matrix_transpose, partition as partition, argpartition as argpartition, sort as sort, argsort as argsort, argmax as argmax, argmin as argmin, searchsorted as searchsorted, resize as resize, squeeze as squeeze, diagonal as diagonal, trace as trace, ravel as ravel, nonzero as nonzero, shape as shape, compress as compress, clip as clip, sum as sum, all as all, any as any, cumsum as cumsum, cumulative_sum as cumulative_sum, ptp as ptp, max as max, min as min, amax as amax, amin as amin, prod as prod, cumprod as cumprod, cumulative_prod as cumulative_prod, ndim as ndim, size as size, around as around, round as round, mean as mean, std as std, var as var, ) from numpy._core._asarray import ( require as require, ) from numpy._core._type_aliases import ( sctypeDict as sctypeDict, ) from numpy._core._ufunc_config import ( seterr as seterr, geterr as geterr, setbufsize as setbufsize, getbufsize as getbufsize, seterrcall as seterrcall, geterrcall as geterrcall, _ErrKind, _ErrFunc, ) from numpy._core.arrayprint import ( set_printoptions as set_printoptions, get_printoptions as get_printoptions, array2string as array2string, format_float_scientific as format_float_scientific, format_float_positional as format_float_positional, array_repr as array_repr, array_str as array_str, printoptions as printoptions, ) from numpy._core.einsumfunc import ( einsum as einsum, einsum_path as einsum_path, ) from numpy._core.multiarray import ( array as array, empty_like as empty_like, empty as empty, zeros as zeros, concatenate as concatenate, inner as inner, where as where, lexsort as lexsort, can_cast as can_cast, min_scalar_type as min_scalar_type, result_type as result_type, dot as dot, vdot as vdot, bincount as bincount, copyto as copyto, putmask as putmask, packbits as packbits, unpackbits as unpackbits, shares_memory as shares_memory, may_share_memory as may_share_memory, asarray as asarray, asanyarray as asanyarray, ascontiguousarray as ascontiguousarray, asfortranarray as asfortranarray, arange as arange, busday_count as busday_count, busday_offset as busday_offset, datetime_as_string as datetime_as_string, datetime_data as datetime_data, frombuffer as frombuffer, fromfile as fromfile, fromiter as fromiter, is_busday as is_busday, promote_types as promote_types, fromstring as fromstring, frompyfunc as frompyfunc, nested_iters as nested_iters, flagsobj, ) from numpy._core.numeric import ( zeros_like as zeros_like, ones as ones, ones_like as ones_like, full as full, full_like as full_like, count_nonzero as count_nonzero, isfortran as isfortran, argwhere as argwhere, flatnonzero as flatnonzero, correlate as correlate, convolve as convolve, outer as outer, tensordot as tensordot, roll as roll, rollaxis as rollaxis, moveaxis as moveaxis, cross as cross, indices as indices, fromfunction as fromfunction, isscalar as isscalar, binary_repr as binary_repr, base_repr as base_repr, identity as identity, allclose as allclose, isclose as isclose, array_equal as array_equal, array_equiv as array_equiv, astype as astype, ) from numpy._core.numerictypes import ( isdtype as isdtype, issubdtype as issubdtype, ScalarType as ScalarType, typecodes as typecodes, ) from numpy._core.shape_base import ( atleast_1d as atleast_1d, atleast_2d as atleast_2d, atleast_3d as atleast_3d, block as block, hstack as hstack, stack as stack, vstack as vstack, unstack as unstack, ) from numpy.lib import ( scimath as emath, ) from numpy.lib._arraypad_impl import ( pad as pad, ) from numpy.lib._arraysetops_impl import ( ediff1d as ediff1d, intersect1d as intersect1d, isin as isin, setdiff1d as setdiff1d, setxor1d as setxor1d, union1d as union1d, unique as unique, unique_all as unique_all, unique_counts as unique_counts, unique_inverse as unique_inverse, unique_values as unique_values, ) from numpy.lib._function_base_impl import ( select as select, piecewise as piecewise, trim_zeros as trim_zeros, copy as copy, iterable as iterable, percentile as percentile, diff as diff, gradient as gradient, angle as angle, unwrap as unwrap, sort_complex as sort_complex, flip as flip, rot90 as rot90, extract as extract, place as place, asarray_chkfinite as asarray_chkfinite, average as average, bincount as bincount, digitize as digitize, cov as cov, corrcoef as corrcoef, median as median, sinc as sinc, hamming as hamming, hanning as hanning, bartlett as bartlett, blackman as blackman, kaiser as kaiser, i0 as i0, meshgrid as meshgrid, delete as delete, insert as insert, append as append, interp as interp, quantile as quantile, trapezoid as trapezoid, ) from numpy.lib._histograms_impl import ( histogram_bin_edges as histogram_bin_edges, histogram as histogram, histogramdd as histogramdd, ) from numpy.lib._index_tricks_impl import ( ravel_multi_index as ravel_multi_index, unravel_index as unravel_index, mgrid as mgrid, ogrid as ogrid, r_ as r_, c_ as c_, s_ as s_, index_exp as index_exp, ix_ as ix_, fill_diagonal as fill_diagonal, diag_indices as diag_indices, diag_indices_from as diag_indices_from, ) from numpy.lib._nanfunctions_impl import ( nansum as nansum, nanmax as nanmax, nanmin as nanmin, nanargmax as nanargmax, nanargmin as nanargmin, nanmean as nanmean, nanmedian as nanmedian, nanpercentile as nanpercentile, nanvar as nanvar, nanstd as nanstd, nanprod as nanprod, nancumsum as nancumsum, nancumprod as nancumprod, nanquantile as nanquantile, ) from numpy.lib._npyio_impl import ( savetxt as savetxt, loadtxt as loadtxt, genfromtxt as genfromtxt, load as load, save as save, savez as savez, savez_compressed as savez_compressed, packbits as packbits, unpackbits as unpackbits, fromregex as fromregex, ) from numpy.lib._polynomial_impl import ( poly as poly, roots as roots, polyint as polyint, polyder as polyder, polyadd as polyadd, polysub as polysub, polymul as polymul, polydiv as polydiv, polyval as polyval, polyfit as polyfit, ) from numpy.lib._shape_base_impl import ( column_stack as column_stack, dstack as dstack, array_split as array_split, split as split, hsplit as hsplit, vsplit as vsplit, dsplit as dsplit, apply_over_axes as apply_over_axes, expand_dims as expand_dims, apply_along_axis as apply_along_axis, kron as kron, tile as tile, take_along_axis as take_along_axis, put_along_axis as put_along_axis, ) from numpy.lib._stride_tricks_impl import ( broadcast_to as broadcast_to, broadcast_arrays as broadcast_arrays, broadcast_shapes as broadcast_shapes, ) from numpy.lib._twodim_base_impl import ( diag as diag, diagflat as diagflat, eye as eye, fliplr as fliplr, flipud as flipud, tri as tri, triu as triu, tril as tril, vander as vander, histogram2d as histogram2d, mask_indices as mask_indices, tril_indices as tril_indices, tril_indices_from as tril_indices_from, triu_indices as triu_indices, triu_indices_from as triu_indices_from, ) from numpy.lib._type_check_impl import ( mintypecode as mintypecode, real as real, imag as imag, iscomplex as iscomplex, isreal as isreal, iscomplexobj as iscomplexobj, isrealobj as isrealobj, nan_to_num as nan_to_num, real_if_close as real_if_close, typename as typename, common_type as common_type, ) from numpy.lib._ufunclike_impl import ( fix as fix, isposinf as isposinf, isneginf as isneginf, ) from numpy.lib._utils_impl import ( get_include as get_include, info as info, show_runtime as show_runtime, ) from numpy.matrixlib import ( asmatrix as asmatrix, bmat as bmat, ) _AnyStr_contra = TypeVar("_AnyStr_contra", LiteralString, builtins.str, bytes, contravariant=True) # Protocol for representing file-like-objects accepted # by `ndarray.tofile` and `fromfile` class _IOProtocol(Protocol): def flush(self) -> object: ... def fileno(self) -> int: ... def tell(self) -> SupportsIndex: ... def seek(self, offset: int, whence: int, /) -> object: ... # NOTE: `seek`, `write` and `flush` are technically only required # for `readwrite`/`write` modes class _MemMapIOProtocol(Protocol): def flush(self) -> object: ... def fileno(self) -> SupportsIndex: ... def tell(self) -> int: ... def seek(self, offset: int, whence: int, /) -> object: ... def write(self, s: bytes, /) -> object: ... @property def read(self) -> object: ... class _SupportsWrite(Protocol[_AnyStr_contra]): def write(self, s: _AnyStr_contra, /) -> object: ... __all__: list[str] def __dir__() -> Sequence[str]: ... __version__: LiteralString __array_api_version__: LiteralString test: PytestTester # TODO: Move placeholders to their respective module once # their annotations are properly implemented # # Placeholders for classes def show_config() -> None: ... _NdArraySubClass = TypeVar("_NdArraySubClass", bound=NDArray[Any]) _NdArraySubClass_co = TypeVar("_NdArraySubClass_co", bound=NDArray[Any], covariant=True) _DTypeScalar_co = TypeVar("_DTypeScalar_co", covariant=True, bound=generic) _SCT = TypeVar("_SCT", bound=generic) _ByteOrderChar: TypeAlias = L[ "<", # little-endian ">", # big-endian "=", # native order "|", # ignore ] # can be anything, is case-insensitive, and only the first character matters _ByteOrder: TypeAlias = L[ "S", # swap the current order (default) "<", "L", "little", # little-endian ">", "B", "big", # big endian "=", "N", "native", # native order "|", "I", # ignore ] _DTypeKind: TypeAlias = L[ "b", # boolean "i", # signed integer "u", # unsigned integer "f", # floating-point "c", # complex floating-point "m", # timedelta64 "M", # datetime64 "O", # python object "S", # byte-string (fixed-width) "U", # unicode-string (fixed-width) "V", # void "T", # unicode-string (variable-width) ] _DTypeChar: TypeAlias = L[ "?", # bool "b", # byte "B", # ubyte "h", # short "H", # ushort "i", # intc "I", # uintc "l", # long "L", # ulong "q", # longlong "Q", # ulonglong "e", # half "f", # single "d", # double "g", # longdouble "F", # csingle "D", # cdouble "G", # clongdouble "O", # object "S", # bytes_ (S0) "a", # bytes_ (deprecated) "U", # str_ "V", # void "M", # datetime64 "m", # timedelta64 "c", # bytes_ (S1) "T", # StringDType ] _DTypeNum: TypeAlias = L[ 0, # bool 1, # byte 2, # ubyte 3, # short 4, # ushort 5, # intc 6, # uintc 7, # long 8, # ulong 9, # longlong 10, # ulonglong 23, # half 11, # single 12, # double 13, # longdouble 14, # csingle 15, # cdouble 16, # clongdouble 17, # object 18, # bytes_ 19, # str_ 20, # void 21, # datetime64 22, # timedelta64 25, # no type 256, # user-defined 2056, # StringDType ] _DTypeBuiltinKind: TypeAlias = L[ 0, # structured array type, with fields 1, # compiled into numpy 2, # user-defined ] @final class dtype(Generic[_DTypeScalar_co]): names: None | tuple[builtins.str, ...] def __hash__(self) -> int: ... # Overload for subclass of generic @overload def __new__( cls, dtype: type[_DTypeScalar_co], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ..., ) -> dtype[_DTypeScalar_co]: ... # Overloads for string aliases, Python types, and some assorted # other special cases. Order is sometimes important because of the # subtype relationships # # builtins.bool < int < float < complex < object # # so we have to make sure the overloads for the narrowest type is # first. # Builtin types @overload def __new__(cls, dtype: type[builtins.bool], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[np.bool]: ... @overload def __new__(cls, dtype: type[int], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int_]: ... @overload def __new__(cls, dtype: None | type[float], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float64]: ... @overload def __new__(cls, dtype: type[complex], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[complex128]: ... @overload def __new__(cls, dtype: type[builtins.str], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[str_]: ... @overload def __new__(cls, dtype: type[bytes], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[bytes_]: ... # `unsignedinteger` string-based representations and ctypes @overload def __new__(cls, dtype: _UInt8Codes | type[ct.c_uint8], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint8]: ... @overload def __new__(cls, dtype: _UInt16Codes | type[ct.c_uint16], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint16]: ... @overload def __new__(cls, dtype: _UInt32Codes | type[ct.c_uint32], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint32]: ... @overload def __new__(cls, dtype: _UInt64Codes | type[ct.c_uint64], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint64]: ... @overload def __new__(cls, dtype: _UByteCodes | type[ct.c_ubyte], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[ubyte]: ... @overload def __new__(cls, dtype: _UShortCodes | type[ct.c_ushort], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[ushort]: ... @overload def __new__(cls, dtype: _UIntCCodes | type[ct.c_uint], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uintc]: ... # NOTE: We're assuming here that `uint_ptr_t == size_t`, # an assumption that does not hold in rare cases (same for `ssize_t`) @overload def __new__(cls, dtype: _UIntPCodes | type[ct.c_void_p] | type[ct.c_size_t], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uintp]: ... @overload def __new__(cls, dtype: _ULongCodes | type[ct.c_ulong], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[ulong]: ... @overload def __new__(cls, dtype: _ULongLongCodes | type[ct.c_ulonglong], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[ulonglong]: ... # `signedinteger` string-based representations and ctypes @overload def __new__(cls, dtype: _Int8Codes | type[ct.c_int8], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int8]: ... @overload def __new__(cls, dtype: _Int16Codes | type[ct.c_int16], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int16]: ... @overload def __new__(cls, dtype: _Int32Codes | type[ct.c_int32], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int32]: ... @overload def __new__(cls, dtype: _Int64Codes | type[ct.c_int64], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int64]: ... @overload def __new__(cls, dtype: _ByteCodes | type[ct.c_byte], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[byte]: ... @overload def __new__(cls, dtype: _ShortCodes | type[ct.c_short], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[short]: ... @overload def __new__(cls, dtype: _IntCCodes | type[ct.c_int], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[intc]: ... @overload def __new__(cls, dtype: _IntPCodes | type[ct.c_ssize_t], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[intp]: ... @overload def __new__(cls, dtype: _LongCodes | type[ct.c_long], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[long]: ... @overload def __new__(cls, dtype: _LongLongCodes | type[ct.c_longlong], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[longlong]: ... # `floating` string-based representations and ctypes @overload def __new__(cls, dtype: _Float16Codes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float16]: ... @overload def __new__(cls, dtype: _Float32Codes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float32]: ... @overload def __new__(cls, dtype: _Float64Codes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float64]: ... @overload def __new__(cls, dtype: _HalfCodes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[half]: ... @overload def __new__(cls, dtype: _SingleCodes | type[ct.c_float], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[single]: ... @overload def __new__(cls, dtype: _DoubleCodes | type[ct.c_double], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[double]: ... @overload def __new__(cls, dtype: _LongDoubleCodes | type[ct.c_longdouble], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[longdouble]: ... # `complexfloating` string-based representations @overload def __new__(cls, dtype: _Complex64Codes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[complex64]: ... @overload def __new__(cls, dtype: _Complex128Codes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[complex128]: ... @overload def __new__(cls, dtype: _CSingleCodes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[csingle]: ... @overload def __new__(cls, dtype: _CDoubleCodes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[cdouble]: ... @overload def __new__(cls, dtype: _CLongDoubleCodes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[clongdouble]: ... # Miscellaneous string-based representations and ctypes @overload def __new__(cls, dtype: _BoolCodes | type[ct.c_bool], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[np.bool]: ... @overload def __new__(cls, dtype: _TD64Codes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[timedelta64]: ... @overload def __new__(cls, dtype: _DT64Codes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[datetime64]: ... @overload def __new__(cls, dtype: _StrCodes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[str_]: ... @overload def __new__(cls, dtype: _BytesCodes | type[ct.c_char], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[bytes_]: ... @overload def __new__(cls, dtype: _VoidCodes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[void]: ... @overload def __new__(cls, dtype: _ObjectCodes | type[ct.py_object[Any]], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[object_]: ... # dtype of a dtype is the same dtype @overload def __new__( cls, dtype: dtype[_DTypeScalar_co], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ..., ) -> dtype[_DTypeScalar_co]: ... @overload def __new__( cls, dtype: _SupportsDType[dtype[_DTypeScalar_co]], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ..., ) -> dtype[_DTypeScalar_co]: ... # Handle strings that can't be expressed as literals; i.e. s1, s2, ... @overload def __new__( cls, dtype: builtins.str, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ..., ) -> dtype[Any]: ... # Catchall overload for void-likes @overload def __new__( cls, dtype: _VoidDTypeLike, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ..., ) -> dtype[void]: ... # Catchall overload for object-likes @overload def __new__( cls, dtype: type[object], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ..., ) -> dtype[object_]: ... def __class_getitem__(cls, item: Any, /) -> GenericAlias: ... @overload def __getitem__(self: dtype[void], key: list[builtins.str], /) -> dtype[void]: ... @overload def __getitem__(self: dtype[void], key: builtins.str | SupportsIndex, /) -> dtype[Any]: ... # NOTE: In the future 1-based multiplications will also yield `flexible` dtypes @overload def __mul__(self: _DType, value: L[1], /) -> _DType: ... @overload def __mul__(self: _FlexDType, value: SupportsIndex, /) -> _FlexDType: ... @overload def __mul__(self, value: SupportsIndex, /) -> dtype[void]: ... # NOTE: `__rmul__` seems to be broken when used in combination with # literals as of mypy 0.902. Set the return-type to `dtype[Any]` for # now for non-flexible dtypes. @overload def __rmul__(self: _FlexDType, value: SupportsIndex, /) -> _FlexDType: ... @overload def __rmul__(self, value: SupportsIndex, /) -> dtype[Any]: ... def __gt__(self, other: DTypeLike, /) -> builtins.bool: ... def __ge__(self, other: DTypeLike, /) -> builtins.bool: ... def __lt__(self, other: DTypeLike, /) -> builtins.bool: ... def __le__(self, other: DTypeLike, /) -> builtins.bool: ... # Explicitly defined `__eq__` and `__ne__` to get around mypy's # `strict_equality` option; even though their signatures are # identical to their `object`-based counterpart def __eq__(self, other: Any, /) -> builtins.bool: ... def __ne__(self, other: Any, /) -> builtins.bool: ... @property def alignment(self) -> int: ... @property def base(self) -> dtype[Any]: ... @property def byteorder(self) -> _ByteOrderChar: ... @property def char(self) -> _DTypeChar: ... @property def descr(self) -> list[tuple[LiteralString, LiteralString] | tuple[LiteralString, LiteralString, _Shape]]: ... @property def fields(self,) -> None | MappingProxyType[LiteralString, tuple[dtype[Any], int] | tuple[dtype[Any], int, Any]]: ... @property def flags(self) -> int: ... @property def hasobject(self) -> builtins.bool: ... @property def isbuiltin(self) -> _DTypeBuiltinKind: ... @property def isnative(self) -> builtins.bool: ... @property def isalignedstruct(self) -> builtins.bool: ... @property def itemsize(self) -> int: ... @property def kind(self) -> _DTypeKind: ... @property def metadata(self) -> None | MappingProxyType[builtins.str, Any]: ... @property def name(self) -> LiteralString: ... @property def num(self) -> _DTypeNum: ... @property def shape(self) -> tuple[()] | _Shape: ... @property def ndim(self) -> int: ... @property def subdtype(self) -> None | tuple[dtype[Any], _Shape]: ... def newbyteorder(self: _DType, new_order: _ByteOrder = ..., /) -> _DType: ... @property def str(self) -> LiteralString: ... @property def type(self) -> type[_DTypeScalar_co]: ... _ArrayLikeInt: TypeAlias = ( int | integer[Any] | Sequence[int | integer[Any]] | Sequence[Sequence[Any]] # TODO: wait for support for recursive types | NDArray[Any] ) _FlatIterSelf = TypeVar("_FlatIterSelf", bound=flatiter[Any]) _FlatShapeType = TypeVar("_FlatShapeType", bound=tuple[int]) @final class flatiter(Generic[_NdArraySubClass_co]): __hash__: ClassVar[None] @property def base(self) -> _NdArraySubClass_co: ... @property def coords(self) -> _Shape: ... @property def index(self) -> int: ... def copy(self) -> _NdArraySubClass_co: ... def __iter__(self: _FlatIterSelf) -> _FlatIterSelf: ... def __next__(self: flatiter[NDArray[_ScalarType]]) -> _ScalarType: ... def __len__(self) -> int: ... @overload def __getitem__( self: flatiter[NDArray[_ScalarType]], key: int | integer[Any] | tuple[int | integer[Any]], ) -> _ScalarType: ... @overload def __getitem__( self, key: _ArrayLikeInt | slice | ellipsis | tuple[_ArrayLikeInt | slice | ellipsis], ) -> _NdArraySubClass_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 | ellipsis | tuple[_ArrayLikeInt | slice | ellipsis], value: Any, ) -> None: ... @overload def __array__(self: flatiter[ndarray[_FlatShapeType, _DType]], dtype: None = ..., /) -> ndarray[_FlatShapeType, _DType]: ... @overload def __array__(self: flatiter[ndarray[_FlatShapeType, Any]], dtype: _DType, /) -> ndarray[_FlatShapeType, _DType]: ... @overload def __array__(self: flatiter[ndarray[Any, _DType]], dtype: None = ..., /) -> ndarray[Any, _DType]: ... @overload def __array__(self, dtype: _DType, /) -> ndarray[Any, _DType]: ... _OrderKACF: TypeAlias = L[None, "K", "A", "C", "F"] _OrderACF: TypeAlias = L[None, "A", "C", "F"] _OrderCF: TypeAlias = L[None, "C", "F"] _ModeKind: TypeAlias = L["raise", "wrap", "clip"] _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", ] _SortSide: TypeAlias = L["left", "right"] _ArraySelf = TypeVar("_ArraySelf", bound=_ArrayOrScalarCommon) class _ArrayOrScalarCommon: @property def T(self: _ArraySelf) -> _ArraySelf: ... @property def mT(self: _ArraySelf) -> _ArraySelf: ... @property def data(self) -> memoryview: ... @property def flags(self) -> flagsobj: ... @property def itemsize(self) -> int: ... @property def nbytes(self) -> int: ... @property def device(self) -> L["cpu"]: ... def __bool__(self) -> builtins.bool: ... def __bytes__(self) -> bytes: ... def __str__(self) -> str: ... def __repr__(self) -> str: ... def __copy__(self: _ArraySelf) -> _ArraySelf: ... def __deepcopy__(self: _ArraySelf, memo: None | dict[int, Any], /) -> _ArraySelf: ... # TODO: How to deal with the non-commutative nature of `==` and `!=`? # xref numpy/numpy#17368 def __eq__(self, other: Any, /) -> Any: ... def __ne__(self, other: Any, /) -> Any: ... def copy(self: _ArraySelf, order: _OrderKACF = ...) -> _ArraySelf: ... def dump(self, file: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _SupportsWrite[bytes]) -> None: ... def dumps(self) -> bytes: ... def tobytes(self, order: _OrderKACF = ...) -> bytes: ... # NOTE: `tostring()` is deprecated and therefore excluded # def tostring(self, order=...): ... def tofile( self, fid: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _IOProtocol, sep: str = ..., format: str = ..., ) -> None: ... # generics and 0d arrays return builtin scalars def tolist(self) -> Any: ... @property def __array_interface__(self) -> dict[str, Any]: ... @property def __array_priority__(self) -> float: ... @property def __array_struct__(self) -> Any: ... # builtins.PyCapsule def __array_namespace__(self, *, api_version: None | _ArrayAPIVersion = ...) -> Any: ... def __setstate__(self, state: tuple[ SupportsIndex, # version _ShapeLike, # Shape _DType_co, # DType np.bool, # F-continuous bytes | list[Any], # Data ], /) -> None: ... # an `np.bool` is returned when `keepdims=True` and `self` is a 0d array @overload def all( self, axis: None = ..., out: None = ..., keepdims: L[False] = ..., *, where: _ArrayLikeBool_co = ..., ) -> np.bool: ... @overload def all( self, axis: None | _ShapeLike = ..., out: None = ..., keepdims: builtins.bool = ..., *, where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def all( self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ..., keepdims: builtins.bool = ..., *, where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def any( self, axis: None = ..., out: None = ..., keepdims: L[False] = ..., *, where: _ArrayLikeBool_co = ..., ) -> np.bool: ... @overload def any( self, axis: None | _ShapeLike = ..., out: None = ..., keepdims: builtins.bool = ..., *, where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def any( self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ..., keepdims: builtins.bool = ..., *, where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def argmax( self, axis: None = ..., out: None = ..., *, keepdims: L[False] = ..., ) -> intp: ... @overload def argmax( self, axis: SupportsIndex = ..., out: None = ..., *, keepdims: builtins.bool = ..., ) -> Any: ... @overload def argmax( self, axis: None | SupportsIndex = ..., out: _NdArraySubClass = ..., *, keepdims: builtins.bool = ..., ) -> _NdArraySubClass: ... @overload def argmin( self, axis: None = ..., out: None = ..., *, keepdims: L[False] = ..., ) -> intp: ... @overload def argmin( self, axis: SupportsIndex = ..., out: None = ..., *, keepdims: builtins.bool = ..., ) -> Any: ... @overload def argmin( self, axis: None | SupportsIndex = ..., out: _NdArraySubClass = ..., *, keepdims: builtins.bool = ..., ) -> _NdArraySubClass: ... def argsort( self, axis: None | SupportsIndex = ..., kind: None | _SortKind = ..., order: None | str | Sequence[str] = ..., *, stable: None | bool = ..., ) -> NDArray[Any]: ... @overload def choose( self, choices: ArrayLike, out: None = ..., mode: _ModeKind = ..., ) -> NDArray[Any]: ... @overload def choose( self, choices: ArrayLike, out: _NdArraySubClass = ..., mode: _ModeKind = ..., ) -> _NdArraySubClass: ... @overload def clip( self, min: ArrayLike = ..., max: None | ArrayLike = ..., out: None = ..., **kwargs: Any, ) -> NDArray[Any]: ... @overload def clip( self, min: None = ..., max: ArrayLike = ..., out: None = ..., **kwargs: Any, ) -> NDArray[Any]: ... @overload def clip( self, min: ArrayLike = ..., max: None | ArrayLike = ..., out: _NdArraySubClass = ..., **kwargs: Any, ) -> _NdArraySubClass: ... @overload def clip( self, min: None = ..., max: ArrayLike = ..., out: _NdArraySubClass = ..., **kwargs: Any, ) -> _NdArraySubClass: ... @overload def compress( self, a: ArrayLike, axis: None | SupportsIndex = ..., out: None = ..., ) -> NDArray[Any]: ... @overload def compress( self, a: ArrayLike, axis: None | SupportsIndex = ..., out: _NdArraySubClass = ..., ) -> _NdArraySubClass: ... def conj(self: _ArraySelf) -> _ArraySelf: ... def conjugate(self: _ArraySelf) -> _ArraySelf: ... @overload def cumprod( self, axis: None | SupportsIndex = ..., dtype: DTypeLike = ..., out: None = ..., ) -> NDArray[Any]: ... @overload def cumprod( self, axis: None | SupportsIndex = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ) -> _NdArraySubClass: ... @overload def cumsum( self, axis: None | SupportsIndex = ..., dtype: DTypeLike = ..., out: None = ..., ) -> NDArray[Any]: ... @overload def cumsum( self, axis: None | SupportsIndex = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ) -> _NdArraySubClass: ... @overload def max( self, axis: None | _ShapeLike = ..., out: None = ..., keepdims: builtins.bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def max( self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ..., keepdims: builtins.bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def mean( self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: None = ..., keepdims: builtins.bool = ..., *, where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def mean( self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., keepdims: builtins.bool = ..., *, where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def min( self, axis: None | _ShapeLike = ..., out: None = ..., keepdims: builtins.bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def min( self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ..., keepdims: builtins.bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def prod( self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: None = ..., keepdims: builtins.bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def prod( self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., keepdims: builtins.bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def round( self: _ArraySelf, decimals: SupportsIndex = ..., out: None = ..., ) -> _ArraySelf: ... @overload def round( self, decimals: SupportsIndex = ..., out: _NdArraySubClass = ..., ) -> _NdArraySubClass: ... @overload def std( self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: None = ..., ddof: float = ..., keepdims: builtins.bool = ..., *, where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def std( self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ddof: float = ..., keepdims: builtins.bool = ..., *, where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def sum( self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: None = ..., keepdims: builtins.bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def sum( self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., keepdims: builtins.bool = ..., initial: _NumberLike_co = ..., where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... @overload def var( self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: None = ..., ddof: float = ..., keepdims: builtins.bool = ..., *, where: _ArrayLikeBool_co = ..., ) -> Any: ... @overload def var( self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ddof: float = ..., keepdims: builtins.bool = ..., *, where: _ArrayLikeBool_co = ..., ) -> _NdArraySubClass: ... _DType = TypeVar("_DType", bound=dtype[Any]) _DType_co = TypeVar("_DType_co", covariant=True, bound=dtype[Any]) _FlexDType = TypeVar("_FlexDType", bound=dtype[flexible]) _ShapeType_co = TypeVar("_ShapeType_co", covariant=True, bound=tuple[int, ...]) _ShapeType2 = TypeVar("_ShapeType2", bound=tuple[int, ...]) _Shape2DType_co = TypeVar("_Shape2DType_co", covariant=True, bound=tuple[int, int]) _NumberType = TypeVar("_NumberType", bound=number[Any]) if sys.version_info >= (3, 12): from collections.abc import Buffer as _SupportsBuffer else: _SupportsBuffer: TypeAlias = ( bytes | bytearray | memoryview | _array.array[Any] | mmap.mmap | NDArray[Any] | generic ) _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) _T_contra = TypeVar("_T_contra", contravariant=True) _2Tuple: TypeAlias = tuple[_T, _T] _CastingKind: TypeAlias = L["no", "equiv", "safe", "same_kind", "unsafe"] _ArrayUInt_co: TypeAlias = NDArray[np.bool | unsignedinteger[Any]] _ArrayInt_co: TypeAlias = NDArray[np.bool | integer[Any]] _ArrayFloat_co: TypeAlias = NDArray[np.bool | integer[Any] | floating[Any]] _ArrayComplex_co: TypeAlias = NDArray[np.bool | integer[Any] | floating[Any] | complexfloating[Any, Any]] _ArrayNumber_co: TypeAlias = NDArray[np.bool | number[Any]] _ArrayTD64_co: TypeAlias = NDArray[np.bool | integer[Any] | timedelta64] # Introduce an alias for `dtype` to avoid naming conflicts. _dtype: TypeAlias = dtype[_ScalarType] if sys.version_info >= (3, 13): from types import CapsuleType as _PyCapsule else: _PyCapsule: TypeAlias = Any _ArrayAPIVersion: TypeAlias = L["2021.12", "2022.12", "2023.12"] class _SupportsItem(Protocol[_T_co]): def item(self, args: Any, /) -> _T_co: ... class _SupportsReal(Protocol[_T_co]): @property def real(self) -> _T_co: ... class _SupportsImag(Protocol[_T_co]): @property def imag(self) -> _T_co: ... class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType_co, _DType_co]): __hash__: ClassVar[None] @property def base(self) -> None | NDArray[Any]: ... @property def ndim(self) -> int: ... @property def size(self) -> int: ... @property def real( self: ndarray[_ShapeType_co, dtype[_SupportsReal[_ScalarType]]], # type: ignore[type-var] ) -> ndarray[_ShapeType_co, _dtype[_ScalarType]]: ... @real.setter def real(self, value: ArrayLike) -> None: ... @property def imag( self: ndarray[_ShapeType_co, dtype[_SupportsImag[_ScalarType]]], # type: ignore[type-var] ) -> ndarray[_ShapeType_co, _dtype[_ScalarType]]: ... @imag.setter def imag(self, value: ArrayLike) -> None: ... def __new__( cls: type[_ArraySelf], shape: _ShapeLike, dtype: DTypeLike = ..., buffer: None | _SupportsBuffer = ..., offset: SupportsIndex = ..., strides: None | _ShapeLike = ..., order: _OrderKACF = ..., ) -> _ArraySelf: ... if sys.version_info >= (3, 12): def __buffer__(self, flags: int, /) -> memoryview: ... def __class_getitem__(cls, item: Any, /) -> GenericAlias: ... @overload def __array__( self, dtype: None = ..., /, *, copy: None | bool = ... ) -> ndarray[_ShapeType_co, _DType_co]: ... @overload def __array__( self, dtype: _DType, /, *, copy: None | bool = ... ) -> ndarray[_ShapeType_co, _DType]: ... def __array_ufunc__( self, ufunc: ufunc, method: L["__call__", "reduce", "reduceat", "accumulate", "outer", "at"], *inputs: Any, **kwargs: Any, ) -> Any: ... def __array_function__( self, func: Callable[..., Any], types: Iterable[type], args: Iterable[Any], kwargs: Mapping[str, Any], ) -> Any: ... # NOTE: In practice any object is accepted by `obj`, but as `__array_finalize__` # is a pseudo-abstract method the type has been narrowed down in order to # grant subclasses a bit more flexibility def __array_finalize__(self, obj: None | NDArray[Any], /) -> None: ... def __array_wrap__( self, array: ndarray[_ShapeType2, _DType], context: None | tuple[ufunc, tuple[Any, ...], int] = ..., return_scalar: builtins.bool = ..., /, ) -> ndarray[_ShapeType2, _DType]: ... @overload def __getitem__(self, key: ( NDArray[integer[Any]] | NDArray[np.bool] | tuple[NDArray[integer[Any]] | NDArray[np.bool], ...] )) -> ndarray[Any, _DType_co]: ... @overload def __getitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...]) -> Any: ... @overload def __getitem__(self, key: ( None | slice | ellipsis | SupportsIndex | _ArrayLikeInt_co | tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...] )) -> ndarray[Any, _DType_co]: ... @overload def __getitem__(self: NDArray[void], key: str) -> NDArray[Any]: ... @overload def __getitem__(self: NDArray[void], key: list[str]) -> ndarray[_ShapeType_co, _dtype[void]]: ... @property def ctypes(self) -> _ctypes[int]: ... @property def shape(self) -> _ShapeType_co: ... @shape.setter def shape(self, value: _ShapeLike) -> None: ... @property def strides(self) -> _Shape: ... @strides.setter def strides(self, value: _ShapeLike) -> None: ... def byteswap(self: _ArraySelf, inplace: builtins.bool = ...) -> _ArraySelf: ... def fill(self, value: Any) -> None: ... @property def flat(self: _NdArraySubClass) -> flatiter[_NdArraySubClass]: ... # Use the same output type as that of the underlying `generic` @overload def item( self: ndarray[Any, _dtype[_SupportsItem[_T]]], # type: ignore[type-var] *args: SupportsIndex, ) -> _T: ... @overload def item( self: ndarray[Any, _dtype[_SupportsItem[_T]]], # type: ignore[type-var] args: tuple[SupportsIndex, ...], /, ) -> _T: ... @overload def resize(self, new_shape: _ShapeLike, /, *, refcheck: builtins.bool = ...) -> None: ... @overload def resize(self, *new_shape: SupportsIndex, refcheck: builtins.bool = ...) -> None: ... def setflags( self, write: builtins.bool = ..., align: builtins.bool = ..., uic: builtins.bool = ... ) -> None: ... def squeeze( self, axis: None | SupportsIndex | tuple[SupportsIndex, ...] = ..., ) -> ndarray[Any, _DType_co]: ... def swapaxes( self, axis1: SupportsIndex, axis2: SupportsIndex, ) -> ndarray[Any, _DType_co]: ... @overload def transpose(self: _ArraySelf, axes: None | _ShapeLike, /) -> _ArraySelf: ... @overload def transpose(self: _ArraySelf, *axes: SupportsIndex) -> _ArraySelf: ... def argpartition( self, kth: _ArrayLikeInt_co, axis: None | SupportsIndex = ..., kind: _PartitionKind = ..., order: None | str | Sequence[str] = ..., ) -> NDArray[intp]: ... def diagonal( self, offset: SupportsIndex = ..., axis1: SupportsIndex = ..., axis2: SupportsIndex = ..., ) -> ndarray[Any, _DType_co]: ... # 1D + 1D returns a scalar; # all other with at least 1 non-0D array return an ndarray. @overload def dot(self, b: _ScalarLike_co, out: None = ...) -> NDArray[Any]: ... @overload def dot(self, b: ArrayLike, out: None = ...) -> Any: ... # type: ignore[misc] @overload def dot(self, b: ArrayLike, out: _NdArraySubClass) -> _NdArraySubClass: ... # `nonzero()` is deprecated for 0d arrays/generics def nonzero(self) -> tuple[NDArray[intp], ...]: ... def partition( self, kth: _ArrayLikeInt_co, axis: SupportsIndex = ..., kind: _PartitionKind = ..., order: None | str | Sequence[str] = ..., ) -> None: ... # `put` is technically available to `generic`, # but is pointless as `generic`s are immutable def put( self, ind: _ArrayLikeInt_co, v: ArrayLike, mode: _ModeKind = ..., ) -> None: ... @overload def searchsorted( # type: ignore[misc] self, # >= 1D array v: _ScalarLike_co, # 0D array-like side: _SortSide = ..., sorter: None | _ArrayLikeInt_co = ..., ) -> intp: ... @overload def searchsorted( self, # >= 1D array v: ArrayLike, side: _SortSide = ..., sorter: None | _ArrayLikeInt_co = ..., ) -> NDArray[intp]: ... def setfield( self, val: ArrayLike, dtype: DTypeLike, offset: SupportsIndex = ..., ) -> None: ... def sort( self, axis: SupportsIndex = ..., kind: None | _SortKind = ..., order: None | str | Sequence[str] = ..., *, stable: None | bool = ..., ) -> None: ... @overload def trace( self, # >= 2D array offset: SupportsIndex = ..., axis1: SupportsIndex = ..., axis2: SupportsIndex = ..., dtype: DTypeLike = ..., out: None = ..., ) -> Any: ... @overload def trace( self, # >= 2D array offset: SupportsIndex = ..., axis1: SupportsIndex = ..., axis2: SupportsIndex = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ) -> _NdArraySubClass: ... @overload def take( # type: ignore[misc] self: NDArray[_ScalarType], indices: _IntLike_co, axis: None | SupportsIndex = ..., out: None = ..., mode: _ModeKind = ..., ) -> _ScalarType: ... @overload def take( # type: ignore[misc] self, indices: _ArrayLikeInt_co, axis: None | SupportsIndex = ..., out: None = ..., mode: _ModeKind = ..., ) -> ndarray[Any, _DType_co]: ... @overload def take( self, indices: _ArrayLikeInt_co, axis: None | SupportsIndex = ..., out: _NdArraySubClass = ..., mode: _ModeKind = ..., ) -> _NdArraySubClass: ... def repeat( self, repeats: _ArrayLikeInt_co, axis: None | SupportsIndex = ..., ) -> ndarray[Any, _DType_co]: ... # TODO: use `tuple[int]` as shape type once covariant (#26081) def flatten( self, order: _OrderKACF = ..., ) -> ndarray[Any, _DType_co]: ... # TODO: use `tuple[int]` as shape type once covariant (#26081) def ravel( self, order: _OrderKACF = ..., ) -> ndarray[Any, _DType_co]: ... @overload def reshape( self, shape: _ShapeLike, /, *, order: _OrderACF = ..., copy: None | bool = ..., ) -> ndarray[Any, _DType_co]: ... @overload def reshape( self, *shape: SupportsIndex, order: _OrderACF = ..., copy: None | bool = ..., ) -> ndarray[Any, _DType_co]: ... @overload def astype( self, dtype: _DTypeLike[_ScalarType], order: _OrderKACF = ..., casting: _CastingKind = ..., subok: builtins.bool = ..., copy: builtins.bool | _CopyMode = ..., ) -> NDArray[_ScalarType]: ... @overload def astype( self, dtype: DTypeLike, order: _OrderKACF = ..., casting: _CastingKind = ..., subok: builtins.bool = ..., copy: builtins.bool | _CopyMode = ..., ) -> NDArray[Any]: ... @overload def view(self: _ArraySelf) -> _ArraySelf: ... @overload def view(self, type: type[_NdArraySubClass]) -> _NdArraySubClass: ... @overload def view(self, dtype: _DTypeLike[_ScalarType]) -> NDArray[_ScalarType]: ... @overload def view(self, dtype: DTypeLike) -> NDArray[Any]: ... @overload def view( self, dtype: DTypeLike, type: type[_NdArraySubClass], ) -> _NdArraySubClass: ... @overload def getfield( self, dtype: _DTypeLike[_ScalarType], offset: SupportsIndex = ... ) -> NDArray[_ScalarType]: ... @overload def getfield( self, dtype: DTypeLike, offset: SupportsIndex = ... ) -> NDArray[Any]: ... # Dispatch to the underlying `generic` via protocols def __int__( self: NDArray[SupportsInt], # type: ignore[type-var] ) -> int: ... def __float__( self: NDArray[SupportsFloat], # type: ignore[type-var] ) -> float: ... def __complex__( self: NDArray[SupportsComplex], # type: ignore[type-var] ) -> complex: ... def __index__( self: NDArray[SupportsIndex], # type: ignore[type-var] ) -> int: ... def __len__(self) -> int: ... def __setitem__(self, key, value): ... def __iter__(self) -> Any: ... def __contains__(self, key) -> builtins.bool: ... # The last overload is for catching recursive objects whose # nesting is too deep. # The first overload is for catching `bytes` (as they are a subtype of # `Sequence[int]`) and `str`. As `str` is a recursive sequence of # strings, it will pass through the final overload otherwise @overload def __lt__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co, /) -> NDArray[np.bool]: ... @overload def __lt__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[np.bool]: ... @overload def __lt__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[np.bool]: ... @overload def __lt__(self: NDArray[object_], other: Any, /) -> NDArray[np.bool]: ... @overload def __lt__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> NDArray[np.bool]: ... @overload def __le__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co, /) -> NDArray[np.bool]: ... @overload def __le__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[np.bool]: ... @overload def __le__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[np.bool]: ... @overload def __le__(self: NDArray[object_], other: Any, /) -> NDArray[np.bool]: ... @overload def __le__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> NDArray[np.bool]: ... @overload def __gt__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co, /) -> NDArray[np.bool]: ... @overload def __gt__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[np.bool]: ... @overload def __gt__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[np.bool]: ... @overload def __gt__(self: NDArray[object_], other: Any, /) -> NDArray[np.bool]: ... @overload def __gt__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> NDArray[np.bool]: ... @overload def __ge__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co, /) -> NDArray[np.bool]: ... @overload def __ge__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[np.bool]: ... @overload def __ge__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[np.bool]: ... @overload def __ge__(self: NDArray[object_], other: Any, /) -> NDArray[np.bool]: ... @overload def __ge__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> NDArray[np.bool]: ... # Unary ops @overload def __abs__(self: NDArray[_UnknownType]) -> NDArray[Any]: ... @overload def __abs__(self: NDArray[np.bool]) -> NDArray[np.bool]: ... @overload def __abs__(self: NDArray[complexfloating[_NBit1, _NBit1]]) -> NDArray[floating[_NBit1]]: ... @overload def __abs__(self: NDArray[_NumberType]) -> NDArray[_NumberType]: ... @overload def __abs__(self: NDArray[timedelta64]) -> NDArray[timedelta64]: ... @overload def __abs__(self: NDArray[object_]) -> Any: ... @overload def __invert__(self: NDArray[_UnknownType]) -> NDArray[Any]: ... @overload def __invert__(self: NDArray[np.bool]) -> NDArray[np.bool]: ... @overload def __invert__(self: NDArray[_IntType]) -> NDArray[_IntType]: ... @overload def __invert__(self: NDArray[object_]) -> Any: ... @overload def __pos__(self: NDArray[_NumberType]) -> NDArray[_NumberType]: ... @overload def __pos__(self: NDArray[timedelta64]) -> NDArray[timedelta64]: ... @overload def __pos__(self: NDArray[object_]) -> Any: ... @overload def __neg__(self: NDArray[_NumberType]) -> NDArray[_NumberType]: ... @overload def __neg__(self: NDArray[timedelta64]) -> NDArray[timedelta64]: ... @overload def __neg__(self: NDArray[object_]) -> Any: ... # Binary ops @overload def __matmul__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __matmul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] @overload def __matmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __matmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __matmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __matmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... @overload def __matmul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... @overload def __matmul__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __matmul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rmatmul__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __rmatmul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] @overload def __rmatmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rmatmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __rmatmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __rmatmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... @overload def __rmatmul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... @overload def __rmatmul__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rmatmul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __mod__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __mod__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] @overload def __mod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __mod__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __mod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __mod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> NDArray[timedelta64]: ... @overload def __mod__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __mod__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rmod__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __rmod__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] @overload def __rmod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rmod__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __rmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __rmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> NDArray[timedelta64]: ... @overload def __rmod__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rmod__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __divmod__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> _2Tuple[NDArray[Any]]: ... @overload def __divmod__(self: NDArray[np.bool], other: _ArrayLikeBool_co) -> _2Tuple[NDArray[int8]]: ... # type: ignore[misc] @overload def __divmod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> _2Tuple[NDArray[unsignedinteger[Any]]]: ... # type: ignore[misc] @overload def __divmod__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> _2Tuple[NDArray[signedinteger[Any]]]: ... # type: ignore[misc] @overload def __divmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> _2Tuple[NDArray[floating[Any]]]: ... # type: ignore[misc] @overload def __divmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> tuple[NDArray[int64], NDArray[timedelta64]]: ... @overload def __rdivmod__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> _2Tuple[NDArray[Any]]: ... @overload def __rdivmod__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> _2Tuple[NDArray[int8]]: ... # type: ignore[misc] @overload def __rdivmod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> _2Tuple[NDArray[unsignedinteger[Any]]]: ... # type: ignore[misc] @overload def __rdivmod__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> _2Tuple[NDArray[signedinteger[Any]]]: ... # type: ignore[misc] @overload def __rdivmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> _2Tuple[NDArray[floating[Any]]]: ... # type: ignore[misc] @overload def __rdivmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> tuple[NDArray[int64], NDArray[timedelta64]]: ... @overload def __add__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __add__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] @overload def __add__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __add__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __add__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __add__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __add__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... @overload def __add__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... # type: ignore[misc] @overload def __add__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co, /) -> NDArray[datetime64]: ... @overload def __add__(self: NDArray[datetime64], other: _ArrayLikeTD64_co, /) -> NDArray[datetime64]: ... @overload def __add__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __add__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __radd__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __radd__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] @overload def __radd__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __radd__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __radd__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __radd__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __radd__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... @overload def __radd__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... # type: ignore[misc] @overload def __radd__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co, /) -> NDArray[datetime64]: ... @overload def __radd__(self: NDArray[datetime64], other: _ArrayLikeTD64_co, /) -> NDArray[datetime64]: ... @overload def __radd__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __radd__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __sub__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __sub__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NoReturn: ... @overload def __sub__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __sub__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __sub__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __sub__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __sub__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... @overload def __sub__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... # type: ignore[misc] @overload def __sub__(self: NDArray[datetime64], other: _ArrayLikeTD64_co, /) -> NDArray[datetime64]: ... @overload def __sub__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[timedelta64]: ... @overload def __sub__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __sub__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rsub__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __rsub__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NoReturn: ... @overload def __rsub__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rsub__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __rsub__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __rsub__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __rsub__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... @overload def __rsub__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... # type: ignore[misc] @overload def __rsub__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co, /) -> NDArray[datetime64]: ... # type: ignore[misc] @overload def __rsub__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[timedelta64]: ... @overload def __rsub__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rsub__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __mul__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __mul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] @overload def __mul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __mul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __mul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __mul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __mul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... @overload def __mul__(self: _ArrayTD64_co, other: _ArrayLikeFloat_co, /) -> NDArray[timedelta64]: ... @overload def __mul__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... @overload def __mul__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __mul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rmul__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __rmul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] @overload def __rmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __rmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __rmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __rmul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... @overload def __rmul__(self: _ArrayTD64_co, other: _ArrayLikeFloat_co, /) -> NDArray[timedelta64]: ... @overload def __rmul__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... @overload def __rmul__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rmul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __floordiv__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __floordiv__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] @overload def __floordiv__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __floordiv__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __floordiv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __floordiv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> NDArray[int64]: ... @overload def __floordiv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co, /) -> NoReturn: ... @overload def __floordiv__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co, /) -> NDArray[timedelta64]: ... @overload def __floordiv__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __floordiv__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rfloordiv__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __rfloordiv__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] @overload def __rfloordiv__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rfloordiv__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __rfloordiv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __rfloordiv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> NDArray[int64]: ... @overload def __rfloordiv__(self: NDArray[np.bool], other: _ArrayLikeTD64_co, /) -> NoReturn: ... @overload def __rfloordiv__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... @overload def __rfloordiv__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rfloordiv__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __pow__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __pow__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] @overload def __pow__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __pow__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __pow__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __pow__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... @overload def __pow__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... @overload def __pow__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __pow__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rpow__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __rpow__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] @overload def __rpow__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rpow__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] @overload def __rpow__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __rpow__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... @overload def __rpow__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... @overload def __rpow__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rpow__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __truediv__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __truediv__(self: _ArrayInt_co, other: _ArrayInt_co, /) -> NDArray[float64]: ... # type: ignore[misc] @overload def __truediv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __truediv__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __truediv__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... @overload def __truediv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> NDArray[float64]: ... @overload def __truediv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co, /) -> NoReturn: ... @overload def __truediv__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co, /) -> NDArray[timedelta64]: ... @overload def __truediv__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __truediv__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rtruediv__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __rtruediv__(self: _ArrayInt_co, other: _ArrayInt_co, /) -> NDArray[float64]: ... # type: ignore[misc] @overload def __rtruediv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] @overload def __rtruediv__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] @overload def __rtruediv__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... @overload def __rtruediv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> NDArray[float64]: ... @overload def __rtruediv__(self: NDArray[np.bool], other: _ArrayLikeTD64_co, /) -> NoReturn: ... @overload def __rtruediv__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... @overload def __rtruediv__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rtruediv__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __lshift__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __lshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] @overload def __lshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __lshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... @overload def __lshift__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __lshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rlshift__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __rlshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] @overload def __rlshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rlshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... @overload def __rlshift__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rlshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rshift__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __rshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] @overload def __rshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... @overload def __rshift__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rrshift__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __rrshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] @overload def __rrshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rrshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... @overload def __rrshift__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rrshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __and__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __and__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] @overload def __and__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __and__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... @overload def __and__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __and__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rand__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __rand__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] @overload def __rand__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rand__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... @overload def __rand__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rand__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __xor__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __xor__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] @overload def __xor__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __xor__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... @overload def __xor__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __xor__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rxor__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __rxor__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] @overload def __rxor__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __rxor__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... @overload def __rxor__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rxor__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __or__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __or__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] @overload def __or__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __or__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... @overload def __or__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __or__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __ror__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __ror__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] @overload def __ror__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] @overload def __ror__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... @overload def __ror__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __ror__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... # `np.generic` does not support inplace operations # NOTE: Inplace ops generally use "same_kind" casting w.r.t. to the left # operand. An exception to this rule are unsigned integers though, which # also accepts a signed integer for the right operand as long it is a 0D # object and its value is >= 0 @overload def __iadd__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __iadd__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... @overload def __iadd__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __iadd__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... @overload def __iadd__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... @overload def __iadd__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... @overload def __iadd__(self: NDArray[timedelta64], other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... @overload def __iadd__(self: NDArray[datetime64], other: _ArrayLikeTD64_co, /) -> NDArray[datetime64]: ... @overload def __iadd__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... @overload def __isub__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __isub__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __isub__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... @overload def __isub__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... @overload def __isub__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... @overload def __isub__(self: NDArray[timedelta64], other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... @overload def __isub__(self: NDArray[datetime64], other: _ArrayLikeTD64_co, /) -> NDArray[datetime64]: ... @overload def __isub__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... @overload def __imul__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __imul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... @overload def __imul__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __imul__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... @overload def __imul__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... @overload def __imul__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... @overload def __imul__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co, /) -> NDArray[timedelta64]: ... @overload def __imul__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... @overload def __itruediv__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __itruediv__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... @overload def __itruediv__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... @overload def __itruediv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co, /) -> NoReturn: ... @overload def __itruediv__(self: NDArray[timedelta64], other: _ArrayLikeInt_co, /) -> NDArray[timedelta64]: ... @overload def __itruediv__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... @overload def __ifloordiv__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __ifloordiv__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __ifloordiv__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... @overload def __ifloordiv__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... @overload def __ifloordiv__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... @overload def __ifloordiv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co, /) -> NoReturn: ... @overload def __ifloordiv__(self: NDArray[timedelta64], other: _ArrayLikeInt_co, /) -> NDArray[timedelta64]: ... @overload def __ifloordiv__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... @overload def __ipow__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __ipow__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __ipow__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... @overload def __ipow__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... @overload def __ipow__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... @overload def __ipow__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... @overload def __imod__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __imod__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __imod__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... @overload def __imod__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... @overload def __imod__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> NDArray[timedelta64]: ... @overload def __imod__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... @overload def __ilshift__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __ilshift__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __ilshift__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... @overload def __ilshift__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... @overload def __irshift__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __irshift__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __irshift__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... @overload def __irshift__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... @overload def __iand__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __iand__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... @overload def __iand__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __iand__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... @overload def __iand__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... @overload def __ixor__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __ixor__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... @overload def __ixor__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __ixor__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... @overload def __ixor__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... @overload def __ior__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __ior__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... @overload def __ior__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __ior__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... @overload def __ior__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... @overload def __imatmul__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... @overload def __imatmul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... @overload def __imatmul__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... @overload def __imatmul__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... @overload def __imatmul__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... @overload def __imatmul__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... @overload def __imatmul__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... def __dlpack__( self: NDArray[number[Any]], *, stream: int | Any | None = ..., max_version: tuple[int, int] | None = ..., dl_device: tuple[int, L[0]] | None = ..., copy: bool | None = ..., ) -> _PyCapsule: ... def __dlpack_device__(self) -> tuple[int, L[0]]: ... @overload def to_device(self: NDArray[_SCT], device: L["cpu"], /, *, stream: None | int | Any = ...) -> NDArray[_SCT]: ... @overload def to_device(self: NDArray[Any], device: L["cpu"], /, *, stream: None | int | Any = ...) -> NDArray[Any]: ... def bitwise_count( self, out: None | NDArray[Any] = ..., *, where: _ArrayLikeBool_co = ..., casting: _CastingKind = ..., order: _OrderKACF = ..., dtype: DTypeLike = ..., subok: builtins.bool = ..., ) -> NDArray[Any]: ... # Keep `dtype` at the bottom to avoid name conflicts with `np.dtype` @property def dtype(self) -> _DType_co: ... # NOTE: while `np.generic` is not technically an instance of `ABCMeta`, # the `@abstractmethod` decorator is herein used to (forcefully) deny # the creation of `np.generic` instances. # The `# type: ignore` comments are necessary to silence mypy errors regarding # the missing `ABCMeta` metaclass. # See https://github.com/numpy/numpy-stubs/pull/80 for more details. _ScalarType = TypeVar("_ScalarType", bound=generic) _NBit1 = TypeVar("_NBit1", bound=NBitBase) _NBit2 = TypeVar("_NBit2", bound=NBitBase) class generic(_ArrayOrScalarCommon): @abstractmethod def __init__(self, *args: Any, **kwargs: Any) -> None: ... # TODO: use `tuple[()]` as shape type once covariant (#26081) @overload def __array__(self: _ScalarType, dtype: None = ..., /) -> NDArray[_ScalarType]: ... @overload def __array__(self, dtype: _DType, /) -> ndarray[Any, _DType]: ... def __hash__(self) -> int: ... @property def base(self) -> None: ... @property def ndim(self) -> L[0]: ... @property def size(self) -> L[1]: ... @property def shape(self) -> tuple[()]: ... @property def strides(self) -> tuple[()]: ... def byteswap(self: _ScalarType, inplace: L[False] = ...) -> _ScalarType: ... @property def flat(self: _ScalarType) -> flatiter[NDArray[_ScalarType]]: ... if sys.version_info >= (3, 12): def __buffer__(self, flags: int, /) -> memoryview: ... def to_device(self: _ScalarType, device: L["cpu"], /, *, stream: None | int | Any = ...) -> _ScalarType: ... @overload def astype( self, dtype: _DTypeLike[_ScalarType], order: _OrderKACF = ..., casting: _CastingKind = ..., subok: builtins.bool = ..., copy: builtins.bool | _CopyMode = ..., ) -> _ScalarType: ... @overload def astype( self, dtype: DTypeLike, order: _OrderKACF = ..., casting: _CastingKind = ..., subok: builtins.bool = ..., copy: builtins.bool | _CopyMode = ..., ) -> Any: ... # NOTE: `view` will perform a 0D->scalar cast, # thus the array `type` is irrelevant to the output type @overload def view( self: _ScalarType, type: type[NDArray[Any]] = ..., ) -> _ScalarType: ... @overload def view( self, dtype: _DTypeLike[_ScalarType], type: type[NDArray[Any]] = ..., ) -> _ScalarType: ... @overload def view( self, dtype: DTypeLike, type: type[NDArray[Any]] = ..., ) -> Any: ... @overload def getfield( self, dtype: _DTypeLike[_ScalarType], offset: SupportsIndex = ... ) -> _ScalarType: ... @overload def getfield( self, dtype: DTypeLike, offset: SupportsIndex = ... ) -> Any: ... def item( self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, ) -> Any: ... @overload def take( # type: ignore[misc] self: _ScalarType, indices: _IntLike_co, axis: None | SupportsIndex = ..., out: None = ..., mode: _ModeKind = ..., ) -> _ScalarType: ... @overload def take( # type: ignore[misc] self: _ScalarType, indices: _ArrayLikeInt_co, axis: None | SupportsIndex = ..., out: None = ..., mode: _ModeKind = ..., ) -> NDArray[_ScalarType]: ... @overload def take( self, indices: _ArrayLikeInt_co, axis: None | SupportsIndex = ..., out: _NdArraySubClass = ..., mode: _ModeKind = ..., ) -> _NdArraySubClass: ... def repeat( self: _ScalarType, repeats: _ArrayLikeInt_co, axis: None | SupportsIndex = ..., ) -> NDArray[_ScalarType]: ... def flatten( self: _ScalarType, order: _OrderKACF = ..., ) -> NDArray[_ScalarType]: ... def ravel( self: _ScalarType, order: _OrderKACF = ..., ) -> NDArray[_ScalarType]: ... @overload def reshape( self: _ScalarType, shape: _ShapeLike, /, *, order: _OrderACF = ... ) -> NDArray[_ScalarType]: ... @overload def reshape( self: _ScalarType, *shape: SupportsIndex, order: _OrderACF = ... ) -> NDArray[_ScalarType]: ... def bitwise_count( self, out: None | NDArray[Any] = ..., *, where: _ArrayLikeBool_co = ..., casting: _CastingKind = ..., order: _OrderKACF = ..., dtype: DTypeLike = ..., subok: builtins.bool = ..., ) -> Any: ... def squeeze( self: _ScalarType, axis: None | L[0] | tuple[()] = ... ) -> _ScalarType: ... def transpose(self: _ScalarType, axes: None | tuple[()] = ..., /) -> _ScalarType: ... # Keep `dtype` at the bottom to avoid name conflicts with `np.dtype` @property def dtype(self: _ScalarType) -> _dtype[_ScalarType]: ... class number(generic, Generic[_NBit1]): # type: ignore @property def real(self: _ArraySelf) -> _ArraySelf: ... @property def imag(self: _ArraySelf) -> _ArraySelf: ... def __class_getitem__(cls, item: Any, /) -> GenericAlias: ... def __int__(self) -> int: ... def __float__(self) -> float: ... def __complex__(self) -> complex: ... def __neg__(self: _ArraySelf) -> _ArraySelf: ... def __pos__(self: _ArraySelf) -> _ArraySelf: ... def __abs__(self: _ArraySelf) -> _ArraySelf: ... # Ensure that objects annotated as `number` support arithmetic operations __add__: _NumberOp __radd__: _NumberOp __sub__: _NumberOp __rsub__: _NumberOp __mul__: _NumberOp __rmul__: _NumberOp __floordiv__: _NumberOp __rfloordiv__: _NumberOp __pow__: _NumberOp __rpow__: _NumberOp __truediv__: _NumberOp __rtruediv__: _NumberOp __lt__: _ComparisonOpLT[_NumberLike_co, _ArrayLikeNumber_co] __le__: _ComparisonOpLE[_NumberLike_co, _ArrayLikeNumber_co] __gt__: _ComparisonOpGT[_NumberLike_co, _ArrayLikeNumber_co] __ge__: _ComparisonOpGE[_NumberLike_co, _ArrayLikeNumber_co] class bool(generic): def __init__(self, value: object = ..., /) -> None: ... def item( self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, ) -> builtins.bool: ... def tolist(self) -> builtins.bool: ... @property def real(self: _ArraySelf) -> _ArraySelf: ... @property def imag(self: _ArraySelf) -> _ArraySelf: ... def __int__(self) -> int: ... def __float__(self) -> float: ... def __complex__(self) -> complex: ... def __abs__(self: _ArraySelf) -> _ArraySelf: ... __add__: _BoolOp[np.bool] __radd__: _BoolOp[np.bool] __sub__: _BoolSub __rsub__: _BoolSub __mul__: _BoolOp[np.bool] __rmul__: _BoolOp[np.bool] __floordiv__: _BoolOp[int8] __rfloordiv__: _BoolOp[int8] __pow__: _BoolOp[int8] __rpow__: _BoolOp[int8] __truediv__: _BoolTrueDiv __rtruediv__: _BoolTrueDiv def __invert__(self) -> np.bool: ... __lshift__: _BoolBitOp[int8] __rlshift__: _BoolBitOp[int8] __rshift__: _BoolBitOp[int8] __rrshift__: _BoolBitOp[int8] __and__: _BoolBitOp[np.bool] __rand__: _BoolBitOp[np.bool] __xor__: _BoolBitOp[np.bool] __rxor__: _BoolBitOp[np.bool] __or__: _BoolBitOp[np.bool] __ror__: _BoolBitOp[np.bool] __mod__: _BoolMod __rmod__: _BoolMod __divmod__: _BoolDivMod __rdivmod__: _BoolDivMod __lt__: _ComparisonOpLT[_NumberLike_co, _ArrayLikeNumber_co] __le__: _ComparisonOpLE[_NumberLike_co, _ArrayLikeNumber_co] __gt__: _ComparisonOpGT[_NumberLike_co, _ArrayLikeNumber_co] __ge__: _ComparisonOpGE[_NumberLike_co, _ArrayLikeNumber_co] bool_: TypeAlias = bool @final class object_(generic): def __init__(self, value: object = ..., /) -> None: ... @property def real(self: _ArraySelf) -> _ArraySelf: ... @property def imag(self: _ArraySelf) -> _ArraySelf: ... # The 3 protocols below may or may not raise, # depending on the underlying object def __int__(self) -> int: ... def __float__(self) -> float: ... def __complex__(self) -> complex: ... if sys.version_info >= (3, 12): def __release_buffer__(self, buffer: memoryview, /) -> None: ... # The `datetime64` constructors requires an object with the three attributes below, # and thus supports datetime duck typing class _DatetimeScalar(Protocol): @property def day(self) -> int: ... @property def month(self) -> int: ... @property def year(self) -> int: ... # TODO: `item`/`tolist` returns either `dt.date`, `dt.datetime` or `int` # depending on the unit class datetime64(generic): @overload def __init__( self, value: None | datetime64 | _CharLike_co | _DatetimeScalar = ..., format: _CharLike_co | tuple[_CharLike_co, _IntLike_co] = ..., /, ) -> None: ... @overload def __init__( self, value: int, format: _CharLike_co | tuple[_CharLike_co, _IntLike_co], /, ) -> None: ... def __add__(self, other: _TD64Like_co, /) -> datetime64: ... def __radd__(self, other: _TD64Like_co, /) -> datetime64: ... @overload def __sub__(self, other: datetime64, /) -> timedelta64: ... @overload def __sub__(self, other: _TD64Like_co, /) -> datetime64: ... def __rsub__(self, other: datetime64, /) -> timedelta64: ... __lt__: _ComparisonOpLT[datetime64, _ArrayLikeDT64_co] __le__: _ComparisonOpLE[datetime64, _ArrayLikeDT64_co] __gt__: _ComparisonOpGT[datetime64, _ArrayLikeDT64_co] __ge__: _ComparisonOpGE[datetime64, _ArrayLikeDT64_co] _IntValue: TypeAlias = SupportsInt | _CharLike_co | SupportsIndex _FloatValue: TypeAlias = None | _CharLike_co | SupportsFloat | SupportsIndex _ComplexValue: TypeAlias = ( None | _CharLike_co | SupportsFloat | SupportsComplex | SupportsIndex | complex # `complex` is not a subtype of `SupportsComplex` ) class integer(number[_NBit1]): # type: ignore @property def numerator(self: _ScalarType) -> _ScalarType: ... @property def denominator(self) -> L[1]: ... @overload def __round__(self, ndigits: None = ..., /) -> int: ... @overload def __round__(self: _ScalarType, ndigits: SupportsIndex, /) -> _ScalarType: ... # NOTE: `__index__` is technically defined in the bottom-most # sub-classes (`int64`, `uint32`, etc) def item( self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, ) -> int: ... def tolist(self) -> int: ... def is_integer(self) -> L[True]: ... def bit_count(self: _ScalarType) -> int: ... def __index__(self) -> int: ... __truediv__: _IntTrueDiv[_NBit1] __rtruediv__: _IntTrueDiv[_NBit1] def __mod__(self, value: _IntLike_co, /) -> integer[Any]: ... def __rmod__(self, value: _IntLike_co, /) -> integer[Any]: ... def __invert__(self: _IntType) -> _IntType: ... # Ensure that objects annotated as `integer` support bit-wise operations def __lshift__(self, other: _IntLike_co, /) -> integer[Any]: ... def __rlshift__(self, other: _IntLike_co, /) -> integer[Any]: ... def __rshift__(self, other: _IntLike_co, /) -> integer[Any]: ... def __rrshift__(self, other: _IntLike_co, /) -> integer[Any]: ... def __and__(self, other: _IntLike_co, /) -> integer[Any]: ... def __rand__(self, other: _IntLike_co, /) -> integer[Any]: ... def __or__(self, other: _IntLike_co, /) -> integer[Any]: ... def __ror__(self, other: _IntLike_co, /) -> integer[Any]: ... def __xor__(self, other: _IntLike_co, /) -> integer[Any]: ... def __rxor__(self, other: _IntLike_co, /) -> integer[Any]: ... class signedinteger(integer[_NBit1]): def __init__(self, value: _IntValue = ..., /) -> None: ... __add__: _SignedIntOp[_NBit1] __radd__: _SignedIntOp[_NBit1] __sub__: _SignedIntOp[_NBit1] __rsub__: _SignedIntOp[_NBit1] __mul__: _SignedIntOp[_NBit1] __rmul__: _SignedIntOp[_NBit1] __floordiv__: _SignedIntOp[_NBit1] __rfloordiv__: _SignedIntOp[_NBit1] __pow__: _SignedIntOp[_NBit1] __rpow__: _SignedIntOp[_NBit1] __lshift__: _SignedIntBitOp[_NBit1] __rlshift__: _SignedIntBitOp[_NBit1] __rshift__: _SignedIntBitOp[_NBit1] __rrshift__: _SignedIntBitOp[_NBit1] __and__: _SignedIntBitOp[_NBit1] __rand__: _SignedIntBitOp[_NBit1] __xor__: _SignedIntBitOp[_NBit1] __rxor__: _SignedIntBitOp[_NBit1] __or__: _SignedIntBitOp[_NBit1] __ror__: _SignedIntBitOp[_NBit1] __mod__: _SignedIntMod[_NBit1] __rmod__: _SignedIntMod[_NBit1] __divmod__: _SignedIntDivMod[_NBit1] __rdivmod__: _SignedIntDivMod[_NBit1] int8 = signedinteger[_8Bit] int16 = signedinteger[_16Bit] int32 = signedinteger[_32Bit] int64 = signedinteger[_64Bit] byte = signedinteger[_NBitByte] short = signedinteger[_NBitShort] intc = signedinteger[_NBitIntC] intp = signedinteger[_NBitIntP] int_ = intp long = signedinteger[_NBitLong] longlong = signedinteger[_NBitLongLong] # TODO: `item`/`tolist` returns either `dt.timedelta` or `int` # depending on the unit class timedelta64(generic): def __init__( self, value: None | int | _CharLike_co | dt.timedelta | timedelta64 = ..., format: _CharLike_co | tuple[_CharLike_co, _IntLike_co] = ..., /, ) -> None: ... @property def numerator(self: _ScalarType) -> _ScalarType: ... @property def denominator(self) -> L[1]: ... # NOTE: Only a limited number of units support conversion # to builtin scalar types: `Y`, `M`, `ns`, `ps`, `fs`, `as` def __int__(self) -> int: ... def __float__(self) -> float: ... def __complex__(self) -> complex: ... def __neg__(self: _ArraySelf) -> _ArraySelf: ... def __pos__(self: _ArraySelf) -> _ArraySelf: ... def __abs__(self: _ArraySelf) -> _ArraySelf: ... def __add__(self, other: _TD64Like_co, /) -> timedelta64: ... def __radd__(self, other: _TD64Like_co, /) -> timedelta64: ... def __sub__(self, other: _TD64Like_co, /) -> timedelta64: ... def __rsub__(self, other: _TD64Like_co, /) -> timedelta64: ... def __mul__(self, other: _FloatLike_co, /) -> timedelta64: ... def __rmul__(self, other: _FloatLike_co, /) -> timedelta64: ... __truediv__: _TD64Div[float64] __floordiv__: _TD64Div[int64] def __rtruediv__(self, other: timedelta64, /) -> float64: ... def __rfloordiv__(self, other: timedelta64, /) -> int64: ... def __mod__(self, other: timedelta64, /) -> timedelta64: ... def __rmod__(self, other: timedelta64, /) -> timedelta64: ... def __divmod__(self, other: timedelta64, /) -> tuple[int64, timedelta64]: ... def __rdivmod__(self, other: timedelta64, /) -> tuple[int64, timedelta64]: ... __lt__: _ComparisonOpLT[_TD64Like_co, _ArrayLikeTD64_co] __le__: _ComparisonOpLE[_TD64Like_co, _ArrayLikeTD64_co] __gt__: _ComparisonOpGT[_TD64Like_co, _ArrayLikeTD64_co] __ge__: _ComparisonOpGE[_TD64Like_co, _ArrayLikeTD64_co] class unsignedinteger(integer[_NBit1]): # NOTE: `uint64 + signedinteger -> float64` def __init__(self, value: _IntValue = ..., /) -> None: ... __add__: _UnsignedIntOp[_NBit1] __radd__: _UnsignedIntOp[_NBit1] __sub__: _UnsignedIntOp[_NBit1] __rsub__: _UnsignedIntOp[_NBit1] __mul__: _UnsignedIntOp[_NBit1] __rmul__: _UnsignedIntOp[_NBit1] __floordiv__: _UnsignedIntOp[_NBit1] __rfloordiv__: _UnsignedIntOp[_NBit1] __pow__: _UnsignedIntOp[_NBit1] __rpow__: _UnsignedIntOp[_NBit1] __lshift__: _UnsignedIntBitOp[_NBit1] __rlshift__: _UnsignedIntBitOp[_NBit1] __rshift__: _UnsignedIntBitOp[_NBit1] __rrshift__: _UnsignedIntBitOp[_NBit1] __and__: _UnsignedIntBitOp[_NBit1] __rand__: _UnsignedIntBitOp[_NBit1] __xor__: _UnsignedIntBitOp[_NBit1] __rxor__: _UnsignedIntBitOp[_NBit1] __or__: _UnsignedIntBitOp[_NBit1] __ror__: _UnsignedIntBitOp[_NBit1] __mod__: _UnsignedIntMod[_NBit1] __rmod__: _UnsignedIntMod[_NBit1] __divmod__: _UnsignedIntDivMod[_NBit1] __rdivmod__: _UnsignedIntDivMod[_NBit1] uint8: TypeAlias = unsignedinteger[_8Bit] uint16: TypeAlias = unsignedinteger[_16Bit] uint32: TypeAlias = unsignedinteger[_32Bit] uint64: TypeAlias = unsignedinteger[_64Bit] ubyte: TypeAlias = unsignedinteger[_NBitByte] ushort: TypeAlias = unsignedinteger[_NBitShort] uintc: TypeAlias = unsignedinteger[_NBitIntC] uintp: TypeAlias = unsignedinteger[_NBitIntP] uint: TypeAlias = uintp ulong: TypeAlias = unsignedinteger[_NBitLong] ulonglong: TypeAlias = unsignedinteger[_NBitLongLong] class inexact(number[_NBit1]): # type: ignore def __getnewargs__(self: inexact[_64Bit]) -> tuple[float, ...]: ... _IntType = TypeVar("_IntType", bound=integer[Any]) _FloatType = TypeVar('_FloatType', bound=floating[Any]) class floating(inexact[_NBit1]): def __init__(self, value: _FloatValue = ..., /) -> None: ... def item( self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, ) -> float: ... def tolist(self) -> float: ... def is_integer(self) -> builtins.bool: ... def hex(self: float64) -> str: ... @classmethod def fromhex(cls: type[float64], string: str, /) -> float64: ... def as_integer_ratio(self) -> tuple[int, int]: ... def __ceil__(self: float64) -> int: ... def __floor__(self: float64) -> int: ... def __trunc__(self: float64) -> int: ... def __getnewargs__(self: float64) -> tuple[float]: ... def __getformat__(self: float64, typestr: L["double", "float"], /) -> str: ... @overload def __round__(self, ndigits: None = ..., /) -> int: ... @overload def __round__(self: _ScalarType, ndigits: SupportsIndex, /) -> _ScalarType: ... __add__: _FloatOp[_NBit1] __radd__: _FloatOp[_NBit1] __sub__: _FloatOp[_NBit1] __rsub__: _FloatOp[_NBit1] __mul__: _FloatOp[_NBit1] __rmul__: _FloatOp[_NBit1] __truediv__: _FloatOp[_NBit1] __rtruediv__: _FloatOp[_NBit1] __floordiv__: _FloatOp[_NBit1] __rfloordiv__: _FloatOp[_NBit1] __pow__: _FloatOp[_NBit1] __rpow__: _FloatOp[_NBit1] __mod__: _FloatMod[_NBit1] __rmod__: _FloatMod[_NBit1] __divmod__: _FloatDivMod[_NBit1] __rdivmod__: _FloatDivMod[_NBit1] float16: TypeAlias = floating[_16Bit] float32: TypeAlias = floating[_32Bit] float64: TypeAlias = floating[_64Bit] half: TypeAlias = floating[_NBitHalf] single: TypeAlias = floating[_NBitSingle] double: TypeAlias = floating[_NBitDouble] longdouble: TypeAlias = floating[_NBitLongDouble] # The main reason for `complexfloating` having two typevars is cosmetic. # It is used to clarify why `complex128`s precision is `_64Bit`, the latter # describing the two 64 bit floats representing its real and imaginary component class complexfloating(inexact[_NBit1], Generic[_NBit1, _NBit2]): def __init__(self, value: _ComplexValue = ..., /) -> None: ... def item( self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, ) -> complex: ... def tolist(self) -> complex: ... @property def real(self) -> floating[_NBit1]: ... # type: ignore[override] @property def imag(self) -> floating[_NBit2]: ... # type: ignore[override] def __abs__(self) -> floating[_NBit1]: ... # type: ignore[override] def __getnewargs__(self: complex128) -> tuple[float, float]: ... # NOTE: Deprecated # def __round__(self, ndigits=...): ... __add__: _ComplexOp[_NBit1] __radd__: _ComplexOp[_NBit1] __sub__: _ComplexOp[_NBit1] __rsub__: _ComplexOp[_NBit1] __mul__: _ComplexOp[_NBit1] __rmul__: _ComplexOp[_NBit1] __truediv__: _ComplexOp[_NBit1] __rtruediv__: _ComplexOp[_NBit1] __pow__: _ComplexOp[_NBit1] __rpow__: _ComplexOp[_NBit1] complex64: TypeAlias = complexfloating[_32Bit, _32Bit] complex128: TypeAlias = complexfloating[_64Bit, _64Bit] csingle: TypeAlias = complexfloating[_NBitSingle, _NBitSingle] cdouble: TypeAlias = complexfloating[_NBitDouble, _NBitDouble] clongdouble: TypeAlias = complexfloating[_NBitLongDouble, _NBitLongDouble] class flexible(generic): ... # type: ignore # TODO: `item`/`tolist` returns either `bytes` or `tuple` # depending on whether or not it's used as an opaque bytes sequence # or a structure class void(flexible): @overload def __init__(self, value: _IntLike_co | bytes, /, dtype : None = ...) -> None: ... @overload def __init__(self, value: Any, /, dtype: _DTypeLikeVoid) -> None: ... @property def real(self: _ArraySelf) -> _ArraySelf: ... @property def imag(self: _ArraySelf) -> _ArraySelf: ... def setfield( self, val: ArrayLike, dtype: DTypeLike, offset: int = ... ) -> None: ... @overload def __getitem__(self, key: str | SupportsIndex, /) -> Any: ... @overload def __getitem__(self, key: list[str], /) -> void: ... def __setitem__( self, key: str | list[str] | SupportsIndex, value: ArrayLike, /, ) -> None: ... class character(flexible): # type: ignore def __int__(self) -> int: ... def __float__(self) -> float: ... # NOTE: Most `np.bytes_` / `np.str_` methods return their # builtin `bytes` / `str` counterpart class bytes_(character, bytes): @overload def __init__(self, value: object = ..., /) -> None: ... @overload def __init__( self, value: str, /, encoding: str = ..., errors: str = ... ) -> None: ... def item( self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, ) -> bytes: ... def tolist(self) -> bytes: ... class str_(character, str): @overload def __init__(self, value: object = ..., /) -> None: ... @overload def __init__( self, value: bytes, /, encoding: str = ..., errors: str = ... ) -> None: ... def item( self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, ) -> str: ... def tolist(self) -> str: ... # # Constants # e: Final[float] euler_gamma: Final[float] inf: Final[float] nan: Final[float] pi: Final[float] little_endian: Final[builtins.bool] True_: Final[np.bool] False_: Final[np.bool] newaxis: None # See `numpy._typing._ufunc` for more concrete nin-/nout-specific stubs @final class ufunc: @property def __name__(self) -> LiteralString: ... @property def __doc__(self) -> str: ... @property def nin(self) -> int: ... @property def nout(self) -> int: ... @property def nargs(self) -> int: ... @property def ntypes(self) -> int: ... @property def types(self) -> list[LiteralString]: ... # Broad return type because it has to encompass things like # # >>> np.logical_and.identity is True # True # >>> np.add.identity is 0 # True # >>> np.sin.identity is None # True # # and any user-defined ufuncs. @property def identity(self) -> Any: ... # This is None for ufuncs and a string for gufuncs. @property def signature(self) -> None | LiteralString: ... def __call__(self, *args: Any, **kwargs: Any) -> Any: ... # The next four methods will always exist, but they will just # raise a ValueError ufuncs with that don't accept two input # arguments and return one output argument. Because of that we # can't type them very precisely. def reduce(self, /, *args: Any, **kwargs: Any) -> NoReturn | Any: ... def accumulate(self, /, *args: Any, **kwargs: Any) -> NoReturn | NDArray[Any]: ... def reduceat(self, /, *args: Any, **kwargs: Any) -> NoReturn | NDArray[Any]: ... def outer(self, *args: Any, **kwargs: Any) -> NoReturn | Any: ... # Similarly at won't be defined for ufuncs that return multiple # outputs, so we can't type it very precisely. def at(self, /, *args: Any, **kwargs: Any) -> NoReturn | None: ... # Parameters: `__name__`, `ntypes` and `identity` absolute: _UFunc_Nin1_Nout1[L['absolute'], L[20], None] add: _UFunc_Nin2_Nout1[L['add'], L[22], L[0]] arccos: _UFunc_Nin1_Nout1[L['arccos'], L[8], None] arccosh: _UFunc_Nin1_Nout1[L['arccosh'], L[8], None] arcsin: _UFunc_Nin1_Nout1[L['arcsin'], L[8], None] arcsinh: _UFunc_Nin1_Nout1[L['arcsinh'], L[8], None] arctan2: _UFunc_Nin2_Nout1[L['arctan2'], L[5], None] arctan: _UFunc_Nin1_Nout1[L['arctan'], L[8], None] arctanh: _UFunc_Nin1_Nout1[L['arctanh'], L[8], None] bitwise_and: _UFunc_Nin2_Nout1[L['bitwise_and'], L[12], L[-1]] bitwise_count: _UFunc_Nin1_Nout1[L['bitwise_count'], L[11], None] bitwise_not: _UFunc_Nin1_Nout1[L['invert'], L[12], None] bitwise_or: _UFunc_Nin2_Nout1[L['bitwise_or'], L[12], L[0]] bitwise_xor: _UFunc_Nin2_Nout1[L['bitwise_xor'], L[12], L[0]] cbrt: _UFunc_Nin1_Nout1[L['cbrt'], L[5], None] ceil: _UFunc_Nin1_Nout1[L['ceil'], L[7], None] conj: _UFunc_Nin1_Nout1[L['conjugate'], L[18], None] conjugate: _UFunc_Nin1_Nout1[L['conjugate'], L[18], None] copysign: _UFunc_Nin2_Nout1[L['copysign'], L[4], None] cos: _UFunc_Nin1_Nout1[L['cos'], L[9], None] cosh: _UFunc_Nin1_Nout1[L['cosh'], L[8], None] deg2rad: _UFunc_Nin1_Nout1[L['deg2rad'], L[5], None] degrees: _UFunc_Nin1_Nout1[L['degrees'], L[5], None] divide: _UFunc_Nin2_Nout1[L['true_divide'], L[11], None] divmod: _UFunc_Nin2_Nout2[L['divmod'], L[15], None] equal: _UFunc_Nin2_Nout1[L['equal'], L[23], None] exp2: _UFunc_Nin1_Nout1[L['exp2'], L[8], None] exp: _UFunc_Nin1_Nout1[L['exp'], L[10], None] expm1: _UFunc_Nin1_Nout1[L['expm1'], L[8], None] fabs: _UFunc_Nin1_Nout1[L['fabs'], L[5], None] float_power: _UFunc_Nin2_Nout1[L['float_power'], L[4], None] floor: _UFunc_Nin1_Nout1[L['floor'], L[7], None] floor_divide: _UFunc_Nin2_Nout1[L['floor_divide'], L[21], None] fmax: _UFunc_Nin2_Nout1[L['fmax'], L[21], None] fmin: _UFunc_Nin2_Nout1[L['fmin'], L[21], None] fmod: _UFunc_Nin2_Nout1[L['fmod'], L[15], None] frexp: _UFunc_Nin1_Nout2[L['frexp'], L[4], None] gcd: _UFunc_Nin2_Nout1[L['gcd'], L[11], L[0]] greater: _UFunc_Nin2_Nout1[L['greater'], L[23], None] greater_equal: _UFunc_Nin2_Nout1[L['greater_equal'], L[23], None] heaviside: _UFunc_Nin2_Nout1[L['heaviside'], L[4], None] hypot: _UFunc_Nin2_Nout1[L['hypot'], L[5], L[0]] invert: _UFunc_Nin1_Nout1[L['invert'], L[12], None] isfinite: _UFunc_Nin1_Nout1[L['isfinite'], L[20], None] isinf: _UFunc_Nin1_Nout1[L['isinf'], L[20], None] isnan: _UFunc_Nin1_Nout1[L['isnan'], L[20], None] isnat: _UFunc_Nin1_Nout1[L['isnat'], L[2], None] lcm: _UFunc_Nin2_Nout1[L['lcm'], L[11], None] ldexp: _UFunc_Nin2_Nout1[L['ldexp'], L[8], None] left_shift: _UFunc_Nin2_Nout1[L['left_shift'], L[11], None] less: _UFunc_Nin2_Nout1[L['less'], L[23], None] less_equal: _UFunc_Nin2_Nout1[L['less_equal'], L[23], None] log10: _UFunc_Nin1_Nout1[L['log10'], L[8], None] log1p: _UFunc_Nin1_Nout1[L['log1p'], L[8], None] log2: _UFunc_Nin1_Nout1[L['log2'], L[8], None] log: _UFunc_Nin1_Nout1[L['log'], L[10], None] logaddexp2: _UFunc_Nin2_Nout1[L['logaddexp2'], L[4], float] logaddexp: _UFunc_Nin2_Nout1[L['logaddexp'], L[4], float] logical_and: _UFunc_Nin2_Nout1[L['logical_and'], L[20], L[True]] logical_not: _UFunc_Nin1_Nout1[L['logical_not'], L[20], None] logical_or: _UFunc_Nin2_Nout1[L['logical_or'], L[20], L[False]] logical_xor: _UFunc_Nin2_Nout1[L['logical_xor'], L[19], L[False]] matmul: _GUFunc_Nin2_Nout1[L['matmul'], L[19], None, L["(n?,k),(k,m?)->(n?,m?)"]] maximum: _UFunc_Nin2_Nout1[L['maximum'], L[21], None] minimum: _UFunc_Nin2_Nout1[L['minimum'], L[21], None] mod: _UFunc_Nin2_Nout1[L['remainder'], L[16], None] modf: _UFunc_Nin1_Nout2[L['modf'], L[4], None] multiply: _UFunc_Nin2_Nout1[L['multiply'], L[23], L[1]] negative: _UFunc_Nin1_Nout1[L['negative'], L[19], None] nextafter: _UFunc_Nin2_Nout1[L['nextafter'], L[4], None] not_equal: _UFunc_Nin2_Nout1[L['not_equal'], L[23], None] positive: _UFunc_Nin1_Nout1[L['positive'], L[19], None] power: _UFunc_Nin2_Nout1[L['power'], L[18], None] rad2deg: _UFunc_Nin1_Nout1[L['rad2deg'], L[5], None] radians: _UFunc_Nin1_Nout1[L['radians'], L[5], None] reciprocal: _UFunc_Nin1_Nout1[L['reciprocal'], L[18], None] remainder: _UFunc_Nin2_Nout1[L['remainder'], L[16], None] right_shift: _UFunc_Nin2_Nout1[L['right_shift'], L[11], None] rint: _UFunc_Nin1_Nout1[L['rint'], L[10], None] sign: _UFunc_Nin1_Nout1[L['sign'], L[19], None] signbit: _UFunc_Nin1_Nout1[L['signbit'], L[4], None] sin: _UFunc_Nin1_Nout1[L['sin'], L[9], None] sinh: _UFunc_Nin1_Nout1[L['sinh'], L[8], None] spacing: _UFunc_Nin1_Nout1[L['spacing'], L[4], None] sqrt: _UFunc_Nin1_Nout1[L['sqrt'], L[10], None] square: _UFunc_Nin1_Nout1[L['square'], L[18], None] subtract: _UFunc_Nin2_Nout1[L['subtract'], L[21], None] tan: _UFunc_Nin1_Nout1[L['tan'], L[8], None] tanh: _UFunc_Nin1_Nout1[L['tanh'], L[8], None] true_divide: _UFunc_Nin2_Nout1[L['true_divide'], L[11], None] trunc: _UFunc_Nin1_Nout1[L['trunc'], L[7], None] vecdot: _GUFunc_Nin2_Nout1[L['vecdot'], L[19], None, L["(n),(n)->()"]] abs = absolute acos = arccos acosh = arccosh asin = arcsin asinh = arcsinh atan = arctan atanh = arctanh atan2 = arctan2 concat = concatenate bitwise_left_shift = left_shift bitwise_invert = invert bitwise_right_shift = right_shift permute_dims = transpose pow = power class _CopyMode(enum.Enum): ALWAYS: L[True] IF_NEEDED: L[False] NEVER: L[2] _CallType = TypeVar("_CallType", bound=Callable[..., Any]) class errstate: def __init__( self, *, call: _ErrFunc | _SupportsWrite[str] = ..., all: None | _ErrKind = ..., divide: None | _ErrKind = ..., over: None | _ErrKind = ..., under: None | _ErrKind = ..., invalid: None | _ErrKind = ..., ) -> None: ... def __enter__(self) -> None: ... def __exit__( self, exc_type: None | type[BaseException], exc_value: None | BaseException, traceback: None | TracebackType, /, ) -> None: ... def __call__(self, func: _CallType) -> _CallType: ... @contextmanager def _no_nep50_warning() -> Generator[None, None, None]: ... def _get_promotion_state() -> str: ... def _set_promotion_state(state: str, /) -> None: ... _ScalarType_co = TypeVar("_ScalarType_co", bound=generic, covariant=True) class ndenumerate(Generic[_ScalarType_co]): @property def iter(self) -> flatiter[NDArray[_ScalarType_co]]: ... @overload def __new__( cls, arr: _FiniteNestedSequence[_SupportsArray[dtype[_ScalarType]]], ) -> ndenumerate[_ScalarType]: ... @overload def __new__(cls, arr: str | _NestedSequence[str]) -> ndenumerate[str_]: ... @overload def __new__(cls, arr: bytes | _NestedSequence[bytes]) -> ndenumerate[bytes_]: ... @overload def __new__(cls, arr: builtins.bool | _NestedSequence[builtins.bool]) -> ndenumerate[np.bool]: ... @overload def __new__(cls, arr: int | _NestedSequence[int]) -> ndenumerate[int_]: ... @overload def __new__(cls, arr: float | _NestedSequence[float]) -> ndenumerate[float64]: ... @overload def __new__(cls, arr: complex | _NestedSequence[complex]) -> ndenumerate[complex128]: ... @overload def __new__(cls, arr: object) -> ndenumerate[object_]: ... # The first overload is a (semi-)workaround for a mypy bug (tested with v1.10 and v1.11) @overload def __next__( self: ndenumerate[np.bool | datetime64 | timedelta64 | number[Any] | flexible], /, ) -> tuple[_Shape, _ScalarType_co]: ... @overload def __next__(self: ndenumerate[object_], /) -> tuple[_Shape, Any]: ... @overload def __next__(self, /) -> tuple[_Shape, _ScalarType_co]: ... def __iter__(self: _T) -> _T: ... class ndindex: @overload def __init__(self, shape: tuple[SupportsIndex, ...], /) -> None: ... @overload def __init__(self, *shape: SupportsIndex) -> None: ... def __iter__(self: _T) -> _T: ... def __next__(self) -> _Shape: ... # TODO: The type of each `__next__` and `iters` return-type depends # on the length and dtype of `args`; we can't describe this behavior yet # as we lack variadics (PEP 646). @final class broadcast: def __new__(cls, *args: ArrayLike) -> broadcast: ... @property def index(self) -> int: ... @property def iters(self) -> tuple[flatiter[Any], ...]: ... @property def nd(self) -> int: ... @property def ndim(self) -> int: ... @property def numiter(self) -> int: ... @property def shape(self) -> _Shape: ... @property def size(self) -> int: ... def __next__(self) -> tuple[Any, ...]: ... def __iter__(self: _T) -> _T: ... def reset(self) -> None: ... @final class busdaycalendar: def __new__( cls, weekmask: ArrayLike = ..., holidays: ArrayLike | dt.date | _NestedSequence[dt.date] = ..., ) -> busdaycalendar: ... @property def weekmask(self) -> NDArray[np.bool]: ... @property def holidays(self) -> NDArray[datetime64]: ... class finfo(Generic[_FloatType]): dtype: dtype[_FloatType] bits: int eps: _FloatType epsneg: _FloatType iexp: int machep: int max: _FloatType maxexp: int min: _FloatType minexp: int negep: int nexp: int nmant: int precision: int resolution: _FloatType smallest_subnormal: _FloatType @property def smallest_normal(self) -> _FloatType: ... @property def tiny(self) -> _FloatType: ... @overload def __new__( cls, dtype: inexact[_NBit1] | _DTypeLike[inexact[_NBit1]] ) -> finfo[floating[_NBit1]]: ... @overload def __new__( cls, dtype: complex | float | type[complex] | type[float] ) -> finfo[float64]: ... @overload def __new__( cls, dtype: str ) -> finfo[floating[Any]]: ... class iinfo(Generic[_IntType]): dtype: dtype[_IntType] kind: LiteralString bits: int key: LiteralString @property def min(self) -> int: ... @property def max(self) -> int: ... @overload def __new__(cls, dtype: _IntType | _DTypeLike[_IntType]) -> iinfo[_IntType]: ... @overload def __new__(cls, dtype: int | type[int]) -> iinfo[int_]: ... @overload def __new__(cls, dtype: str) -> iinfo[Any]: ... _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", ] _NDIterOpFlagsKind: TypeAlias = L[ "aligned", "allocate", "arraymask", "copy", "config", "nbo", "no_subtype", "no_broadcast", "overlap_assume_elementwise", "readonly", "readwrite", "updateifcopy", "virtual", "writeonly", "writemasked" ] @final class nditer: def __new__( cls, op: ArrayLike | Sequence[ArrayLike], flags: None | Sequence[_NDIterFlagsKind] = ..., op_flags: None | Sequence[Sequence[_NDIterOpFlagsKind]] = ..., op_dtypes: DTypeLike | Sequence[DTypeLike] = ..., order: _OrderKACF = ..., casting: _CastingKind = ..., op_axes: None | Sequence[Sequence[SupportsIndex]] = ..., itershape: None | _ShapeLike = ..., buffersize: SupportsIndex = ..., ) -> nditer: ... def __enter__(self) -> nditer: ... def __exit__( self, exc_type: None | type[BaseException], exc_value: None | BaseException, traceback: None | TracebackType, ) -> None: ... def __iter__(self) -> nditer: ... def __next__(self) -> tuple[NDArray[Any], ...]: ... def __len__(self) -> int: ... def __copy__(self) -> nditer: ... @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 close(self) -> None: ... def copy(self) -> nditer: ... def debug_print(self) -> None: ... def enable_external_loop(self) -> None: ... def iternext(self) -> builtins.bool: ... def remove_axis(self, i: SupportsIndex, /) -> None: ... def remove_multi_index(self) -> None: ... def reset(self) -> None: ... @property def dtypes(self) -> tuple[dtype[Any], ...]: ... @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 index(self) -> int: ... @property def iterationneedsapi(self) -> builtins.bool: ... @property def iterindex(self) -> int: ... @property def iterrange(self) -> tuple[int, ...]: ... @property def itersize(self) -> int: ... @property def itviews(self) -> tuple[NDArray[Any], ...]: ... @property def multi_index(self) -> tuple[int, ...]: ... @property def ndim(self) -> int: ... @property def nop(self) -> int: ... @property def operands(self) -> tuple[NDArray[Any], ...]: ... @property def shape(self) -> tuple[int, ...]: ... @property def value(self) -> tuple[NDArray[Any], ...]: ... _MemMapModeKind: TypeAlias = L[ "readonly", "r", "copyonwrite", "c", "readwrite", "r+", "write", "w+", ] class memmap(ndarray[_ShapeType_co, _DType_co]): __array_priority__: ClassVar[float] filename: str | None offset: int mode: str @overload def __new__( subtype, filename: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _MemMapIOProtocol, dtype: type[uint8] = ..., mode: _MemMapModeKind = ..., offset: int = ..., shape: None | int | tuple[int, ...] = ..., order: _OrderKACF = ..., ) -> memmap[Any, dtype[uint8]]: ... @overload def __new__( subtype, filename: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _MemMapIOProtocol, dtype: _DTypeLike[_ScalarType], mode: _MemMapModeKind = ..., offset: int = ..., shape: None | int | tuple[int, ...] = ..., order: _OrderKACF = ..., ) -> memmap[Any, dtype[_ScalarType]]: ... @overload def __new__( subtype, filename: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _MemMapIOProtocol, dtype: DTypeLike, mode: _MemMapModeKind = ..., offset: int = ..., shape: None | int | tuple[int, ...] = ..., order: _OrderKACF = ..., ) -> memmap[Any, dtype[Any]]: ... def __array_finalize__(self, obj: object) -> None: ... def __array_wrap__( self, array: memmap[_ShapeType_co, _DType_co], context: None | tuple[ufunc, tuple[Any, ...], int] = ..., return_scalar: builtins.bool = ..., ) -> Any: ... def flush(self) -> None: ... # TODO: Add a mypy plugin for managing functions whose output type is dependent # on the literal value of some sort of signature (e.g. `einsum` and `vectorize`) class vectorize: pyfunc: Callable[..., Any] cache: builtins.bool signature: None | LiteralString otypes: None | LiteralString excluded: set[int | str] __doc__: None | str def __init__( self, pyfunc: Callable[..., Any], otypes: None | str | Iterable[DTypeLike] = ..., doc: None | str = ..., excluded: None | Iterable[int | str] = ..., cache: builtins.bool = ..., signature: None | str = ..., ) -> None: ... def __call__(self, *args: Any, **kwargs: Any) -> Any: ... class poly1d: @property def variable(self) -> LiteralString: ... @property def order(self) -> int: ... @property def o(self) -> int: ... @property def roots(self) -> NDArray[Any]: ... @property def r(self) -> NDArray[Any]: ... @property def coeffs(self) -> NDArray[Any]: ... @coeffs.setter def coeffs(self, value: NDArray[Any]) -> None: ... @property def c(self) -> NDArray[Any]: ... @c.setter def c(self, value: NDArray[Any]) -> None: ... @property def coef(self) -> NDArray[Any]: ... @coef.setter def coef(self, value: NDArray[Any]) -> None: ... @property def coefficients(self) -> NDArray[Any]: ... @coefficients.setter def coefficients(self, value: NDArray[Any]) -> None: ... __hash__: ClassVar[None] # type: ignore # TODO: use `tuple[int]` as shape type once covariant (#26081) @overload def __array__(self, t: None = ..., copy: None | bool = ...) -> NDArray[Any]: ... @overload def __array__(self, t: _DType, copy: None | bool = ...) -> ndarray[Any, _DType]: ... @overload def __call__(self, val: _ScalarLike_co) -> Any: ... @overload def __call__(self, val: poly1d) -> poly1d: ... @overload def __call__(self, val: ArrayLike) -> NDArray[Any]: ... def __init__( self, c_or_r: ArrayLike, r: builtins.bool = ..., variable: None | str = ..., ) -> None: ... def __len__(self) -> int: ... def __neg__(self) -> poly1d: ... def __pos__(self) -> poly1d: ... def __mul__(self, other: ArrayLike, /) -> poly1d: ... def __rmul__(self, other: ArrayLike, /) -> poly1d: ... def __add__(self, other: ArrayLike, /) -> poly1d: ... def __radd__(self, other: ArrayLike, /) -> poly1d: ... def __pow__(self, val: _FloatLike_co, /) -> poly1d: ... # Integral floats are accepted def __sub__(self, other: ArrayLike, /) -> poly1d: ... def __rsub__(self, other: ArrayLike, /) -> poly1d: ... def __div__(self, other: ArrayLike, /) -> poly1d: ... def __truediv__(self, other: ArrayLike, /) -> poly1d: ... def __rdiv__(self, other: ArrayLike, /) -> poly1d: ... def __rtruediv__(self, other: ArrayLike, /) -> poly1d: ... def __getitem__(self, val: int, /) -> Any: ... def __setitem__(self, key: int, val: Any, /) -> None: ... def __iter__(self) -> Iterator[Any]: ... def deriv(self, m: SupportsInt | SupportsIndex = ...) -> poly1d: ... def integ( self, m: SupportsInt | SupportsIndex = ..., k: None | _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., ) -> poly1d: ... class matrix(ndarray[_Shape2DType_co, _DType_co]): __array_priority__: ClassVar[float] def __new__( subtype, data: ArrayLike, dtype: DTypeLike = ..., copy: builtins.bool = ..., ) -> matrix[Any, Any]: ... def __array_finalize__(self, obj: object) -> None: ... @overload def __getitem__( self, key: ( SupportsIndex | _ArrayLikeInt_co | tuple[SupportsIndex | _ArrayLikeInt_co, ...] ), /, ) -> Any: ... @overload def __getitem__( self, key: ( None | slice | ellipsis | SupportsIndex | _ArrayLikeInt_co | tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...] ), /, ) -> matrix[Any, _DType_co]: ... @overload def __getitem__(self: NDArray[void], key: str, /) -> matrix[Any, dtype[Any]]: ... @overload def __getitem__(self: NDArray[void], key: list[str], /) -> matrix[_Shape2DType_co, dtype[void]]: ... def __mul__(self, other: ArrayLike, /) -> matrix[Any, Any]: ... def __rmul__(self, other: ArrayLike, /) -> matrix[Any, Any]: ... def __imul__(self, other: ArrayLike, /) -> matrix[_Shape2DType_co, _DType_co]: ... def __pow__(self, other: ArrayLike, /) -> matrix[Any, Any]: ... def __ipow__(self, other: ArrayLike, /) -> matrix[_Shape2DType_co, _DType_co]: ... @overload def sum(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ...) -> Any: ... @overload def sum(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ...) -> matrix[Any, Any]: ... @overload def sum(self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def mean(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ...) -> Any: ... @overload def mean(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ...) -> matrix[Any, Any]: ... @overload def mean(self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def std(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> Any: ... @overload def std(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> matrix[Any, Any]: ... @overload def std(self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ddof: float = ...) -> _NdArraySubClass: ... @overload def var(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> Any: ... @overload def var(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> matrix[Any, Any]: ... @overload def var(self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ddof: float = ...) -> _NdArraySubClass: ... @overload def prod(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ...) -> Any: ... @overload def prod(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ...) -> matrix[Any, Any]: ... @overload def prod(self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def any(self, axis: None = ..., out: None = ...) -> np.bool: ... @overload def any(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[np.bool]]: ... @overload def any(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def all(self, axis: None = ..., out: None = ...) -> np.bool: ... @overload def all(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[np.bool]]: ... @overload def all(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def max(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> _ScalarType: ... @overload def max(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, _DType_co]: ... @overload def max(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def min(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> _ScalarType: ... @overload def min(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, _DType_co]: ... @overload def min(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def argmax(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> intp: ... @overload def argmax(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[intp]]: ... @overload def argmax(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def argmin(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> intp: ... @overload def argmin(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[intp]]: ... @overload def argmin(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... @overload def ptp(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> _ScalarType: ... @overload def ptp(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, _DType_co]: ... @overload def ptp(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... def squeeze(self, axis: None | _ShapeLike = ...) -> matrix[Any, _DType_co]: ... def tolist(self: matrix[Any, dtype[_SupportsItem[_T]]]) -> list[list[_T]]: ... # type: ignore[typevar] def ravel(self, order: _OrderKACF = ...) -> matrix[Any, _DType_co]: ... def flatten(self, order: _OrderKACF = ...) -> matrix[Any, _DType_co]: ... @property def T(self) -> matrix[Any, _DType_co]: ... @property def I(self) -> matrix[Any, Any]: ... @property def A(self) -> ndarray[_Shape2DType_co, _DType_co]: ... @property def A1(self) -> ndarray[Any, _DType_co]: ... @property def H(self) -> matrix[Any, _DType_co]: ... def getT(self) -> matrix[Any, _DType_co]: ... def getI(self) -> matrix[Any, Any]: ... def getA(self) -> ndarray[_Shape2DType_co, _DType_co]: ... def getA1(self) -> ndarray[Any, _DType_co]: ... def getH(self) -> matrix[Any, _DType_co]: ... _CharType = TypeVar("_CharType", str_, bytes_) _CharDType = TypeVar("_CharDType", dtype[str_], dtype[bytes_]) # NOTE: Deprecated # class MachAr: ... class _SupportsDLPack(Protocol[_T_contra]): def __dlpack__(self, *, stream: None | _T_contra = ...) -> _PyCapsule: ... def from_dlpack( obj: _SupportsDLPack[None], /, *, device: L["cpu"] | None = ..., copy: bool | None = ..., ) -> NDArray[Any]: ...