# ruff: noqa: I001 import builtins import sys import mmap import ctypes as ct import array as _array import datetime as dt import inspect from abc import abstractmethod from types import EllipsisType, ModuleType, TracebackType, MappingProxyType, GenericAlias from decimal import Decimal from fractions import Fraction from uuid import UUID import numpy as np from numpy.__config__ import show as show_config from numpy._pytesttester import PytestTester from numpy._core._internal import _ctypes from numpy._typing import ( # type: ignore[deprecated] # Arrays ArrayLike, NDArray, _SupportsArray, _NestedSequence, _ArrayLike, _ArrayLikeBool_co, _ArrayLikeUInt_co, _ArrayLikeInt, _ArrayLikeInt_co, _ArrayLikeFloat64_co, _ArrayLikeFloat_co, _ArrayLikeComplex128_co, _ArrayLikeComplex_co, _ArrayLikeNumber_co, _ArrayLikeObject_co, _ArrayLikeBytes_co, _ArrayLikeStr_co, _ArrayLikeString_co, _ArrayLikeTD64_co, _ArrayLikeDT64_co, # DTypes DTypeLike, _DTypeLike, _DTypeLikeVoid, _VoidDTypeLike, # Shapes _AnyShape, _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 _128Bit, _96Bit, _64Bit, _32Bit, _16Bit, _8Bit, _NBitByte, _NBitShort, _NBitIntC, _NBitIntP, _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, _StringCodes, _UnsignedIntegerCodes, _SignedIntegerCodes, _IntegerCodes, _FloatingCodes, _ComplexFloatingCodes, _InexactCodes, _CharacterCodes, # Ufuncs _UFunc_Nin1_Nout1, _UFunc_Nin2_Nout1, _UFunc_Nin1_Nout2, _UFunc_Nin2_Nout2, _GUFunc_Nin2_Nout1, ) # NOTE: Numpy's mypy plugin is used for removing the types unavailable to the specific platform from numpy._typing._extended_precision import ( float96, float128, complex192, complex256, ) from numpy._array_api_info import __array_namespace_info__ from collections.abc import ( Callable, Iterable, Iterator, Mapping, Sequence, ) 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 ) from typing import ( Any, ClassVar, Final, Generic, Literal as L, LiteralString, Never, NoReturn, Protocol, Self, SupportsComplex, SupportsFloat, SupportsInt, SupportsIndex, TypeAlias, TypedDict, final, overload, type_check_only, ) # NOTE: `typing_extensions` and `_typeshed` are always available in `.pyi` stubs, even # if not available at runtime. This is because the `typeshed` stubs for the standard # library include `typing_extensions` stubs: # https://github.com/python/typeshed/blob/main/stdlib/typing_extensions.pyi from _typeshed import Incomplete, StrOrBytesPath, SupportsFlush, SupportsLenAndGetItem, SupportsWrite from typing_extensions import CapsuleType, TypeVar, deprecated, override from numpy import ( char, core, ctypeslib, dtypes, exceptions, f2py, fft, lib, linalg, ma, polynomial, random, rec, strings, testing, typing, ) # available through `__getattr__`, but not in `__all__` or `__dir__` from numpy import ( __config__ as __config__, matlib as matlib, matrixlib as matrixlib, version as version, ) if sys.version_info < (3, 12): from numpy import distutils as distutils from numpy._core.records import ( record, recarray, ) from numpy._core.function_base import ( linspace, logspace, geomspace, ) from numpy._core.fromnumeric import ( take, reshape, choose, repeat, put, swapaxes, transpose, matrix_transpose, partition, argpartition, sort, argsort, argmax, argmin, searchsorted, resize, squeeze, diagonal, trace, ravel, nonzero, shape, compress, clip, sum, all, any, cumsum, cumulative_sum, ptp, max, min, amax, amin, prod, cumprod, cumulative_prod, ndim, size, around, round, mean, std, var, ) from numpy._core._asarray import ( require, ) from numpy._core._type_aliases import ( sctypeDict, ) from numpy._core._ufunc_config import ( seterr, geterr, setbufsize, getbufsize, seterrcall, geterrcall, errstate, ) from numpy._core.arrayprint import ( set_printoptions, get_printoptions, array2string, format_float_scientific, format_float_positional, array_repr, array_str, printoptions, ) from numpy._core.einsumfunc import ( einsum, einsum_path, ) from numpy._core.getlimits import ( finfo, iinfo, ) from numpy._core.multiarray import ( array, empty_like, empty, zeros, concatenate, inner, where, lexsort, can_cast, min_scalar_type, result_type, dot, vdot, bincount, copyto, putmask, packbits, unpackbits, shares_memory, may_share_memory, asarray, asanyarray, ascontiguousarray, asfortranarray, arange, busday_count, busday_offset, datetime_as_string, datetime_data, frombuffer, fromfile, fromiter, is_busday, promote_types, fromstring, frompyfunc, nested_iters, flagsobj, ) from numpy._core.numeric import ( zeros_like, ones, ones_like, full, full_like, count_nonzero, isfortran, argwhere, flatnonzero, correlate, convolve, outer, tensordot, roll, rollaxis, moveaxis, cross, indices, fromfunction, isscalar, binary_repr, base_repr, identity, allclose, isclose, array_equal, array_equiv, astype, ) from numpy._core.numerictypes import ( isdtype, issubdtype, ScalarType, typecodes, ) from numpy._core.shape_base import ( atleast_1d, atleast_2d, atleast_3d, block, hstack, stack, vstack, unstack, ) from ._expired_attrs_2_0 import __expired_attributes__ as __expired_attributes__ from ._globals import _CopyMode as _CopyMode from ._globals import _NoValue as _NoValue, _NoValueType from numpy.lib import ( scimath as emath, ) from numpy.lib._arraypad_impl import ( pad, ) from numpy.lib._arraysetops_impl import ( ediff1d, intersect1d, isin, setdiff1d, setxor1d, union1d, unique, unique_all, unique_counts, unique_inverse, unique_values, ) from numpy.lib._function_base_impl import ( # type: ignore[deprecated] select, piecewise, trim_zeros, copy, iterable, percentile, diff, gradient, angle, unwrap, sort_complex, flip, rot90, extract, place, asarray_chkfinite, average, digitize, cov, corrcoef, median, sinc, hamming, hanning, bartlett, blackman, kaiser, trapezoid, i0, meshgrid, delete, insert, append, interp, quantile, vectorize, ) from numpy.lib._histograms_impl import ( histogram_bin_edges, histogram, histogramdd, ) from numpy.lib._index_tricks_impl import ( ndenumerate, ndindex, ravel_multi_index, unravel_index, mgrid, ogrid, r_, c_, s_, index_exp, ix_, fill_diagonal, diag_indices, diag_indices_from, ) from numpy.lib._nanfunctions_impl import ( nansum, nanmax, nanmin, nanargmax, nanargmin, nanmean, nanmedian, nanpercentile, nanvar, nanstd, nanprod, nancumsum, nancumprod, nanquantile, ) from numpy.lib._npyio_impl import ( savetxt, loadtxt, genfromtxt, load, save, savez, savez_compressed, fromregex, ) from numpy.lib._polynomial_impl import ( poly, roots, polyint, polyder, polyadd, polysub, polymul, polydiv, polyval, polyfit, ) from numpy.lib._shape_base_impl import ( # type: ignore[deprecated] column_stack, row_stack, dstack, array_split, split, hsplit, vsplit, dsplit, apply_over_axes, expand_dims, apply_along_axis, kron, tile, take_along_axis, put_along_axis, ) from numpy.lib._stride_tricks_impl import ( broadcast_to, broadcast_arrays, broadcast_shapes, ) from numpy.lib._twodim_base_impl import ( diag, diagflat, eye, fliplr, flipud, tri, triu, tril, vander, histogram2d, mask_indices, tril_indices, tril_indices_from, triu_indices, triu_indices_from, ) from numpy.lib._type_check_impl import ( mintypecode, real, imag, iscomplex, isreal, iscomplexobj, isrealobj, nan_to_num, real_if_close, typename, common_type, ) from numpy.lib._ufunclike_impl import ( fix, isposinf, isneginf, ) from numpy.lib._utils_impl import ( get_include, info, show_runtime, ) from numpy.matrixlib import ( asmatrix, bmat, matrix, ) __all__ = [ # noqa: RUF022 # __numpy_submodules__ "char", "core", "ctypeslib", "dtypes", "exceptions", "f2py", "fft", "lib", "linalg", "ma", "polynomial", "random", "rec", "strings", "test", "testing", "typing", # _core.__all__ "abs", "acos", "acosh", "asin", "asinh", "atan", "atanh", "atan2", "bitwise_invert", "bitwise_left_shift", "bitwise_right_shift", "concat", "pow", "permute_dims", "memmap", "sctypeDict", "record", "recarray", # _core.numeric.__all__ "newaxis", "ndarray", "flatiter", "nditer", "nested_iters", "ufunc", "arange", "array", "asarray", "asanyarray", "ascontiguousarray", "asfortranarray", "zeros", "count_nonzero", "empty", "broadcast", "dtype", "fromstring", "fromfile", "frombuffer", "from_dlpack", "where", "argwhere", "copyto", "concatenate", "lexsort", "astype", "can_cast", "promote_types", "min_scalar_type", "result_type", "isfortran", "empty_like", "zeros_like", "ones_like", "correlate", "convolve", "inner", "dot", "outer", "vdot", "roll", "rollaxis", "moveaxis", "cross", "tensordot", "little_endian", "fromiter", "array_equal", "array_equiv", "indices", "fromfunction", "isclose", "isscalar", "binary_repr", "base_repr", "ones", "identity", "allclose", "putmask", "flatnonzero", "inf", "nan", "False_", "True_", "bitwise_not", "full", "full_like", "matmul", "vecdot", "vecmat", "shares_memory", "may_share_memory", "all", "amax", "amin", "any", "argmax", "argmin", "argpartition", "argsort", "around", "choose", "clip", "compress", "cumprod", "cumsum", "cumulative_prod", "cumulative_sum", "diagonal", "mean", "max", "min", "matrix_transpose", "ndim", "nonzero", "partition", "prod", "ptp", "put", "ravel", "repeat", "reshape", "resize", "round", "searchsorted", "shape", "size", "sort", "squeeze", "std", "sum", "swapaxes", "take", "trace", "transpose", "var", "absolute", "add", "arccos", "arccosh", "arcsin", "arcsinh", "arctan", "arctan2", "arctanh", "bitwise_and", "bitwise_or", "bitwise_xor", "cbrt", "ceil", "conj", "conjugate", "copysign", "cos", "cosh", "bitwise_count", "deg2rad", "degrees", "divide", "divmod", "e", "equal", "euler_gamma", "exp", "exp2", "expm1", "fabs", "floor", "floor_divide", "float_power", "fmax", "fmin", "fmod", "frexp", "frompyfunc", "gcd", "greater", "greater_equal", "heaviside", "hypot", "invert", "isfinite", "isinf", "isnan", "isnat", "lcm", "ldexp", "left_shift", "less", "less_equal", "log", "log10", "log1p", "log2", "logaddexp", "logaddexp2", "logical_and", "logical_not", "logical_or", "logical_xor", "matvec", "maximum", "minimum", "mod", "modf", "multiply", "negative", "nextafter", "not_equal", "pi", "positive", "power", "rad2deg", "radians", "reciprocal", "remainder", "right_shift", "rint", "sign", "signbit", "sin", "sinh", "spacing", "sqrt", "square", "subtract", "tan", "tanh", "true_divide", "trunc", "ScalarType", "typecodes", "issubdtype", "datetime_data", "datetime_as_string", "busday_offset", "busday_count", "is_busday", "busdaycalendar", "isdtype", "complexfloating", "character", "unsignedinteger", "inexact", "generic", "floating", "integer", "signedinteger", "number", "flexible", "bool", "float16", "float32", "float64", "longdouble", "complex64", "complex128", "clongdouble", "bytes_", "str_", "void", "object_", "datetime64", "timedelta64", "int8", "byte", "uint8", "ubyte", "int16", "short", "uint16", "ushort", "int32", "intc", "uint32", "uintc", "int64", "long", "uint64", "ulong", "longlong", "ulonglong", "intp", "uintp", "double", "cdouble", "single", "csingle", "half", "bool_", "int_", "uint", "float96", "float128", "complex192", "complex256", "array2string", "array_str", "array_repr", "set_printoptions", "get_printoptions", "printoptions", "format_float_positional", "format_float_scientific", "require", "seterr", "geterr", "setbufsize", "getbufsize", "seterrcall", "geterrcall", "errstate", # _core.function_base.__all__ "logspace", "linspace", "geomspace", # _core.getlimits.__all__ "finfo", "iinfo", # _core.shape_base.__all__ "atleast_1d", "atleast_2d", "atleast_3d", "block", "hstack", "stack", "unstack", "vstack", # _core.einsumfunc.__all__ "einsum", "einsum_path", # matrixlib.__all__ "matrix", "bmat", "asmatrix", # lib._histograms_impl.__all__ "histogram", "histogramdd", "histogram_bin_edges", # lib._nanfunctions_impl.__all__ "nansum", "nanmax", "nanmin", "nanargmax", "nanargmin", "nanmean", "nanmedian", "nanpercentile", "nanvar", "nanstd", "nanprod", "nancumsum", "nancumprod", "nanquantile", # lib._function_base_impl.__all__ "select", "piecewise", "trim_zeros", "copy", "iterable", "percentile", "diff", "gradient", "angle", "unwrap", "sort_complex", "flip", "rot90", "extract", "place", "vectorize", "asarray_chkfinite", "average", "bincount", "digitize", "cov", "corrcoef", "median", "sinc", "hamming", "hanning", "bartlett", "blackman", "kaiser", "trapezoid", "i0", "meshgrid", "delete", "insert", "append", "interp", "quantile", # lib._twodim_base_impl.__all__ "diag", "diagflat", "eye", "fliplr", "flipud", "tri", "triu", "tril", "vander", "histogram2d", "mask_indices", "tril_indices", "tril_indices_from", "triu_indices", "triu_indices_from", # lib._shape_base_impl.__all__ "column_stack", "dstack", "array_split", "split", "hsplit", "vsplit", "dsplit", "apply_over_axes", "expand_dims", "apply_along_axis", "kron", "tile", "take_along_axis", "put_along_axis", "row_stack", # lib._type_check_impl.__all__ "iscomplexobj", "isrealobj", "imag", "iscomplex", "isreal", "nan_to_num", "real", "real_if_close", "typename", "mintypecode", "common_type", # lib._arraysetops_impl.__all__ "ediff1d", "intersect1d", "isin", "setdiff1d", "setxor1d", "union1d", "unique", "unique_all", "unique_counts", "unique_inverse", "unique_values", # lib._ufunclike_impl.__all__ "fix", "isneginf", "isposinf", # lib._arraypad_impl.__all__ "pad", # lib._utils_impl.__all__ "get_include", "info", "show_runtime", # lib._stride_tricks_impl.__all__ "broadcast_to", "broadcast_arrays", "broadcast_shapes", # lib._polynomial_impl.__all__ "poly", "roots", "polyint", "polyder", "polyadd", "polysub", "polymul", "polydiv", "polyval", "poly1d", "polyfit", # lib._npyio_impl.__all__ "savetxt", "loadtxt", "genfromtxt", "load", "save", "savez", "savez_compressed", "packbits", "unpackbits", "fromregex", # lib._index_tricks_impl.__all__ "ravel_multi_index", "unravel_index", "mgrid", "ogrid", "r_", "c_", "s_", "index_exp", "ix_", "ndenumerate", "ndindex", "fill_diagonal", "diag_indices", "diag_indices_from", # __init__.__all__ "emath", "show_config", "__version__", "__array_namespace_info__", ] # fmt: skip ### Constrained types (for internal use only) # Only use these for functions; never as generic type parameter. _AnyStr = TypeVar("_AnyStr", LiteralString, str, bytes) _AnyShapeT = TypeVar( "_AnyShapeT", tuple[()], # 0-d tuple[int], # 1-d tuple[int, int], # 2-d tuple[int, int, int], # 3-d tuple[int, int, int, int], # 4-d tuple[int, int, int, int, int], # 5-d tuple[int, int, int, int, int, int], # 6-d tuple[int, int, int, int, int, int, int], # 7-d tuple[int, int, int, int, int, int, int, int], # 8-d tuple[int, ...], # N-d ) _AnyTD64Item = TypeVar("_AnyTD64Item", dt.timedelta, int, None, dt.timedelta | int | None) _AnyDT64Arg = TypeVar("_AnyDT64Arg", dt.datetime, dt.date, None) _AnyDT64Item = TypeVar("_AnyDT64Item", dt.datetime, dt.date, int, None, dt.date, int | None) _AnyDate = TypeVar("_AnyDate", dt.date, dt.datetime) _AnyDateOrTime = TypeVar("_AnyDateOrTime", dt.date, dt.datetime, dt.timedelta) ### Type parameters (for internal use only) _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) _T_contra = TypeVar("_T_contra", contravariant=True) _RealT_co = TypeVar("_RealT_co", covariant=True) _ImagT_co = TypeVar("_ImagT_co", covariant=True) _DTypeT = TypeVar("_DTypeT", bound=dtype) _DTypeT_co = TypeVar("_DTypeT_co", bound=dtype, default=dtype, covariant=True) _FlexDTypeT = TypeVar("_FlexDTypeT", bound=dtype[flexible]) _ArrayT = TypeVar("_ArrayT", bound=ndarray) _ArrayT_co = TypeVar("_ArrayT_co", bound=ndarray, default=ndarray, covariant=True) _BoolArrayT = TypeVar("_BoolArrayT", bound=NDArray[np.bool]) _IntegerArrayT = TypeVar("_IntegerArrayT", bound=NDArray[integer]) _IntegralArrayT = TypeVar("_IntegralArrayT", bound=NDArray[np.bool | integer | object_]) _FloatingArrayT = TypeVar("_FloatingArrayT", bound=NDArray[floating]) _FloatingTimedeltaArrayT = TypeVar("_FloatingTimedeltaArrayT", bound=NDArray[floating | timedelta64]) _ComplexFloatingArrayT = TypeVar("_ComplexFloatingArrayT", bound=NDArray[complexfloating]) _InexactArrayT = TypeVar("_InexactArrayT", bound=NDArray[inexact]) _InexactTimedeltaArrayT = TypeVar("_InexactTimedeltaArrayT", bound=NDArray[inexact | timedelta64]) _NumberArrayT = TypeVar("_NumberArrayT", bound=NDArray[number]) _NumberCharacterArrayT = TypeVar("_NumberCharacterArrayT", bound=ndarray[Any, dtype[number | character] | dtypes.StringDType]) _TimedeltaArrayT = TypeVar("_TimedeltaArrayT", bound=NDArray[timedelta64]) _TimeArrayT = TypeVar("_TimeArrayT", bound=NDArray[datetime64 | timedelta64]) _ObjectArrayT = TypeVar("_ObjectArrayT", bound=NDArray[object_]) _BytesArrayT = TypeVar("_BytesArrayT", bound=NDArray[bytes_]) _StringArrayT = TypeVar("_StringArrayT", bound=ndarray[Any, dtype[str_] | dtypes.StringDType]) _RealArrayT = TypeVar("_RealArrayT", bound=NDArray[floating | integer | timedelta64 | np.bool | object_]) _NumericArrayT = TypeVar("_NumericArrayT", bound=NDArray[number | timedelta64 | object_]) _ShapeT = TypeVar("_ShapeT", bound=_Shape) _Shape1T = TypeVar("_Shape1T", bound=tuple[int, *tuple[int, ...]]) _ShapeT_co = TypeVar("_ShapeT_co", bound=_Shape, default=_AnyShape, covariant=True) _2DShapeT_co = TypeVar("_2DShapeT_co", bound=_2D, default=_2D, covariant=True) _1NShapeT = TypeVar("_1NShapeT", bound=tuple[L[1], *tuple[L[1], ...]]) # (1,) | (1, 1) | (1, 1, 1) | ... _ScalarT = TypeVar("_ScalarT", bound=generic) _ScalarT_co = TypeVar("_ScalarT_co", bound=generic, default=Any, covariant=True) _NumberT = TypeVar("_NumberT", bound=number) _InexactT = TypeVar("_InexactT", bound=inexact) _RealNumberT = TypeVar("_RealNumberT", bound=floating | integer) _IntegerT = TypeVar("_IntegerT", bound=integer) _NonObjectScalarT = TypeVar("_NonObjectScalarT", bound=np.bool | number | flexible | datetime64 | timedelta64) _NBit = TypeVar("_NBit", bound=NBitBase, default=Any) # pyright: ignore[reportDeprecated] _NBit1 = TypeVar("_NBit1", bound=NBitBase, default=Any) # pyright: ignore[reportDeprecated] _NBit2 = TypeVar("_NBit2", bound=NBitBase, default=_NBit1) # pyright: ignore[reportDeprecated] _ItemT_co = TypeVar("_ItemT_co", default=Any, covariant=True) _BoolItemT = TypeVar("_BoolItemT", bound=builtins.bool) _BoolItemT_co = TypeVar("_BoolItemT_co", bound=builtins.bool, default=builtins.bool, covariant=True) _NumberItemT_co = TypeVar("_NumberItemT_co", bound=complex, default=int | float | complex, covariant=True) _InexactItemT_co = TypeVar("_InexactItemT_co", bound=complex, default=float | complex, covariant=True) _FlexibleItemT_co = TypeVar( "_FlexibleItemT_co", bound=_CharLike_co | tuple[Any, ...], default=_CharLike_co | tuple[Any, ...], covariant=True, ) _CharacterItemT_co = TypeVar("_CharacterItemT_co", bound=_CharLike_co, default=_CharLike_co, covariant=True) _TD64ItemT_co = TypeVar("_TD64ItemT_co", bound=dt.timedelta | int | None, default=dt.timedelta | int | None, covariant=True) _DT64ItemT_co = TypeVar("_DT64ItemT_co", bound=dt.date | int | None, default=dt.date | int | None, covariant=True) _TD64UnitT = TypeVar("_TD64UnitT", bound=_TD64Unit, default=_TD64Unit) _BoolOrIntArrayT = TypeVar("_BoolOrIntArrayT", bound=NDArray[integer | np.bool]) ### Type Aliases (for internal use only) _Falsy: TypeAlias = L[False, 0] | np.bool[L[False]] _Truthy: TypeAlias = L[True, 1] | np.bool[L[True]] _1D: TypeAlias = tuple[int] _2D: TypeAlias = tuple[int, int] _2Tuple: TypeAlias = tuple[_T, _T] _ArrayUInt_co: TypeAlias = NDArray[unsignedinteger | np.bool] _ArrayInt_co: TypeAlias = NDArray[integer | np.bool] _ArrayFloat64_co: TypeAlias = NDArray[floating[_64Bit] | float32 | float16 | integer | np.bool] _ArrayFloat_co: TypeAlias = NDArray[floating | integer | np.bool] _ArrayComplex128_co: TypeAlias = NDArray[number[_64Bit] | number[_32Bit] | float16 | integer | np.bool] _ArrayComplex_co: TypeAlias = NDArray[inexact | integer | np.bool] _ArrayNumber_co: TypeAlias = NDArray[number | np.bool] _ArrayTD64_co: TypeAlias = NDArray[timedelta64 | integer | np.bool] _Float64_co: TypeAlias = float | floating[_64Bit] | float32 | float16 | integer | np.bool _Complex64_co: TypeAlias = number[_32Bit] | number[_16Bit] | number[_8Bit] | builtins.bool | np.bool _Complex128_co: TypeAlias = complex | number[_64Bit] | _Complex64_co _ToIndex: TypeAlias = SupportsIndex | slice | EllipsisType | _ArrayLikeInt_co | None _ToIndices: TypeAlias = _ToIndex | tuple[_ToIndex, ...] _UnsignedIntegerCType: TypeAlias = type[ ct.c_uint8 | ct.c_uint16 | ct.c_uint32 | ct.c_uint64 | ct.c_ushort | ct.c_uint | ct.c_ulong | ct.c_ulonglong | ct.c_size_t | ct.c_void_p ] # fmt: skip _SignedIntegerCType: TypeAlias = type[ ct.c_int8 | ct.c_int16 | ct.c_int32 | ct.c_int64 | ct.c_short | ct.c_int | ct.c_long | ct.c_longlong | ct.c_ssize_t ] # fmt: skip _FloatingCType: TypeAlias = type[ct.c_float | ct.c_double | ct.c_longdouble] _IntegerCType: TypeAlias = _UnsignedIntegerCType | _SignedIntegerCType # some commonly used builtin types that are known to result in a # `dtype[object_]`, when their *type* is passed to the `dtype` constructor # NOTE: `builtins.object` should not be included here _BuiltinObjectLike: TypeAlias = ( slice | Decimal | Fraction | UUID | dt.date | dt.time | dt.timedelta | dt.tzinfo | tuple[Any, ...] | list[Any] | set[Any] | frozenset[Any] | dict[Any, Any] ) # fmt: skip # Introduce an alias for `dtype` to avoid naming conflicts. _dtype: TypeAlias = dtype[_ScalarT] _ByteOrderChar: TypeAlias = L["<", ">", "=", "|"] # 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 ] # fmt: skip _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, 1, 2] _ArrayAPIVersion: TypeAlias = L["2021.12", "2022.12", "2023.12", "2024.12"] _CastingKind: TypeAlias = L["no", "equiv", "safe", "same_kind", "same_value", "unsafe"] _OrderKACF: TypeAlias = L["K", "A", "C", "F"] | None _OrderACF: TypeAlias = L["A", "C", "F"] | None _OrderCF: TypeAlias = L["C", "F"] | None # noqa: PYI047 _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"] _ConvertibleToInt: TypeAlias = SupportsInt | SupportsIndex | _CharLike_co _ConvertibleToFloat: TypeAlias = SupportsFloat | SupportsIndex | _CharLike_co _ConvertibleToComplex: TypeAlias = SupportsComplex | SupportsFloat | SupportsIndex | _CharLike_co _ConvertibleToTD64: TypeAlias = dt.timedelta | int | _CharLike_co | character | number | timedelta64 | np.bool | None _ConvertibleToDT64: TypeAlias = dt.date | int | _CharLike_co | character | number | datetime64 | np.bool | None _NDIterFlagsKind: TypeAlias = L[ "buffered", "c_index", "copy_if_overlap", "common_dtype", "delay_bufalloc", "external_loop", "f_index", "grow_inner", "growinner", "multi_index", "ranged", "refs_ok", "reduce_ok", "zerosize_ok", ] _NDIterFlagsOp: TypeAlias = L[ "aligned", "allocate", "arraymask", "copy", "config", "nbo", "no_subtype", "no_broadcast", "overlap_assume_elementwise", "readonly", "readwrite", "updateifcopy", "virtual", "writeonly", "writemasked", ] _MemMapModeKind: TypeAlias = L[ "readonly", "r", "copyonwrite", "c", "readwrite", "r+", "write", "w+", ] _DT64Date: TypeAlias = _HasDateAttributes | L["TODAY", "today", b"TODAY", b"today"] _DT64Now: TypeAlias = L["NOW", "now", b"NOW", b"now"] _NaTValue: TypeAlias = L["NAT", "NaT", "nat", b"NAT", b"NaT", b"nat"] _MonthUnit: TypeAlias = L["Y", "M", b"Y", b"M"] _DayUnit: TypeAlias = L["W", "D", b"W", b"D"] _DateUnit: TypeAlias = L[_MonthUnit, _DayUnit] _NativeTimeUnit: TypeAlias = L["h", "m", "s", "ms", "us", "μs", b"h", b"m", b"s", b"ms", b"us"] _IntTimeUnit: TypeAlias = L["ns", "ps", "fs", "as", b"ns", b"ps", b"fs", b"as"] _TimeUnit: TypeAlias = L[_NativeTimeUnit, _IntTimeUnit] _NativeTD64Unit: TypeAlias = L[_DayUnit, _NativeTimeUnit] _IntTD64Unit: TypeAlias = L[_MonthUnit, _IntTimeUnit] _TD64Unit: TypeAlias = L[_DateUnit, _TimeUnit] _TimeUnitSpec: TypeAlias = _TD64UnitT | tuple[_TD64UnitT, SupportsIndex] ### TypedDict's (for internal use only) @type_check_only class _FormerAttrsDict(TypedDict): object: LiteralString float: LiteralString complex: LiteralString str: LiteralString int: LiteralString ### Protocols (for internal use only) @final @type_check_only class _SupportsLT(Protocol): def __lt__(self, other: Any, /) -> Any: ... @final @type_check_only class _SupportsLE(Protocol): def __le__(self, other: Any, /) -> Any: ... @final @type_check_only class _SupportsGT(Protocol): def __gt__(self, other: Any, /) -> Any: ... @final @type_check_only class _SupportsGE(Protocol): def __ge__(self, other: Any, /) -> Any: ... @type_check_only class _SupportsFileMethods(SupportsFlush, Protocol): # Protocol for representing file-like-objects accepted by `ndarray.tofile` and `fromfile` def fileno(self) -> SupportsIndex: ... def tell(self) -> SupportsIndex: ... def seek(self, offset: int, whence: int, /) -> object: ... @type_check_only class _SupportsFileMethodsRW(SupportsWrite[bytes], _SupportsFileMethods, Protocol): ... @type_check_only class _SupportsDLPack(Protocol[_T_contra]): def __dlpack__(self, /, *, stream: _T_contra | None = None) -> CapsuleType: ... @type_check_only class _HasDType(Protocol[_T_co]): @property def dtype(self, /) -> _T_co: ... @type_check_only class _HasRealAndImag(Protocol[_RealT_co, _ImagT_co]): @property def real(self, /) -> _RealT_co: ... @property def imag(self, /) -> _ImagT_co: ... @type_check_only class _HasTypeWithRealAndImag(Protocol[_RealT_co, _ImagT_co]): @property def type(self, /) -> type[_HasRealAndImag[_RealT_co, _ImagT_co]]: ... @type_check_only class _HasDTypeWithRealAndImag(Protocol[_RealT_co, _ImagT_co]): @property def dtype(self, /) -> _HasTypeWithRealAndImag[_RealT_co, _ImagT_co]: ... @type_check_only class _HasDateAttributes(Protocol): # The `datetime64` constructors requires an object with the three attributes below, # and thus supports datetime duck typing @property def day(self) -> int: ... @property def month(self) -> int: ... @property def year(self) -> int: ... ### Mixins (for internal use only) @type_check_only class _RealMixin: @property def real(self) -> Self: ... @property def imag(self) -> Self: ... @type_check_only class _RoundMixin: @overload def __round__(self, /, ndigits: None = None) -> int: ... @overload def __round__(self, /, ndigits: SupportsIndex) -> Self: ... @type_check_only class _IntegralMixin(_RealMixin): @property def numerator(self) -> Self: ... @property def denominator(self) -> L[1]: ... def is_integer(self, /) -> L[True]: ... ### Public API __version__: Final[LiteralString] = ... e: Final[float] = ... euler_gamma: Final[float] = ... pi: Final[float] = ... inf: Final[float] = ... nan: Final[float] = ... little_endian: Final[builtins.bool] = ... False_: Final[np.bool[L[False]]] = ... True_: Final[np.bool[L[True]]] = ... newaxis: Final[None] = None # not in __all__ __NUMPY_SETUP__: Final[L[False]] = False __numpy_submodules__: Final[set[LiteralString]] = ... __former_attrs__: Final[_FormerAttrsDict] = ... __future_scalars__: Final[set[L["bytes", "str", "object"]]] = ... __array_api_version__: Final[L["2024.12"]] = "2024.12" test: Final[PytestTester] = ... @type_check_only class _DTypeMeta(type): @property def type(cls, /) -> type[generic] | None: ... @property def _abstract(cls, /) -> bool: ... @property def _is_numeric(cls, /) -> bool: ... @property def _parametric(cls, /) -> bool: ... @property def _legacy(cls, /) -> bool: ... @final class dtype(Generic[_ScalarT_co], metaclass=_DTypeMeta): names: tuple[builtins.str, ...] | None def __hash__(self) -> int: ... # `None` results in the default dtype @overload def __new__( cls, dtype: type[float64 | ct.c_double] | _Float64Codes | _DoubleCodes | None, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ... ) -> dtype[float64]: ... # Overload for `dtype` instances, scalar types, and instances that have a # `dtype: dtype[_ScalarT]` attribute @overload def __new__( cls, dtype: _DTypeLike[_ScalarT], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[_ScalarT]: ... # Builtin types # # NOTE: Typecheckers act as if `bool <: int <: float <: complex <: object`, # even though at runtime `int`, `float`, and `complex` aren't subtypes.. # This makes it impossible to express e.g. "a float that isn't an int", # since type checkers treat `_: float` like `_: float | int`. # # For more details, see: # - https://github.com/numpy/numpy/issues/27032#issuecomment-2278958251 # - https://typing.readthedocs.io/en/latest/spec/special-types.html#special-cases-for-float-and-complex @overload def __new__( cls, dtype: type[builtins.bool | np.bool | ct.c_bool] | _BoolCodes, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[str, Any] = ..., ) -> dtype[np.bool]: ... @overload def __new__( cls, dtype: type[int], # also accepts `type[builtins.bool]` align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[str, Any] = ..., ) -> dtype[int_ | np.bool]: ... @overload def __new__( cls, dtype: type[float], # also accepts `type[int | bool]` align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[str, Any] = ..., ) -> dtype[float64 | int_ | np.bool]: ... @overload def __new__( cls, dtype: type[complex], # also accepts `type[float | int | bool]` align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[str, Any] = ..., ) -> dtype[complex128 | float64 | int_ | np.bool]: ... @overload def __new__( cls, dtype: type[bytes | ct.c_char] | _BytesCodes, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[str, Any] = ..., ) -> dtype[bytes_]: ... @overload def __new__( cls, dtype: type[str] | _StrCodes, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[str, Any] = ..., ) -> dtype[str_]: ... # NOTE: These `memoryview` overloads assume PEP 688, which requires mypy to # be run with the (undocumented) `--disable-memoryview-promotion` flag, # This will be the default in a future mypy release, see: # https://github.com/python/mypy/issues/15313 # Pyright / Pylance requires setting `disableBytesTypePromotions=true`, # which is the default in strict mode @overload def __new__( cls, dtype: type[void | memoryview] | _VoidDTypeLike | _VoidCodes, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[str, Any] = ..., ) -> dtype[void]: ... # NOTE: `_: type[object]` would also accept e.g. `type[object | complex]`, # and is therefore not included here @overload def __new__( cls, dtype: type[object_ | _BuiltinObjectLike | ct.py_object[Any]] | _ObjectCodes, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[str, Any] = ..., ) -> dtype[object_]: ... # `unsignedinteger` string-based representations and ctypes @overload def __new__( cls, dtype: _UInt8Codes | _UByteCodes | type[ct.c_uint8 | ct.c_ubyte], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[uint8]: ... @overload def __new__( cls, dtype: _UInt16Codes | _UShortCodes | type[ct.c_uint16 | ct.c_ushort], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[uint16]: ... @overload def __new__( cls, dtype: _UInt32Codes | _UIntCCodes | type[ct.c_uint32 | ct.c_uint], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[uint32]: ... @overload def __new__( cls, dtype: _UInt64Codes | _ULongLongCodes | type[ct.c_uint64 | ct.c_ulonglong], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[uint64]: ... @overload def __new__( cls, dtype: _UIntPCodes | type[ct.c_void_p | ct.c_size_t], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[uintp]: ... @overload def __new__( cls, dtype: _ULongCodes | type[ct.c_ulong], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[ulong]: ... # `signedinteger` string-based representations and ctypes @overload def __new__( cls, dtype: _Int8Codes | _ByteCodes | type[ct.c_int8 | ct.c_byte], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[int8]: ... @overload def __new__( cls, dtype: _Int16Codes | _ShortCodes | type[ct.c_int16 | ct.c_short], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[int16]: ... @overload def __new__( cls, dtype: _Int32Codes | _IntCCodes | type[ct.c_int32 | ct.c_int], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[int32]: ... @overload def __new__( cls, dtype: _Int64Codes | _LongLongCodes | type[ct.c_int64 | ct.c_longlong], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[int64]: ... @overload def __new__( cls, dtype: _IntPCodes | type[intp | ct.c_ssize_t], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[intp]: ... @overload def __new__( cls, dtype: _LongCodes | type[ct.c_long], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[long]: ... # `floating` string-based representations and ctypes @overload def __new__( cls, dtype: _Float16Codes | _HalfCodes, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[float16]: ... @overload def __new__( cls, dtype: _Float32Codes | _SingleCodes, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[float32]: ... # float64 codes are covered by overload 1 @overload def __new__( cls, dtype: _LongDoubleCodes | type[ct.c_longdouble], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[longdouble]: ... # `complexfloating` string-based representations @overload def __new__( cls, dtype: _Complex64Codes | _CSingleCodes, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[complex64]: ... @overload def __new__( cls, dtype: _Complex128Codes | _CDoubleCodes, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[complex128]: ... @overload def __new__( cls, dtype: _CLongDoubleCodes, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[clongdouble]: ... # Miscellaneous string-based representations and ctypes @overload def __new__( cls, dtype: _TD64Codes, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[timedelta64]: ... @overload def __new__( cls, dtype: _DT64Codes, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[datetime64]: ... # `StringDType` requires special treatment because it has no scalar type @overload def __new__( cls, dtype: dtypes.StringDType | _StringCodes, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtypes.StringDType: ... # Combined char-codes and ctypes, analogous to the scalar-type hierarchy @overload def __new__( cls, dtype: _UnsignedIntegerCodes | _UnsignedIntegerCType, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[unsignedinteger]: ... @overload def __new__( cls, dtype: _SignedIntegerCodes | _SignedIntegerCType, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[signedinteger]: ... @overload def __new__( cls, dtype: _IntegerCodes | _IntegerCType, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[integer]: ... @overload def __new__( cls, dtype: _FloatingCodes | _FloatingCType, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[floating]: ... @overload def __new__( cls, dtype: _ComplexFloatingCodes, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[complexfloating]: ... @overload def __new__( cls, dtype: _InexactCodes | _FloatingCType, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[inexact]: ... @overload def __new__( cls, dtype: _CharacterCodes | type[bytes | builtins.str | ct.c_char], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[str, Any] = ..., ) -> dtype[character]: ... # Handle strings that can't be expressed as literals; i.e. "S1", "S2", ... @overload def __new__( cls, dtype: builtins.str, align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype: ... # Catch-all overload for object-likes # NOTE: `object_ | Any` is NOT equivalent to `Any`. It is specified to behave # like a "sum type" (a.k.a. variant type, discriminated union, or tagged union). # So the union of a type and `Any` is not the same "union type" that all other # unions are (by definition). # https://typing.python.org/en/latest/spec/concepts.html#union-types @overload def __new__( cls, dtype: type[object], align: builtins.bool = False, copy: builtins.bool = False, *, metadata: dict[builtins.str, Any] = ..., ) -> dtype[object_ | Any]: ... 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: ... # NOTE: In the future 1-based multiplications will also yield `flexible` dtypes @overload def __mul__(self: _DTypeT, value: L[1], /) -> _DTypeT: ... @overload def __mul__(self: _FlexDTypeT, value: SupportsIndex, /) -> _FlexDTypeT: ... @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` for # now for non-flexible dtypes. @overload def __rmul__(self: _FlexDTypeT, value: SupportsIndex, /) -> _FlexDTypeT: ... @overload def __rmul__(self, value: SupportsIndex, /) -> dtype: ... def __gt__(self, other: DTypeLike | None, /) -> builtins.bool: ... def __ge__(self, other: DTypeLike | None, /) -> builtins.bool: ... def __lt__(self, other: DTypeLike | None, /) -> builtins.bool: ... def __le__(self, other: DTypeLike | None, /) -> 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: ... @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,) -> MappingProxyType[LiteralString, tuple[dtype, int] | tuple[dtype, int, Any]] | None: ... @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) -> MappingProxyType[builtins.str, Any] | None: ... @property def name(self) -> LiteralString: ... @property def num(self) -> _DTypeNum: ... @property def shape(self) -> _AnyShape: ... @property def ndim(self) -> int: ... @property def subdtype(self) -> tuple[dtype, _AnyShape] | None: ... def newbyteorder(self, new_order: _ByteOrder = ..., /) -> Self: ... @property def str(self) -> LiteralString: ... @property def type(self) -> type[_ScalarT_co]: ... @final class flatiter(Generic[_ArrayT_co]): __hash__: ClassVar[None] = None # type: ignore[assignment] # pyright: ignore[reportIncompatibleMethodOverride] @property def base(self, /) -> _ArrayT_co: ... @property def coords(self: flatiter[ndarray[_ShapeT]], /) -> _ShapeT: ... @property def index(self, /) -> int: ... # iteration def __len__(self, /) -> int: ... def __iter__(self, /) -> Self: ... def __next__(self: flatiter[NDArray[_ScalarT]], /) -> _ScalarT: ... # indexing @overload # nd: _[()] def __getitem__(self, key: tuple[()], /) -> _ArrayT_co: ... @overload # 0d; _[] def __getitem__(self: flatiter[NDArray[_ScalarT]], key: int | integer, /) -> _ScalarT: ... @overload # 1d; _[[*]], _[:], _[...] def __getitem__( self: flatiter[ndarray[Any, _DTypeT]], key: list[int] | slice | EllipsisType | flatiter[NDArray[integer]], /, ) -> ndarray[tuple[int], _DTypeT]: ... @overload # 2d; _[[*[*]]] def __getitem__( self: flatiter[ndarray[Any, _DTypeT]], key: list[list[int]], /, ) -> ndarray[tuple[int, int], _DTypeT]: ... @overload # ?d def __getitem__( self: flatiter[ndarray[Any, _DTypeT]], key: NDArray[integer] | _NestedSequence[int], /, ) -> ndarray[_AnyShape, _DTypeT]: ... # NOTE: `__setitem__` operates via `unsafe` casting rules, and can thus accept any # type accepted by the relevant underlying `np.generic` constructor, which isn't # known statically. So we cannot meaningfully annotate the value parameter. def __setitem__(self, key: slice | EllipsisType | _ArrayLikeInt, val: object, /) -> None: ... # NOTE: `dtype` and `copy` are no-ops at runtime, so we don't support them here to # avoid confusion def __array__( self: flatiter[ndarray[Any, _DTypeT]], dtype: None = None, /, *, copy: None = None, ) -> ndarray[tuple[int], _DTypeT]: ... # This returns a flat copy of the underlying array, not of the iterator itself def copy(self: flatiter[ndarray[Any, _DTypeT]], /) -> ndarray[tuple[int], _DTypeT]: ... @type_check_only class _ArrayOrScalarCommon: @property def real(self, /) -> Any: ... @property def imag(self, /) -> Any: ... @property def T(self) -> Self: ... @property def mT(self) -> Self: ... @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 __int__(self, /) -> int: ... def __float__(self, /) -> float: ... def __copy__(self) -> Self: ... def __deepcopy__(self, memo: dict[int, Any] | None, /) -> Self: ... # 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, order: _OrderKACF = ...) -> Self: ... def dump(self, file: StrOrBytesPath | SupportsWrite[bytes]) -> None: ... def dumps(self) -> bytes: ... def tobytes(self, order: _OrderKACF = ...) -> bytes: ... def tofile(self, fid: StrOrBytesPath | _SupportsFileMethods, /, sep: str = "", format: str = "%s") -> None: ... # generics and 0d arrays return builtin scalars def tolist(self) -> Any: ... def to_device(self, device: L["cpu"], /, *, stream: int | Any | None = ...) -> Self: ... # NOTE: for `generic`, these two methods don't do anything def fill(self, /, value: Incomplete) -> None: ... def put(self, indices: _ArrayLikeInt_co, values: ArrayLike, /, mode: _ModeKind = "raise") -> None: ... # NOTE: even on `generic` this seems to work def setflags( self, /, *, write: builtins.bool | None = None, align: builtins.bool | None = None, uic: builtins.bool | None = None, ) -> None: ... @property def __array_interface__(self) -> dict[str, Any]: ... @property def __array_priority__(self) -> float: ... @property def __array_struct__(self) -> CapsuleType: ... # builtins.PyCapsule def __array_namespace__(self, /, *, api_version: _ArrayAPIVersion | None = None) -> ModuleType: ... def __setstate__(self, state: tuple[ SupportsIndex, # version _ShapeLike, # Shape _DTypeT_co, # DType np.bool, # F-continuous bytes | list[Any], # Data ], /) -> None: ... def conj(self) -> Self: ... def conjugate(self) -> Self: ... def argsort( self, axis: SupportsIndex | None = ..., kind: _SortKind | None = ..., order: str | Sequence[str] | None = ..., *, stable: builtins.bool | None = ..., ) -> NDArray[intp]: ... @overload # axis=None (default), out=None (default), keepdims=False (default) def argmax(self, /, axis: None = None, out: None = None, *, keepdims: L[False] = False) -> intp: ... @overload # axis=index, out=None (default) def argmax(self, /, axis: SupportsIndex, out: None = None, *, keepdims: builtins.bool = False) -> Any: ... @overload # axis=index, out=ndarray def argmax(self, /, axis: SupportsIndex | None, out: _BoolOrIntArrayT, *, keepdims: builtins.bool = False) -> _BoolOrIntArrayT: ... @overload def argmax(self, /, axis: SupportsIndex | None = None, *, out: _BoolOrIntArrayT, keepdims: builtins.bool = False) -> _BoolOrIntArrayT: ... @overload # axis=None (default), out=None (default), keepdims=False (default) def argmin(self, /, axis: None = None, out: None = None, *, keepdims: L[False] = False) -> intp: ... @overload # axis=index, out=None (default) def argmin(self, /, axis: SupportsIndex, out: None = None, *, keepdims: builtins.bool = False) -> Any: ... @overload # axis=index, out=ndarray def argmin(self, /, axis: SupportsIndex | None, out: _BoolOrIntArrayT, *, keepdims: builtins.bool = False) -> _BoolOrIntArrayT: ... @overload def argmin(self, /, axis: SupportsIndex | None = None, *, out: _BoolOrIntArrayT, keepdims: builtins.bool = False) -> _BoolOrIntArrayT: ... # Keep in sync with `MaskedArray.round` @overload # out=None (default) def round(self, /, decimals: SupportsIndex = 0, out: None = None) -> Self: ... @overload # out=ndarray def round(self, /, decimals: SupportsIndex, out: _ArrayT) -> _ArrayT: ... @overload def round(self, /, decimals: SupportsIndex = 0, *, out: _ArrayT) -> _ArrayT: ... @overload # out=None (default) def choose(self, /, choices: ArrayLike, out: None = None, mode: _ModeKind = "raise") -> NDArray[Any]: ... @overload # out=ndarray def choose(self, /, choices: ArrayLike, out: _ArrayT, mode: _ModeKind = "raise") -> _ArrayT: ... # TODO: Annotate kwargs with an unpacked `TypedDict` @overload # out: None (default) def clip(self, /, min: ArrayLike, max: ArrayLike | None = None, out: None = None, **kwargs: Any) -> NDArray[Any]: ... @overload def clip(self, /, min: None, max: ArrayLike, out: None = None, **kwargs: Any) -> NDArray[Any]: ... @overload def clip(self, /, min: None = None, *, max: ArrayLike, out: None = None, **kwargs: Any) -> NDArray[Any]: ... @overload # out: ndarray def clip(self, /, min: ArrayLike, max: ArrayLike | None, out: _ArrayT, **kwargs: Any) -> _ArrayT: ... @overload def clip(self, /, min: ArrayLike, max: ArrayLike | None = None, *, out: _ArrayT, **kwargs: Any) -> _ArrayT: ... @overload def clip(self, /, min: None, max: ArrayLike, out: _ArrayT, **kwargs: Any) -> _ArrayT: ... @overload def clip(self, /, min: None = None, *, max: ArrayLike, out: _ArrayT, **kwargs: Any) -> _ArrayT: ... @overload def compress(self, /, condition: _ArrayLikeInt_co, axis: SupportsIndex | None = None, out: None = None) -> NDArray[Any]: ... @overload def compress(self, /, condition: _ArrayLikeInt_co, axis: SupportsIndex | None, out: _ArrayT) -> _ArrayT: ... @overload def compress(self, /, condition: _ArrayLikeInt_co, axis: SupportsIndex | None = None, *, out: _ArrayT) -> _ArrayT: ... # Keep in sync with `MaskedArray.cumprod` @overload # out: None (default) def cumprod(self, /, axis: SupportsIndex | None = None, dtype: DTypeLike | None = None, out: None = None) -> NDArray[Any]: ... @overload # out: ndarray def cumprod(self, /, axis: SupportsIndex | None, dtype: DTypeLike | None, out: _ArrayT) -> _ArrayT: ... @overload def cumprod(self, /, axis: SupportsIndex | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT) -> _ArrayT: ... # Keep in sync with `MaskedArray.cumsum` @overload # out: None (default) def cumsum(self, /, axis: SupportsIndex | None = None, dtype: DTypeLike | None = None, out: None = None) -> NDArray[Any]: ... @overload # out: ndarray def cumsum(self, /, axis: SupportsIndex | None, dtype: DTypeLike | None, out: _ArrayT) -> _ArrayT: ... @overload def cumsum(self, /, axis: SupportsIndex | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT) -> _ArrayT: ... @overload def max( self, /, axis: _ShapeLike | None = None, out: None = None, *, keepdims: builtins.bool | _NoValueType = ..., initial: _NumberLike_co | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., ) -> Any: ... @overload def max( self, /, axis: _ShapeLike | None, out: _ArrayT, *, keepdims: builtins.bool | _NoValueType = ..., initial: _NumberLike_co | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., ) -> _ArrayT: ... @overload def max( self, /, axis: _ShapeLike | None = None, *, out: _ArrayT, keepdims: builtins.bool | _NoValueType = ..., initial: _NumberLike_co | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., ) -> _ArrayT: ... @overload def min( self, /, axis: _ShapeLike | None = None, out: None = None, *, keepdims: builtins.bool | _NoValueType = ..., initial: _NumberLike_co | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., ) -> Any: ... @overload def min( self, /, axis: _ShapeLike | None, out: _ArrayT, *, keepdims: builtins.bool | _NoValueType = ..., initial: _NumberLike_co | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., ) -> _ArrayT: ... @overload def min( self, /, axis: _ShapeLike | None = None, *, out: _ArrayT, keepdims: builtins.bool | _NoValueType = ..., initial: _NumberLike_co | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., ) -> _ArrayT: ... @overload def sum( self, /, axis: _ShapeLike | None = None, dtype: DTypeLike | None = None, out: None = None, *, keepdims: builtins.bool | _NoValueType = ..., initial: _NumberLike_co | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., ) -> Any: ... @overload def sum( self, /, axis: _ShapeLike | None, dtype: DTypeLike | None, out: _ArrayT, *, keepdims: builtins.bool | _NoValueType = ..., initial: _NumberLike_co | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., ) -> _ArrayT: ... @overload def sum( self, /, axis: _ShapeLike | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT, keepdims: builtins.bool | _NoValueType = ..., initial: _NumberLike_co | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., ) -> _ArrayT: ... @overload def prod( self, /, axis: _ShapeLike | None = None, dtype: DTypeLike | None = None, out: None = None, *, keepdims: builtins.bool | _NoValueType = ..., initial: _NumberLike_co | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., ) -> Any: ... @overload def prod( self, /, axis: _ShapeLike | None, dtype: DTypeLike | None, out: _ArrayT, *, keepdims: builtins.bool | _NoValueType = ..., initial: _NumberLike_co | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., ) -> _ArrayT: ... @overload def prod( self, /, axis: _ShapeLike | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT, keepdims: builtins.bool | _NoValueType = ..., initial: _NumberLike_co | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., ) -> _ArrayT: ... @overload def mean( self, axis: _ShapeLike | None = None, dtype: DTypeLike | None = None, out: None = None, *, keepdims: builtins.bool | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., ) -> Any: ... @overload def mean( self, /, axis: _ShapeLike | None, dtype: DTypeLike | None, out: _ArrayT, *, keepdims: builtins.bool | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., ) -> _ArrayT: ... @overload def mean( self, /, axis: _ShapeLike | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT, keepdims: builtins.bool | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., ) -> _ArrayT: ... @overload def std( self, axis: _ShapeLike | None = None, dtype: DTypeLike | None = None, out: None = None, ddof: float = 0, *, keepdims: builtins.bool | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., mean: _ArrayLikeNumber_co | _NoValueType = ..., correction: float | _NoValueType = ..., ) -> Any: ... @overload def std( self, axis: _ShapeLike | None, dtype: DTypeLike | None, out: _ArrayT, ddof: float = 0, *, keepdims: builtins.bool | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., mean: _ArrayLikeNumber_co | _NoValueType = ..., correction: float | _NoValueType = ..., ) -> _ArrayT: ... @overload def std( self, axis: _ShapeLike | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT, ddof: float = 0, keepdims: builtins.bool | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., mean: _ArrayLikeNumber_co | _NoValueType = ..., correction: float | _NoValueType = ..., ) -> _ArrayT: ... @overload def var( self, axis: _ShapeLike | None = None, dtype: DTypeLike | None = None, out: None = None, ddof: float = 0, *, keepdims: builtins.bool | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., mean: _ArrayLikeNumber_co | _NoValueType = ..., correction: float | _NoValueType = ..., ) -> Any: ... @overload def var( self, axis: _ShapeLike | None, dtype: DTypeLike | None, out: _ArrayT, ddof: float = 0, *, keepdims: builtins.bool | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., mean: _ArrayLikeNumber_co | _NoValueType = ..., correction: float | _NoValueType = ..., ) -> _ArrayT: ... @overload def var( self, axis: _ShapeLike | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT, ddof: float = 0, keepdims: builtins.bool | _NoValueType = ..., where: _ArrayLikeBool_co | _NoValueType = ..., mean: _ArrayLikeNumber_co | _NoValueType = ..., correction: float | _NoValueType = ..., ) -> _ArrayT: ... class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DTypeT_co]): __hash__: ClassVar[None] # type: ignore[assignment] # pyright: ignore[reportIncompatibleMethodOverride] @property def base(self) -> NDArray[Any] | None: ... @property def ndim(self) -> int: ... @property def size(self) -> int: ... @property def real(self: _HasDTypeWithRealAndImag[_ScalarT, object], /) -> ndarray[_ShapeT_co, dtype[_ScalarT]]: ... @real.setter def real(self, value: ArrayLike, /) -> None: ... @property def imag(self: _HasDTypeWithRealAndImag[object, _ScalarT], /) -> ndarray[_ShapeT_co, dtype[_ScalarT]]: ... @imag.setter def imag(self, value: ArrayLike, /) -> None: ... def __new__( cls, shape: _ShapeLike, dtype: DTypeLike | None = ..., buffer: _SupportsBuffer | None = ..., offset: SupportsIndex = ..., strides: _ShapeLike | None = ..., order: _OrderKACF = ..., ) -> Self: ... 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 = None, /, *, copy: builtins.bool | None = None) -> ndarray[_ShapeT_co, _DTypeT_co]: ... @overload def __array__(self, dtype: _DTypeT, /, *, copy: builtins.bool | None = None) -> ndarray[_ShapeT_co, _DTypeT]: ... 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: NDArray[Any] | None, /) -> None: ... def __array_wrap__( self, array: ndarray[_ShapeT, _DTypeT], context: tuple[ufunc, tuple[Any, ...], int] | None = ..., return_scalar: builtins.bool = ..., /, ) -> ndarray[_ShapeT, _DTypeT]: ... # Keep in sync with `MaskedArray.__getitem__` @overload def __getitem__(self, key: _ArrayInt_co | tuple[_ArrayInt_co, ...], /) -> ndarray[_AnyShape, _DTypeT_co]: ... @overload def __getitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...], /) -> Any: ... @overload def __getitem__(self, key: _ToIndices, /) -> ndarray[_AnyShape, _DTypeT_co]: ... @overload # can be of any shape def __getitem__(self: NDArray[void], key: str, /) -> ndarray[_ShapeT_co | _AnyShape]: ... @overload def __getitem__(self: NDArray[void], key: list[str], /) -> ndarray[_ShapeT_co | _AnyShape, dtype[void]]: ... @overload # flexible | object_ | bool def __setitem__( self: ndarray[Any, dtype[flexible | object_ | np.bool] | dtypes.StringDType], key: _ToIndices, value: object, /, ) -> None: ... @overload # integer def __setitem__( self: NDArray[integer], key: _ToIndices, value: _ConvertibleToInt | _NestedSequence[_ConvertibleToInt] | _ArrayLikeInt_co, /, ) -> None: ... @overload # floating def __setitem__( self: NDArray[floating], key: _ToIndices, value: _ConvertibleToFloat | _NestedSequence[_ConvertibleToFloat | None] | _ArrayLikeFloat_co | None, /, ) -> None: ... @overload # complexfloating def __setitem__( self: NDArray[complexfloating], key: _ToIndices, value: _ConvertibleToComplex | _NestedSequence[_ConvertibleToComplex | None] | _ArrayLikeNumber_co | None, /, ) -> None: ... @overload # timedelta64 def __setitem__( self: NDArray[timedelta64], key: _ToIndices, value: _ConvertibleToTD64 | _NestedSequence[_ConvertibleToTD64], /, ) -> None: ... @overload # datetime64 def __setitem__( self: NDArray[datetime64], key: _ToIndices, value: _ConvertibleToDT64 | _NestedSequence[_ConvertibleToDT64], /, ) -> None: ... @overload # void def __setitem__(self: NDArray[void], key: str | list[str], value: object, /) -> None: ... @overload # catch-all def __setitem__(self, key: _ToIndices, value: ArrayLike, /) -> None: ... @property def ctypes(self) -> _ctypes[int]: ... # @property def shape(self) -> _ShapeT_co: ... @shape.setter @deprecated("In-place shape modification will be deprecated in NumPy 2.5.", category=PendingDeprecationWarning) def shape(self, value: _ShapeLike) -> None: ... # @property def strides(self) -> _Shape: ... @strides.setter @deprecated("Setting the strides on a NumPy array has been deprecated in NumPy 2.4") def strides(self, value: _ShapeLike) -> None: ... # def byteswap(self, inplace: builtins.bool = ...) -> Self: ... @property def flat(self) -> flatiter[Self]: ... @overload # use the same output type as that of the underlying `generic` def item(self: NDArray[generic[_T]], i0: SupportsIndex | tuple[SupportsIndex, ...] = ..., /, *args: SupportsIndex) -> _T: ... @overload # special casing for `StringDType`, which has no scalar type def item( self: ndarray[Any, dtypes.StringDType], arg0: SupportsIndex | tuple[SupportsIndex, ...] = ..., /, *args: SupportsIndex, ) -> str: ... # keep in sync with `ma.MaskedArray.tolist` @overload # this first overload prevents mypy from over-eagerly selecting `tuple[()]` in case of `_AnyShape` def tolist(self: ndarray[tuple[Never], dtype[generic[_T]]], /) -> Any: ... @overload def tolist(self: ndarray[tuple[()], dtype[generic[_T]]], /) -> _T: ... @overload def tolist(self: ndarray[tuple[int], dtype[generic[_T]]], /) -> list[_T]: ... @overload def tolist(self: ndarray[tuple[int, int], dtype[generic[_T]]], /) -> list[list[_T]]: ... @overload def tolist(self: ndarray[tuple[int, int, int], dtype[generic[_T]]], /) -> list[list[list[_T]]]: ... @overload def tolist(self, /) -> Any: ... @overload def resize(self, new_shape: _ShapeLike, /, *, refcheck: builtins.bool = True) -> None: ... @overload def resize(self, /, *new_shape: SupportsIndex, refcheck: builtins.bool = True) -> None: ... # keep in sync with `ma.MaskedArray.squeeze` def squeeze( self, /, axis: SupportsIndex | tuple[SupportsIndex, ...] | None = ..., ) -> ndarray[_AnyShape, _DTypeT_co]: ... def swapaxes(self, axis1: SupportsIndex, axis2: SupportsIndex, /) -> Self: ... @overload def transpose(self, axes: _ShapeLike | None, /) -> Self: ... @overload def transpose(self, /, *axes: SupportsIndex) -> Self: ... @overload def all( self, axis: None = None, out: None = None, keepdims: L[False, 0] = False, *, where: _ArrayLikeBool_co = True ) -> np.bool: ... @overload def all( self, axis: int | tuple[int, ...] | None = None, out: None = None, keepdims: SupportsIndex = False, *, where: _ArrayLikeBool_co = True, ) -> np.bool | NDArray[np.bool]: ... @overload def all( self, axis: int | tuple[int, ...] | None, out: _ArrayT, keepdims: SupportsIndex = False, *, where: _ArrayLikeBool_co = True, ) -> _ArrayT: ... @overload def all( self, axis: int | tuple[int, ...] | None = None, *, out: _ArrayT, keepdims: SupportsIndex = False, where: _ArrayLikeBool_co = True, ) -> _ArrayT: ... @overload def any( self, axis: None = None, out: None = None, keepdims: L[False, 0] = False, *, where: _ArrayLikeBool_co = True ) -> np.bool: ... @overload def any( self, axis: int | tuple[int, ...] | None = None, out: None = None, keepdims: SupportsIndex = False, *, where: _ArrayLikeBool_co = True, ) -> np.bool | NDArray[np.bool]: ... @overload def any( self, axis: int | tuple[int, ...] | None, out: _ArrayT, keepdims: SupportsIndex = False, *, where: _ArrayLikeBool_co = True, ) -> _ArrayT: ... @overload def any( self, axis: int | tuple[int, ...] | None = None, *, out: _ArrayT, keepdims: SupportsIndex = False, where: _ArrayLikeBool_co = True, ) -> _ArrayT: ... # @overload def partition( self, kth: _ArrayLikeInt, /, axis: SupportsIndex = -1, kind: _PartitionKind = "introselect", order: None = None, ) -> None: ... @overload def partition( self: NDArray[void], kth: _ArrayLikeInt, /, axis: SupportsIndex = -1, kind: _PartitionKind = "introselect", order: str | Sequence[str] | None = None, ) -> None: ... # @overload def argpartition( self, kth: _ArrayLikeInt, /, axis: SupportsIndex | None = -1, kind: _PartitionKind = "introselect", order: None = None, ) -> NDArray[intp]: ... @overload def argpartition( self: NDArray[void], kth: _ArrayLikeInt, /, axis: SupportsIndex | None = -1, kind: _PartitionKind = "introselect", order: str | Sequence[str] | None = None, ) -> NDArray[intp]: ... # keep in sync with `ma.MaskedArray.diagonal` def diagonal( self, offset: SupportsIndex = 0, axis1: SupportsIndex = 0, axis2: SupportsIndex = 1, ) -> ndarray[_AnyShape, _DTypeT_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 = None) -> NDArray[Any]: ... @overload def dot(self, b: ArrayLike, /, out: None = None) -> Any: ... @overload def dot(self, b: ArrayLike, /, out: _ArrayT) -> _ArrayT: ... # `nonzero()` raises for 0d arrays/generics def nonzero(self) -> tuple[ndarray[tuple[int], np.dtype[intp]], ...]: ... @overload def searchsorted( self, # >= 1D array v: _ScalarLike_co, # 0D array-like /, side: _SortSide = "left", sorter: _ArrayLikeInt_co | None = None, ) -> intp: ... @overload def searchsorted( self, # >= 1D array v: ArrayLike, /, side: _SortSide = "left", sorter: _ArrayLikeInt_co | None = None, ) -> NDArray[intp]: ... def sort( self, /, axis: SupportsIndex = -1, kind: _SortKind | None = None, order: str | Sequence[str] | None = None, *, stable: builtins.bool | None = None, ) -> None: ... # Keep in sync with `MaskedArray.trace` @overload def trace( self, # >= 2D array /, offset: SupportsIndex = 0, axis1: SupportsIndex = 0, axis2: SupportsIndex = 1, dtype: DTypeLike | None = None, out: None = None, ) -> Any: ... @overload def trace( self, # >= 2D array /, offset: SupportsIndex = 0, axis1: SupportsIndex = 0, axis2: SupportsIndex = 1, dtype: DTypeLike | None = None, *, out: _ArrayT, ) -> _ArrayT: ... @overload def trace( self, # >= 2D array /, offset: SupportsIndex, axis1: SupportsIndex, axis2: SupportsIndex, dtype: DTypeLike | None, out: _ArrayT, ) -> _ArrayT: ... @overload def take( self: NDArray[_ScalarT], indices: _IntLike_co, /, axis: SupportsIndex | None = ..., out: None = None, mode: _ModeKind = ..., ) -> _ScalarT: ... @overload def take( self, indices: _ArrayLikeInt_co, /, axis: SupportsIndex | None = ..., out: None = None, mode: _ModeKind = ..., ) -> ndarray[_AnyShape, _DTypeT_co]: ... @overload def take( self, indices: _ArrayLikeInt_co, /, axis: SupportsIndex | None = ..., *, out: _ArrayT, mode: _ModeKind = ..., ) -> _ArrayT: ... @overload def take( self, indices: _ArrayLikeInt_co, /, axis: SupportsIndex | None, out: _ArrayT, mode: _ModeKind = ..., ) -> _ArrayT: ... # keep in sync with `ma.MaskedArray.repeat` @overload def repeat(self, repeats: _ArrayLikeInt_co, /, axis: None = None) -> ndarray[tuple[int], _DTypeT_co]: ... @overload def repeat(self, repeats: _ArrayLikeInt_co, /, axis: SupportsIndex) -> ndarray[_AnyShape, _DTypeT_co]: ... # keep in sync with `ma.MaskedArray.flatten` and `ma.MaskedArray.ravel` def flatten(self, /, order: _OrderKACF = "C") -> ndarray[tuple[int], _DTypeT_co]: ... def ravel(self, /, order: _OrderKACF = "C") -> ndarray[tuple[int], _DTypeT_co]: ... # Keep in sync with `MaskedArray.reshape` # NOTE: reshape also accepts negative integers, so we can't use integer literals @overload # (None) def reshape(self, shape: None, /, *, order: _OrderACF = "C", copy: builtins.bool | None = None) -> Self: ... @overload # (empty_sequence) def reshape( # type: ignore[overload-overlap] # mypy false positive self, shape: Sequence[Never], /, *, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> ndarray[tuple[()], _DTypeT_co]: ... @overload # (() | (int) | (int, int) | ....) # up to 8-d def reshape( self, shape: _AnyShapeT, /, *, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> ndarray[_AnyShapeT, _DTypeT_co]: ... @overload # (index) def reshape( self, size1: SupportsIndex, /, *, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> ndarray[tuple[int], _DTypeT_co]: ... @overload # (index, index) def reshape( self, size1: SupportsIndex, size2: SupportsIndex, /, *, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> ndarray[tuple[int, int], _DTypeT_co]: ... @overload # (index, index, index) def reshape( self, size1: SupportsIndex, size2: SupportsIndex, size3: SupportsIndex, /, *, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> ndarray[tuple[int, int, int], _DTypeT_co]: ... @overload # (index, index, index, index) def reshape( self, size1: SupportsIndex, size2: SupportsIndex, size3: SupportsIndex, size4: SupportsIndex, /, *, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> ndarray[tuple[int, int, int, int], _DTypeT_co]: ... @overload # (int, *(index, ...)) def reshape( self, size0: SupportsIndex, /, *shape: SupportsIndex, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> ndarray[_AnyShape, _DTypeT_co]: ... @overload # (sequence[index]) def reshape( self, shape: Sequence[SupportsIndex], /, *, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> ndarray[_AnyShape, _DTypeT_co]: ... @overload def astype( self, dtype: _DTypeLike[_ScalarT], order: _OrderKACF = ..., casting: _CastingKind = ..., subok: builtins.bool = ..., copy: builtins.bool | _CopyMode = ..., ) -> ndarray[_ShapeT_co, dtype[_ScalarT]]: ... @overload def astype( self, dtype: DTypeLike | None, order: _OrderKACF = ..., casting: _CastingKind = ..., subok: builtins.bool = ..., copy: builtins.bool | _CopyMode = ..., ) -> ndarray[_ShapeT_co, dtype]: ... # @overload # () def view(self, /) -> Self: ... @overload # (dtype: T) def view(self, /, dtype: _DTypeT | _HasDType[_DTypeT]) -> ndarray[_ShapeT_co, _DTypeT]: ... @overload # (dtype: dtype[T]) def view(self, /, dtype: _DTypeLike[_ScalarT]) -> ndarray[_ShapeT_co, dtype[_ScalarT]]: ... @overload # (type: T) def view(self, /, *, type: type[_ArrayT]) -> _ArrayT: ... @overload # (_: T) def view(self, /, dtype: type[_ArrayT]) -> _ArrayT: ... @overload # (dtype: ?) def view(self, /, dtype: DTypeLike) -> ndarray[_ShapeT_co, dtype]: ... @overload # (dtype: ?, type: T) def view(self, /, dtype: DTypeLike, type: type[_ArrayT]) -> _ArrayT: ... def setfield(self, val: ArrayLike, /, dtype: DTypeLike, offset: SupportsIndex = 0) -> None: ... @overload def getfield(self, /, dtype: _DTypeLike[_ScalarT], offset: SupportsIndex = 0) -> NDArray[_ScalarT]: ... @overload def getfield(self, /, dtype: DTypeLike, offset: SupportsIndex = 0) -> NDArray[Any]: ... def __index__(self: NDArray[integer], /) -> int: ... def __complex__(self: NDArray[number | np.bool | object_], /) -> complex: ... def __len__(self) -> int: ... def __contains__(self, value: object, /) -> builtins.bool: ... # NOTE: This weird `Never` tuple works around a strange mypy issue where it assigns # `tuple[int]` to `tuple[Never]` or `tuple[int, int]` to `tuple[Never, Never]`. # This way the bug only occurs for 9-D arrays, which are probably not very common. @overload def __iter__( self: ndarray[tuple[Never, Never, Never, Never, Never, Never, Never, Never, Never], Any], / ) -> Iterator[Any]: ... @overload # == 1-d & dtype[T \ object_] def __iter__(self: ndarray[tuple[int], dtype[_NonObjectScalarT]], /) -> Iterator[_NonObjectScalarT]: ... @overload # == 1-d & StringDType def __iter__(self: ndarray[tuple[int], dtypes.StringDType], /) -> Iterator[str]: ... @overload # >= 2-d def __iter__(self: ndarray[tuple[int, int, *tuple[int, ...]], _DTypeT], /) -> Iterator[ndarray[_AnyShape, _DTypeT]]: ... @overload # ?-d def __iter__(self, /) -> Iterator[Any]: ... # @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[bytes_], other: _ArrayLikeBytes_co, /) -> NDArray[np.bool]: ... @overload def __lt__( self: ndarray[Any, dtype[str_] | dtypes.StringDType], other: _ArrayLikeStr_co | _ArrayLikeString_co, / ) -> NDArray[np.bool]: ... @overload def __lt__(self: NDArray[object_], other: object, /) -> NDArray[np.bool]: ... @overload def __lt__(self, 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[bytes_], other: _ArrayLikeBytes_co, /) -> NDArray[np.bool]: ... @overload def __le__( self: ndarray[Any, dtype[str_] | dtypes.StringDType], other: _ArrayLikeStr_co | _ArrayLikeString_co, / ) -> NDArray[np.bool]: ... @overload def __le__(self: NDArray[object_], other: object, /) -> NDArray[np.bool]: ... @overload def __le__(self, 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[bytes_], other: _ArrayLikeBytes_co, /) -> NDArray[np.bool]: ... @overload def __gt__( self: ndarray[Any, dtype[str_] | dtypes.StringDType], other: _ArrayLikeStr_co | _ArrayLikeString_co, / ) -> NDArray[np.bool]: ... @overload def __gt__(self: NDArray[object_], other: object, /) -> NDArray[np.bool]: ... @overload def __gt__(self, 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[bytes_], other: _ArrayLikeBytes_co, /) -> NDArray[np.bool]: ... @overload def __ge__( self: ndarray[Any, dtype[str_] | dtypes.StringDType], other: _ArrayLikeStr_co | _ArrayLikeString_co, / ) -> NDArray[np.bool]: ... @overload def __ge__(self: NDArray[object_], other: object, /) -> NDArray[np.bool]: ... @overload def __ge__(self, other: _ArrayLikeObject_co, /) -> NDArray[np.bool]: ... # Unary ops # TODO: Uncomment once https://github.com/python/mypy/issues/14070 is fixed # @overload # def __abs__(self: ndarray[_ShapeT, dtypes.Complex64DType], /) -> ndarray[_ShapeT, dtypes.Float32DType]: ... # @overload # def __abs__(self: ndarray[_ShapeT, dtypes.Complex128DType], /) -> ndarray[_ShapeT, dtypes.Float64DType]: ... # @overload # def __abs__(self: ndarray[_ShapeT, dtypes.CLongDoubleDType], /) -> ndarray[_ShapeT, dtypes.LongDoubleDType]: ... # @overload # def __abs__(self: ndarray[_ShapeT, dtype[complex128]], /) -> ndarray[_ShapeT, dtype[float64]]: ... @overload def __abs__(self: ndarray[_ShapeT, dtype[complexfloating[_NBit]]], /) -> ndarray[_ShapeT, dtype[floating[_NBit]]]: ... @overload def __abs__(self: _RealArrayT, /) -> _RealArrayT: ... def __invert__(self: _IntegralArrayT, /) -> _IntegralArrayT: ... # noqa: PYI019 def __neg__(self: _NumericArrayT, /) -> _NumericArrayT: ... # noqa: PYI019 def __pos__(self: _NumericArrayT, /) -> _NumericArrayT: ... # noqa: PYI019 # Binary ops # TODO: Support the "1d @ 1d -> scalar" case @overload def __matmul__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... @overload def __matmul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[overload-overlap] @overload def __matmul__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __matmul__(self: NDArray[floating[_64Bit]], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... @overload def __matmul__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... @overload def __matmul__(self: NDArray[complexfloating[_64Bit]], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... @overload def __matmul__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... @overload def __matmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __matmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] @overload def __matmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] @overload def __matmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... @overload def __matmul__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... @overload def __matmul__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __matmul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload # signature equivalent to __matmul__ def __rmatmul__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... @overload def __rmatmul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[overload-overlap] @overload def __rmatmul__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __rmatmul__(self: NDArray[floating[_64Bit]], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... @overload def __rmatmul__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... @overload def __rmatmul__(self: NDArray[complexfloating[_64Bit]], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... @overload def __rmatmul__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... @overload def __rmatmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __rmatmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] @overload def __rmatmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] @overload def __rmatmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... @overload def __rmatmul__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... @overload def __rmatmul__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rmatmul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __mod__(self: NDArray[_RealNumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_RealNumberT]]: ... @overload def __mod__(self: NDArray[_RealNumberT], other: _ArrayLikeBool_co, /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] @overload def __mod__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[overload-overlap] @overload def __mod__(self: NDArray[np.bool], other: _ArrayLike[_RealNumberT], /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] @overload def __mod__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... @overload def __mod__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... @overload def __mod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __mod__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] @overload def __mod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... @overload def __mod__(self: NDArray[timedelta64], other: _ArrayLike[timedelta64], /) -> NDArray[timedelta64]: ... @overload def __mod__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __mod__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload # signature equivalent to __mod__ def __rmod__(self: NDArray[_RealNumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_RealNumberT]]: ... @overload def __rmod__(self: NDArray[_RealNumberT], other: _ArrayLikeBool_co, /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] @overload def __rmod__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[overload-overlap] @overload def __rmod__(self: NDArray[np.bool], other: _ArrayLike[_RealNumberT], /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] @overload def __rmod__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... @overload def __rmod__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... @overload def __rmod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __rmod__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] @overload def __rmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... @overload def __rmod__(self: NDArray[timedelta64], other: _ArrayLike[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[_RealNumberT], rhs: int | np.bool, /) -> _2Tuple[ndarray[_ShapeT_co, dtype[_RealNumberT]]]: ... @overload def __divmod__(self: NDArray[_RealNumberT], rhs: _ArrayLikeBool_co, /) -> _2Tuple[NDArray[_RealNumberT]]: ... # type: ignore[overload-overlap] @overload def __divmod__(self: NDArray[np.bool], rhs: _ArrayLikeBool_co, /) -> _2Tuple[NDArray[int8]]: ... # type: ignore[overload-overlap] @overload def __divmod__(self: NDArray[np.bool], rhs: _ArrayLike[_RealNumberT], /) -> _2Tuple[NDArray[_RealNumberT]]: ... # type: ignore[overload-overlap] @overload def __divmod__(self: NDArray[float64], rhs: _ArrayLikeFloat64_co, /) -> _2Tuple[NDArray[float64]]: ... @overload def __divmod__(self: _ArrayFloat64_co, rhs: _ArrayLike[floating[_64Bit]], /) -> _2Tuple[NDArray[float64]]: ... @overload def __divmod__(self: _ArrayUInt_co, rhs: _ArrayLikeUInt_co, /) -> _2Tuple[NDArray[unsignedinteger]]: ... # type: ignore[overload-overlap] @overload def __divmod__(self: _ArrayInt_co, rhs: _ArrayLikeInt_co, /) -> _2Tuple[NDArray[signedinteger]]: ... # type: ignore[overload-overlap] @overload def __divmod__(self: _ArrayFloat_co, rhs: _ArrayLikeFloat_co, /) -> _2Tuple[NDArray[floating]]: ... @overload def __divmod__(self: NDArray[timedelta64], rhs: _ArrayLike[timedelta64], /) -> tuple[NDArray[int64], NDArray[timedelta64]]: ... @overload # signature equivalent to __divmod__ def __rdivmod__(self: NDArray[_RealNumberT], lhs: int | np.bool, /) -> _2Tuple[ndarray[_ShapeT_co, dtype[_RealNumberT]]]: ... @overload def __rdivmod__(self: NDArray[_RealNumberT], lhs: _ArrayLikeBool_co, /) -> _2Tuple[NDArray[_RealNumberT]]: ... # type: ignore[overload-overlap] @overload def __rdivmod__(self: NDArray[np.bool], lhs: _ArrayLikeBool_co, /) -> _2Tuple[NDArray[int8]]: ... # type: ignore[overload-overlap] @overload def __rdivmod__(self: NDArray[np.bool], lhs: _ArrayLike[_RealNumberT], /) -> _2Tuple[NDArray[_RealNumberT]]: ... # type: ignore[overload-overlap] @overload def __rdivmod__(self: NDArray[float64], lhs: _ArrayLikeFloat64_co, /) -> _2Tuple[NDArray[float64]]: ... @overload def __rdivmod__(self: _ArrayFloat64_co, lhs: _ArrayLike[floating[_64Bit]], /) -> _2Tuple[NDArray[float64]]: ... @overload def __rdivmod__(self: _ArrayUInt_co, lhs: _ArrayLikeUInt_co, /) -> _2Tuple[NDArray[unsignedinteger]]: ... # type: ignore[overload-overlap] @overload def __rdivmod__(self: _ArrayInt_co, lhs: _ArrayLikeInt_co, /) -> _2Tuple[NDArray[signedinteger]]: ... # type: ignore[overload-overlap] @overload def __rdivmod__(self: _ArrayFloat_co, lhs: _ArrayLikeFloat_co, /) -> _2Tuple[NDArray[floating]]: ... @overload def __rdivmod__(self: NDArray[timedelta64], lhs: _ArrayLike[timedelta64], /) -> tuple[NDArray[int64], NDArray[timedelta64]]: ... # Keep in sync with `MaskedArray.__add__` @overload def __add__(self: NDArray[_NumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... @overload def __add__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __add__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[overload-overlap] @overload def __add__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __add__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... @overload def __add__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... @overload def __add__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... @overload def __add__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... @overload def __add__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __add__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] @overload def __add__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] @overload def __add__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... # type: ignore[overload-overlap] @overload def __add__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... # type: ignore[overload-overlap] @overload def __add__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... @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[bytes_], other: _ArrayLikeBytes_co, /) -> NDArray[bytes_]: ... @overload def __add__(self: NDArray[str_], other: _ArrayLikeStr_co, /) -> NDArray[str_]: ... @overload def __add__( self: ndarray[Any, dtypes.StringDType], other: _ArrayLikeStr_co | _ArrayLikeString_co, /, ) -> ndarray[tuple[Any, ...], dtypes.StringDType]: ... @overload def __add__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __add__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... # Keep in sync with `MaskedArray.__radd__` @overload # signature equivalent to __add__ def __radd__(self: NDArray[_NumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... @overload def __radd__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __radd__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[overload-overlap] @overload def __radd__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __radd__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... @overload def __radd__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... @overload def __radd__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... @overload def __radd__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... @overload def __radd__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __radd__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] @overload def __radd__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] @overload def __radd__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... # type: ignore[overload-overlap] @overload def __radd__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... # type: ignore[overload-overlap] @overload def __radd__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... @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[bytes_], other: _ArrayLikeBytes_co, /) -> NDArray[bytes_]: ... @overload def __radd__(self: NDArray[str_], other: _ArrayLikeStr_co, /) -> NDArray[str_]: ... @overload def __radd__( self: ndarray[Any, dtypes.StringDType], other: _ArrayLikeStr_co | _ArrayLikeString_co, /, ) -> ndarray[tuple[Any, ...], dtypes.StringDType]: ... @overload def __radd__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __radd__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... # Keep in sync with `MaskedArray.__sub__` @overload def __sub__(self: NDArray[_NumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... @overload def __sub__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __sub__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NoReturn: ... @overload def __sub__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __sub__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... @overload def __sub__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... @overload def __sub__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... @overload def __sub__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... @overload def __sub__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __sub__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] @overload def __sub__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] @overload def __sub__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... # type: ignore[overload-overlap] @overload def __sub__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... # type: ignore[overload-overlap] @overload def __sub__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... @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: ... # Keep in sync with `MaskedArray.__rsub__` @overload def __rsub__(self: NDArray[_NumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... @overload def __rsub__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __rsub__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NoReturn: ... @overload def __rsub__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __rsub__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... @overload def __rsub__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... @overload def __rsub__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... @overload def __rsub__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... @overload def __rsub__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __rsub__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] @overload def __rsub__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] @overload def __rsub__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... # type: ignore[overload-overlap] @overload def __rsub__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... # type: ignore[overload-overlap] @overload def __rsub__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... @overload def __rsub__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co, /) -> NDArray[datetime64]: ... @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: ... # Keep in sync with `MaskedArray.__mul__` @overload def __mul__(self: NDArray[_NumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... @overload def __mul__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __mul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[overload-overlap] @overload def __mul__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __mul__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... @overload def __mul__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... @overload def __mul__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... @overload def __mul__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... @overload def __mul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __mul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] @overload def __mul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] @overload def __mul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... @overload def __mul__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... @overload def __mul__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co, /) -> NDArray[timedelta64]: ... @overload def __mul__(self: _ArrayFloat_co, other: _ArrayLike[timedelta64], /) -> NDArray[timedelta64]: ... @overload def __mul__( self: ndarray[Any, dtype[character] | dtypes.StringDType], other: _ArrayLikeInt, /, ) -> ndarray[tuple[Any, ...], _DTypeT_co]: ... @overload def __mul__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __mul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... # Keep in sync with `MaskedArray.__rmul__` @overload # signature equivalent to __mul__ def __rmul__(self: NDArray[_NumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... @overload def __rmul__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __rmul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[overload-overlap] @overload def __rmul__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __rmul__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... @overload def __rmul__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... @overload def __rmul__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... @overload def __rmul__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... @overload def __rmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __rmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] @overload def __rmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] @overload def __rmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ... @overload def __rmul__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... @overload def __rmul__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co, /) -> NDArray[timedelta64]: ... @overload def __rmul__(self: _ArrayFloat_co, other: _ArrayLike[timedelta64], /) -> NDArray[timedelta64]: ... @overload def __rmul__( self: ndarray[Any, dtype[character] | dtypes.StringDType], other: _ArrayLikeInt, /, ) -> ndarray[tuple[Any, ...], _DTypeT_co]: ... @overload def __rmul__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rmul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... # Keep in sync with `MaskedArray.__truediv__` @overload def __truediv__(self: _ArrayInt_co | NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... @overload def __truediv__(self: _ArrayFloat64_co, other: _ArrayLikeInt_co | _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... @overload def __truediv__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... @overload def __truediv__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... @overload def __truediv__(self: NDArray[floating], other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... @overload def __truediv__(self: _ArrayFloat_co, other: _ArrayLike[floating], /) -> NDArray[floating]: ... @overload def __truediv__(self: NDArray[complexfloating], other: _ArrayLikeNumber_co, /) -> NDArray[complexfloating]: ... @overload def __truediv__(self: _ArrayNumber_co, other: _ArrayLike[complexfloating], /) -> NDArray[complexfloating]: ... @overload def __truediv__(self: NDArray[inexact], other: _ArrayLikeNumber_co, /) -> NDArray[inexact]: ... @overload def __truediv__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... @overload def __truediv__(self: NDArray[timedelta64], other: _ArrayLike[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: ... # Keep in sync with `MaskedArray.__rtruediv__` @overload def __rtruediv__(self: _ArrayInt_co | NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... @overload def __rtruediv__(self: _ArrayFloat64_co, other: _ArrayLikeInt_co | _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... @overload def __rtruediv__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, /) -> NDArray[complex128]: ... @overload def __rtruediv__(self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> NDArray[complex128]: ... @overload def __rtruediv__(self: NDArray[floating], other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... @overload def __rtruediv__(self: _ArrayFloat_co, other: _ArrayLike[floating], /) -> NDArray[floating]: ... @overload def __rtruediv__(self: NDArray[complexfloating], other: _ArrayLikeNumber_co, /) -> NDArray[complexfloating]: ... @overload def __rtruediv__(self: _ArrayNumber_co, other: _ArrayLike[complexfloating], /) -> NDArray[complexfloating]: ... @overload def __rtruediv__(self: NDArray[inexact], other: _ArrayLikeNumber_co, /) -> NDArray[inexact]: ... @overload def __rtruediv__(self: NDArray[number], other: _ArrayLikeNumber_co, /) -> NDArray[number]: ... @overload def __rtruediv__(self: NDArray[timedelta64], other: _ArrayLike[timedelta64], /) -> NDArray[float64]: ... @overload def __rtruediv__(self: NDArray[integer | floating], other: _ArrayLike[timedelta64], /) -> NDArray[timedelta64]: ... @overload def __rtruediv__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rtruediv__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... # Keep in sync with `MaskedArray.__floordiv__` @overload def __floordiv__(self: NDArray[_RealNumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_RealNumberT]]: ... @overload def __floordiv__(self: NDArray[_RealNumberT], other: _ArrayLikeBool_co, /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] @overload def __floordiv__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[overload-overlap] @overload def __floordiv__(self: NDArray[np.bool], other: _ArrayLike[_RealNumberT], /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] @overload def __floordiv__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... @overload def __floordiv__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... @overload def __floordiv__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __floordiv__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] @overload def __floordiv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... @overload def __floordiv__(self: NDArray[timedelta64], other: _ArrayLike[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: ... # Keep in sync with `MaskedArray.__rfloordiv__` @overload def __rfloordiv__(self: NDArray[_RealNumberT], other: int | np.bool, /) -> ndarray[_ShapeT_co, dtype[_RealNumberT]]: ... @overload def __rfloordiv__(self: NDArray[_RealNumberT], other: _ArrayLikeBool_co, /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] @overload def __rfloordiv__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[overload-overlap] @overload def __rfloordiv__(self: NDArray[np.bool], other: _ArrayLike[_RealNumberT], /) -> NDArray[_RealNumberT]: ... # type: ignore[overload-overlap] @overload def __rfloordiv__(self: NDArray[float64], other: _ArrayLikeFloat64_co, /) -> NDArray[float64]: ... @overload def __rfloordiv__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> NDArray[float64]: ... @overload def __rfloordiv__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __rfloordiv__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] @overload def __rfloordiv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating]: ... @overload def __rfloordiv__(self: NDArray[timedelta64], other: _ArrayLike[timedelta64], /) -> NDArray[int64]: ... @overload def __rfloordiv__(self: NDArray[floating | integer], other: _ArrayLike[timedelta64], /) -> NDArray[timedelta64]: ... @overload def __rfloordiv__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rfloordiv__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... # Keep in sync with `MaskedArray.__pow__` @overload def __pow__(self: NDArray[_NumberT], other: int | np.bool, mod: None = None, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... @overload def __pow__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, mod: None = None, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __pow__(self: NDArray[np.bool], other: _ArrayLikeBool_co, mod: None = None, /) -> NDArray[int8]: ... # type: ignore[overload-overlap] @overload def __pow__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], mod: None = None, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __pow__(self: NDArray[float64], other: _ArrayLikeFloat64_co, mod: None = None, /) -> NDArray[float64]: ... @overload def __pow__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], mod: None = None, /) -> NDArray[float64]: ... @overload def __pow__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, mod: None = None, /) -> NDArray[complex128]: ... @overload def __pow__( self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], mod: None = None, / ) -> NDArray[complex128]: ... @overload def __pow__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, mod: None = None, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __pow__(self: _ArrayInt_co, other: _ArrayLikeInt_co, mod: None = None, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] @overload def __pow__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, mod: None = None, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] @overload def __pow__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, mod: None = None, /) -> NDArray[complexfloating]: ... @overload def __pow__(self: NDArray[number], other: _ArrayLikeNumber_co, mod: None = None, /) -> NDArray[number]: ... @overload def __pow__(self: NDArray[object_], other: Any, mod: None = None, /) -> Any: ... @overload def __pow__(self: NDArray[Any], other: _ArrayLikeObject_co, mod: None = None, /) -> Any: ... # Keep in sync with `MaskedArray.__rpow__` @overload def __rpow__(self: NDArray[_NumberT], other: int | np.bool, mod: None = None, /) -> ndarray[_ShapeT_co, dtype[_NumberT]]: ... @overload def __rpow__(self: NDArray[_NumberT], other: _ArrayLikeBool_co, mod: None = None, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __rpow__(self: NDArray[np.bool], other: _ArrayLikeBool_co, mod: None = None, /) -> NDArray[int8]: ... # type: ignore[overload-overlap] @overload def __rpow__(self: NDArray[np.bool], other: _ArrayLike[_NumberT], mod: None = None, /) -> NDArray[_NumberT]: ... # type: ignore[overload-overlap] @overload def __rpow__(self: NDArray[float64], other: _ArrayLikeFloat64_co, mod: None = None, /) -> NDArray[float64]: ... @overload def __rpow__(self: _ArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], mod: None = None, /) -> NDArray[float64]: ... @overload def __rpow__(self: NDArray[complex128], other: _ArrayLikeComplex128_co, mod: None = None, /) -> NDArray[complex128]: ... @overload def __rpow__( self: _ArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], mod: None = None, / ) -> NDArray[complex128]: ... @overload def __rpow__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, mod: None = None, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __rpow__(self: _ArrayInt_co, other: _ArrayLikeInt_co, mod: None = None, /) -> NDArray[signedinteger]: ... # type: ignore[overload-overlap] @overload def __rpow__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, mod: None = None, /) -> NDArray[floating]: ... # type: ignore[overload-overlap] @overload def __rpow__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, mod: None = None, /) -> NDArray[complexfloating]: ... @overload def __rpow__(self: NDArray[number], other: _ArrayLikeNumber_co, mod: None = None, /) -> NDArray[number]: ... @overload def __rpow__(self: NDArray[object_], other: Any, mod: None = None, /) -> Any: ... @overload def __rpow__(self: NDArray[Any], other: _ArrayLikeObject_co, mod: None = None, /) -> Any: ... @overload def __lshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... @overload def __lshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __lshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... @overload def __lshift__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __lshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rlshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... @overload def __rlshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __rlshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... @overload def __rlshift__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rlshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... @overload def __rshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __rshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... @overload def __rshift__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rrshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... @overload def __rrshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __rrshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... @overload def __rrshift__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rrshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __and__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... @overload def __and__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __and__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... @overload def __and__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __and__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rand__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... @overload def __rand__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __rand__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... @overload def __rand__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rand__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __xor__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... @overload def __xor__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __xor__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... @overload def __xor__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __xor__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __rxor__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... @overload def __rxor__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __rxor__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... @overload def __rxor__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __rxor__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __or__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... @overload def __or__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __or__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... @overload def __or__(self: NDArray[object_], other: Any, /) -> Any: ... @overload def __or__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... @overload def __ror__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... @overload def __ror__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ... # type: ignore[overload-overlap] @overload def __ror__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ... @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 # NOTE: Due to a mypy bug, overloading on e.g. `self: NDArray[SCT_floating]` won't # work, as this will lead to `false negatives` when using these inplace ops. # += @overload # type: ignore[misc] def __iadd__(self: _BoolArrayT, other: _ArrayLikeBool_co, /) -> _BoolArrayT: ... @overload def __iadd__(self: _ComplexFloatingArrayT, other: _ArrayLikeComplex_co, /) -> _ComplexFloatingArrayT: ... @overload def __iadd__(self: _InexactArrayT, other: _ArrayLikeFloat_co, /) -> _InexactArrayT: ... @overload def __iadd__(self: _NumberArrayT, other: _ArrayLikeInt_co, /) -> _NumberArrayT: ... @overload def __iadd__(self: _TimeArrayT, other: _ArrayLikeTD64_co, /) -> _TimeArrayT: ... @overload def __iadd__(self: _BytesArrayT, other: _ArrayLikeBytes_co, /) -> _BytesArrayT: ... @overload def __iadd__(self: _StringArrayT, other: _ArrayLikeStr_co | _ArrayLikeString_co, /) -> _StringArrayT: ... @overload def __iadd__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... # -= @overload # type: ignore[misc] def __isub__(self: _ComplexFloatingArrayT, other: _ArrayLikeComplex_co, /) -> _ComplexFloatingArrayT: ... @overload def __isub__(self: _InexactArrayT, other: _ArrayLikeFloat_co, /) -> _InexactArrayT: ... @overload def __isub__(self: _NumberArrayT, other: _ArrayLikeInt_co, /) -> _NumberArrayT: ... @overload def __isub__(self: _TimeArrayT, other: _ArrayLikeTD64_co, /) -> _TimeArrayT: ... @overload def __isub__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... # *= @overload # type: ignore[misc] def __imul__(self: _BoolArrayT, other: _ArrayLikeBool_co, /) -> _BoolArrayT: ... @overload def __imul__(self: _ComplexFloatingArrayT, other: _ArrayLikeComplex_co, /) -> _ComplexFloatingArrayT: ... @overload def __imul__(self: _InexactTimedeltaArrayT, other: _ArrayLikeFloat_co, /) -> _InexactTimedeltaArrayT: ... @overload def __imul__(self: _NumberCharacterArrayT, other: _ArrayLikeInt_co, /) -> _NumberCharacterArrayT: ... @overload def __imul__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... # @= @overload # type: ignore[misc] def __imatmul__(self: _BoolArrayT, other: _ArrayLikeBool_co, /) -> _BoolArrayT: ... @overload def __imatmul__(self: _ComplexFloatingArrayT, other: _ArrayLikeComplex_co, /) -> _ComplexFloatingArrayT: ... @overload def __imatmul__(self: _InexactArrayT, other: _ArrayLikeFloat_co, /) -> _InexactArrayT: ... @overload def __imatmul__(self: _NumberArrayT, other: _ArrayLikeInt_co, /) -> _NumberArrayT: ... @overload def __imatmul__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... # **= @overload # type: ignore[misc] def __ipow__(self: _ComplexFloatingArrayT, other: _ArrayLikeComplex_co, /) -> _ComplexFloatingArrayT: ... @overload def __ipow__(self: _InexactArrayT, other: _ArrayLikeFloat_co, /) -> _InexactArrayT: ... @overload def __ipow__(self: _NumberArrayT, other: _ArrayLikeInt_co, /) -> _NumberArrayT: ... @overload def __ipow__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... # /= @overload # type: ignore[misc] def __itruediv__(self: _ComplexFloatingArrayT, other: _ArrayLikeComplex_co, /) -> _ComplexFloatingArrayT: ... @overload def __itruediv__(self: _InexactTimedeltaArrayT, other: _ArrayLikeFloat_co, /) -> _InexactTimedeltaArrayT: ... @overload def __itruediv__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... # //= # keep in sync with `__imod__` @overload # type: ignore[misc] def __ifloordiv__(self: _IntegerArrayT, other: _ArrayLikeInt_co, /) -> _IntegerArrayT: ... @overload def __ifloordiv__(self: _FloatingTimedeltaArrayT, other: _ArrayLikeFloat_co, /) -> _FloatingTimedeltaArrayT: ... @overload def __ifloordiv__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... # %= # keep in sync with `__ifloordiv__` @overload # type: ignore[misc] def __imod__(self: _IntegerArrayT, other: _ArrayLikeInt_co, /) -> _IntegerArrayT: ... @overload def __imod__(self: _FloatingArrayT, other: _ArrayLikeFloat_co, /) -> _FloatingArrayT: ... @overload def __imod__(self: _TimedeltaArrayT, other: _ArrayLike[timedelta64], /) -> _TimedeltaArrayT: ... @overload def __imod__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... # <<= # keep in sync with `__irshift__` @overload # type: ignore[misc] def __ilshift__(self: _IntegerArrayT, other: _ArrayLikeInt_co, /) -> _IntegerArrayT: ... @overload def __ilshift__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... # >>= # keep in sync with `__ilshift__` @overload # type: ignore[misc] def __irshift__(self: _IntegerArrayT, other: _ArrayLikeInt_co, /) -> _IntegerArrayT: ... @overload def __irshift__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... # &= # keep in sync with `__ixor__` and `__ior__` @overload # type: ignore[misc] def __iand__(self: _BoolArrayT, other: _ArrayLikeBool_co, /) -> _BoolArrayT: ... @overload def __iand__(self: _IntegerArrayT, other: _ArrayLikeInt_co, /) -> _IntegerArrayT: ... @overload def __iand__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... # ^= # keep in sync with `__iand__` and `__ior__` @overload # type: ignore[misc] def __ixor__(self: _BoolArrayT, other: _ArrayLikeBool_co, /) -> _BoolArrayT: ... @overload def __ixor__(self: _IntegerArrayT, other: _ArrayLikeInt_co, /) -> _IntegerArrayT: ... @overload def __ixor__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... # |= # keep in sync with `__iand__` and `__ixor__` @overload # type: ignore[misc] def __ior__(self: _BoolArrayT, other: _ArrayLikeBool_co, /) -> _BoolArrayT: ... @overload def __ior__(self: _IntegerArrayT, other: _ArrayLikeInt_co, /) -> _IntegerArrayT: ... @overload def __ior__(self: _ObjectArrayT, other: object, /) -> _ObjectArrayT: ... # def __dlpack__( self: NDArray[number], /, *, stream: int | Any | None = None, max_version: tuple[int, int] | None = None, dl_device: tuple[int, int] | None = None, copy: builtins.bool | None = None, ) -> CapsuleType: ... def __dlpack_device__(self, /) -> tuple[L[1], L[0]]: ... # Keep `dtype` at the bottom to avoid name conflicts with `np.dtype` @property def dtype(self) -> _DTypeT_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. class generic(_ArrayOrScalarCommon, Generic[_ItemT_co]): @abstractmethod def __new__(cls, /, *args: Any, **kwargs: Any) -> Self: ... # NOTE: Technically this doesn't exist at runtime, but it is unlikely to lead to # type-unsafe situations (the abstract scalar types cannot be instantiated # themselves) and is convenient to have, so we include it regardless. See # https://github.com/numpy/numpy/issues/30445 for use-cases and discussion. def __hash__(self, /) -> int: ... if sys.version_info >= (3, 12): def __buffer__(self, flags: int, /) -> memoryview: ... @overload def __array__(self, dtype: None = None, /) -> ndarray[tuple[()], dtype[Self]]: ... @overload def __array__(self, dtype: _DTypeT, /) -> ndarray[tuple[()], _DTypeT]: ... @overload def __array_wrap__( self, array: ndarray[_ShapeT, _DTypeT], context: tuple[ufunc, tuple[object, ...], int] | None, return_scalar: L[False], /, ) -> ndarray[_ShapeT, _DTypeT]: ... @overload def __array_wrap__( self, array: ndarray[tuple[()], dtype[_ScalarT]], context: tuple[ufunc, tuple[object, ...], int] | None = None, return_scalar: L[True] = True, /, ) -> _ScalarT: ... @overload def __array_wrap__( self, array: ndarray[_Shape1T, _DTypeT], context: tuple[ufunc, tuple[object, ...], int] | None = None, return_scalar: L[True] = True, /, ) -> ndarray[_Shape1T, _DTypeT]: ... @overload def __array_wrap__( self, array: ndarray[_ShapeT, dtype[_ScalarT]], context: tuple[ufunc, tuple[object, ...], int] | None = None, return_scalar: L[True] = True, /, ) -> _ScalarT | ndarray[_ShapeT, dtype[_ScalarT]]: ... @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[()]: ... @property def flat(self) -> flatiter[ndarray[tuple[int], dtype[Self]]]: ... @overload def item(self, /) -> _ItemT_co: ... @overload def item(self, arg0: L[0, -1] | tuple[L[0, -1]] | tuple[()] = ..., /) -> _ItemT_co: ... @override def tolist(self, /) -> _ItemT_co: ... # NOTE: these technically exist, but will always raise when called def trace( # type: ignore[misc] self: Never, /, offset: L[0] = 0, axis1: L[0] = 0, axis2: L[1] = 1, dtype: None = None, out: None = None, ) -> Never: ... def diagonal(self: Never, /, offset: L[0] = 0, axis1: L[0] = 0, axis2: L[1] = 1) -> Never: ... # type: ignore[misc] def swapaxes(self: Never, axis1: Never, axis2: Never, /) -> Never: ... # type: ignore[misc] def sort(self: Never, /, axis: L[-1] = -1, kind: None = None, order: None = None, *, stable: None = None) -> Never: ... # type: ignore[misc] def nonzero(self: Never, /) -> Never: ... # type: ignore[misc] def setfield(self: Never, val: Never, /, dtype: Never, offset: L[0] = 0) -> None: ... # type: ignore[misc] def searchsorted(self: Never, v: Never, /, side: L["left"] = "left", sorter: None = None) -> Never: ... # type: ignore[misc] # NOTE: this wont't raise, but won't do anything either @overload def resize(self, /, *, refcheck: builtins.bool = True) -> None: ... @overload def resize(self, new_shape: L[0, -1] | tuple[L[0, -1]] | tuple[()], /, *, refcheck: builtins.bool = True) -> None: ... # def byteswap(self, /, inplace: L[False] = False) -> Self: ... # @overload def astype( self, /, dtype: _DTypeLike[_ScalarT], order: _OrderKACF = "K", casting: _CastingKind = "unsafe", subok: builtins.bool = True, copy: builtins.bool | _CopyMode = True, ) -> _ScalarT: ... @overload def astype( self, /, dtype: DTypeLike | None, order: _OrderKACF = "K", casting: _CastingKind = "unsafe", subok: builtins.bool = True, copy: builtins.bool | _CopyMode = True, ) -> Incomplete: ... # NOTE: `view` will perform a 0D->scalar cast, # thus the array `type` is irrelevant to the output type @overload def view(self, type: type[ndarray] = ...) -> Self: ... @overload def view(self, /, dtype: _DTypeLike[_ScalarT], type: type[ndarray] = ...) -> _ScalarT: ... @overload def view(self, /, dtype: DTypeLike, type: type[ndarray] = ...) -> Incomplete: ... @overload def getfield(self, /, dtype: _DTypeLike[_ScalarT], offset: SupportsIndex = 0) -> _ScalarT: ... @overload def getfield(self, /, dtype: DTypeLike, offset: SupportsIndex = 0) -> Incomplete: ... @overload def take( self, indices: _IntLike_co, /, axis: SupportsIndex | None = None, out: None = None, mode: _ModeKind = "raise", ) -> Self: ... @overload def take( self, indices: _ArrayLikeInt_co, /, axis: SupportsIndex | None = None, out: None = None, mode: _ModeKind = "raise", ) -> NDArray[Self]: ... @overload def take( self, indices: _ArrayLikeInt_co, /, axis: SupportsIndex | None = None, *, out: _ArrayT, mode: _ModeKind = "raise", ) -> _ArrayT: ... @overload def take( self, indices: _ArrayLikeInt_co, /, axis: SupportsIndex | None, out: _ArrayT, mode: _ModeKind = "raise", ) -> _ArrayT: ... def repeat(self, repeats: _ArrayLikeInt_co, /, axis: SupportsIndex | None = None) -> ndarray[tuple[int], dtype[Self]]: ... def flatten(self, /, order: _OrderKACF = "C") -> ndarray[tuple[int], dtype[Self]]: ... def ravel(self, /, order: _OrderKACF = "C") -> ndarray[tuple[int], dtype[Self]]: ... @overload # (() | []) def reshape( self, shape: tuple[()] | list[Never], /, *, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> Self: ... @overload # ((1, *(1, ...))@_ShapeT) def reshape( self, shape: _1NShapeT, /, *, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> ndarray[_1NShapeT, dtype[Self]]: ... @overload # (Sequence[index, ...]) # not recommended def reshape( self, shape: Sequence[SupportsIndex], /, *, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> Self | ndarray[tuple[L[1], ...], dtype[Self]]: ... @overload # _(index) def reshape( self, size1: SupportsIndex, /, *, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> ndarray[tuple[L[1]], dtype[Self]]: ... @overload # _(index, index) def reshape( self, size1: SupportsIndex, size2: SupportsIndex, /, *, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> ndarray[tuple[L[1], L[1]], dtype[Self]]: ... @overload # _(index, index, index) def reshape( self, size1: SupportsIndex, size2: SupportsIndex, size3: SupportsIndex, /, *, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> ndarray[tuple[L[1], L[1], L[1]], dtype[Self]]: ... @overload # _(index, index, index, index) def reshape( self, size1: SupportsIndex, size2: SupportsIndex, size3: SupportsIndex, size4: SupportsIndex, /, *, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> ndarray[tuple[L[1], L[1], L[1], L[1]], dtype[Self]]: ... @overload # _(index, index, index, index, index, *index) # ndim >= 5 def reshape( self, size1: SupportsIndex, size2: SupportsIndex, size3: SupportsIndex, size4: SupportsIndex, size5: SupportsIndex, /, *sizes6_: SupportsIndex, order: _OrderACF = "C", copy: builtins.bool | None = None, ) -> ndarray[tuple[L[1], L[1], L[1], L[1], L[1], *tuple[L[1], ...]], dtype[Self]]: ... def squeeze(self, axis: L[0] | tuple[()] | None = ...) -> Self: ... def transpose(self, axes: tuple[()] | None = ..., /) -> Self: ... @overload def all( self, /, axis: L[0, -1] | tuple[()] | None = None, out: None = None, keepdims: SupportsIndex = False, *, where: builtins.bool | np.bool | ndarray[tuple[()], dtype[np.bool]] = True ) -> np.bool: ... @overload def all( self, /, axis: L[0, -1] | tuple[()] | None, out: ndarray[tuple[()], dtype[_ScalarT]], keepdims: SupportsIndex = False, *, where: builtins.bool | np.bool | ndarray[tuple[()], dtype[np.bool]] = True, ) -> _ScalarT: ... @overload def all( self, /, axis: L[0, -1] | tuple[()] | None = None, *, out: ndarray[tuple[()], dtype[_ScalarT]], keepdims: SupportsIndex = False, where: builtins.bool | np.bool | ndarray[tuple[()], dtype[np.bool]] = True, ) -> _ScalarT: ... @overload def any( self, /, axis: L[0, -1] | tuple[()] | None = None, out: None = None, keepdims: SupportsIndex = False, *, where: builtins.bool | np.bool | ndarray[tuple[()], dtype[np.bool]] = True ) -> np.bool: ... @overload def any( self, /, axis: L[0, -1] | tuple[()] | None, out: ndarray[tuple[()], dtype[_ScalarT]], keepdims: SupportsIndex = False, *, where: builtins.bool | np.bool | ndarray[tuple[()], dtype[np.bool]] = True, ) -> _ScalarT: ... @overload def any( self, /, axis: L[0, -1] | tuple[()] | None = None, *, out: ndarray[tuple[()], dtype[_ScalarT]], keepdims: SupportsIndex = False, where: builtins.bool | np.bool | ndarray[tuple[()], dtype[np.bool]] = True, ) -> _ScalarT: ... # Keep `dtype` at the bottom to avoid name conflicts with `np.dtype` @property def dtype(self) -> _dtype[Self]: ... class number(generic[_NumberItemT_co], Generic[_NBit, _NumberItemT_co]): @abstractmethod # `SupportsIndex | str | bytes` equivs `_ConvertibleToInt & _ConvertibleToFloat` def __new__(cls, value: SupportsIndex | str | bytes = 0, /) -> Self: ... def __class_getitem__(cls, item: Any, /) -> GenericAlias: ... def __neg__(self) -> Self: ... def __pos__(self) -> Self: ... def __abs__(self) -> Self: ... def __add__(self, other: _NumberLike_co, /) -> Incomplete: ... def __radd__(self, other: _NumberLike_co, /) -> Incomplete: ... def __sub__(self, other: _NumberLike_co, /) -> Incomplete: ... def __rsub__(self, other: _NumberLike_co, /) -> Incomplete: ... def __mul__(self, other: _NumberLike_co, /) -> Incomplete: ... def __rmul__(self, other: _NumberLike_co, /) -> Incomplete: ... def __pow__(self, other: _NumberLike_co, mod: None = None, /) -> Incomplete: ... def __rpow__(self, other: _NumberLike_co, mod: None = None, /) -> Incomplete: ... def __truediv__(self, other: _NumberLike_co, /) -> Incomplete: ... def __rtruediv__(self, other: _NumberLike_co, /) -> Incomplete: ... @overload def __lt__(self, other: _NumberLike_co, /) -> bool_: ... @overload def __lt__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsGT], /) -> NDArray[bool_]: ... @overload def __lt__(self, other: _SupportsGT, /) -> bool_: ... @overload def __le__(self, other: _NumberLike_co, /) -> bool_: ... @overload def __le__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsGE], /) -> NDArray[bool_]: ... @overload def __le__(self, other: _SupportsGE, /) -> bool_: ... @overload def __gt__(self, other: _NumberLike_co, /) -> bool_: ... @overload def __gt__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsLT], /) -> NDArray[bool_]: ... @overload def __gt__(self, other: _SupportsLT, /) -> bool_: ... @overload def __ge__(self, other: _NumberLike_co, /) -> bool_: ... @overload def __ge__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsLE], /) -> NDArray[bool_]: ... @overload def __ge__(self, other: _SupportsLE, /) -> bool_: ... class bool(generic[_BoolItemT_co], Generic[_BoolItemT_co]): @property def itemsize(self) -> L[1]: ... @property def nbytes(self) -> L[1]: ... @property def real(self) -> Self: ... @property def imag(self) -> np.bool[L[False]]: ... @overload # mypy bug workaround: https://github.com/numpy/numpy/issues/29245 def __new__(cls, value: Never, /) -> np.bool[builtins.bool]: ... @overload def __new__(cls, value: _Falsy = ..., /) -> np.bool[L[False]]: ... @overload def __new__(cls, value: _Truthy, /) -> np.bool[L[True]]: ... @overload def __new__(cls, value: object, /) -> np.bool[builtins.bool]: ... def __class_getitem__(cls, type_arg: type | object, /) -> GenericAlias: ... def __bool__(self, /) -> _BoolItemT_co: ... @overload def __int__(self: np.bool[L[False]], /) -> L[0]: ... @overload def __int__(self: np.bool[L[True]], /) -> L[1]: ... @overload def __int__(self, /) -> L[0, 1]: ... def __abs__(self) -> Self: ... @overload def __invert__(self: np.bool[L[False]], /) -> np.bool[L[True]]: ... @overload def __invert__(self: np.bool[L[True]], /) -> np.bool[L[False]]: ... @overload def __invert__(self, /) -> np.bool: ... @overload def __add__(self, other: _NumberT, /) -> _NumberT: ... @overload def __add__(self, other: builtins.bool | bool_, /) -> bool_: ... @overload def __add__(self, other: int, /) -> int_: ... @overload def __add__(self, other: float, /) -> float64: ... @overload def __add__(self, other: complex, /) -> complex128: ... @overload def __radd__(self, other: _NumberT, /) -> _NumberT: ... @overload def __radd__(self, other: builtins.bool, /) -> bool_: ... @overload def __radd__(self, other: int, /) -> int_: ... @overload def __radd__(self, other: float, /) -> float64: ... @overload def __radd__(self, other: complex, /) -> complex128: ... @overload def __sub__(self, other: _NumberT, /) -> _NumberT: ... @overload def __sub__(self, other: int, /) -> int_: ... @overload def __sub__(self, other: float, /) -> float64: ... @overload def __sub__(self, other: complex, /) -> complex128: ... @overload def __rsub__(self, other: _NumberT, /) -> _NumberT: ... @overload def __rsub__(self, other: int, /) -> int_: ... @overload def __rsub__(self, other: float, /) -> float64: ... @overload def __rsub__(self, other: complex, /) -> complex128: ... @overload def __mul__(self, other: _NumberT, /) -> _NumberT: ... @overload def __mul__(self, other: builtins.bool | bool_, /) -> bool_: ... @overload def __mul__(self, other: int, /) -> int_: ... @overload def __mul__(self, other: float, /) -> float64: ... @overload def __mul__(self, other: complex, /) -> complex128: ... @overload def __rmul__(self, other: _NumberT, /) -> _NumberT: ... @overload def __rmul__(self, other: builtins.bool, /) -> bool_: ... @overload def __rmul__(self, other: int, /) -> int_: ... @overload def __rmul__(self, other: float, /) -> float64: ... @overload def __rmul__(self, other: complex, /) -> complex128: ... @overload def __pow__(self, other: _NumberT, mod: None = None, /) -> _NumberT: ... @overload def __pow__(self, other: builtins.bool | bool_, mod: None = None, /) -> int8: ... @overload def __pow__(self, other: int, mod: None = None, /) -> int_: ... @overload def __pow__(self, other: float, mod: None = None, /) -> float64: ... @overload def __pow__(self, other: complex, mod: None = None, /) -> complex128: ... @overload def __rpow__(self, other: _NumberT, mod: None = None, /) -> _NumberT: ... @overload def __rpow__(self, other: builtins.bool, mod: None = None, /) -> int8: ... @overload def __rpow__(self, other: int, mod: None = None, /) -> int_: ... @overload def __rpow__(self, other: float, mod: None = None, /) -> float64: ... @overload def __rpow__(self, other: complex, mod: None = None, /) -> complex128: ... @overload def __truediv__(self, other: _InexactT, /) -> _InexactT: ... @overload def __truediv__(self, other: float | integer | bool_, /) -> float64: ... @overload def __truediv__(self, other: complex, /) -> complex128: ... @overload def __rtruediv__(self, other: _InexactT, /) -> _InexactT: ... @overload def __rtruediv__(self, other: float | integer, /) -> float64: ... @overload def __rtruediv__(self, other: complex, /) -> complex128: ... @overload def __floordiv__(self, other: _RealNumberT, /) -> _RealNumberT: ... @overload def __floordiv__(self, other: builtins.bool | bool_, /) -> int8: ... @overload def __floordiv__(self, other: int, /) -> int_: ... @overload def __floordiv__(self, other: float, /) -> float64: ... @overload def __rfloordiv__(self, other: _RealNumberT, /) -> _RealNumberT: ... @overload def __rfloordiv__(self, other: builtins.bool, /) -> int8: ... @overload def __rfloordiv__(self, other: int, /) -> int_: ... @overload def __rfloordiv__(self, other: float, /) -> float64: ... # keep in sync with __floordiv__ @overload def __mod__(self, other: _RealNumberT, /) -> _RealNumberT: ... @overload def __mod__(self, other: builtins.bool | bool_, /) -> int8: ... @overload def __mod__(self, other: int, /) -> int_: ... @overload def __mod__(self, other: float, /) -> float64: ... # keep in sync with __rfloordiv__ @overload def __rmod__(self, other: _RealNumberT, /) -> _RealNumberT: ... @overload def __rmod__(self, other: builtins.bool, /) -> int8: ... @overload def __rmod__(self, other: int, /) -> int_: ... @overload def __rmod__(self, other: float, /) -> float64: ... # keep in sync with __mod__ @overload def __divmod__(self, other: _RealNumberT, /) -> _2Tuple[_RealNumberT]: ... @overload def __divmod__(self, other: builtins.bool | bool_, /) -> _2Tuple[int8]: ... @overload def __divmod__(self, other: int, /) -> _2Tuple[int_]: ... @overload def __divmod__(self, other: float, /) -> _2Tuple[float64]: ... # keep in sync with __rmod__ @overload def __rdivmod__(self, other: _RealNumberT, /) -> _2Tuple[_RealNumberT]: ... @overload def __rdivmod__(self, other: builtins.bool, /) -> _2Tuple[int8]: ... @overload def __rdivmod__(self, other: int, /) -> _2Tuple[int_]: ... @overload def __rdivmod__(self, other: float, /) -> _2Tuple[float64]: ... @overload def __lshift__(self, other: _IntegerT, /) -> _IntegerT: ... @overload def __lshift__(self, other: builtins.bool | bool_, /) -> int8: ... @overload def __lshift__(self, other: int, /) -> int_: ... @overload def __rlshift__(self, other: _IntegerT, /) -> _IntegerT: ... @overload def __rlshift__(self, other: builtins.bool, /) -> int8: ... @overload def __rlshift__(self, other: int, /) -> int_: ... # keep in sync with __lshift__ @overload def __rshift__(self, other: _IntegerT, /) -> _IntegerT: ... @overload def __rshift__(self, other: builtins.bool | bool_, /) -> int8: ... @overload def __rshift__(self, other: int, /) -> int_: ... # keep in sync with __rlshift__ @overload def __rrshift__(self, other: _IntegerT, /) -> _IntegerT: ... @overload def __rrshift__(self, other: builtins.bool, /) -> int8: ... @overload def __rrshift__(self, other: int, /) -> int_: ... @overload def __and__(self: np.bool[L[False]], other: builtins.bool | np.bool, /) -> np.bool[L[False]]: ... @overload def __and__(self, other: L[False] | np.bool[L[False]], /) -> np.bool[L[False]]: ... @overload def __and__(self, other: L[True] | np.bool[L[True]], /) -> Self: ... @overload def __and__(self, other: builtins.bool | np.bool, /) -> np.bool: ... @overload def __and__(self, other: _IntegerT, /) -> _IntegerT: ... @overload def __and__(self, other: int, /) -> np.bool | intp: ... __rand__ = __and__ @overload def __xor__(self: np.bool[L[False]], other: _BoolItemT | np.bool[_BoolItemT], /) -> np.bool[_BoolItemT]: ... @overload def __xor__(self: np.bool[L[True]], other: L[True] | np.bool[L[True]], /) -> np.bool[L[False]]: ... @overload def __xor__(self, other: L[False] | np.bool[L[False]], /) -> Self: ... @overload def __xor__(self, other: builtins.bool | np.bool, /) -> np.bool: ... @overload def __xor__(self, other: _IntegerT, /) -> _IntegerT: ... @overload def __xor__(self, other: int, /) -> np.bool | intp: ... __rxor__ = __xor__ @overload def __or__(self: np.bool[L[True]], other: builtins.bool | np.bool, /) -> np.bool[L[True]]: ... @overload def __or__(self, other: L[False] | np.bool[L[False]], /) -> Self: ... @overload def __or__(self, other: L[True] | np.bool[L[True]], /) -> np.bool[L[True]]: ... @overload def __or__(self, other: builtins.bool | np.bool, /) -> np.bool: ... @overload def __or__(self, other: _IntegerT, /) -> _IntegerT: ... @overload def __or__(self, other: int, /) -> np.bool | intp: ... __ror__ = __or__ @overload def __lt__(self, other: _NumberLike_co, /) -> bool_: ... @overload def __lt__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsGT], /) -> NDArray[bool_]: ... @overload def __lt__(self, other: _SupportsGT, /) -> bool_: ... @overload def __le__(self, other: _NumberLike_co, /) -> bool_: ... @overload def __le__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsGE], /) -> NDArray[bool_]: ... @overload def __le__(self, other: _SupportsGE, /) -> bool_: ... @overload def __gt__(self, other: _NumberLike_co, /) -> bool_: ... @overload def __gt__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsLT], /) -> NDArray[bool_]: ... @overload def __gt__(self, other: _SupportsLT, /) -> bool_: ... @overload def __ge__(self, other: _NumberLike_co, /) -> bool_: ... @overload def __ge__(self, other: _ArrayLikeNumber_co | _NestedSequence[_SupportsLE], /) -> NDArray[bool_]: ... @overload def __ge__(self, other: _SupportsLE, /) -> bool_: ... # NOTE: This should _not_ be `Final` or a `TypeAlias` bool_ = bool # NOTE: The `object_` constructor returns the passed object, so instances with type # `object_` cannot exists (at runtime). # NOTE: Because mypy has some long-standing bugs related to `__new__`, `object_` can't # be made generic. @final class object_(_RealMixin, generic): @overload def __new__(cls, value: None = None, /) -> None: ... # type: ignore[misc] @overload def __new__(cls, value: _AnyStr, /) -> _AnyStr: ... # type: ignore[misc] @overload def __new__(cls, value: ndarray[_ShapeT, Any], /) -> ndarray[_ShapeT, dtype[Self]]: ... # type: ignore[misc] @overload def __new__(cls, value: SupportsLenAndGetItem[object], /) -> NDArray[Self]: ... # type: ignore[misc] @overload def __new__(cls, value: _T, /) -> _T: ... # type: ignore[misc] @overload # catch-all def __new__(cls, value: Any = ..., /) -> object | NDArray[Self]: ... # type: ignore[misc] def __hash__(self, /) -> int: ... def __abs__(self, /) -> object_: ... # this affects NDArray[object_].__abs__ def __call__(self, /, *args: object, **kwargs: object) -> Any: ... if sys.version_info >= (3, 12): def __release_buffer__(self, buffer: memoryview, /) -> None: ... class integer(_IntegralMixin, _RoundMixin, number[_NBit, int]): @abstractmethod def __new__(cls, value: _ConvertibleToInt = 0, /) -> Self: ... # NOTE: `bit_count` and `__index__` are technically defined in the concrete subtypes def bit_count(self, /) -> int: ... def __index__(self, /) -> int: ... def __invert__(self, /) -> Self: ... @override # type: ignore[override] @overload def __truediv__(self, other: float | integer, /) -> float64: ... @overload def __truediv__(self, other: complex, /) -> complex128: ... @override # type: ignore[override] @overload def __rtruediv__(self, other: float | integer, /) -> float64: ... @overload def __rtruediv__(self, other: complex, /) -> complex128: ... def __floordiv__(self, value: _IntLike_co, /) -> integer: ... def __rfloordiv__(self, value: _IntLike_co, /) -> integer: ... def __mod__(self, value: _IntLike_co, /) -> integer: ... def __rmod__(self, value: _IntLike_co, /) -> integer: ... def __divmod__(self, value: _IntLike_co, /) -> _2Tuple[integer]: ... def __rdivmod__(self, value: _IntLike_co, /) -> _2Tuple[integer]: ... # Ensure that objects annotated as `integer` support bit-wise operations def __lshift__(self, other: _IntLike_co, /) -> integer: ... def __rlshift__(self, other: _IntLike_co, /) -> integer: ... def __rshift__(self, other: _IntLike_co, /) -> integer: ... def __rrshift__(self, other: _IntLike_co, /) -> integer: ... def __and__(self, other: _IntLike_co, /) -> integer: ... def __rand__(self, other: _IntLike_co, /) -> integer: ... def __or__(self, other: _IntLike_co, /) -> integer: ... def __ror__(self, other: _IntLike_co, /) -> integer: ... def __xor__(self, other: _IntLike_co, /) -> integer: ... def __rxor__(self, other: _IntLike_co, /) -> integer: ... class signedinteger(integer[_NBit]): def __new__(cls, value: _ConvertibleToInt = 0, /) -> Self: ... # arithmetic ops @override # type: ignore[override] @overload def __add__(self, other: int | int8 | bool_ | Self, /) -> Self: ... @overload def __add__(self, other: float, /) -> float64: ... @overload def __add__(self, other: complex, /) -> complex128: ... @overload def __add__(self, other: signedinteger, /) -> signedinteger: ... @overload def __add__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __radd__(self, other: int | int8 | bool_, /) -> Self: ... @overload def __radd__(self, other: float, /) -> float64: ... @overload def __radd__(self, other: complex, /) -> complex128: ... @overload def __radd__(self, other: signedinteger, /) -> signedinteger: ... @overload def __radd__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __sub__(self, other: int | int8 | bool_ | Self, /) -> Self: ... @overload def __sub__(self, other: float, /) -> float64: ... @overload def __sub__(self, other: complex, /) -> complex128: ... @overload def __sub__(self, other: signedinteger, /) -> signedinteger: ... @overload def __sub__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __rsub__(self, other: int | int8 | bool_, /) -> Self: ... @overload def __rsub__(self, other: float, /) -> float64: ... @overload def __rsub__(self, other: complex, /) -> complex128: ... @overload def __rsub__(self, other: signedinteger, /) -> signedinteger: ... @overload def __rsub__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __mul__(self, other: int | int8 | bool_ | Self, /) -> Self: ... @overload def __mul__(self, other: float, /) -> float64: ... @overload def __mul__(self, other: complex, /) -> complex128: ... @overload def __mul__(self, other: signedinteger, /) -> signedinteger: ... @overload def __mul__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __rmul__(self, other: int | int8 | bool_, /) -> Self: ... @overload def __rmul__(self, other: float, /) -> float64: ... @overload def __rmul__(self, other: complex, /) -> complex128: ... @overload def __rmul__(self, other: signedinteger, /) -> signedinteger: ... @overload def __rmul__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __pow__(self, other: int | int8 | bool_ | Self, mod: None = None, /) -> Self: ... @overload def __pow__(self, other: float, mod: None = None, /) -> float64: ... @overload def __pow__(self, other: complex, mod: None = None, /) -> complex128: ... @overload def __pow__(self, other: signedinteger, mod: None = None, /) -> signedinteger: ... @overload def __pow__(self, other: integer, mod: None = None, /) -> Incomplete: ... @override # type: ignore[override] @overload def __rpow__(self, other: int | int8 | bool_, mod: None = None, /) -> Self: ... @overload def __rpow__(self, other: float, mod: None = None, /) -> float64: ... @overload def __rpow__(self, other: complex, mod: None = None, /) -> complex128: ... @overload def __rpow__(self, other: signedinteger, mod: None = None, /) -> signedinteger: ... @overload def __rpow__(self, other: integer, mod: None = None, /) -> Incomplete: ... # modular division ops @override # type: ignore[override] @overload def __floordiv__(self, other: int | int8 | bool_ | Self, /) -> Self: ... @overload def __floordiv__(self, other: float, /) -> float64: ... @overload def __floordiv__(self, other: signedinteger, /) -> signedinteger: ... @overload def __floordiv__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __rfloordiv__(self, other: int | int8 | bool_, /) -> Self: ... @overload def __rfloordiv__(self, other: float, /) -> float64: ... @overload def __rfloordiv__(self, other: signedinteger, /) -> signedinteger: ... @overload def __rfloordiv__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __mod__(self, other: int | int8 | bool_ | Self, /) -> Self: ... @overload def __mod__(self, other: float, /) -> float64: ... @overload def __mod__(self, other: signedinteger, /) -> signedinteger: ... @overload def __mod__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __rmod__(self, other: int | int8 | bool_, /) -> Self: ... @overload def __rmod__(self, other: float, /) -> float64: ... @overload def __rmod__(self, other: signedinteger, /) -> signedinteger: ... @overload def __rmod__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __divmod__(self, other: int | int8 | bool_ | Self, /) -> _2Tuple[Self]: ... @overload def __divmod__(self, other: float, /) -> _2Tuple[float64]: ... @overload def __divmod__(self, other: signedinteger, /) -> _2Tuple[signedinteger]: ... @overload def __divmod__(self, other: integer, /) -> _2Tuple[Incomplete]: ... @override # type: ignore[override] @overload def __rdivmod__(self, other: int | int8 | bool_, /) -> _2Tuple[Self]: ... @overload def __rdivmod__(self, other: float, /) -> _2Tuple[float64]: ... @overload def __rdivmod__(self, other: signedinteger, /) -> _2Tuple[signedinteger]: ... @overload def __rdivmod__(self, other: integer, /) -> _2Tuple[Incomplete]: ... # bitwise ops @override # type: ignore[override] @overload def __lshift__(self, other: int | int8 | bool_ | Self, /) -> Self: ... @overload def __lshift__(self, other: integer, /) -> signedinteger: ... @override # type: ignore[override] @overload def __rlshift__(self, other: int | int8 | bool_, /) -> Self: ... @overload def __rlshift__(self, other: integer, /) -> signedinteger: ... @override # type: ignore[override] @overload def __rshift__(self, other: int | int8 | bool_ | Self, /) -> Self: ... @overload def __rshift__(self, other: integer, /) -> signedinteger: ... @override # type: ignore[override] @overload def __rrshift__(self, other: int | int8 | bool_, /) -> Self: ... @overload def __rrshift__(self, other: integer, /) -> signedinteger: ... @override # type: ignore[override] @overload def __and__(self, other: int | int8 | bool_ | Self, /) -> Self: ... @overload def __and__(self, other: integer, /) -> signedinteger: ... @override # type: ignore[override] @overload def __rand__(self, other: int | int8 | bool_, /) -> Self: ... @overload def __rand__(self, other: integer, /) -> signedinteger: ... @override # type: ignore[override] @overload def __xor__(self, other: int | int8 | bool_ | Self, /) -> Self: ... @overload def __xor__(self, other: integer, /) -> signedinteger: ... @override # type: ignore[override] @overload def __rxor__(self, other: int | int8 | bool_, /) -> Self: ... @overload def __rxor__(self, other: integer, /) -> signedinteger: ... @override # type: ignore[override] @overload def __or__(self, other: int | int8 | bool_ | Self, /) -> Self: ... @overload def __or__(self, other: integer, /) -> signedinteger: ... @override # type: ignore[override] @overload def __ror__(self, other: int | int8 | bool_, /) -> Self: ... @overload def __ror__(self, other: integer, /) -> signedinteger: ... 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] class unsignedinteger(integer[_NBit1]): def __new__(cls, value: _ConvertibleToInt = 0, /) -> Self: ... # arithmetic ops @override # type: ignore[override] @overload def __add__(self, other: int | uint8 | bool_ | Self, /) -> Self: ... @overload def __add__(self, other: float, /) -> float64: ... @overload def __add__(self, other: complex, /) -> complex128: ... @overload def __add__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __add__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __radd__(self, other: int | uint8 | bool_, /) -> Self: ... @overload def __radd__(self, other: float, /) -> float64: ... @overload def __radd__(self, other: complex, /) -> complex128: ... @overload def __radd__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __radd__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __sub__(self, other: int | uint8 | bool_ | Self, /) -> Self: ... @overload def __sub__(self, other: float, /) -> float64: ... @overload def __sub__(self, other: complex, /) -> complex128: ... @overload def __sub__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __sub__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __rsub__(self, other: int | uint8 | bool_, /) -> Self: ... @overload def __rsub__(self, other: float, /) -> float64: ... @overload def __rsub__(self, other: complex, /) -> complex128: ... @overload def __rsub__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __rsub__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __mul__(self, other: int | uint8 | bool_ | Self, /) -> Self: ... @overload def __mul__(self, other: float, /) -> float64: ... @overload def __mul__(self, other: complex, /) -> complex128: ... @overload def __mul__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __mul__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __rmul__(self, other: int | uint8 | bool_, /) -> Self: ... @overload def __rmul__(self, other: float, /) -> float64: ... @overload def __rmul__(self, other: complex, /) -> complex128: ... @overload def __rmul__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __rmul__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __pow__(self, other: int | uint8 | bool_ | Self, mod: None = None, /) -> Self: ... @overload def __pow__(self, other: float, mod: None = None, /) -> float64: ... @overload def __pow__(self, other: complex, mod: None = None, /) -> complex128: ... @overload def __pow__(self, other: unsignedinteger, mod: None = None, /) -> unsignedinteger: ... @overload def __pow__(self, other: integer, mod: None = None, /) -> Incomplete: ... @override # type: ignore[override] @overload def __rpow__(self, other: int | uint8 | bool_, mod: None = None, /) -> Self: ... @overload def __rpow__(self, other: float, mod: None = None, /) -> float64: ... @overload def __rpow__(self, other: complex, mod: None = None, /) -> complex128: ... @overload def __rpow__(self, other: unsignedinteger, mod: None = None, /) -> unsignedinteger: ... @overload def __rpow__(self, other: integer, mod: None = None, /) -> Incomplete: ... # modular division ops @override # type: ignore[override] @overload def __floordiv__(self, other: int | uint8 | bool_ | Self, /) -> Self: ... @overload def __floordiv__(self, other: float, /) -> float64: ... @overload def __floordiv__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __floordiv__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __rfloordiv__(self, other: int | uint8 | bool_, /) -> Self: ... @overload def __rfloordiv__(self, other: float, /) -> float64: ... @overload def __rfloordiv__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __rfloordiv__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __mod__(self, other: int | uint8 | bool_ | Self, /) -> Self: ... @overload def __mod__(self, other: float, /) -> float64: ... @overload def __mod__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __mod__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __rmod__(self, other: int | uint8 | bool_, /) -> Self: ... @overload def __rmod__(self, other: float, /) -> float64: ... @overload def __rmod__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __rmod__(self, other: integer, /) -> Incomplete: ... @override # type: ignore[override] @overload def __divmod__(self, other: int | uint8 | bool_ | Self, /) -> _2Tuple[Self]: ... @overload def __divmod__(self, other: float, /) -> _2Tuple[float64]: ... @overload def __divmod__(self, other: unsignedinteger, /) -> _2Tuple[unsignedinteger]: ... @overload def __divmod__(self, other: integer, /) -> _2Tuple[Incomplete]: ... @override # type: ignore[override] @overload def __rdivmod__(self, other: int | uint8 | bool_, /) -> _2Tuple[Self]: ... @overload def __rdivmod__(self, other: float, /) -> _2Tuple[float64]: ... @overload def __rdivmod__(self, other: unsignedinteger, /) -> _2Tuple[unsignedinteger]: ... @overload def __rdivmod__(self, other: integer, /) -> _2Tuple[Incomplete]: ... # bitwise ops @override # type: ignore[override] @overload def __lshift__(self, other: int | int8 | bool_ | Self, /) -> Self: ... @overload def __lshift__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __lshift__(self, other: signedinteger, /) -> signedinteger: ... @override # type: ignore[override] @overload def __rlshift__(self, other: int | int8 | bool_, /) -> Self: ... @overload def __rlshift__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __rlshift__(self, other: signedinteger, /) -> signedinteger: ... @override # type: ignore[override] @overload def __rshift__(self, other: int | int8 | bool_ | Self, /) -> Self: ... @overload def __rshift__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __rshift__(self, other: signedinteger, /) -> signedinteger: ... @override # type: ignore[override] @overload def __rrshift__(self, other: int | int8 | bool_, /) -> Self: ... @overload def __rrshift__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __rrshift__(self, other: signedinteger, /) -> signedinteger: ... @override # type: ignore[override] @overload def __and__(self, other: int | int8 | bool_ | Self, /) -> Self: ... @overload def __and__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __and__(self, other: signedinteger, /) -> signedinteger: ... @override # type: ignore[override] @overload def __rand__(self, other: int | int8 | bool_, /) -> Self: ... @overload def __rand__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __rand__(self, other: signedinteger, /) -> signedinteger: ... @override # type: ignore[override] @overload def __xor__(self, other: int | int8 | bool_ | Self, /) -> Self: ... @overload def __xor__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __xor__(self, other: signedinteger, /) -> signedinteger: ... @override # type: ignore[override] @overload def __rxor__(self, other: int | int8 | bool_, /) -> Self: ... @overload def __rxor__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __rxor__(self, other: signedinteger, /) -> signedinteger: ... @override # type: ignore[override] @overload def __or__(self, other: int | int8 | bool_ | Self, /) -> Self: ... @overload def __or__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __or__(self, other: signedinteger, /) -> signedinteger: ... @override # type: ignore[override] @overload def __ror__(self, other: int | int8 | bool_, /) -> Self: ... @overload def __ror__(self, other: unsignedinteger, /) -> unsignedinteger: ... @overload def __ror__(self, other: signedinteger, /) -> signedinteger: ... 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[_NBit, _InexactItemT_co], Generic[_NBit, _InexactItemT_co]): @abstractmethod def __new__(cls, value: _ConvertibleToFloat | None = 0, /) -> Self: ... class floating(_RealMixin, _RoundMixin, inexact[_NBit1, float]): def __new__(cls, value: _ConvertibleToFloat | None = 0, /) -> Self: ... # arithmetic ops @override # type: ignore[override] @overload def __add__(self, other: int | float16 | uint8 | int8 | bool_ | Self, /) -> Self: ... @overload def __add__(self, other: integer | floating, /) -> floating: ... @overload def __add__(self, other: float, /) -> Self: ... @overload def __add__(self, other: complex, /) -> complexfloating: ... @override # type: ignore[override] @overload def __radd__(self, other: int | float16 | uint8 | int8 | bool_, /) -> Self: ... @overload def __radd__(self, other: integer | floating, /) -> floating: ... @overload def __radd__(self, other: float, /) -> Self: ... @overload def __radd__(self, other: complex, /) -> complexfloating: ... @override # type: ignore[override] @overload def __sub__(self, other: int | float16 | uint8 | int8 | bool_ | Self, /) -> Self: ... @overload def __sub__(self, other: integer | floating, /) -> floating: ... @overload def __sub__(self, other: float, /) -> Self: ... @overload def __sub__(self, other: complex, /) -> complexfloating: ... @override # type: ignore[override] @overload def __rsub__(self, other: int | float16 | uint8 | int8 | bool_, /) -> Self: ... @overload def __rsub__(self, other: integer | floating, /) -> floating: ... @overload def __rsub__(self, other: float, /) -> Self: ... @overload def __rsub__(self, other: complex, /) -> complexfloating: ... @override # type: ignore[override] @overload def __mul__(self, other: int | float16 | uint8 | int8 | bool_ | Self, /) -> Self: ... @overload def __mul__(self, other: integer | floating, /) -> floating: ... @overload def __mul__(self, other: float, /) -> Self: ... @overload def __mul__(self, other: complex, /) -> complexfloating: ... @override # type: ignore[override] @overload def __rmul__(self, other: int | float16 | uint8 | int8 | bool_, /) -> Self: ... @overload def __rmul__(self, other: integer | floating, /) -> floating: ... @overload def __rmul__(self, other: float, /) -> Self: ... @overload def __rmul__(self, other: complex, /) -> complexfloating: ... @override # type: ignore[override] @overload def __pow__(self, other: int | float16 | uint8 | int8 | bool_ | Self, mod: None = None, /) -> Self: ... @overload def __pow__(self, other: integer | floating, mod: None = None, /) -> floating: ... @overload def __pow__(self, other: float, mod: None = None, /) -> Self: ... @overload def __pow__(self, other: complex, mod: None = None, /) -> complexfloating: ... @override # type: ignore[override] @overload def __rpow__(self, other: int | float16 | uint8 | int8 | bool_, mod: None = None, /) -> Self: ... @overload def __rpow__(self, other: integer | floating, mod: None = None, /) -> floating: ... @overload def __rpow__(self, other: float, mod: None = None, /) -> Self: ... @overload def __rpow__(self, other: complex, mod: None = None, /) -> complexfloating: ... @override # type: ignore[override] @overload def __truediv__(self, other: int | float16 | uint8 | int8 | bool_ | Self, /) -> Self: ... @overload def __truediv__(self, other: integer | floating, /) -> floating: ... @overload def __truediv__(self, other: float, /) -> Self: ... @overload def __truediv__(self, other: complex, /) -> complexfloating: ... @override # type: ignore[override] @overload def __rtruediv__(self, other: int | float16 | uint8 | int8 | bool_, /) -> Self: ... @overload def __rtruediv__(self, other: integer | floating, /) -> floating: ... @overload def __rtruediv__(self, other: float, /) -> Self: ... @overload def __rtruediv__(self, other: complex, /) -> complexfloating: ... # modular division ops @overload def __floordiv__(self, other: int | float16 | uint8 | int8 | bool_ | Self, /) -> Self: ... @overload def __floordiv__(self, other: integer | floating, /) -> floating: ... @overload def __floordiv__(self, other: float, /) -> Self: ... @overload def __rfloordiv__(self, other: int | float16 | uint8 | int8 | bool_, /) -> Self: ... @overload def __rfloordiv__(self, other: integer | floating, /) -> floating: ... @overload def __rfloordiv__(self, other: float, /) -> Self: ... @overload def __mod__(self, other: int | float16 | uint8 | int8 | bool_ | Self, /) -> Self: ... @overload def __mod__(self, other: integer | floating, /) -> floating: ... @overload def __mod__(self, other: float, /) -> Self: ... @overload def __rmod__(self, other: int | float16 | uint8 | int8 | bool_, /) -> Self: ... @overload def __rmod__(self, other: integer | floating, /) -> floating: ... @overload def __rmod__(self, other: float, /) -> Self: ... @overload def __divmod__(self, other: int | float16 | uint8 | int8 | bool_ | Self, /) -> _2Tuple[Self]: ... @overload def __divmod__(self, other: integer | floating, /) -> _2Tuple[floating]: ... @overload def __divmod__(self, other: float, /) -> _2Tuple[Self]: ... @overload def __rdivmod__(self, other: int | float16 | uint8 | int8 | bool_, /) -> _2Tuple[Self]: ... @overload def __rdivmod__(self, other: integer | floating, /) -> _2Tuple[floating]: ... @overload def __rdivmod__(self, other: float, /) -> _2Tuple[Self]: ... # NOTE: `is_integer` and `as_integer_ratio` are technically defined in the concrete subtypes def is_integer(self, /) -> builtins.bool: ... def as_integer_ratio(self, /) -> tuple[int, int]: ... float16: TypeAlias = floating[_16Bit] float32: TypeAlias = floating[_32Bit] # either a C `double`, `float`, or `longdouble` class float64(floating[_64Bit], float): # type: ignore[misc] @property def itemsize(self) -> L[8]: ... @property def nbytes(self) -> L[8]: ... # overrides for `floating` and `builtins.float` compatibility (`_RealMixin` doesn't work) @property def real(self) -> Self: ... @property def imag(self) -> Self: ... def conjugate(self) -> Self: ... def __getnewargs__(self, /) -> tuple[float]: ... @classmethod def __getformat__(cls, typestr: L["double", "float"], /) -> str: ... # undocumented # float64-specific operator overrides # NOTE: Mypy reports [misc] errors about "unsafely overlapping signatures" for the # reflected methods. But since they are identical to the non-reflected versions, # these errors appear to be false positives. @overload # type: ignore[override] def __add__(self, other: _Float64_co, /) -> float64: ... @overload def __add__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... @overload def __add__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... @overload def __add__(self, other: complex, /) -> float64 | complex128: ... @overload # type: ignore[override] def __radd__(self, other: _Float64_co, /) -> float64: ... # type: ignore[misc] @overload def __radd__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... # type: ignore[misc] @overload def __radd__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... @overload def __radd__(self, other: complex, /) -> float64 | complex128: ... @overload # type: ignore[override] def __sub__(self, other: _Float64_co, /) -> float64: ... @overload def __sub__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... @overload def __sub__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... @overload def __sub__(self, other: complex, /) -> float64 | complex128: ... @overload # type: ignore[override] def __rsub__(self, other: _Float64_co, /) -> float64: ... # type: ignore[misc] @overload def __rsub__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... # type: ignore[misc] @overload def __rsub__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... @overload def __rsub__(self, other: complex, /) -> float64 | complex128: ... @overload # type: ignore[override] def __mul__(self, other: _Float64_co, /) -> float64: ... @overload def __mul__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... @overload def __mul__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... @overload def __mul__(self, other: complex, /) -> float64 | complex128: ... @overload # type: ignore[override] def __rmul__(self, other: _Float64_co, /) -> float64: ... # type: ignore[misc] @overload def __rmul__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... # type: ignore[misc] @overload def __rmul__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... @overload def __rmul__(self, other: complex, /) -> float64 | complex128: ... @overload # type: ignore[override] def __truediv__(self, other: _Float64_co, /) -> float64: ... @overload def __truediv__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... @overload def __truediv__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... @overload def __truediv__(self, other: complex, /) -> float64 | complex128: ... @overload # type: ignore[override] def __rtruediv__(self, other: _Float64_co, /) -> float64: ... # type: ignore[misc] @overload def __rtruediv__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... # type: ignore[misc] @overload def __rtruediv__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... @overload def __rtruediv__(self, other: complex, /) -> float64 | complex128: ... @overload # type: ignore[override] def __floordiv__(self, other: _Float64_co, /) -> float64: ... @overload def __floordiv__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... @overload def __floordiv__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... @overload def __floordiv__(self, other: complex, /) -> float64 | complex128: ... @overload def __rfloordiv__(self, other: _Float64_co, /) -> float64: ... # type: ignore[misc] @overload def __rfloordiv__(self, other: complexfloating[_64Bit, _64Bit], /) -> complex128: ... @overload def __rfloordiv__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... @overload def __rfloordiv__(self, other: complex, /) -> float64 | complex128: ... @overload # type: ignore[override] def __pow__(self, other: _Float64_co, mod: None = None, /) -> float64: ... @overload def __pow__(self, other: complexfloating[_64Bit, _64Bit], mod: None = None, /) -> complex128: ... @overload def __pow__( self, other: complexfloating[_NBit1, _NBit2], mod: None = None, / ) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... @overload def __pow__(self, other: complex, mod: None = None, /) -> float64 | complex128: ... @overload # type: ignore[override] def __rpow__(self, other: _Float64_co, mod: None = None, /) -> float64: ... # type: ignore[misc] @overload def __rpow__(self, other: complexfloating[_64Bit, _64Bit], mod: None = None, /) -> complex128: ... # type: ignore[misc] @overload def __rpow__( self, other: complexfloating[_NBit1, _NBit2], mod: None = None, / ) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... @overload def __rpow__(self, other: complex, mod: None = None, /) -> float64 | complex128: ... def __mod__(self, other: _Float64_co, /) -> float64: ... def __rmod__(self, other: _Float64_co, /) -> float64: ... # type: ignore[misc] def __divmod__(self, other: _Float64_co, /) -> _2Tuple[float64]: ... def __rdivmod__(self, other: _Float64_co, /) -> _2Tuple[float64]: ... # type: ignore[misc] half: TypeAlias = float16 single: TypeAlias = float32 double: TypeAlias = float64 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, complex], Generic[_NBit1, _NBit2]): @overload def __new__( cls, real: complex | SupportsComplex | SupportsFloat | SupportsIndex = 0, imag: complex | SupportsFloat | SupportsIndex = 0, /, ) -> Self: ... @overload def __new__(cls, real: _ConvertibleToComplex | None = 0, /) -> Self: ... @property def real(self) -> floating[_NBit1]: ... @property def imag(self) -> floating[_NBit2]: ... # NOTE: `__complex__` is technically defined in the concrete subtypes def __complex__(self, /) -> complex: ... def __abs__(self, /) -> floating[_NBit1 | _NBit2]: ... # type: ignore[override] @overload # type: ignore[override] def __add__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... @overload def __add__(self, other: complex | float64 | complex128, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... @overload def __add__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... @overload # type: ignore[override] def __radd__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... @overload def __radd__(self, other: complex, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... @overload def __radd__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... @overload # type: ignore[override] def __sub__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... @overload def __sub__(self, other: complex | float64 | complex128, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... @overload def __sub__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... @overload # type: ignore[override] def __rsub__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... @overload def __rsub__(self, other: complex, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... @overload def __rsub__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... @overload # type: ignore[override] def __mul__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... @overload def __mul__(self, other: complex | float64 | complex128, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... @overload def __mul__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... @overload # type: ignore[override] def __rmul__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... @overload def __rmul__(self, other: complex, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... @overload def __rmul__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... @overload # type: ignore[override] def __truediv__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... @overload def __truediv__(self, other: complex | float64 | complex128, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... @overload def __truediv__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... @overload # type: ignore[override] def __rtruediv__(self, other: _Complex64_co, /) -> complexfloating[_NBit1, _NBit2]: ... @overload def __rtruediv__(self, other: complex, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... @overload def __rtruediv__(self, other: number[_NBit], /) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... @overload # type: ignore[override] def __pow__(self, other: _Complex64_co, mod: None = None, /) -> complexfloating[_NBit1, _NBit2]: ... @overload def __pow__( self, other: complex | float64 | complex128, mod: None = None, / ) -> complexfloating[_NBit1, _NBit2] | complex128: ... @overload def __pow__( self, other: number[_NBit], mod: None = None, / ) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... @overload # type: ignore[override] def __rpow__(self, other: _Complex64_co, mod: None = None, /) -> complexfloating[_NBit1, _NBit2]: ... @overload def __rpow__(self, other: complex, mod: None = None, /) -> complexfloating[_NBit1, _NBit2] | complex128: ... @overload def __rpow__( self, other: number[_NBit], mod: None = None, / ) -> complexfloating[_NBit1, _NBit2] | complexfloating[_NBit, _NBit]: ... complex64: TypeAlias = complexfloating[_32Bit] class complex128(complexfloating[_64Bit, _64Bit], complex): @property def itemsize(self) -> L[16]: ... @property def nbytes(self) -> L[16]: ... # overrides for `floating` and `builtins.float` compatibility @property def real(self) -> float64: ... @property def imag(self) -> float64: ... def conjugate(self) -> Self: ... def __abs__(self) -> float64: ... # type: ignore[override] def __getnewargs__(self, /) -> tuple[float, float]: ... # complex128-specific operator overrides @overload # type: ignore[override] def __add__(self, other: _Complex128_co, /) -> complex128: ... @overload def __add__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... def __radd__(self, other: _Complex128_co, /) -> complex128: ... # type: ignore[override] @overload # type: ignore[override] def __sub__(self, other: _Complex128_co, /) -> complex128: ... @overload def __sub__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... def __rsub__(self, other: _Complex128_co, /) -> complex128: ... # type: ignore[override] @overload # type: ignore[override] def __mul__(self, other: _Complex128_co, /) -> complex128: ... @overload def __mul__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... def __rmul__(self, other: _Complex128_co, /) -> complex128: ... # type: ignore[override] @overload # type: ignore[override] def __truediv__(self, other: _Complex128_co, /) -> complex128: ... @overload def __truediv__(self, other: complexfloating[_NBit1, _NBit2], /) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... def __rtruediv__(self, other: _Complex128_co, /) -> complex128: ... # type: ignore[override] @overload # type: ignore[override] def __pow__(self, other: _Complex128_co, mod: None = None, /) -> complex128: ... @overload def __pow__( self, other: complexfloating[_NBit1, _NBit2], mod: None = None, / ) -> complexfloating[_NBit1 | _64Bit, _NBit2 | _64Bit]: ... def __rpow__(self, other: _Complex128_co, mod: None = None, /) -> complex128: ... # type: ignore[override] csingle: TypeAlias = complex64 cdouble: TypeAlias = complex128 clongdouble: TypeAlias = complexfloating[_NBitLongDouble] class timedelta64(_IntegralMixin, generic[_TD64ItemT_co], Generic[_TD64ItemT_co]): @property def itemsize(self) -> L[8]: ... @property def nbytes(self) -> L[8]: ... @overload def __new__(cls, value: _TD64ItemT_co | timedelta64[_TD64ItemT_co], /) -> Self: ... @overload def __new__(cls, /) -> timedelta64[L[0]]: ... @overload def __new__(cls, value: _NaTValue | None, format: _TimeUnitSpec, /) -> timedelta64[None]: ... @overload def __new__(cls, value: L[0], format: _TimeUnitSpec[_IntTD64Unit] = ..., /) -> timedelta64[L[0]]: ... @overload def __new__(cls, value: _IntLike_co, format: _TimeUnitSpec[_IntTD64Unit] = ..., /) -> timedelta64[int]: ... @overload def __new__(cls, value: dt.timedelta, format: _TimeUnitSpec[_IntTimeUnit], /) -> timedelta64[int]: ... @overload def __new__( cls, value: dt.timedelta | _IntLike_co, format: _TimeUnitSpec[_NativeTD64Unit] = ..., /, ) -> timedelta64[dt.timedelta]: ... @overload def __new__(cls, value: _ConvertibleToTD64, format: _TimeUnitSpec = ..., /) -> Self: ... # inherited at runtime from `signedinteger` def __class_getitem__(cls, type_arg: type | object, /) -> GenericAlias: ... # NOTE: Only a limited number of units support conversion # to builtin scalar types: `Y`, `M`, `ns`, `ps`, `fs`, `as` def __int__(self: timedelta64[int], /) -> int: ... def __float__(self: timedelta64[int], /) -> float: ... def __neg__(self, /) -> Self: ... def __pos__(self, /) -> Self: ... def __abs__(self, /) -> Self: ... @overload def __add__(self: timedelta64[None], x: _TD64Like_co, /) -> timedelta64[None]: ... @overload def __add__(self: timedelta64[int], x: timedelta64[int | dt.timedelta], /) -> timedelta64[int]: ... @overload def __add__(self: timedelta64[int], x: timedelta64, /) -> timedelta64[int | None]: ... @overload def __add__(self: timedelta64[dt.timedelta], x: _AnyDateOrTime, /) -> _AnyDateOrTime: ... @overload def __add__(self: timedelta64[_AnyTD64Item], x: timedelta64[_AnyTD64Item] | _IntLike_co, /) -> timedelta64[_AnyTD64Item]: ... @overload def __add__(self, x: timedelta64[None], /) -> timedelta64[None]: ... # type: ignore[overload-cannot-match] __radd__ = __add__ @overload def __mul__(self: timedelta64[_AnyTD64Item], x: int | np.integer | np.bool, /) -> timedelta64[_AnyTD64Item]: ... @overload def __mul__(self: timedelta64[_AnyTD64Item], x: float | np.floating, /) -> timedelta64[_AnyTD64Item | None]: ... @overload def __mul__(self, x: float | np.floating | np.integer | np.bool, /) -> timedelta64: ... __rmul__ = __mul__ @overload def __mod__(self, x: timedelta64[L[0] | None], /) -> timedelta64[None]: ... @overload def __mod__(self: timedelta64[None], x: timedelta64, /) -> timedelta64[None]: ... @overload def __mod__(self: timedelta64[int], x: timedelta64[int | dt.timedelta], /) -> timedelta64[int | None]: ... @overload def __mod__(self: timedelta64[dt.timedelta], x: timedelta64[_AnyTD64Item], /) -> timedelta64[_AnyTD64Item | None]: ... @overload def __mod__(self: timedelta64[dt.timedelta], x: dt.timedelta, /) -> dt.timedelta: ... @overload def __mod__(self, x: timedelta64[int], /) -> timedelta64[int | None]: ... @overload def __mod__(self, x: timedelta64, /) -> timedelta64: ... # NOTE: The L[0] makes __mod__ non-commutative, which the first two overloads # reflect. However, mypy does not seem to like this, so we ignore the errors. @overload def __rmod__(self, x: timedelta64[None], /) -> timedelta64[None]: ... # type: ignore[misc] @overload def __rmod__(self: timedelta64[L[0] | None], x: timedelta64, /) -> timedelta64[None]: ... @overload def __rmod__(self: timedelta64[int], x: timedelta64[int | dt.timedelta], /) -> timedelta64[int | None]: ... # type: ignore[misc] @overload def __rmod__(self: timedelta64[dt.timedelta], x: timedelta64[_AnyTD64Item], /) -> timedelta64[_AnyTD64Item | None]: ... # type: ignore[misc] @overload def __rmod__(self: timedelta64[dt.timedelta], x: dt.timedelta, /) -> dt.timedelta: ... @overload def __rmod__(self, x: timedelta64[int], /) -> timedelta64[int | None]: ... # type: ignore[misc] @overload def __rmod__(self, x: timedelta64, /) -> timedelta64: ... # type: ignore[misc] # keep in sync with __mod__ @overload def __divmod__(self, x: timedelta64[L[0] | None], /) -> tuple[int64, timedelta64[None]]: ... @overload def __divmod__(self: timedelta64[None], x: timedelta64, /) -> tuple[int64, timedelta64[None]]: ... @overload def __divmod__(self: timedelta64[int], x: timedelta64[int | dt.timedelta], /) -> tuple[int64, timedelta64[int | None]]: ... @overload def __divmod__( self: timedelta64[dt.timedelta], x: timedelta64[_AnyTD64Item], / ) -> tuple[int64, timedelta64[_AnyTD64Item | None]]: ... @overload def __divmod__(self: timedelta64[dt.timedelta], x: dt.timedelta, /) -> tuple[int, dt.timedelta]: ... @overload def __divmod__(self, x: timedelta64[int], /) -> tuple[int64, timedelta64[int | None]]: ... @overload def __divmod__(self, x: timedelta64, /) -> tuple[int64, timedelta64]: ... # keep in sync with __rmod__ @overload def __rdivmod__(self, x: timedelta64[None], /) -> tuple[int64, timedelta64[None]]: ... # type: ignore[misc] @overload def __rdivmod__(self: timedelta64[L[0] | None], x: timedelta64, /) -> tuple[int64, timedelta64[None]]: ... # type: ignore[misc] @overload def __rdivmod__(self: timedelta64[int], x: timedelta64[int | dt.timedelta], /) -> tuple[int64, timedelta64[int | None]]: ... # type: ignore[misc] @overload def __rdivmod__( # type: ignore[misc] self: timedelta64[dt.timedelta], x: timedelta64[_AnyTD64Item], / ) -> tuple[int64, timedelta64[_AnyTD64Item | None]]: ... @overload def __rdivmod__(self: timedelta64[dt.timedelta], x: dt.timedelta, /) -> tuple[int, dt.timedelta]: ... @overload def __rdivmod__(self, x: timedelta64[int], /) -> tuple[int64, timedelta64[int | None]]: ... # type: ignore[misc] @overload def __rdivmod__(self, x: timedelta64, /) -> tuple[int64, timedelta64]: ... # type: ignore[misc] @overload def __sub__(self: timedelta64[None], b: _TD64Like_co, /) -> timedelta64[None]: ... @overload def __sub__(self: timedelta64[int], b: timedelta64[int | dt.timedelta], /) -> timedelta64[int]: ... @overload def __sub__(self: timedelta64[int], b: timedelta64, /) -> timedelta64[int | None]: ... @overload def __sub__(self: timedelta64[dt.timedelta], b: dt.timedelta, /) -> dt.timedelta: ... @overload def __sub__(self: timedelta64[_AnyTD64Item], b: timedelta64[_AnyTD64Item] | _IntLike_co, /) -> timedelta64[_AnyTD64Item]: ... @overload def __sub__(self, b: timedelta64[None], /) -> timedelta64[None]: ... # type: ignore[overload-cannot-match] # NOTE: subtraction is not commutative, so __rsub__ differs from __sub__. # This confuses mypy, so we ignore the [misc] errors it reports. @overload def __rsub__(self: timedelta64[None], a: _TD64Like_co, /) -> timedelta64[None]: ... @overload def __rsub__(self: timedelta64[dt.timedelta], a: _AnyDateOrTime, /) -> _AnyDateOrTime: ... @overload def __rsub__(self: timedelta64[dt.timedelta], a: timedelta64[_AnyTD64Item], /) -> timedelta64[_AnyTD64Item]: ... # type: ignore[misc] @overload def __rsub__(self: timedelta64[_AnyTD64Item], a: timedelta64[_AnyTD64Item] | _IntLike_co, /) -> timedelta64[_AnyTD64Item]: ... # type: ignore[misc] @overload def __rsub__(self, a: timedelta64[None], /) -> timedelta64[None]: ... # type: ignore[overload-cannot-match] @overload def __rsub__(self, a: datetime64[None], /) -> datetime64[None]: ... # type: ignore[misc] @overload def __truediv__(self: timedelta64[dt.timedelta], b: dt.timedelta, /) -> float: ... @overload def __truediv__(self, b: timedelta64, /) -> float64: ... @overload def __truediv__(self: timedelta64[_AnyTD64Item], b: int | integer, /) -> timedelta64[_AnyTD64Item]: ... @overload def __truediv__(self: timedelta64[_AnyTD64Item], b: float | floating, /) -> timedelta64[_AnyTD64Item | None]: ... @overload def __truediv__(self, b: float | floating | integer, /) -> timedelta64: ... @overload def __rtruediv__(self: timedelta64[dt.timedelta], a: dt.timedelta, /) -> float: ... @overload def __rtruediv__(self, a: timedelta64, /) -> float64: ... @overload def __floordiv__(self: timedelta64[dt.timedelta], b: dt.timedelta, /) -> int: ... @overload def __floordiv__(self, b: timedelta64, /) -> int64: ... @overload def __floordiv__(self: timedelta64[_AnyTD64Item], b: int | integer, /) -> timedelta64[_AnyTD64Item]: ... @overload def __floordiv__(self: timedelta64[_AnyTD64Item], b: float | floating, /) -> timedelta64[_AnyTD64Item | None]: ... @overload def __rfloordiv__(self: timedelta64[dt.timedelta], a: dt.timedelta, /) -> int: ... @overload def __rfloordiv__(self, a: timedelta64, /) -> int64: ... # comparison ops @overload def __lt__(self, other: _TD64Like_co, /) -> bool_: ... @overload def __lt__(self, other: _ArrayLikeTD64_co | _NestedSequence[_SupportsGT], /) -> NDArray[bool_]: ... @overload def __lt__(self, other: _SupportsGT, /) -> bool_: ... @overload def __le__(self, other: _TD64Like_co, /) -> bool_: ... @overload def __le__(self, other: _ArrayLikeTD64_co | _NestedSequence[_SupportsGE], /) -> NDArray[bool_]: ... @overload def __le__(self, other: _SupportsGT, /) -> bool_: ... @overload def __gt__(self, other: _TD64Like_co, /) -> bool_: ... @overload def __gt__(self, other: _ArrayLikeTD64_co | _NestedSequence[_SupportsLT], /) -> NDArray[bool_]: ... @overload def __gt__(self, other: _SupportsGT, /) -> bool_: ... @overload def __ge__(self, other: _TD64Like_co, /) -> bool_: ... @overload def __ge__(self, other: _ArrayLikeTD64_co | _NestedSequence[_SupportsLE], /) -> NDArray[bool_]: ... @overload def __ge__(self, other: _SupportsGT, /) -> bool_: ... class datetime64(_RealMixin, generic[_DT64ItemT_co], Generic[_DT64ItemT_co]): @property def itemsize(self) -> L[8]: ... @property def nbytes(self) -> L[8]: ... @overload def __new__(cls, value: datetime64[_DT64ItemT_co], /) -> Self: ... @overload def __new__(cls, value: _AnyDT64Arg, /) -> datetime64[_AnyDT64Arg]: ... @overload def __new__(cls, value: _NaTValue | None = ..., format: _TimeUnitSpec = ..., /) -> datetime64[None]: ... @overload def __new__(cls, value: _DT64Now, format: _TimeUnitSpec[_NativeTimeUnit] = ..., /) -> datetime64[dt.datetime]: ... @overload def __new__(cls, value: _DT64Date, format: _TimeUnitSpec[_DateUnit] = ..., /) -> datetime64[dt.date]: ... @overload def __new__(cls, value: int | bytes | str | dt.date, format: _TimeUnitSpec[_IntTimeUnit], /) -> datetime64[int]: ... @overload def __new__( cls, value: int | bytes | str | dt.date, format: _TimeUnitSpec[_NativeTimeUnit], / ) -> datetime64[dt.datetime]: ... @overload def __new__(cls, value: int | bytes | str | dt.date, format: _TimeUnitSpec[_DateUnit], /) -> datetime64[dt.date]: ... @overload def __new__(cls, value: bytes | str | dt.date | None, format: _TimeUnitSpec = ..., /) -> Self: ... def __class_getitem__(cls, type_arg: type | object, /) -> GenericAlias: ... @overload def __add__(self: datetime64[_AnyDT64Item], x: int | integer | np.bool, /) -> datetime64[_AnyDT64Item]: ... @overload def __add__(self: datetime64[None], x: _TD64Like_co, /) -> datetime64[None]: ... @overload def __add__(self: datetime64[int], x: timedelta64[int | dt.timedelta], /) -> datetime64[int]: ... @overload def __add__(self: datetime64[dt.datetime], x: timedelta64[dt.timedelta], /) -> datetime64[dt.datetime]: ... @overload def __add__(self: datetime64[dt.date], x: timedelta64[dt.timedelta], /) -> datetime64[dt.date]: ... @overload def __add__(self: datetime64[dt.date], x: timedelta64[int], /) -> datetime64[int]: ... @overload def __add__(self, x: datetime64[None], /) -> datetime64[None]: ... @overload def __add__(self, x: _TD64Like_co, /) -> datetime64: ... __radd__ = __add__ @overload def __sub__(self: datetime64[_AnyDT64Item], x: int | integer | np.bool, /) -> datetime64[_AnyDT64Item]: ... @overload def __sub__(self: datetime64[_AnyDate], x: _AnyDate, /) -> dt.timedelta: ... @overload def __sub__(self: datetime64[None], x: timedelta64, /) -> datetime64[None]: ... @overload def __sub__(self: datetime64[None], x: datetime64, /) -> timedelta64[None]: ... @overload def __sub__(self: datetime64[int], x: timedelta64, /) -> datetime64[int]: ... @overload def __sub__(self: datetime64[int], x: datetime64, /) -> timedelta64[int]: ... @overload def __sub__(self: datetime64[dt.datetime], x: timedelta64[int], /) -> datetime64[int]: ... @overload def __sub__(self: datetime64[dt.datetime], x: timedelta64[dt.timedelta], /) -> datetime64[dt.datetime]: ... @overload def __sub__(self: datetime64[dt.datetime], x: datetime64[int], /) -> timedelta64[int]: ... @overload def __sub__(self: datetime64[dt.date], x: timedelta64[int], /) -> datetime64[dt.date | int]: ... @overload def __sub__(self: datetime64[dt.date], x: timedelta64[dt.timedelta], /) -> datetime64[dt.date]: ... @overload def __sub__(self: datetime64[dt.date], x: datetime64[dt.date], /) -> timedelta64[dt.timedelta]: ... @overload def __sub__(self, x: timedelta64[None], /) -> datetime64[None]: ... @overload def __sub__(self, x: datetime64[None], /) -> timedelta64[None]: ... @overload def __sub__(self, x: _TD64Like_co, /) -> datetime64: ... @overload def __sub__(self, x: datetime64, /) -> timedelta64: ... # NOTE: mypy gets confused by the non-commutativity of subtraction here @overload def __rsub__(self: datetime64[_AnyDT64Item], x: int | integer | np.bool, /) -> datetime64[_AnyDT64Item]: ... @overload def __rsub__(self: datetime64[_AnyDate], x: _AnyDate, /) -> dt.timedelta: ... @overload def __rsub__(self: datetime64[None], x: datetime64, /) -> timedelta64[None]: ... @overload def __rsub__(self: datetime64[int], x: datetime64, /) -> timedelta64[int]: ... @overload def __rsub__(self: datetime64[dt.datetime], x: datetime64[int], /) -> timedelta64[int]: ... # type: ignore[misc] @overload def __rsub__(self: datetime64[dt.datetime], x: datetime64[dt.date], /) -> timedelta64[dt.timedelta]: ... # type: ignore[misc] @overload def __rsub__(self, x: datetime64[None], /) -> timedelta64[None]: ... # type: ignore[misc] @overload def __rsub__(self, x: datetime64, /) -> timedelta64: ... # type: ignore[misc] @overload def __lt__(self, other: datetime64, /) -> bool_: ... @overload def __lt__(self, other: _ArrayLikeDT64_co | _NestedSequence[_SupportsGT], /) -> NDArray[bool_]: ... @overload def __lt__(self, other: _SupportsGT, /) -> bool_: ... @overload def __le__(self, other: datetime64, /) -> bool_: ... @overload def __le__(self, other: _ArrayLikeDT64_co | _NestedSequence[_SupportsGE], /) -> NDArray[bool_]: ... @overload def __le__(self, other: _SupportsGT, /) -> bool_: ... @overload def __gt__(self, other: datetime64, /) -> bool_: ... @overload def __gt__(self, other: _ArrayLikeDT64_co | _NestedSequence[_SupportsLT], /) -> NDArray[bool_]: ... @overload def __gt__(self, other: _SupportsGT, /) -> bool_: ... @overload def __ge__(self, other: datetime64, /) -> bool_: ... @overload def __ge__(self, other: _ArrayLikeDT64_co | _NestedSequence[_SupportsLE], /) -> NDArray[bool_]: ... @overload def __ge__(self, other: _SupportsGT, /) -> bool_: ... @final # cannot be subclassed at runtime class flexible(_RealMixin, generic[_FlexibleItemT_co], Generic[_FlexibleItemT_co]): ... # type: ignore[misc] class void(flexible[bytes | tuple[Any, ...]]): # type: ignore[misc] @overload def __new__(cls, length_or_data: _IntLike_co | bytes, /, dtype: None = None) -> Self: ... @overload def __new__(cls, length_or_data: object, /, dtype: _DTypeLikeVoid) -> Self: ... @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: ... def setfield(self, val: ArrayLike, dtype: DTypeLike, offset: int = ...) -> None: ... class character(flexible[_CharacterItemT_co], Generic[_CharacterItemT_co]): # type: ignore[misc] @abstractmethod def __new__(cls, value: object = ..., /) -> Self: ... # NOTE: Most `np.bytes_` / `np.str_` methods return their builtin `bytes` / `str` counterpart class bytes_(character[bytes], bytes): # type: ignore[misc] @overload def __new__(cls, value: object = b"", /) -> Self: ... @overload def __new__(cls, value: str, /, encoding: str, errors: str = "strict") -> Self: ... # @override def __hash__(self, /) -> int: ... # def __bytes__(self, /) -> bytes: ... class str_(character[str], str): # type: ignore[misc] @overload def __new__(cls, value: object = "", /) -> Self: ... @overload def __new__(cls, value: bytes, /, encoding: str, errors: str = "strict") -> Self: ... # @override def __hash__(self, /) -> int: ... # See `numpy._typing._ufunc` for more concrete nin-/nout-specific stubs @final class ufunc: __signature__: Final[inspect.Signature] @property def __name__(self) -> LiteralString: ... @property def __qualname__(self) -> LiteralString: ... # pyright: ignore[reportIncompatibleVariableOverride] @property def __doc__(self) -> str: ... # type: ignore[override] @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) -> LiteralString | None: ... 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 accumulate( self, array: ArrayLike, /, axis: SupportsIndex = 0, dtype: DTypeLike | None = None, out: ndarray | EllipsisType | None = None, ) -> NDArray[Incomplete]: ... def reduce( self, array: ArrayLike, /, axis: _ShapeLike | None = 0, dtype: DTypeLike | None = None, out: ndarray | EllipsisType | None = None, **kwargs: Incomplete, ) -> Incomplete: ... def reduceat( self, array: ArrayLike, /, indices: _ArrayLikeInt_co, axis: SupportsIndex = 0, dtype: DTypeLike | None = None, out: ndarray | EllipsisType | None = None, ) -> NDArray[Incomplete]: ... def outer(self, A: ArrayLike, B: ArrayLike, /, **kwargs: Incomplete) -> NDArray[Incomplete]: ... # Similarly `at` won't be defined for ufuncs that return multiple # outputs, so we can't type it very precisely. def at(self, a: ndarray, indices: _ArrayLikeInt_co, b: ArrayLike | None = None, /) -> None: ... # def resolve_dtypes( self, /, dtypes: tuple[dtype | type | None, ...], *, signature: tuple[dtype | None, ...] | None = None, casting: _CastingKind | None = None, reduction: builtins.bool = False, ) -> tuple[dtype, ...]: ... # 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_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] 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["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?)"]] matvec: _GUFunc_Nin2_Nout1[L["matvec"], L[19], None, L["(m,n),(n)->(m)"]] maximum: _UFunc_Nin2_Nout1[L["maximum"], L[21], None] minimum: _UFunc_Nin2_Nout1[L["minimum"], L[21], 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] trunc: _UFunc_Nin1_Nout1[L["trunc"], L[7], None] vecdot: _GUFunc_Nin2_Nout1[L["vecdot"], L[19], None, L["(n),(n)->()"]] vecmat: _GUFunc_Nin2_Nout1[L["vecmat"], L[19], None, L["(n),(n,m)->(m)"]] abs = absolute acos = arccos acosh = arccosh asin = arcsin asinh = arcsinh atan = arctan atanh = arctanh atan2 = arctan2 concat = concatenate bitwise_left_shift = left_shift bitwise_not = invert bitwise_invert = invert bitwise_right_shift = right_shift conj = conjugate mod = remainder permute_dims = transpose pow = power true_divide = divide # 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) -> _AnyShape: ... @property def size(self) -> int: ... def __next__(self) -> tuple[Any, ...]: ... def __iter__(self) -> Self: ... def reset(self) -> None: ... @final class busdaycalendar: def __init__( self, /, weekmask: str | Sequence[int | bool_ | integer] | _SupportsArray[dtype[bool_ | integer]] = "1111100", holidays: Sequence[dt.date | datetime64] | _SupportsArray[dtype[datetime64]] | None = None, ) -> None: ... @property def weekmask(self) -> ndarray[tuple[int], dtype[bool_]]: ... @property def holidays(self) -> ndarray[tuple[int], dtype[datetime64[dt.date]]]: ... @final class nditer: @overload def __init__( self, /, op: ArrayLike, flags: Sequence[_NDIterFlagsKind] | None = None, op_flags: Sequence[_NDIterFlagsOp] | None = None, op_dtypes: DTypeLike | None = None, order: _OrderKACF = "K", casting: _CastingKind = "safe", op_axes: Sequence[SupportsIndex] | None = None, itershape: _ShapeLike | None = None, buffersize: SupportsIndex = 0, ) -> None: ... @overload def __init__( self, /, op: Sequence[ArrayLike | None], flags: Sequence[_NDIterFlagsKind] | None = None, op_flags: Sequence[Sequence[_NDIterFlagsOp]] | None = None, op_dtypes: Sequence[DTypeLike | None] | None = None, order: _OrderKACF = "K", casting: _CastingKind = "safe", op_axes: Sequence[Sequence[SupportsIndex]] | None = None, itershape: _ShapeLike | None = None, buffersize: SupportsIndex = 0, ) -> None: ... def __enter__(self) -> nditer: ... def __exit__( self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, ) -> 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, ...]: ... @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], ...]: ... class memmap(ndarray[_ShapeT_co, _DTypeT_co]): __array_priority__: ClassVar[float] filename: str | None offset: int mode: str @overload def __new__( subtype, filename: StrOrBytesPath | _SupportsFileMethodsRW, dtype: type[uint8] = ..., mode: _MemMapModeKind = "r+", offset: int = 0, shape: int | tuple[int, ...] | None = None, order: _OrderKACF = "C", ) -> memmap[Any, dtype[uint8]]: ... @overload def __new__( subtype, filename: StrOrBytesPath | _SupportsFileMethodsRW, dtype: _DTypeLike[_ScalarT], mode: _MemMapModeKind = "r+", offset: int = 0, shape: int | tuple[int, ...] | None = None, order: _OrderKACF = "C", ) -> memmap[Any, dtype[_ScalarT]]: ... @overload def __new__( subtype, filename: StrOrBytesPath | _SupportsFileMethodsRW, dtype: DTypeLike, mode: _MemMapModeKind = "r+", offset: int = 0, shape: int | tuple[int, ...] | None = None, order: _OrderKACF = "C", ) -> memmap[Any, dtype]: ... def __array_finalize__(self, obj: object) -> None: ... def __array_wrap__( self, array: memmap[_ShapeT_co, _DTypeT_co], # type: ignore[override] context: tuple[ufunc, tuple[Any, ...], int] | None = None, return_scalar: builtins.bool = False, ) -> Any: ... def flush(self) -> None: ... 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[assignment] # pyright: ignore[reportIncompatibleMethodOverride] @overload def __array__(self, /, t: None = None, copy: builtins.bool | None = None) -> ndarray[tuple[int], dtype]: ... @overload def __array__(self, /, t: _DTypeT, copy: builtins.bool | None = None) -> ndarray[tuple[int], _DTypeT]: ... @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 = False, variable: str | None = None, ) -> 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 __truediv__(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 = 1) -> poly1d: ... def integ( self, m: SupportsInt | SupportsIndex = 1, k: _ArrayLikeComplex_co | _ArrayLikeObject_co | None = 0, ) -> poly1d: ... def from_dlpack( x: _SupportsDLPack[None], /, *, device: L["cpu"] | None = None, copy: builtins.bool | None = None, ) -> NDArray[number | np.bool]: ...