Projekt_AI-Automatyczny_saper/venv/Lib/site-packages/numpy/__init__.pyi
2021-05-18 00:21:14 +02:00

2261 lines
59 KiB
Python

import builtins
import sys
import datetime as dt
from abc import abstractmethod
from types import TracebackType
from contextlib import ContextDecorator
from numpy.core._internal import _ctypes
from numpy.typing import (
ArrayLike,
DTypeLike,
_Shape,
_ShapeLike,
_CharLike,
_BoolLike,
_IntLike,
_FloatLike,
_ComplexLike,
_NumberLike,
_SupportsDType,
_VoidDTypeLike,
NBitBase,
_64Bit,
_32Bit,
_16Bit,
_8Bit,
)
from numpy.typing._callable import (
_BoolOp,
_BoolBitOp,
_BoolSub,
_BoolTrueDiv,
_BoolMod,
_BoolDivMod,
_TD64Div,
_IntTrueDiv,
_UnsignedIntOp,
_UnsignedIntBitOp,
_UnsignedIntMod,
_UnsignedIntDivMod,
_SignedIntOp,
_SignedIntBitOp,
_SignedIntMod,
_SignedIntDivMod,
_FloatOp,
_FloatMod,
_FloatDivMod,
_ComplexOp,
_NumberOp,
)
from typing import (
Any,
ByteString,
Callable,
Container,
Callable,
Dict,
Generic,
IO,
Iterable,
List,
Mapping,
Optional,
overload,
Sequence,
Sized,
SupportsComplex,
SupportsFloat,
SupportsInt,
Text,
Tuple,
Type,
TypeVar,
Union,
)
if sys.version_info >= (3, 8):
from typing import Literal, Protocol, SupportsIndex, Final
else:
from typing_extensions import Literal, Protocol, Final
class SupportsIndex(Protocol):
def __index__(self) -> int: ...
# Ensures that the stubs are picked up
from numpy import (
char as char,
ctypeslib as ctypeslib,
emath as emath,
fft as fft,
lib as lib,
linalg as linalg,
ma as ma,
matrixlib as matrixlib,
polynomial as polynomial,
random as random,
rec as rec,
testing as testing,
version as version,
)
from numpy.core.function_base import (
linspace as linspace,
logspace as logspace,
geomspace as geomspace,
)
from numpy.core.fromnumeric import (
take as take,
reshape as reshape,
choose as choose,
repeat as repeat,
put as put,
swapaxes as swapaxes,
transpose as transpose,
partition as partition,
argpartition as argpartition,
sort as sort,
argsort as argsort,
argmax as argmax,
argmin as argmin,
searchsorted as searchsorted,
resize as resize,
squeeze as squeeze,
diagonal as diagonal,
trace as trace,
ravel as ravel,
nonzero as nonzero,
shape as shape,
compress as compress,
clip as clip,
sum as sum,
all as all,
any as any,
cumsum as cumsum,
ptp as ptp,
amax as amax,
amin as amin,
prod as prod,
cumprod as cumprod,
ndim as ndim,
size as size,
around as around,
mean as mean,
std as std,
var as var,
)
from numpy.core._asarray import (
asarray as asarray,
asanyarray as asanyarray,
ascontiguousarray as ascontiguousarray,
asfortranarray as asfortranarray,
require as require,
)
from numpy.core._type_aliases import (
sctypes as sctypes,
sctypeDict as sctypeDict,
)
from numpy.core._ufunc_config import (
seterr as seterr,
geterr as geterr,
setbufsize as setbufsize,
getbufsize as getbufsize,
seterrcall as seterrcall,
geterrcall as geterrcall,
_SupportsWrite,
_ErrKind,
_ErrFunc,
_ErrDictOptional,
)
from numpy.core.numeric import (
zeros_like as zeros_like,
ones as ones,
ones_like as ones_like,
empty_like as empty_like,
full as full,
full_like as full_like,
count_nonzero as count_nonzero,
isfortran as isfortran,
argwhere as argwhere,
flatnonzero as flatnonzero,
correlate as correlate,
convolve as convolve,
outer as outer,
tensordot as tensordot,
roll as roll,
rollaxis as rollaxis,
moveaxis as moveaxis,
cross as cross,
indices as indices,
fromfunction as fromfunction,
isscalar as isscalar,
binary_repr as binary_repr,
base_repr as base_repr,
identity as identity,
allclose as allclose,
isclose as isclose,
array_equal as array_equal,
array_equiv as array_equiv,
)
from numpy.core.numerictypes import (
maximum_sctype as maximum_sctype,
issctype as issctype,
obj2sctype as obj2sctype,
issubclass_ as issubclass_,
issubsctype as issubsctype,
issubdtype as issubdtype,
sctype2char as sctype2char,
find_common_type as find_common_type,
)
from numpy.core.shape_base import (
atleast_1d as atleast_1d,
atleast_2d as atleast_2d,
atleast_3d as atleast_3d,
block as block,
hstack as hstack,
stack as stack,
vstack as vstack,
)
__all__: List[str]
__path__: List[str]
__version__: str
DataSource: Any
MachAr: Any
ScalarType: Any
angle: Any
append: Any
apply_along_axis: Any
apply_over_axes: Any
arange: Any
array2string: Any
array_repr: Any
array_split: Any
array_str: Any
asarray_chkfinite: Any
asfarray: Any
asmatrix: Any
asscalar: Any
average: Any
bartlett: Any
bincount: Any
bitwise_not: Any
blackman: Any
bmat: Any
bool8: Any
broadcast: Any
broadcast_arrays: Any
broadcast_to: Any
busday_count: Any
busday_offset: Any
busdaycalendar: Any
byte: Any
byte_bounds: Any
bytes0: Any
c_: Any
can_cast: Any
cast: Any
cdouble: Any
cfloat: Any
chararray: Any
clongdouble: Any
clongfloat: Any
column_stack: Any
common_type: Any
compare_chararrays: Any
complex256: Any
complex_: Any
concatenate: Any
conj: Any
copy: Any
copyto: Any
corrcoef: Any
cov: Any
csingle: Any
cumproduct: Any
datetime_as_string: Any
datetime_data: Any
delete: Any
deprecate: Any
deprecate_with_doc: Any
diag: Any
diag_indices: Any
diag_indices_from: Any
diagflat: Any
diff: Any
digitize: Any
disp: Any
divide: Any
dot: Any
double: Any
dsplit: Any
dstack: Any
ediff1d: Any
einsum: Any
einsum_path: Any
expand_dims: Any
extract: Any
eye: Any
fill_diagonal: Any
finfo: Any
fix: Any
flip: Any
fliplr: Any
flipud: Any
float128: Any
float_: Any
format_float_positional: Any
format_float_scientific: Any
format_parser: Any
frombuffer: Any
fromfile: Any
fromiter: Any
frompyfunc: Any
fromregex: Any
fromstring: Any
genfromtxt: Any
get_include: Any
get_printoptions: Any
geterrobj: Any
gradient: Any
half: Any
hamming: Any
hanning: Any
histogram: Any
histogram2d: Any
histogram_bin_edges: Any
histogramdd: Any
hsplit: Any
i0: Any
iinfo: Any
imag: Any
in1d: Any
index_exp: Any
info: Any
inner: Any
insert: Any
int0: Any
int_: Any
intc: Any
interp: Any
intersect1d: Any
intp: Any
is_busday: Any
iscomplex: Any
iscomplexobj: Any
isin: Any
isneginf: Any
isposinf: Any
isreal: Any
isrealobj: Any
iterable: Any
ix_: Any
kaiser: Any
kron: Any
lexsort: Any
load: Any
loads: Any
loadtxt: Any
longcomplex: Any
longdouble: Any
longfloat: Any
longlong: Any
lookfor: Any
mafromtxt: Any
mask_indices: Any
mat: Any
matrix: Any
max: Any
may_share_memory: Any
median: Any
memmap: Any
meshgrid: Any
mgrid: Any
min: Any
min_scalar_type: Any
mintypecode: Any
mod: Any
msort: Any
nan_to_num: Any
nanargmax: Any
nanargmin: Any
nancumprod: Any
nancumsum: Any
nanmax: Any
nanmean: Any
nanmedian: Any
nanmin: Any
nanpercentile: Any
nanprod: Any
nanquantile: Any
nanstd: Any
nansum: Any
nanvar: Any
nbytes: Any
ndenumerate: Any
ndfromtxt: Any
ndindex: Any
nditer: Any
nested_iters: Any
newaxis: Any
numarray: Any
object0: Any
ogrid: Any
packbits: Any
pad: Any
percentile: Any
piecewise: Any
place: Any
poly: Any
poly1d: Any
polyadd: Any
polyder: Any
polydiv: Any
polyfit: Any
polyint: Any
polymul: Any
polysub: Any
polyval: Any
printoptions: Any
product: Any
promote_types: Any
put_along_axis: Any
putmask: Any
quantile: Any
r_: Any
ravel_multi_index: Any
real: Any
real_if_close: Any
recarray: Any
recfromcsv: Any
recfromtxt: Any
record: Any
result_type: Any
roots: Any
rot90: Any
round: Any
round_: Any
row_stack: Any
s_: Any
save: Any
savetxt: Any
savez: Any
savez_compressed: Any
select: Any
set_printoptions: Any
set_string_function: Any
setdiff1d: Any
seterrobj: Any
setxor1d: Any
shares_memory: Any
short: Any
show_config: Any
sinc: Any
single: Any
singlecomplex: Any
sort_complex: Any
source: Any
split: Any
string_: Any
take_along_axis: Any
tile: Any
trapz: Any
tri: Any
tril: Any
tril_indices: Any
tril_indices_from: Any
trim_zeros: Any
triu: Any
triu_indices: Any
triu_indices_from: Any
typeDict: Any
typecodes: Any
typename: Any
ubyte: Any
uint: Any
uint0: Any
uintc: Any
uintp: Any
ulonglong: Any
union1d: Any
unique: Any
unpackbits: Any
unravel_index: Any
unwrap: Any
ushort: Any
vander: Any
vdot: Any
vectorize: Any
void0: Any
vsplit: Any
where: Any
who: Any
_NdArraySubClass = TypeVar("_NdArraySubClass", bound=ndarray)
_DTypeScalar = TypeVar("_DTypeScalar", bound=generic)
_ByteOrder = Literal["S", "<", ">", "=", "|", "L", "B", "N", "I"]
class dtype(Generic[_DTypeScalar]):
names: Optional[Tuple[str, ...]]
# Overload for subclass of generic
@overload
def __new__(
cls,
dtype: Type[_DTypeScalar],
align: bool = ...,
copy: bool = ...,
) -> dtype[_DTypeScalar]: ...
# Overloads for string aliases, Python types, and some assorted
# other special cases. Order is sometimes important because of the
# subtype relationships
#
# bool < int < float < complex
#
# so we have to make sure the overloads for the narrowest type is
# first.
@overload
def __new__(
cls,
dtype: Union[
Type[bool],
Literal[
"?",
"=?",
"<?",
">?",
"bool",
"bool_",
],
],
align: bool = ...,
copy: bool = ...,
) -> dtype[bool_]: ...
@overload
def __new__(
cls,
dtype: Literal[
"uint8",
"u1",
"=u1",
"<u1",
">u1",
],
align: bool = ...,
copy: bool = ...,
) -> dtype[uint8]: ...
@overload
def __new__(
cls,
dtype: Literal[
"uint16",
"u2",
"=u2",
"<u2",
">u2",
],
align: bool = ...,
copy: bool = ...,
) -> dtype[uint16]: ...
@overload
def __new__(
cls,
dtype: Literal[
"uint32",
"u4",
"=u4",
"<u4",
">u4",
],
align: bool = ...,
copy: bool = ...,
) -> dtype[uint32]: ...
@overload
def __new__(
cls,
dtype: Literal[
"uint64",
"u8",
"=u8",
"<u8",
">u8",
],
align: bool = ...,
copy: bool = ...,
) -> dtype[uint64]: ...
@overload
def __new__(
cls,
dtype: Literal[
"int8",
"i1",
"=i1",
"<i1",
">i1",
],
align: bool = ...,
copy: bool = ...,
) -> dtype[int8]: ...
@overload
def __new__(
cls,
dtype: Literal[
"int16",
"i2",
"=i2",
"<i2",
">i2",
],
align: bool = ...,
copy: bool = ...,
) -> dtype[int16]: ...
@overload
def __new__(
cls,
dtype: Literal[
"int32",
"i4",
"=i4",
"<i4",
">i4",
],
align: bool = ...,
copy: bool = ...,
) -> dtype[int32]: ...
@overload
def __new__(
cls,
dtype: Literal[
"int64",
"i8",
"=i8",
"<i8",
">i8",
],
align: bool = ...,
copy: bool = ...,
) -> dtype[int64]: ...
# "int"/int resolve to int_, which is system dependent and as of
# now untyped. Long-term we'll do something fancier here.
@overload
def __new__(
cls,
dtype: Union[Type[int], Literal["int"]],
align: bool = ...,
copy: bool = ...,
) -> dtype: ...
@overload
def __new__(
cls,
dtype: Literal[
"float16",
"f4",
"=f4",
"<f4",
">f4",
"e",
"=e",
"<e",
">e",
"half",
],
align: bool = ...,
copy: bool = ...,
) -> dtype[float16]: ...
@overload
def __new__(
cls,
dtype: Literal[
"float32",
"f4",
"=f4",
"<f4",
">f4",
"f",
"=f",
"<f",
">f",
"single",
],
align: bool = ...,
copy: bool = ...,
) -> dtype[float32]: ...
@overload
def __new__(
cls,
dtype: Union[
None,
Type[float],
Literal[
"float64",
"f8",
"=f8",
"<f8",
">f8",
"d",
"<d",
">d",
"float",
"double",
"float_",
],
],
align: bool = ...,
copy: bool = ...,
) -> dtype[float64]: ...
@overload
def __new__(
cls,
dtype: Literal[
"complex64",
"c8",
"=c8",
"<c8",
">c8",
"F",
"=F",
"<F",
">F",
],
align: bool = ...,
copy: bool = ...,
) -> dtype[complex64]: ...
@overload
def __new__(
cls,
dtype: Union[
Type[complex],
Literal[
"complex128",
"c16",
"=c16",
"<c16",
">c16",
"D",
"=D",
"<D",
">D",
],
],
align: bool = ...,
copy: bool = ...,
) -> dtype[complex128]: ...
@overload
def __new__(
cls,
dtype: Union[
Type[bytes],
Literal[
"S",
"=S",
"<S",
">S",
"bytes",
"bytes_",
"bytes0",
],
],
align: bool = ...,
copy: bool = ...,
) -> dtype[bytes_]: ...
@overload
def __new__(
cls,
dtype: Union[
Type[str],
Literal[
"U",
"=U",
# <U and >U intentionally not included; they are not
# the same dtype and which one dtype("U") translates
# to is platform-dependent.
"str",
"str_",
"str0",
],
],
align: bool = ...,
copy: bool = ...,
) -> dtype[str_]: ...
# dtype of a dtype is the same dtype
@overload
def __new__(
cls,
dtype: dtype[_DTypeScalar],
align: bool = ...,
copy: bool = ...,
) -> dtype[_DTypeScalar]: ...
# TODO: handle _SupportsDType better
@overload
def __new__(
cls,
dtype: _SupportsDType,
align: bool = ...,
copy: bool = ...,
) -> dtype[Any]: ...
# Handle strings that can't be expressed as literals; i.e. s1, s2, ...
@overload
def __new__(
cls,
dtype: str,
align: bool = ...,
copy: bool = ...,
) -> dtype[Any]: ...
# Catchall overload
@overload
def __new__(
cls,
dtype: _VoidDTypeLike,
align: bool = ...,
copy: bool = ...,
) -> dtype[void]: ...
@overload
def __getitem__(self: dtype[void], key: List[str]) -> dtype[void]: ...
@overload
def __getitem__(self: dtype[void], key: Union[str, int]) -> dtype[Any]: ...
# NOTE: In the future 1-based multiplications will also yield `void` dtypes
@overload
def __mul__(self, value: Literal[0]) -> None: ... # type: ignore[misc]
@overload
def __mul__(self, value: Literal[1]) -> dtype[_DTypeScalar]: ...
@overload
def __mul__(self, value: int) -> dtype[void]: ...
# NOTE: `__rmul__` seems to be broken when used in combination with
# literals as of mypy 0.800. Set the return-type to `Any` for now.
def __rmul__(self, value: int) -> Any: ...
def __eq__(self, other: DTypeLike) -> bool: ...
def __ne__(self, other: DTypeLike) -> bool: ...
def __gt__(self, other: DTypeLike) -> bool: ...
def __ge__(self, other: DTypeLike) -> bool: ...
def __lt__(self, other: DTypeLike) -> bool: ...
def __le__(self, other: DTypeLike) -> bool: ...
@property
def alignment(self) -> int: ...
@property
def base(self) -> dtype: ...
@property
def byteorder(self) -> str: ...
@property
def char(self) -> str: ...
@property
def descr(self) -> List[Union[Tuple[str, str], Tuple[str, str, _Shape]]]: ...
@property
def fields(
self,
) -> Optional[Mapping[str, Union[Tuple[dtype, int], Tuple[dtype, int, Any]]]]: ...
@property
def flags(self) -> int: ...
@property
def hasobject(self) -> bool: ...
@property
def isbuiltin(self) -> int: ...
@property
def isnative(self) -> bool: ...
@property
def isalignedstruct(self) -> bool: ...
@property
def itemsize(self) -> int: ...
@property
def kind(self) -> str: ...
@property
def metadata(self) -> Optional[Mapping[str, Any]]: ...
@property
def name(self) -> str: ...
@property
def names(self) -> Optional[Tuple[str, ...]]: ...
@property
def num(self) -> int: ...
@property
def shape(self) -> _Shape: ...
@property
def ndim(self) -> int: ...
@property
def subdtype(self) -> Optional[Tuple[dtype, _Shape]]: ...
def newbyteorder(self, __new_order: _ByteOrder = ...) -> dtype: ...
# Leave str and type for end to avoid having to use `builtins.str`
# everywhere. See https://github.com/python/mypy/issues/3775
@property
def str(self) -> builtins.str: ...
@property
def type(self) -> Type[generic]: ...
_DType = dtype # to avoid name conflicts with ndarray.dtype
class _flagsobj:
aligned: bool
updateifcopy: bool
writeable: bool
writebackifcopy: bool
@property
def behaved(self) -> bool: ...
@property
def c_contiguous(self) -> bool: ...
@property
def carray(self) -> bool: ...
@property
def contiguous(self) -> bool: ...
@property
def f_contiguous(self) -> bool: ...
@property
def farray(self) -> bool: ...
@property
def fnc(self) -> bool: ...
@property
def forc(self) -> bool: ...
@property
def fortran(self) -> bool: ...
@property
def num(self) -> int: ...
@property
def owndata(self) -> bool: ...
def __getitem__(self, key: str) -> bool: ...
def __setitem__(self, key: str, value: bool) -> None: ...
_ArrayLikeInt = Union[
int,
integer,
Sequence[Union[int, integer]],
Sequence[Sequence[Any]], # TODO: wait for support for recursive types
ndarray
]
_FlatIterSelf = TypeVar("_FlatIterSelf", bound=flatiter)
class flatiter(Generic[_ArraySelf]):
@property
def base(self) -> _ArraySelf: ...
@property
def coords(self) -> _Shape: ...
@property
def index(self) -> int: ...
def copy(self) -> _ArraySelf: ...
def __iter__(self: _FlatIterSelf) -> _FlatIterSelf: ...
def __next__(self) -> generic: ...
def __len__(self) -> int: ...
@overload
def __getitem__(self, key: Union[int, integer]) -> generic: ...
@overload
def __getitem__(
self, key: Union[_ArrayLikeInt, slice, ellipsis],
) -> _ArraySelf: ...
def __array__(self, __dtype: DTypeLike = ...) -> ndarray: ...
_OrderKACF = Optional[Literal["K", "A", "C", "F"]]
_OrderACF = Optional[Literal["A", "C", "F"]]
_OrderCF = Optional[Literal["C", "F"]]
_ModeKind = Literal["raise", "wrap", "clip"]
_PartitionKind = Literal["introselect"]
_SortKind = Literal["quicksort", "mergesort", "heapsort", "stable"]
_SortSide = Literal["left", "right"]
_ArrayLikeBool = Union[_BoolLike, Sequence[_BoolLike], ndarray]
_ArrayLikeIntOrBool = Union[
_IntLike,
_BoolLike,
ndarray,
Sequence[_IntLike],
Sequence[_BoolLike],
Sequence[Sequence[Any]], # TODO: wait for support for recursive types
]
_ArraySelf = TypeVar("_ArraySelf", bound=_ArrayOrScalarCommon)
class _ArrayOrScalarCommon:
@property
def T(self: _ArraySelf) -> _ArraySelf: ...
@property
def data(self) -> memoryview: ...
@property
def flags(self) -> _flagsobj: ...
@property
def itemsize(self) -> int: ...
@property
def nbytes(self) -> int: ...
def __array__(self, __dtype: DTypeLike = ...) -> ndarray: ...
def __bool__(self) -> bool: ...
def __bytes__(self) -> bytes: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __copy__(self: _ArraySelf) -> _ArraySelf: ...
def __deepcopy__(self: _ArraySelf, __memo: Optional[dict] = ...) -> _ArraySelf: ...
def __lt__(self, other): ...
def __le__(self, other): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
def __gt__(self, other): ...
def __ge__(self, other): ...
def astype(
self: _ArraySelf,
dtype: DTypeLike,
order: _OrderKACF = ...,
casting: _Casting = ...,
subok: bool = ...,
copy: bool = ...,
) -> _ArraySelf: ...
def copy(self: _ArraySelf, order: _OrderKACF = ...) -> _ArraySelf: ...
def dump(self, file: str) -> None: ...
def dumps(self) -> bytes: ...
def flatten(self, order: _OrderKACF = ...) -> ndarray: ...
def getfield(
self: _ArraySelf, dtype: DTypeLike, offset: int = ...
) -> _ArraySelf: ...
def ravel(self, order: _OrderKACF = ...) -> ndarray: ...
@overload
def reshape(
self, __shape: _ShapeLike, *, order: _OrderACF = ...
) -> ndarray: ...
@overload
def reshape(
self, *shape: SupportsIndex, order: _OrderACF = ...
) -> ndarray: ...
def tobytes(self, order: _OrderKACF = ...) -> bytes: ...
# NOTE: `tostring()` is deprecated and therefore excluded
# def tostring(self, order=...): ...
def tofile(
self, fid: Union[IO[bytes], str], sep: str = ..., format: str = ...
) -> None: ...
# generics and 0d arrays return builtin scalars
def tolist(self) -> Any: ...
@overload
def view(self, type: Type[_NdArraySubClass]) -> _NdArraySubClass: ...
@overload
def view(self: _ArraySelf, dtype: DTypeLike = ...) -> _ArraySelf: ...
@overload
def view(
self, dtype: DTypeLike, type: Type[_NdArraySubClass]
) -> _NdArraySubClass: ...
# TODO: Add proper signatures
def __getitem__(self, key) -> Any: ...
@property
def __array_interface__(self): ...
@property
def __array_priority__(self): ...
@property
def __array_struct__(self): ...
def __array_wrap__(array, context=...): ...
def __setstate__(self, __state): ...
# a `bool_` is returned when `keepdims=True` and `self` is a 0d array
@overload
def all(
self,
axis: None = ...,
out: None = ...,
keepdims: Literal[False] = ...,
) -> bool_: ...
@overload
def all(
self,
axis: Optional[_ShapeLike] = ...,
out: None = ...,
keepdims: bool = ...,
) -> Any: ...
@overload
def all(
self,
axis: Optional[_ShapeLike] = ...,
out: _NdArraySubClass = ...,
keepdims: bool = ...,
) -> _NdArraySubClass: ...
@overload
def any(
self,
axis: None = ...,
out: None = ...,
keepdims: Literal[False] = ...,
) -> bool_: ...
@overload
def any(
self,
axis: Optional[_ShapeLike] = ...,
out: None = ...,
keepdims: bool = ...,
) -> Any: ...
@overload
def any(
self,
axis: Optional[_ShapeLike] = ...,
out: _NdArraySubClass = ...,
keepdims: bool = ...,
) -> _NdArraySubClass: ...
@overload
def argmax(
self,
axis: None = ...,
out: None = ...,
) -> signedinteger[Any]: ...
@overload
def argmax(
self,
axis: _ShapeLike = ...,
out: None = ...,
) -> Any: ...
@overload
def argmax(
self,
axis: Optional[_ShapeLike] = ...,
out: _NdArraySubClass = ...,
) -> _NdArraySubClass: ...
@overload
def argmin(
self,
axis: None = ...,
out: None = ...,
) -> signedinteger[Any]: ...
@overload
def argmin(
self,
axis: _ShapeLike = ...,
out: None = ...,
) -> Any: ...
@overload
def argmin(
self,
axis: Optional[_ShapeLike] = ...,
out: _NdArraySubClass = ...,
) -> _NdArraySubClass: ...
def argsort(
self,
axis: Optional[SupportsIndex] = ...,
kind: Optional[_SortKind] = ...,
order: Union[None, str, Sequence[str]] = ...,
) -> ndarray: ...
@overload
def choose(
self,
choices: ArrayLike,
out: None = ...,
mode: _ModeKind = ...,
) -> ndarray: ...
@overload
def choose(
self,
choices: ArrayLike,
out: _NdArraySubClass = ...,
mode: _ModeKind = ...,
) -> _NdArraySubClass: ...
@overload
def clip(
self,
min: ArrayLike = ...,
max: Optional[ArrayLike] = ...,
out: None = ...,
**kwargs: Any,
) -> Any: ...
@overload
def clip(
self,
min: None = ...,
max: ArrayLike = ...,
out: None = ...,
**kwargs: Any,
) -> Any: ...
@overload
def clip(
self,
min: ArrayLike = ...,
max: Optional[ArrayLike] = ...,
out: _NdArraySubClass = ...,
**kwargs: Any,
) -> _NdArraySubClass: ...
@overload
def clip(
self,
min: None = ...,
max: ArrayLike = ...,
out: _NdArraySubClass = ...,
**kwargs: Any,
) -> _NdArraySubClass: ...
@overload
def compress(
self,
a: ArrayLike,
axis: Optional[SupportsIndex] = ...,
out: None = ...,
) -> ndarray: ...
@overload
def compress(
self,
a: ArrayLike,
axis: Optional[SupportsIndex] = ...,
out: _NdArraySubClass = ...,
) -> _NdArraySubClass: ...
def conj(self: _ArraySelf) -> _ArraySelf: ...
def conjugate(self: _ArraySelf) -> _ArraySelf: ...
@overload
def cumprod(
self,
axis: Optional[SupportsIndex] = ...,
dtype: DTypeLike = ...,
out: None = ...,
) -> ndarray: ...
@overload
def cumprod(
self,
axis: Optional[SupportsIndex] = ...,
dtype: DTypeLike = ...,
out: _NdArraySubClass = ...,
) -> _NdArraySubClass: ...
@overload
def cumsum(
self,
axis: Optional[SupportsIndex] = ...,
dtype: DTypeLike = ...,
out: None = ...,
) -> ndarray: ...
@overload
def cumsum(
self,
axis: Optional[SupportsIndex] = ...,
dtype: DTypeLike = ...,
out: _NdArraySubClass = ...,
) -> _NdArraySubClass: ...
@overload
def max(
self,
axis: Optional[_ShapeLike] = ...,
out: None = ...,
keepdims: bool = ...,
initial: _NumberLike = ...,
where: _ArrayLikeBool = ...,
) -> Any: ...
@overload
def max(
self,
axis: Optional[_ShapeLike] = ...,
out: _NdArraySubClass = ...,
keepdims: bool = ...,
initial: _NumberLike = ...,
where: _ArrayLikeBool = ...,
) -> _NdArraySubClass: ...
@overload
def mean(
self,
axis: Optional[_ShapeLike] = ...,
dtype: DTypeLike = ...,
out: None = ...,
keepdims: bool = ...,
) -> Any: ...
@overload
def mean(
self,
axis: Optional[_ShapeLike] = ...,
dtype: DTypeLike = ...,
out: _NdArraySubClass = ...,
keepdims: bool = ...,
) -> _NdArraySubClass: ...
@overload
def min(
self,
axis: Optional[_ShapeLike] = ...,
out: None = ...,
keepdims: bool = ...,
initial: _NumberLike = ...,
where: _ArrayLikeBool = ...,
) -> Any: ...
@overload
def min(
self,
axis: Optional[_ShapeLike] = ...,
out: _NdArraySubClass = ...,
keepdims: bool = ...,
initial: _NumberLike = ...,
where: _ArrayLikeBool = ...,
) -> _NdArraySubClass: ...
def newbyteorder(
self: _ArraySelf,
__new_order: _ByteOrder = ...,
) -> _ArraySelf: ...
@overload
def prod(
self,
axis: Optional[_ShapeLike] = ...,
dtype: DTypeLike = ...,
out: None = ...,
keepdims: bool = ...,
initial: _NumberLike = ...,
where: _ArrayLikeBool = ...,
) -> Any: ...
@overload
def prod(
self,
axis: Optional[_ShapeLike] = ...,
dtype: DTypeLike = ...,
out: _NdArraySubClass = ...,
keepdims: bool = ...,
initial: _NumberLike = ...,
where: _ArrayLikeBool = ...,
) -> _NdArraySubClass: ...
@overload
def ptp(
self,
axis: Optional[_ShapeLike] = ...,
out: None = ...,
keepdims: bool = ...,
) -> Any: ...
@overload
def ptp(
self,
axis: Optional[_ShapeLike] = ...,
out: _NdArraySubClass = ...,
keepdims: bool = ...,
) -> _NdArraySubClass: ...
def repeat(
self,
repeats: _ArrayLikeIntOrBool,
axis: Optional[SupportsIndex] = ...,
) -> ndarray: ...
@overload
def round(
self: _ArraySelf,
decimals: SupportsIndex = ...,
out: None = ...,
) -> _ArraySelf: ...
@overload
def round(
self,
decimals: SupportsIndex = ...,
out: _NdArraySubClass = ...,
) -> _NdArraySubClass: ...
@overload
def std(
self,
axis: Optional[_ShapeLike] = ...,
dtype: DTypeLike = ...,
out: None = ...,
ddof: int = ...,
keepdims: bool = ...,
) -> Any: ...
@overload
def std(
self,
axis: Optional[_ShapeLike] = ...,
dtype: DTypeLike = ...,
out: _NdArraySubClass = ...,
ddof: int = ...,
keepdims: bool = ...,
) -> _NdArraySubClass: ...
@overload
def sum(
self,
axis: Optional[_ShapeLike] = ...,
dtype: DTypeLike = ...,
out: None = ...,
keepdims: bool = ...,
initial: _NumberLike = ...,
where: _ArrayLikeBool = ...,
) -> Any: ...
@overload
def sum(
self,
axis: Optional[_ShapeLike] = ...,
dtype: DTypeLike = ...,
out: _NdArraySubClass = ...,
keepdims: bool = ...,
initial: _NumberLike = ...,
where: _ArrayLikeBool = ...,
) -> _NdArraySubClass: ...
@overload
def take(
self,
indices: Union[_IntLike, _BoolLike],
axis: Optional[SupportsIndex] = ...,
out: None = ...,
mode: _ModeKind = ...,
) -> Any: ...
@overload
def take(
self,
indices: _ArrayLikeIntOrBool,
axis: Optional[SupportsIndex] = ...,
out: None = ...,
mode: _ModeKind = ...,
) -> ndarray: ...
@overload
def take(
self,
indices: _ArrayLikeIntOrBool,
axis: Optional[SupportsIndex] = ...,
out: _NdArraySubClass = ...,
mode: _ModeKind = ...,
) -> _NdArraySubClass: ...
@overload
def var(
self,
axis: Optional[_ShapeLike] = ...,
dtype: DTypeLike = ...,
out: None = ...,
ddof: int = ...,
keepdims: bool = ...,
) -> Any: ...
@overload
def var(
self,
axis: Optional[_ShapeLike] = ...,
dtype: DTypeLike = ...,
out: _NdArraySubClass = ...,
ddof: int = ...,
keepdims: bool = ...,
) -> _NdArraySubClass: ...
_BufferType = Union[ndarray, bytes, bytearray, memoryview]
_Casting = Literal["no", "equiv", "safe", "same_kind", "unsafe"]
class ndarray(_ArrayOrScalarCommon, Iterable, Sized, Container):
@property
def base(self) -> Optional[ndarray]: ...
@property
def ndim(self) -> int: ...
@property
def size(self) -> int: ...
@property
def real(self: _ArraySelf) -> _ArraySelf: ...
@real.setter
def real(self, value: ArrayLike) -> None: ...
@property
def imag(self: _ArraySelf) -> _ArraySelf: ...
@imag.setter
def imag(self, value: ArrayLike) -> None: ...
def __new__(
cls: Type[_ArraySelf],
shape: _ShapeLike,
dtype: DTypeLike = ...,
buffer: _BufferType = ...,
offset: int = ...,
strides: _ShapeLike = ...,
order: _OrderKACF = ...,
) -> _ArraySelf: ...
@property
def dtype(self) -> _DType: ...
@property
def ctypes(self) -> _ctypes: ...
@property
def shape(self) -> _Shape: ...
@shape.setter
def shape(self, value: _ShapeLike): ...
@property
def strides(self) -> _Shape: ...
@strides.setter
def strides(self, value: _ShapeLike): ...
def byteswap(self: _ArraySelf, inplace: bool = ...) -> _ArraySelf: ...
def fill(self, value: Any) -> None: ...
@property
def flat(self: _ArraySelf) -> flatiter[_ArraySelf]: ...
@overload
def item(self, *args: SupportsIndex) -> Any: ...
@overload
def item(self, __args: Tuple[SupportsIndex, ...]) -> Any: ...
@overload
def itemset(self, __value: Any) -> None: ...
@overload
def itemset(self, __item: _ShapeLike, __value: Any) -> None: ...
@overload
def resize(self, __new_shape: _ShapeLike, *, refcheck: bool = ...) -> None: ...
@overload
def resize(self, *new_shape: SupportsIndex, refcheck: bool = ...) -> None: ...
def setflags(
self, write: bool = ..., align: bool = ..., uic: bool = ...
) -> None: ...
def squeeze(
self: _ArraySelf, axis: Union[SupportsIndex, Tuple[SupportsIndex, ...]] = ...
) -> _ArraySelf: ...
def swapaxes(self: _ArraySelf, axis1: SupportsIndex, axis2: SupportsIndex) -> _ArraySelf: ...
@overload
def transpose(self: _ArraySelf, __axes: _ShapeLike) -> _ArraySelf: ...
@overload
def transpose(self: _ArraySelf, *axes: SupportsIndex) -> _ArraySelf: ...
def argpartition(
self,
kth: _ArrayLikeIntOrBool,
axis: Optional[SupportsIndex] = ...,
kind: _PartitionKind = ...,
order: Union[None, str, Sequence[str]] = ...,
) -> ndarray: ...
def diagonal(
self: _ArraySelf,
offset: SupportsIndex = ...,
axis1: SupportsIndex = ...,
axis2: SupportsIndex = ...,
) -> _ArraySelf: ...
@overload
def dot(self, b: ArrayLike, out: None = ...) -> Any: ...
@overload
def dot(self, b: ArrayLike, out: _NdArraySubClass = ...) -> _NdArraySubClass: ...
# `nonzero()` is deprecated for 0d arrays/generics
def nonzero(self) -> Tuple[ndarray, ...]: ...
def partition(
self,
kth: _ArrayLikeIntOrBool,
axis: SupportsIndex = ...,
kind: _PartitionKind = ...,
order: Union[None, str, Sequence[str]] = ...,
) -> None: ...
# `put` is technically available to `generic`,
# but is pointless as `generic`s are immutable
def put(
self, ind: _ArrayLikeIntOrBool, v: ArrayLike, mode: _ModeKind = ...
) -> None: ...
def searchsorted(
self, # >= 1D array
v: ArrayLike,
side: _SortSide = ...,
sorter: Optional[_ArrayLikeIntOrBool] = ..., # 1D int array
) -> ndarray: ...
def setfield(
self, val: ArrayLike, dtype: DTypeLike, offset: SupportsIndex = ...
) -> None: ...
def sort(
self,
axis: SupportsIndex = ...,
kind: Optional[_SortKind] = ...,
order: Union[None, str, Sequence[str]] = ...,
) -> None: ...
@overload
def trace(
self, # >= 2D array
offset: SupportsIndex = ...,
axis1: SupportsIndex = ...,
axis2: SupportsIndex = ...,
dtype: DTypeLike = ...,
out: None = ...,
) -> Any: ...
@overload
def trace(
self, # >= 2D array
offset: SupportsIndex = ...,
axis1: SupportsIndex = ...,
axis2: SupportsIndex = ...,
dtype: DTypeLike = ...,
out: _NdArraySubClass = ...,
) -> _NdArraySubClass: ...
# Many of these special methods are irrelevant currently, since protocols
# aren't supported yet. That said, I'm adding them for completeness.
# https://docs.python.org/3/reference/datamodel.html
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __complex__(self) -> complex: ...
def __len__(self) -> int: ...
def __setitem__(self, key, value): ...
def __iter__(self) -> Any: ...
def __contains__(self, key) -> bool: ...
def __index__(self) -> int: ...
def __matmul__(self, other: ArrayLike) -> Any: ...
# NOTE: `ndarray` does not implement `__imatmul__`
def __rmatmul__(self, other: ArrayLike) -> Any: ...
def __neg__(self: _ArraySelf) -> Any: ...
def __pos__(self: _ArraySelf) -> Any: ...
def __abs__(self: _ArraySelf) -> Any: ...
def __mod__(self, other: ArrayLike) -> Any: ...
def __rmod__(self, other: ArrayLike) -> Any: ...
def __divmod__(self, other: ArrayLike) -> Tuple[Any, Any]: ...
def __rdivmod__(self, other: ArrayLike) -> Tuple[Any, Any]: ...
def __add__(self, other: ArrayLike) -> Any: ...
def __radd__(self, other: ArrayLike) -> Any: ...
def __sub__(self, other: ArrayLike) -> Any: ...
def __rsub__(self, other: ArrayLike) -> Any: ...
def __mul__(self, other: ArrayLike) -> Any: ...
def __rmul__(self, other: ArrayLike) -> Any: ...
def __floordiv__(self, other: ArrayLike) -> Any: ...
def __rfloordiv__(self, other: ArrayLike) -> Any: ...
def __pow__(self, other: ArrayLike) -> Any: ...
def __rpow__(self, other: ArrayLike) -> Any: ...
def __truediv__(self, other: ArrayLike) -> Any: ...
def __rtruediv__(self, other: ArrayLike) -> Any: ...
def __invert__(self: _ArraySelf) -> Any: ...
def __lshift__(self, other: ArrayLike) -> Any: ...
def __rlshift__(self, other: ArrayLike) -> Any: ...
def __rshift__(self, other: ArrayLike) -> Any: ...
def __rrshift__(self, other: ArrayLike) -> Any: ...
def __and__(self, other: ArrayLike) -> Any: ...
def __rand__(self, other: ArrayLike) -> Any: ...
def __xor__(self, other: ArrayLike) -> Any: ...
def __rxor__(self, other: ArrayLike) -> Any: ...
def __or__(self, other: ArrayLike) -> Any: ...
def __ror__(self, other: ArrayLike) -> Any: ...
# `np.generic` does not support inplace operations
def __iadd__(self: _ArraySelf, other: ArrayLike) -> _ArraySelf: ...
def __isub__(self: _ArraySelf, other: ArrayLike) -> _ArraySelf: ...
def __imul__(self: _ArraySelf, other: ArrayLike) -> _ArraySelf: ...
def __itruediv__(self: _ArraySelf, other: ArrayLike) -> _ArraySelf: ...
def __ifloordiv__(self: _ArraySelf, other: ArrayLike) -> _ArraySelf: ...
def __ipow__(self: _ArraySelf, other: ArrayLike) -> _ArraySelf: ...
def __imod__(self: _ArraySelf, other: ArrayLike) -> _ArraySelf: ...
def __ilshift__(self: _ArraySelf, other: ArrayLike) -> _ArraySelf: ...
def __irshift__(self: _ArraySelf, other: ArrayLike) -> _ArraySelf: ...
def __iand__(self: _ArraySelf, other: ArrayLike) -> _ArraySelf: ...
def __ixor__(self: _ArraySelf, other: ArrayLike) -> _ArraySelf: ...
def __ior__(self: _ArraySelf, other: ArrayLike) -> _ArraySelf: ...
# NOTE: while `np.generic` is not technically an instance of `ABCMeta`,
# the `@abstractmethod` decorator is herein used to (forcefully) deny
# the creation of `np.generic` instances.
# The `# type: ignore` comments are necessary to silence mypy errors regarding
# the missing `ABCMeta` metaclass.
# See https://github.com/numpy/numpy-stubs/pull/80 for more details.
_ScalarType = TypeVar("_ScalarType", bound=generic)
_NBit_co = TypeVar("_NBit_co", covariant=True, bound=NBitBase)
_NBit_co2 = TypeVar("_NBit_co2", covariant=True, bound=NBitBase)
class generic(_ArrayOrScalarCommon):
@abstractmethod
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
@property
def base(self) -> None: ...
@property
def dtype(self: _ScalarType) -> _DType[_ScalarType]: ...
@property
def ndim(self) -> Literal[0]: ...
@property
def size(self) -> Literal[1]: ...
@property
def shape(self) -> Tuple[()]: ...
@property
def strides(self) -> Tuple[()]: ...
def byteswap(self: _ScalarType, inplace: Literal[False] = ...) -> _ScalarType: ...
@property
def flat(self) -> flatiter[ndarray]: ...
def item(
self: _ScalarType,
__args: Union[Literal[0], Tuple[()], Tuple[Literal[0]]] = ...,
) -> Any: ...
def squeeze(
self: _ScalarType, axis: Union[Literal[0], Tuple[()]] = ...
) -> _ScalarType: ...
def transpose(self: _ScalarType, __axes: Tuple[()] = ...) -> _ScalarType: ...
class number(generic, Generic[_NBit_co]): # type: ignore
@property
def real(self: _ArraySelf) -> _ArraySelf: ...
@property
def imag(self: _ArraySelf) -> _ArraySelf: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __complex__(self) -> complex: ...
def __neg__(self: _ArraySelf) -> _ArraySelf: ...
def __pos__(self: _ArraySelf) -> _ArraySelf: ...
def __abs__(self: _ArraySelf) -> _ArraySelf: ...
# Ensure that objects annotated as `number` support arithmetic operations
__add__: _NumberOp
__radd__: _NumberOp
__sub__: _NumberOp
__rsub__: _NumberOp
__mul__: _NumberOp
__rmul__: _NumberOp
__floordiv__: _NumberOp
__rfloordiv__: _NumberOp
__pow__: _NumberOp
__rpow__: _NumberOp
__truediv__: _NumberOp
__rtruediv__: _NumberOp
class bool_(generic):
def __init__(self, __value: object = ...) -> None: ...
@property
def real(self: _ArraySelf) -> _ArraySelf: ...
@property
def imag(self: _ArraySelf) -> _ArraySelf: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __complex__(self) -> complex: ...
def __abs__(self: _ArraySelf) -> _ArraySelf: ...
__add__: _BoolOp[bool_]
__radd__: _BoolOp[bool_]
__sub__: _BoolSub
__rsub__: _BoolSub
__mul__: _BoolOp[bool_]
__rmul__: _BoolOp[bool_]
__floordiv__: _BoolOp[int8]
__rfloordiv__: _BoolOp[int8]
__pow__: _BoolOp[int8]
__rpow__: _BoolOp[int8]
__truediv__: _BoolTrueDiv
__rtruediv__: _BoolTrueDiv
def __invert__(self) -> bool_: ...
__lshift__: _BoolBitOp[int8]
__rlshift__: _BoolBitOp[int8]
__rshift__: _BoolBitOp[int8]
__rrshift__: _BoolBitOp[int8]
__and__: _BoolBitOp[bool_]
__rand__: _BoolBitOp[bool_]
__xor__: _BoolBitOp[bool_]
__rxor__: _BoolBitOp[bool_]
__or__: _BoolBitOp[bool_]
__ror__: _BoolBitOp[bool_]
__mod__: _BoolMod
__rmod__: _BoolMod
__divmod__: _BoolDivMod
__rdivmod__: _BoolDivMod
class object_(generic):
def __init__(self, __value: object = ...) -> None: ...
@property
def real(self: _ArraySelf) -> _ArraySelf: ...
@property
def imag(self: _ArraySelf) -> _ArraySelf: ...
# The `datetime64` constructors requires an object with the three attributes below,
# and thus supports datetime duck typing
class _DatetimeScalar(Protocol):
@property
def day(self) -> int: ...
@property
def month(self) -> int: ...
@property
def year(self) -> int: ...
class datetime64(generic):
@overload
def __init__(
self,
__value: Union[None, datetime64, _CharLike, _DatetimeScalar] = ...,
__format: Union[_CharLike, Tuple[_CharLike, _IntLike]] = ...,
) -> None: ...
@overload
def __init__(
self,
__value: int,
__format: Union[_CharLike, Tuple[_CharLike, _IntLike]]
) -> None: ...
def __add__(self, other: Union[timedelta64, _IntLike, _BoolLike]) -> datetime64: ...
def __radd__(self, other: Union[timedelta64, _IntLike, _BoolLike]) -> datetime64: ...
@overload
def __sub__(self, other: datetime64) -> timedelta64: ...
@overload
def __sub__(self, other: Union[timedelta64, _IntLike, _BoolLike]) -> datetime64: ...
def __rsub__(self, other: datetime64) -> timedelta64: ...
# Support for `__index__` was added in python 3.8 (bpo-20092)
if sys.version_info >= (3, 8):
_IntValue = Union[SupportsInt, _CharLike, SupportsIndex]
_FloatValue = Union[None, _CharLike, SupportsFloat, SupportsIndex]
_ComplexValue = Union[None, _CharLike, SupportsFloat, SupportsComplex, SupportsIndex]
else:
_IntValue = Union[SupportsInt, _CharLike]
_FloatValue = Union[None, _CharLike, SupportsFloat]
_ComplexValue = Union[None, _CharLike, SupportsFloat, SupportsComplex]
class integer(number[_NBit_co]): # type: ignore
# NOTE: `__index__` is technically defined in the bottom-most
# sub-classes (`int64`, `uint32`, etc)
def __index__(self) -> int: ...
__truediv__: _IntTrueDiv[_NBit_co]
__rtruediv__: _IntTrueDiv[_NBit_co]
def __mod__(self, value: Union[_IntLike, integer]) -> integer: ...
def __rmod__(self, value: Union[_IntLike, integer]) -> integer: ...
def __invert__(self: _IntType) -> _IntType: ...
# Ensure that objects annotated as `integer` support bit-wise operations
def __lshift__(self, other: Union[_IntLike, _BoolLike]) -> integer: ...
def __rlshift__(self, other: Union[_IntLike, _BoolLike]) -> integer: ...
def __rshift__(self, other: Union[_IntLike, _BoolLike]) -> integer: ...
def __rrshift__(self, other: Union[_IntLike, _BoolLike]) -> integer: ...
def __and__(self, other: Union[_IntLike, _BoolLike]) -> integer: ...
def __rand__(self, other: Union[_IntLike, _BoolLike]) -> integer: ...
def __or__(self, other: Union[_IntLike, _BoolLike]) -> integer: ...
def __ror__(self, other: Union[_IntLike, _BoolLike]) -> integer: ...
def __xor__(self, other: Union[_IntLike, _BoolLike]) -> integer: ...
def __rxor__(self, other: Union[_IntLike, _BoolLike]) -> integer: ...
class signedinteger(integer[_NBit_co]):
def __init__(self, __value: _IntValue = ...) -> None: ...
__add__: _SignedIntOp[_NBit_co]
__radd__: _SignedIntOp[_NBit_co]
__sub__: _SignedIntOp[_NBit_co]
__rsub__: _SignedIntOp[_NBit_co]
__mul__: _SignedIntOp[_NBit_co]
__rmul__: _SignedIntOp[_NBit_co]
__floordiv__: _SignedIntOp[_NBit_co]
__rfloordiv__: _SignedIntOp[_NBit_co]
__pow__: _SignedIntOp[_NBit_co]
__rpow__: _SignedIntOp[_NBit_co]
__lshift__: _SignedIntBitOp[_NBit_co]
__rlshift__: _SignedIntBitOp[_NBit_co]
__rshift__: _SignedIntBitOp[_NBit_co]
__rrshift__: _SignedIntBitOp[_NBit_co]
__and__: _SignedIntBitOp[_NBit_co]
__rand__: _SignedIntBitOp[_NBit_co]
__xor__: _SignedIntBitOp[_NBit_co]
__rxor__: _SignedIntBitOp[_NBit_co]
__or__: _SignedIntBitOp[_NBit_co]
__ror__: _SignedIntBitOp[_NBit_co]
__mod__: _SignedIntMod[_NBit_co]
__rmod__: _SignedIntMod[_NBit_co]
__divmod__: _SignedIntDivMod[_NBit_co]
__rdivmod__: _SignedIntDivMod[_NBit_co]
int8 = signedinteger[_8Bit]
int16 = signedinteger[_16Bit]
int32 = signedinteger[_32Bit]
int64 = signedinteger[_64Bit]
class timedelta64(generic):
def __init__(
self,
__value: Union[None, int, _CharLike, dt.timedelta, timedelta64] = ...,
__format: Union[_CharLike, Tuple[_CharLike, _IntLike]] = ...,
) -> None: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __complex__(self) -> complex: ...
def __neg__(self: _ArraySelf) -> _ArraySelf: ...
def __pos__(self: _ArraySelf) -> _ArraySelf: ...
def __abs__(self: _ArraySelf) -> _ArraySelf: ...
def __add__(self, other: Union[timedelta64, _IntLike, _BoolLike]) -> timedelta64: ...
def __radd__(self, other: Union[timedelta64, _IntLike, _BoolLike]) -> timedelta64: ...
def __sub__(self, other: Union[timedelta64, _IntLike, _BoolLike]) -> timedelta64: ...
def __rsub__(self, other: Union[timedelta64, _IntLike, _BoolLike]) -> timedelta64: ...
def __mul__(self, other: Union[_FloatLike, _BoolLike]) -> timedelta64: ...
def __rmul__(self, other: Union[_FloatLike, _BoolLike]) -> timedelta64: ...
__truediv__: _TD64Div[float64]
__floordiv__: _TD64Div[int64]
def __rtruediv__(self, other: timedelta64) -> float64: ...
def __rfloordiv__(self, other: timedelta64) -> int64: ...
def __mod__(self, other: timedelta64) -> timedelta64: ...
def __rmod__(self, other: timedelta64) -> timedelta64: ...
def __divmod__(self, other: timedelta64) -> Tuple[int64, timedelta64]: ...
def __rdivmod__(self, other: timedelta64) -> Tuple[int64, timedelta64]: ...
class unsignedinteger(integer[_NBit_co]):
# NOTE: `uint64 + signedinteger -> float64`
def __init__(self, __value: _IntValue = ...) -> None: ...
__add__: _UnsignedIntOp[_NBit_co]
__radd__: _UnsignedIntOp[_NBit_co]
__sub__: _UnsignedIntOp[_NBit_co]
__rsub__: _UnsignedIntOp[_NBit_co]
__mul__: _UnsignedIntOp[_NBit_co]
__rmul__: _UnsignedIntOp[_NBit_co]
__floordiv__: _UnsignedIntOp[_NBit_co]
__rfloordiv__: _UnsignedIntOp[_NBit_co]
__pow__: _UnsignedIntOp[_NBit_co]
__rpow__: _UnsignedIntOp[_NBit_co]
__lshift__: _UnsignedIntBitOp[_NBit_co]
__rlshift__: _UnsignedIntBitOp[_NBit_co]
__rshift__: _UnsignedIntBitOp[_NBit_co]
__rrshift__: _UnsignedIntBitOp[_NBit_co]
__and__: _UnsignedIntBitOp[_NBit_co]
__rand__: _UnsignedIntBitOp[_NBit_co]
__xor__: _UnsignedIntBitOp[_NBit_co]
__rxor__: _UnsignedIntBitOp[_NBit_co]
__or__: _UnsignedIntBitOp[_NBit_co]
__ror__: _UnsignedIntBitOp[_NBit_co]
__mod__: _UnsignedIntMod[_NBit_co]
__rmod__: _UnsignedIntMod[_NBit_co]
__divmod__: _UnsignedIntDivMod[_NBit_co]
__rdivmod__: _UnsignedIntDivMod[_NBit_co]
uint8 = unsignedinteger[_8Bit]
uint16 = unsignedinteger[_16Bit]
uint32 = unsignedinteger[_32Bit]
uint64 = unsignedinteger[_64Bit]
class inexact(number[_NBit_co]): ... # type: ignore
_IntType = TypeVar("_IntType", bound=integer)
_FloatType = TypeVar('_FloatType', bound=floating)
class floating(inexact[_NBit_co]):
def __init__(self, __value: _FloatValue = ...) -> None: ...
__add__: _FloatOp[_NBit_co]
__radd__: _FloatOp[_NBit_co]
__sub__: _FloatOp[_NBit_co]
__rsub__: _FloatOp[_NBit_co]
__mul__: _FloatOp[_NBit_co]
__rmul__: _FloatOp[_NBit_co]
__truediv__: _FloatOp[_NBit_co]
__rtruediv__: _FloatOp[_NBit_co]
__floordiv__: _FloatOp[_NBit_co]
__rfloordiv__: _FloatOp[_NBit_co]
__pow__: _FloatOp[_NBit_co]
__rpow__: _FloatOp[_NBit_co]
__mod__: _FloatMod[_NBit_co]
__rmod__: _FloatMod[_NBit_co]
__divmod__: _FloatDivMod[_NBit_co]
__rdivmod__: _FloatDivMod[_NBit_co]
float16 = floating[_16Bit]
float32 = floating[_32Bit]
float64 = floating[_64Bit]
# 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[_NBit_co], Generic[_NBit_co, _NBit_co2]):
def __init__(self, __value: _ComplexValue = ...) -> None: ...
@property
def real(self) -> floating[_NBit_co]: ... # type: ignore[override]
@property
def imag(self) -> floating[_NBit_co2]: ... # type: ignore[override]
def __abs__(self) -> floating[_NBit_co]: ... # type: ignore[override]
__add__: _ComplexOp[_NBit_co]
__radd__: _ComplexOp[_NBit_co]
__sub__: _ComplexOp[_NBit_co]
__rsub__: _ComplexOp[_NBit_co]
__mul__: _ComplexOp[_NBit_co]
__rmul__: _ComplexOp[_NBit_co]
__truediv__: _ComplexOp[_NBit_co]
__rtruediv__: _ComplexOp[_NBit_co]
__floordiv__: _ComplexOp[_NBit_co]
__rfloordiv__: _ComplexOp[_NBit_co]
__pow__: _ComplexOp[_NBit_co]
__rpow__: _ComplexOp[_NBit_co]
complex64 = complexfloating[_32Bit, _32Bit]
complex128 = complexfloating[_64Bit, _64Bit]
class flexible(generic): ... # type: ignore
class void(flexible):
def __init__(self, __value: Union[_IntLike, _BoolLike, bytes]): ...
@property
def real(self: _ArraySelf) -> _ArraySelf: ...
@property
def imag(self: _ArraySelf) -> _ArraySelf: ...
def setfield(
self, val: ArrayLike, dtype: DTypeLike, offset: int = ...
) -> None: ...
class character(flexible): # type: ignore
def __int__(self) -> int: ...
def __float__(self) -> float: ...
# NOTE: Most `np.bytes_` / `np.str_` methods return their
# builtin `bytes` / `str` counterpart
class bytes_(character, bytes):
@overload
def __init__(self, __value: object = ...) -> None: ...
@overload
def __init__(
self, __value: str, encoding: str = ..., errors: str = ...
) -> None: ...
class str_(character, str):
@overload
def __init__(self, __value: object = ...) -> None: ...
@overload
def __init__(
self, __value: bytes, encoding: str = ..., errors: str = ...
) -> None: ...
unicode_ = str0 = str_
# TODO(alan): Platform dependent types
# longcomplex, longdouble, longfloat
# bytes, short, intc, intp, longlong
# half, single, double, longdouble
# uint_, int_, float_, complex_
# float128, complex256
# float96
def array(
object: object,
dtype: DTypeLike = ...,
*,
copy: bool = ...,
order: _OrderKACF = ...,
subok: bool = ...,
ndmin: int = ...,
like: ArrayLike = ...,
) -> ndarray: ...
def zeros(
shape: _ShapeLike,
dtype: DTypeLike = ...,
order: _OrderCF = ...,
*,
like: ArrayLike = ...,
) -> ndarray: ...
def empty(
shape: _ShapeLike,
dtype: DTypeLike = ...,
order: _OrderCF = ...,
*,
like: ArrayLike = ...,
) -> ndarray: ...
def broadcast_shapes(*args: _ShapeLike) -> _Shape: ...
#
# Constants
#
Inf: Final[float]
Infinity: Final[float]
NAN: Final[float]
NINF: Final[float]
NZERO: Final[float]
NaN: Final[float]
PINF: Final[float]
PZERO: Final[float]
e: Final[float]
euler_gamma: Final[float]
inf: Final[float]
infty: Final[float]
nan: Final[float]
pi: Final[float]
ALLOW_THREADS: Final[int]
BUFSIZE: Final[int]
CLIP: Final[int]
ERR_CALL: Final[int]
ERR_DEFAULT: Final[int]
ERR_IGNORE: Final[int]
ERR_LOG: Final[int]
ERR_PRINT: Final[int]
ERR_RAISE: Final[int]
ERR_WARN: Final[int]
FLOATING_POINT_SUPPORT: Final[int]
FPE_DIVIDEBYZERO: Final[int]
FPE_INVALID: Final[int]
FPE_OVERFLOW: Final[int]
FPE_UNDERFLOW: Final[int]
MAXDIMS: Final[int]
MAY_SHARE_BOUNDS: Final[int]
MAY_SHARE_EXACT: Final[int]
RAISE: Final[int]
SHIFT_DIVIDEBYZERO: Final[int]
SHIFT_INVALID: Final[int]
SHIFT_OVERFLOW: Final[int]
SHIFT_UNDERFLOW: Final[int]
UFUNC_BUFSIZE_DEFAULT: Final[int]
WRAP: Final[int]
tracemalloc_domain: Final[int]
little_endian: Final[bool]
True_: Final[bool_]
False_: Final[bool_]
UFUNC_PYVALS_NAME: Final[str]
class ufunc:
@property
def __name__(self) -> str: ...
def __call__(
self,
*args: ArrayLike,
out: Optional[Union[ndarray, Tuple[ndarray, ...]]] = ...,
where: Optional[ndarray] = ...,
# The list should be a list of tuples of ints, but since we
# don't know the signature it would need to be
# Tuple[int, ...]. But, since List is invariant something like
# e.g. List[Tuple[int, int]] isn't a subtype of
# List[Tuple[int, ...]], so we can't type precisely here.
axes: List[Any] = ...,
axis: int = ...,
keepdims: bool = ...,
casting: _Casting = ...,
order: _OrderKACF = ...,
dtype: DTypeLike = ...,
subok: bool = ...,
signature: Union[str, Tuple[str]] = ...,
# In reality this should be a length of list 3 containing an
# int, an int, and a callable, but there's no way to express
# that.
extobj: List[Union[int, Callable]] = ...,
) -> Any: ...
@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[str]: ...
# 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) -> Optional[str]: ...
# 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.
@property
def reduce(self) -> Any: ...
@property
def accumulate(self) -> Any: ...
@property
def reduceat(self) -> Any: ...
@property
def outer(self) -> Any: ...
# Similarly at won't be defined for ufuncs that return multiple
# outputs, so we can't type it very precisely.
@property
def at(self) -> Any: ...
absolute: ufunc
add: ufunc
arccos: ufunc
arccosh: ufunc
arcsin: ufunc
arcsinh: ufunc
arctan2: ufunc
arctan: ufunc
arctanh: ufunc
bitwise_and: ufunc
bitwise_or: ufunc
bitwise_xor: ufunc
cbrt: ufunc
ceil: ufunc
conjugate: ufunc
copysign: ufunc
cos: ufunc
cosh: ufunc
deg2rad: ufunc
degrees: ufunc
divmod: ufunc
equal: ufunc
exp2: ufunc
exp: ufunc
expm1: ufunc
fabs: ufunc
float_power: ufunc
floor: ufunc
floor_divide: ufunc
fmax: ufunc
fmin: ufunc
fmod: ufunc
frexp: ufunc
gcd: ufunc
greater: ufunc
greater_equal: ufunc
heaviside: ufunc
hypot: ufunc
invert: ufunc
isfinite: ufunc
isinf: ufunc
isnan: ufunc
isnat: ufunc
lcm: ufunc
ldexp: ufunc
left_shift: ufunc
less: ufunc
less_equal: ufunc
log10: ufunc
log1p: ufunc
log2: ufunc
log: ufunc
logaddexp2: ufunc
logaddexp: ufunc
logical_and: ufunc
logical_not: ufunc
logical_or: ufunc
logical_xor: ufunc
matmul: ufunc
maximum: ufunc
minimum: ufunc
modf: ufunc
multiply: ufunc
negative: ufunc
nextafter: ufunc
not_equal: ufunc
positive: ufunc
power: ufunc
rad2deg: ufunc
radians: ufunc
reciprocal: ufunc
remainder: ufunc
right_shift: ufunc
rint: ufunc
sign: ufunc
signbit: ufunc
sin: ufunc
sinh: ufunc
spacing: ufunc
sqrt: ufunc
square: ufunc
subtract: ufunc
tan: ufunc
tanh: ufunc
true_divide: ufunc
trunc: ufunc
abs = absolute
# Warnings
class ModuleDeprecationWarning(DeprecationWarning): ...
class VisibleDeprecationWarning(UserWarning): ...
class ComplexWarning(RuntimeWarning): ...
class RankWarning(UserWarning): ...
# Errors
class TooHardError(RuntimeError): ...
class AxisError(ValueError, IndexError):
def __init__(
self, axis: int, ndim: Optional[int] = ..., msg_prefix: Optional[str] = ...
) -> None: ...
_CallType = TypeVar("_CallType", bound=Union[_ErrFunc, _SupportsWrite])
class errstate(Generic[_CallType], ContextDecorator):
call: _CallType
kwargs: _ErrDictOptional
# Expand `**kwargs` into explicit keyword-only arguments
def __init__(
self,
*,
call: _CallType = ...,
all: Optional[_ErrKind] = ...,
divide: Optional[_ErrKind] = ...,
over: Optional[_ErrKind] = ...,
under: Optional[_ErrKind] = ...,
invalid: Optional[_ErrKind] = ...,
) -> None: ...
def __enter__(self) -> None: ...
def __exit__(
self,
__exc_type: Optional[Type[BaseException]],
__exc_value: Optional[BaseException],
__traceback: Optional[TracebackType],
) -> None: ...