| # pyright: reportIncompatibleMethodOverride=false |
|
|
| import datetime as dt |
| import types |
| from _typeshed import Incomplete |
| from collections.abc import Callable, Sequence |
| from typing import ( |
| Any, |
| Concatenate, |
| Final, |
| Generic, |
| Literal, |
| Never, |
| NoReturn, |
| Self, |
| SupportsComplex, |
| SupportsFloat, |
| SupportsIndex, |
| SupportsInt, |
| TypeAlias, |
| Unpack, |
| final, |
| overload, |
| ) |
| from typing_extensions import Buffer, ParamSpec, TypeIs, TypeVar, override |
|
|
| import numpy as np |
| from numpy import ( |
| _AnyShapeT, |
| _HasDType, |
| _HasDTypeWithRealAndImag, |
| _ModeKind, |
| _OrderACF, |
| _OrderCF, |
| _OrderKACF, |
| _PartitionKind, |
| _SortKind, |
| _ToIndices, |
| amax, |
| amin, |
| bool_, |
| bytes_, |
| character, |
| complex128, |
| complexfloating, |
| datetime64, |
| dtype, |
| dtypes, |
| expand_dims, |
| flexible, |
| float16, |
| float32, |
| float64, |
| floating, |
| generic, |
| inexact, |
| int8, |
| int64, |
| int_, |
| integer, |
| intp, |
| ndarray, |
| number, |
| object_, |
| signedinteger, |
| str_, |
| timedelta64, |
| ufunc, |
| unsignedinteger, |
| void, |
| ) |
| from numpy._core.fromnumeric import _UFuncKwargs # type-check only |
| from numpy._globals import _NoValueType |
| from numpy._typing import ( |
| ArrayLike, |
| DTypeLike, |
| NDArray, |
| _32Bit, |
| _64Bit, |
| _AnyShape, |
| _ArrayLike, |
| _ArrayLikeBool_co, |
| _ArrayLikeBytes_co, |
| _ArrayLikeComplex128_co, |
| _ArrayLikeComplex_co, |
| _ArrayLikeDT64_co, |
| _ArrayLikeFloat64_co, |
| _ArrayLikeFloat_co, |
| _ArrayLikeInt, |
| _ArrayLikeInt_co, |
| _ArrayLikeNumber_co, |
| _ArrayLikeObject_co, |
| _ArrayLikeStr_co, |
| _ArrayLikeString_co, |
| _ArrayLikeTD64_co, |
| _ArrayLikeUInt_co, |
| _CharLike_co, |
| _DT64Codes, |
| _DTypeLike, |
| _DTypeLikeBool, |
| _DTypeLikeVoid, |
| _FloatLike_co, |
| _IntLike_co, |
| _NestedSequence, |
| _ScalarLike_co, |
| _Shape, |
| _ShapeLike, |
| _SupportsArrayFunc, |
| _SupportsDType, |
| _TD64Like_co, |
| ) |
| from numpy._typing._dtype_like import _VoidDTypeLike |
|
|
| __all__ = [ |
| "MAError", |
| "MaskError", |
| "MaskType", |
| "MaskedArray", |
| "abs", |
| "absolute", |
| "add", |
| "all", |
| "allclose", |
| "allequal", |
| "alltrue", |
| "amax", |
| "amin", |
| "angle", |
| "anom", |
| "anomalies", |
| "any", |
| "append", |
| "arange", |
| "arccos", |
| "arccosh", |
| "arcsin", |
| "arcsinh", |
| "arctan", |
| "arctan2", |
| "arctanh", |
| "argmax", |
| "argmin", |
| "argsort", |
| "around", |
| "array", |
| "asanyarray", |
| "asarray", |
| "bitwise_and", |
| "bitwise_or", |
| "bitwise_xor", |
| "bool_", |
| "ceil", |
| "choose", |
| "clip", |
| "common_fill_value", |
| "compress", |
| "compressed", |
| "concatenate", |
| "conjugate", |
| "convolve", |
| "copy", |
| "correlate", |
| "cos", |
| "cosh", |
| "count", |
| "cumprod", |
| "cumsum", |
| "default_fill_value", |
| "diag", |
| "diagonal", |
| "diff", |
| "divide", |
| "empty", |
| "empty_like", |
| "equal", |
| "exp", |
| "expand_dims", |
| "fabs", |
| "filled", |
| "fix_invalid", |
| "flatten_mask", |
| "flatten_structured_array", |
| "floor", |
| "floor_divide", |
| "fmod", |
| "frombuffer", |
| "fromflex", |
| "fromfunction", |
| "getdata", |
| "getmask", |
| "getmaskarray", |
| "greater", |
| "greater_equal", |
| "harden_mask", |
| "hypot", |
| "identity", |
| "ids", |
| "indices", |
| "inner", |
| "innerproduct", |
| "isMA", |
| "isMaskedArray", |
| "is_mask", |
| "is_masked", |
| "isarray", |
| "left_shift", |
| "less", |
| "less_equal", |
| "log", |
| "log2", |
| "log10", |
| "logical_and", |
| "logical_not", |
| "logical_or", |
| "logical_xor", |
| "make_mask", |
| "make_mask_descr", |
| "make_mask_none", |
| "mask_or", |
| "masked", |
| "masked_array", |
| "masked_equal", |
| "masked_greater", |
| "masked_greater_equal", |
| "masked_inside", |
| "masked_invalid", |
| "masked_less", |
| "masked_less_equal", |
| "masked_not_equal", |
| "masked_object", |
| "masked_outside", |
| "masked_print_option", |
| "masked_singleton", |
| "masked_values", |
| "masked_where", |
| "max", |
| "maximum", |
| "maximum_fill_value", |
| "mean", |
| "min", |
| "minimum", |
| "minimum_fill_value", |
| "mod", |
| "multiply", |
| "mvoid", |
| "ndim", |
| "negative", |
| "nomask", |
| "nonzero", |
| "not_equal", |
| "ones", |
| "ones_like", |
| "outer", |
| "outerproduct", |
| "power", |
| "prod", |
| "product", |
| "ptp", |
| "put", |
| "putmask", |
| "ravel", |
| "remainder", |
| "repeat", |
| "reshape", |
| "resize", |
| "right_shift", |
| "round", |
| "round_", |
| "set_fill_value", |
| "shape", |
| "sin", |
| "sinh", |
| "size", |
| "soften_mask", |
| "sometrue", |
| "sort", |
| "sqrt", |
| "squeeze", |
| "std", |
| "subtract", |
| "sum", |
| "swapaxes", |
| "take", |
| "tan", |
| "tanh", |
| "trace", |
| "transpose", |
| "true_divide", |
| "var", |
| "where", |
| "zeros", |
| "zeros_like", |
| ] |
|
|
| _ShapeT = TypeVar("_ShapeT", bound=_Shape) |
| _ShapeOrAnyT = TypeVar("_ShapeOrAnyT", bound=_Shape, default=_AnyShape) |
| _ShapeT_co = TypeVar("_ShapeT_co", bound=_Shape, default=_AnyShape, covariant=True) |
| _DTypeT = TypeVar("_DTypeT", bound=dtype) |
| _DTypeT_co = TypeVar("_DTypeT_co", bound=dtype, default=dtype, covariant=True) |
| _ArrayT = TypeVar("_ArrayT", bound=ndarray[Any, Any]) |
| _MArrayT = TypeVar("_MArrayT", bound=MaskedArray[Any, Any]) |
| _ScalarT = TypeVar("_ScalarT", bound=generic) |
| _ScalarT_co = TypeVar("_ScalarT_co", bound=generic, covariant=True) |
| _NumberT = TypeVar("_NumberT", bound=number) |
| _RealNumberT = TypeVar("_RealNumberT", bound=floating | integer) |
| _ArangeScalarT = TypeVar("_ArangeScalarT", bound=_ArangeScalar) |
| _UFuncT_co = TypeVar( |
| "_UFuncT_co", |
| # the `| Callable` simplifies self-binding to the ufunc's callable signature |
| bound=np.ufunc | Callable[..., object], |
| default=np.ufunc, |
| covariant=True, |
| ) |
| _Pss = ParamSpec("_Pss") |
| _T = TypeVar("_T") |
|
|
| _Ignored: TypeAlias = object |
|
|
| # A subset of `MaskedArray` that can be parametrized w.r.t. `np.generic` |
| _MaskedArray: TypeAlias = MaskedArray[_AnyShape, dtype[_ScalarT]] |
| _Masked1D: TypeAlias = MaskedArray[tuple[int], dtype[_ScalarT]] |
|
|
| _MaskedArrayUInt_co: TypeAlias = _MaskedArray[unsignedinteger | np.bool] |
| _MaskedArrayInt_co: TypeAlias = _MaskedArray[integer | np.bool] |
| _MaskedArrayFloat64_co: TypeAlias = _MaskedArray[floating[_64Bit] | float32 | float16 | integer | np.bool] |
| _MaskedArrayFloat_co: TypeAlias = _MaskedArray[floating | integer | np.bool] |
| _MaskedArrayComplex128_co: TypeAlias = _MaskedArray[number[_64Bit] | number[_32Bit] | float16 | integer | np.bool] |
| _MaskedArrayComplex_co: TypeAlias = _MaskedArray[inexact | integer | np.bool] |
| _MaskedArrayNumber_co: TypeAlias = _MaskedArray[number | np.bool] |
| _MaskedArrayTD64_co: TypeAlias = _MaskedArray[timedelta64 | integer | np.bool] |
|
|
| _ArrayInt_co: TypeAlias = NDArray[integer | bool_] |
| _Array1D: TypeAlias = np.ndarray[tuple[int], np.dtype[_ScalarT]] |
|
|
| _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 |
| _ArangeScalar: TypeAlias = floating | integer | datetime64 | timedelta64 |
|
|
| _NoMaskType: TypeAlias = np.bool_[Literal[False]] # type of `np.False_` |
| _MaskArray: TypeAlias = np.ndarray[_ShapeOrAnyT, np.dtype[np.bool_]] |
|
|
| _FillValue: TypeAlias = complex | None # int | float | complex | None |
| _FillValueCallable: TypeAlias = Callable[[np.dtype | ArrayLike], _FillValue] |
| _DomainCallable: TypeAlias = Callable[..., NDArray[np.bool_]] |
|
|
| ### |
|
|
| MaskType = np.bool_ |
|
|
| nomask: Final[_NoMaskType] = ... |
|
|
| class MaskedArrayFutureWarning(FutureWarning): ... |
| class MAError(Exception): ... |
| class MaskError(MAError): ... |
|
|
| # not generic at runtime |
| class _MaskedUFunc(Generic[_UFuncT_co]): |
| f: _UFuncT_co # readonly |
| def __init__(self, /, ufunc: _UFuncT_co) -> None: ... |
|
|
| # not generic at runtime |
| class _MaskedUnaryOperation(_MaskedUFunc[_UFuncT_co], Generic[_UFuncT_co]): |
| fill: Final[_FillValue] |
| domain: Final[_DomainCallable | None] |
|
|
| def __init__(self, /, mufunc: _UFuncT_co, fill: _FillValue = 0, domain: _DomainCallable | None = None) -> None: ... |
|
|
| # NOTE: This might not work with overloaded callable signatures might not work on |
| # pyright, which is a long-standing issue, and is unique to pyright: |
| # https://github.com/microsoft/pyright/issues/9663 |
| # https://github.com/microsoft/pyright/issues/10849 |
| # https://github.com/microsoft/pyright/issues/10899 |
| # https://github.com/microsoft/pyright/issues/11049 |
| def __call__( |
| self: _MaskedUnaryOperation[Callable[Concatenate[Any, _Pss], _T]], |
| /, |
| a: ArrayLike, |
| *args: _Pss.args, |
| **kwargs: _Pss.kwargs, |
| ) -> _T: ... |
|
|
| # not generic at runtime |
| class _MaskedBinaryOperation(_MaskedUFunc[_UFuncT_co], Generic[_UFuncT_co]): |
| fillx: Final[_FillValue] |
| filly: Final[_FillValue] |
|
|
| def __init__(self, /, mbfunc: _UFuncT_co, fillx: _FillValue = 0, filly: _FillValue = 0) -> None: ... |
|
|
| # NOTE: See the comment in `_MaskedUnaryOperation.__call__` |
| def __call__( |
| self: _MaskedBinaryOperation[Callable[Concatenate[Any, Any, _Pss], _T]], |
| /, |
| a: ArrayLike, |
| b: ArrayLike, |
| *args: _Pss.args, |
| **kwargs: _Pss.kwargs, |
| ) -> _T: ... |
|
|
| # NOTE: We cannot meaningfully annotate the return (d)types of these methods until |
| # the signatures of the corresponding `numpy.ufunc` methods are specified. |
| def reduce(self, /, target: ArrayLike, axis: SupportsIndex = 0, dtype: DTypeLike | None = None) -> Incomplete: ... |
| def outer(self, /, a: ArrayLike, b: ArrayLike) -> _MaskedArray[Incomplete]: ... |
| def accumulate(self, /, target: ArrayLike, axis: SupportsIndex = 0) -> _MaskedArray[Incomplete]: ... |
|
|
| # not generic at runtime |
| class _DomainedBinaryOperation(_MaskedUFunc[_UFuncT_co], Generic[_UFuncT_co]): |
| domain: Final[_DomainCallable] |
| fillx: Final[_FillValue] |
| filly: Final[_FillValue] |
|
|
| def __init__( |
| self, |
| /, |
| dbfunc: _UFuncT_co, |
| domain: _DomainCallable, |
| fillx: _FillValue = 0, |
| filly: _FillValue = 0, |
| ) -> None: ... |
|
|
| # NOTE: See the comment in `_MaskedUnaryOperation.__call__` |
| def __call__( |
| self: _DomainedBinaryOperation[Callable[Concatenate[Any, Any, _Pss], _T]], |
| /, |
| a: ArrayLike, |
| b: ArrayLike, |
| *args: _Pss.args, |
| **kwargs: _Pss.kwargs, |
| ) -> _T: ... |
|
|
| # not generic at runtime |
| class _extrema_operation(_MaskedUFunc[_UFuncT_co], Generic[_UFuncT_co]): |
| compare: Final[_MaskedBinaryOperation] |
| fill_value_func: Final[_FillValueCallable] |
|
|
| def __init__( |
| self, |
| /, |
| ufunc: _UFuncT_co, |
| compare: _MaskedBinaryOperation, |
| fill_value: _FillValueCallable, |
| ) -> None: ... |
|
|
| # NOTE: This class is only used internally for `maximum` and `minimum`, so we are |
| # able to annotate the `__call__` method specifically for those two functions. |
| @overload |
| def __call__(self, /, a: _ArrayLike[_ScalarT], b: _ArrayLike[_ScalarT]) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def __call__(self, /, a: ArrayLike, b: ArrayLike) -> _MaskedArray[Incomplete]: ... |
|
|
| # NOTE: We cannot meaningfully annotate the return (d)types of these methods until |
| # the signatures of the corresponding `numpy.ufunc` methods are specified. |
| def reduce(self, /, target: ArrayLike, axis: SupportsIndex | _NoValueType = ...) -> Incomplete: ... |
| def outer(self, /, a: ArrayLike, b: ArrayLike) -> _MaskedArray[Incomplete]: ... |
|
|
| @final |
| class _MaskedPrintOption: |
| _display: str |
| _enabled: bool | Literal[0, 1] |
| def __init__(self, /, display: str) -> None: ... |
| def display(self, /) -> str: ... |
| def set_display(self, /, s: str) -> None: ... |
| def enabled(self, /) -> bool: ... |
| def enable(self, /, shrink: bool | Literal[0, 1] = 1) -> None: ... |
|
|
| masked_print_option: Final[_MaskedPrintOption] = ... |
|
|
| exp: _MaskedUnaryOperation = ... |
| conjugate: _MaskedUnaryOperation = ... |
| sin: _MaskedUnaryOperation = ... |
| cos: _MaskedUnaryOperation = ... |
| arctan: _MaskedUnaryOperation = ... |
| arcsinh: _MaskedUnaryOperation = ... |
| sinh: _MaskedUnaryOperation = ... |
| cosh: _MaskedUnaryOperation = ... |
| tanh: _MaskedUnaryOperation = ... |
| abs: _MaskedUnaryOperation = ... |
| absolute: _MaskedUnaryOperation = ... |
| angle: _MaskedUnaryOperation = ... |
| fabs: _MaskedUnaryOperation = ... |
| negative: _MaskedUnaryOperation = ... |
| floor: _MaskedUnaryOperation = ... |
| ceil: _MaskedUnaryOperation = ... |
| around: _MaskedUnaryOperation = ... |
| logical_not: _MaskedUnaryOperation = ... |
| sqrt: _MaskedUnaryOperation = ... |
| log: _MaskedUnaryOperation = ... |
| log2: _MaskedUnaryOperation = ... |
| log10: _MaskedUnaryOperation = ... |
| tan: _MaskedUnaryOperation = ... |
| arcsin: _MaskedUnaryOperation = ... |
| arccos: _MaskedUnaryOperation = ... |
| arccosh: _MaskedUnaryOperation = ... |
| arctanh: _MaskedUnaryOperation = ... |
|
|
| add: _MaskedBinaryOperation = ... |
| subtract: _MaskedBinaryOperation = ... |
| multiply: _MaskedBinaryOperation = ... |
| arctan2: _MaskedBinaryOperation = ... |
| equal: _MaskedBinaryOperation = ... |
| not_equal: _MaskedBinaryOperation = ... |
| less_equal: _MaskedBinaryOperation = ... |
| greater_equal: _MaskedBinaryOperation = ... |
| less: _MaskedBinaryOperation = ... |
| greater: _MaskedBinaryOperation = ... |
| logical_and: _MaskedBinaryOperation = ... |
| def alltrue(target: ArrayLike, axis: SupportsIndex | None = 0, dtype: _DTypeLikeBool | None = None) -> Incomplete: ... |
| logical_or: _MaskedBinaryOperation = ... |
| def sometrue(target: ArrayLike, axis: SupportsIndex | None = 0, dtype: _DTypeLikeBool | None = None) -> Incomplete: ... |
| logical_xor: _MaskedBinaryOperation = ... |
| bitwise_and: _MaskedBinaryOperation = ... |
| bitwise_or: _MaskedBinaryOperation = ... |
| bitwise_xor: _MaskedBinaryOperation = ... |
| hypot: _MaskedBinaryOperation = ... |
|
|
| divide: _DomainedBinaryOperation = ... |
| true_divide: _DomainedBinaryOperation = ... |
| floor_divide: _DomainedBinaryOperation = ... |
| remainder: _DomainedBinaryOperation = ... |
| fmod: _DomainedBinaryOperation = ... |
| mod: _DomainedBinaryOperation = ... |
|
|
| # `obj` can be anything (even `object()`), and is too "flexible", so we can't |
| # meaningfully annotate it, or its return type. |
| def default_fill_value(obj: object) -> Any: ... |
| def minimum_fill_value(obj: object) -> Any: ... |
| def maximum_fill_value(obj: object) -> Any: ... |
|
|
| # |
| @overload # returns `a.fill_value` if `a` is a `MaskedArray` |
| def get_fill_value(a: _MaskedArray[_ScalarT]) -> _ScalarT: ... |
| @overload # otherwise returns `default_fill_value(a)` |
| def get_fill_value(a: object) -> Any: ... |
|
|
| # this is a noop if `a` isn't a `MaskedArray`, so we only accept `MaskedArray` input |
| def set_fill_value(a: MaskedArray, fill_value: _ScalarLike_co) -> None: ... |
|
|
| # the return type depends on the *values* of `a` and `b` (which cannot be known |
| # statically), which is why we need to return an awkward `_ | None` |
| @overload |
| def common_fill_value(a: _MaskedArray[_ScalarT], b: MaskedArray) -> _ScalarT | None: ... |
| @overload |
| def common_fill_value(a: object, b: object) -> Any: ... |
|
|
| # keep in sync with `fix_invalid`, but return `ndarray` instead of `MaskedArray` |
| @overload |
| def filled(a: ndarray[_ShapeT, _DTypeT], fill_value: _ScalarLike_co | None = None) -> ndarray[_ShapeT, _DTypeT]: ... |
| @overload |
| def filled(a: _ArrayLike[_ScalarT], fill_value: _ScalarLike_co | None = None) -> NDArray[_ScalarT]: ... |
| @overload |
| def filled(a: ArrayLike, fill_value: _ScalarLike_co | None = None) -> NDArray[Incomplete]: ... |
|
|
| # keep in sync with `filled`, but return `MaskedArray` instead of `ndarray` |
| @overload |
| def fix_invalid( |
| a: np.ndarray[_ShapeT, _DTypeT], |
| mask: _ArrayLikeBool_co = nomask, |
| copy: bool = True, |
| fill_value: _ScalarLike_co | None = None, |
| ) -> MaskedArray[_ShapeT, _DTypeT]: ... |
| @overload |
| def fix_invalid( |
| a: _ArrayLike[_ScalarT], |
| mask: _ArrayLikeBool_co = nomask, |
| copy: bool = True, |
| fill_value: _ScalarLike_co | None = None, |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def fix_invalid( |
| a: ArrayLike, |
| mask: _ArrayLikeBool_co = nomask, |
| copy: bool = True, |
| fill_value: _ScalarLike_co | None = None, |
| ) -> _MaskedArray[Incomplete]: ... |
|
|
| # |
| def get_masked_subclass(*arrays: object) -> type[MaskedArray]: ... |
|
|
| # |
| @overload |
| def getdata(a: np.ndarray[_ShapeT, _DTypeT], subok: bool = True) -> np.ndarray[_ShapeT, _DTypeT]: ... |
| @overload |
| def getdata(a: _ArrayLike[_ScalarT], subok: bool = True) -> NDArray[_ScalarT]: ... |
| @overload |
| def getdata(a: ArrayLike, subok: bool = True) -> NDArray[Incomplete]: ... |
|
|
| get_data = getdata |
|
|
| # |
| @overload |
| def getmask(a: _ScalarLike_co) -> _NoMaskType: ... |
| @overload |
| def getmask(a: MaskedArray[_ShapeT, Any]) -> _MaskArray[_ShapeT] | _NoMaskType: ... |
| @overload |
| def getmask(a: ArrayLike) -> _MaskArray | _NoMaskType: ... |
|
|
| get_mask = getmask |
|
|
| # like `getmask`, but instead of `nomask` returns `make_mask_none(arr, arr.dtype?)` |
| @overload |
| def getmaskarray(arr: _ScalarLike_co) -> _MaskArray[tuple[()]]: ... |
| @overload |
| def getmaskarray(arr: np.ndarray[_ShapeT, Any]) -> _MaskArray[_ShapeT]: ... |
|
|
| # It's sufficient for `m` to have dtype with type: `type[np.bool_]`, |
| # which isn't necessarily a ndarray. Please open an issue if this causes issues. |
| def is_mask(m: object) -> TypeIs[NDArray[bool_]]: ... |
|
|
| # |
| @overload |
| def make_mask_descr(ndtype: _VoidDTypeLike) -> np.dtype[np.void]: ... |
| @overload |
| def make_mask_descr(ndtype: _DTypeLike[np.generic] | str | type) -> np.dtype[np.bool_]: ... |
|
|
| # |
| @overload # m is nomask |
| def make_mask( |
| m: _NoMaskType, |
| copy: bool = False, |
| shrink: bool = True, |
| dtype: _DTypeLikeBool = ..., |
| ) -> _NoMaskType: ... |
| @overload # m: ndarray, shrink=True (default), dtype: bool-like (default) |
| def make_mask( |
| m: np.ndarray[_ShapeT], |
| copy: bool = False, |
| shrink: Literal[True] = True, |
| dtype: _DTypeLikeBool = ..., |
| ) -> _MaskArray[_ShapeT] | _NoMaskType: ... |
| @overload # m: ndarray, shrink=False (kwarg), dtype: bool-like (default) |
| def make_mask( |
| m: np.ndarray[_ShapeT], |
| copy: bool = False, |
| *, |
| shrink: Literal[False], |
| dtype: _DTypeLikeBool = ..., |
| ) -> _MaskArray[_ShapeT]: ... |
| @overload # m: ndarray, dtype: void-like |
| def make_mask( |
| m: np.ndarray[_ShapeT], |
| copy: bool = False, |
| shrink: bool = True, |
| *, |
| dtype: _DTypeLikeVoid, |
| ) -> np.ndarray[_ShapeT, np.dtype[np.void]]: ... |
| @overload # m: array-like, shrink=True (default), dtype: bool-like (default) |
| def make_mask( |
| m: ArrayLike, |
| copy: bool = False, |
| shrink: Literal[True] = True, |
| dtype: _DTypeLikeBool = ..., |
| ) -> _MaskArray | _NoMaskType: ... |
| @overload # m: array-like, shrink=False (kwarg), dtype: bool-like (default) |
| def make_mask( |
| m: ArrayLike, |
| copy: bool = False, |
| *, |
| shrink: Literal[False], |
| dtype: _DTypeLikeBool = ..., |
| ) -> _MaskArray: ... |
| @overload # m: array-like, dtype: void-like |
| def make_mask( |
| m: ArrayLike, |
| copy: bool = False, |
| shrink: bool = True, |
| *, |
| dtype: _DTypeLikeVoid, |
| ) -> NDArray[np.void]: ... |
| @overload # fallback |
| def make_mask( |
| m: ArrayLike, |
| copy: bool = False, |
| shrink: bool = True, |
| *, |
| dtype: DTypeLike = ..., |
| ) -> NDArray[Incomplete] | _NoMaskType: ... |
|
|
| # |
| @overload # known shape, dtype: unstructured (default) |
| def make_mask_none(newshape: _ShapeT, dtype: np.dtype | type | str | None = None) -> _MaskArray[_ShapeT]: ... |
| @overload # known shape, dtype: structured |
| def make_mask_none(newshape: _ShapeT, dtype: _VoidDTypeLike) -> np.ndarray[_ShapeT, dtype[np.void]]: ... |
| @overload # unknown shape, dtype: unstructured (default) |
| def make_mask_none(newshape: _ShapeLike, dtype: np.dtype | type | str | None = None) -> _MaskArray: ... |
| @overload # unknown shape, dtype: structured |
| def make_mask_none(newshape: _ShapeLike, dtype: _VoidDTypeLike) -> NDArray[np.void]: ... |
|
|
| # |
| @overload # nomask, scalar-like, shrink=True (default) |
| def mask_or( |
| m1: _NoMaskType | Literal[False], |
| m2: _ScalarLike_co, |
| copy: bool = False, |
| shrink: Literal[True] = True, |
| ) -> _NoMaskType: ... |
| @overload # nomask, scalar-like, shrink=False (kwarg) |
| def mask_or( |
| m1: _NoMaskType | Literal[False], |
| m2: _ScalarLike_co, |
| copy: bool = False, |
| *, |
| shrink: Literal[False], |
| ) -> _MaskArray[tuple[()]]: ... |
| @overload # scalar-like, nomask, shrink=True (default) |
| def mask_or( |
| m1: _ScalarLike_co, |
| m2: _NoMaskType | Literal[False], |
| copy: bool = False, |
| shrink: Literal[True] = True, |
| ) -> _NoMaskType: ... |
| @overload # scalar-like, nomask, shrink=False (kwarg) |
| def mask_or( |
| m1: _ScalarLike_co, |
| m2: _NoMaskType | Literal[False], |
| copy: bool = False, |
| *, |
| shrink: Literal[False], |
| ) -> _MaskArray[tuple[()]]: ... |
| @overload # ndarray, ndarray | nomask, shrink=True (default) |
| def mask_or( |
| m1: np.ndarray[_ShapeT, np.dtype[_ScalarT]], |
| m2: np.ndarray[_ShapeT, np.dtype[_ScalarT]] | _NoMaskType | Literal[False], |
| copy: bool = False, |
| shrink: Literal[True] = True, |
| ) -> _MaskArray[_ShapeT] | _NoMaskType: ... |
| @overload # ndarray, ndarray | nomask, shrink=False (kwarg) |
| def mask_or( |
| m1: np.ndarray[_ShapeT, np.dtype[_ScalarT]], |
| m2: np.ndarray[_ShapeT, np.dtype[_ScalarT]] | _NoMaskType | Literal[False], |
| copy: bool = False, |
| *, |
| shrink: Literal[False], |
| ) -> _MaskArray[_ShapeT]: ... |
| @overload # ndarray | nomask, ndarray, shrink=True (default) |
| def mask_or( |
| m1: np.ndarray[_ShapeT, np.dtype[_ScalarT]] | _NoMaskType | Literal[False], |
| m2: np.ndarray[_ShapeT, np.dtype[_ScalarT]], |
| copy: bool = False, |
| shrink: Literal[True] = True, |
| ) -> _MaskArray[_ShapeT] | _NoMaskType: ... |
| @overload # ndarray | nomask, ndarray, shrink=False (kwarg) |
| def mask_or( |
| m1: np.ndarray[_ShapeT, np.dtype[_ScalarT]] | _NoMaskType | Literal[False], |
| m2: np.ndarray[_ShapeT, np.dtype[_ScalarT]], |
| copy: bool = False, |
| *, |
| shrink: Literal[False], |
| ) -> _MaskArray[_ShapeT]: ... |
|
|
| # |
| @overload |
| def flatten_mask(mask: np.ndarray[_ShapeT]) -> _MaskArray[_ShapeT]: ... |
| @overload |
| def flatten_mask(mask: ArrayLike) -> _MaskArray: ... |
|
|
| # NOTE: we currently don't know the field types of `void` dtypes, so it's not possible |
| # to know the output dtype of the returned array. |
| @overload |
| def flatten_structured_array(a: MaskedArray[_ShapeT, np.dtype[np.void]]) -> MaskedArray[_ShapeT]: ... |
| @overload |
| def flatten_structured_array(a: np.ndarray[_ShapeT, np.dtype[np.void]]) -> np.ndarray[_ShapeT]: ... |
| @overload # for some reason this accepts unstructured array-likes, hence this fallback overload |
| def flatten_structured_array(a: ArrayLike) -> np.ndarray: ... |
|
|
| # keep in sync with other the `masked_*` functions |
| @overload # known array with known shape and dtype |
| def masked_invalid(a: ndarray[_ShapeT, _DTypeT], copy: bool = True) -> MaskedArray[_ShapeT, _DTypeT]: ... |
| @overload # array-like of known scalar-type |
| def masked_invalid(a: _ArrayLike[_ScalarT], copy: bool = True) -> _MaskedArray[_ScalarT]: ... |
| @overload # unknown array-like |
| def masked_invalid(a: ArrayLike, copy: bool = True) -> _MaskedArray[Incomplete]: ... |
|
|
| # keep in sync with other the `masked_*` functions |
| @overload # array-like of known scalar-type |
| def masked_where( |
| condition: _ArrayLikeBool_co, a: ndarray[_ShapeT, _DTypeT], copy: bool = True |
| ) -> MaskedArray[_ShapeT, _DTypeT]: ... |
| @overload # array-like of known scalar-type |
| def masked_where(condition: _ArrayLikeBool_co, a: _ArrayLike[_ScalarT], copy: bool = True) -> _MaskedArray[_ScalarT]: ... |
| @overload # unknown array-like |
| def masked_where(condition: _ArrayLikeBool_co, a: ArrayLike, copy: bool = True) -> _MaskedArray[Incomplete]: ... |
|
|
| # keep in sync with other the `masked_*` functions |
| @overload # known array with known shape and dtype |
| def masked_greater(x: ndarray[_ShapeT, _DTypeT], value: ArrayLike, copy: bool = True) -> MaskedArray[_ShapeT, _DTypeT]: ... |
| @overload # array-like of known scalar-type |
| def masked_greater(x: _ArrayLike[_ScalarT], value: ArrayLike, copy: bool = True) -> _MaskedArray[_ScalarT]: ... |
| @overload # unknown array-like |
| def masked_greater(x: ArrayLike, value: ArrayLike, copy: bool = True) -> _MaskedArray[Incomplete]: ... |
|
|
| # keep in sync with other the `masked_*` functions |
| @overload # known array with known shape and dtype |
| def masked_greater_equal(x: ndarray[_ShapeT, _DTypeT], value: ArrayLike, copy: bool = True) -> MaskedArray[_ShapeT, _DTypeT]: ... |
| @overload # array-like of known scalar-type |
| def masked_greater_equal(x: _ArrayLike[_ScalarT], value: ArrayLike, copy: bool = True) -> _MaskedArray[_ScalarT]: ... |
| @overload # unknown array-like |
| def masked_greater_equal(x: ArrayLike, value: ArrayLike, copy: bool = True) -> _MaskedArray[Incomplete]: ... |
|
|
| # keep in sync with other the `masked_*` functions |
| @overload # known array with known shape and dtype |
| def masked_less(x: ndarray[_ShapeT, _DTypeT], value: ArrayLike, copy: bool = True) -> MaskedArray[_ShapeT, _DTypeT]: ... |
| @overload # array-like of known scalar-type |
| def masked_less(x: _ArrayLike[_ScalarT], value: ArrayLike, copy: bool = True) -> _MaskedArray[_ScalarT]: ... |
| @overload # unknown array-like |
| def masked_less(x: ArrayLike, value: ArrayLike, copy: bool = True) -> _MaskedArray[Incomplete]: ... |
|
|
| # keep in sync with other the `masked_*` functions |
| @overload # known array with known shape and dtype |
| def masked_less_equal(x: ndarray[_ShapeT, _DTypeT], value: ArrayLike, copy: bool = True) -> MaskedArray[_ShapeT, _DTypeT]: ... |
| @overload # array-like of known scalar-type |
| def masked_less_equal(x: _ArrayLike[_ScalarT], value: ArrayLike, copy: bool = True) -> _MaskedArray[_ScalarT]: ... |
| @overload # unknown array-like |
| def masked_less_equal(x: ArrayLike, value: ArrayLike, copy: bool = True) -> _MaskedArray[Incomplete]: ... |
|
|
| # keep in sync with other the `masked_*` functions |
| @overload # known array with known shape and dtype |
| def masked_not_equal(x: ndarray[_ShapeT, _DTypeT], value: ArrayLike, copy: bool = True) -> MaskedArray[_ShapeT, _DTypeT]: ... |
| @overload # array-like of known scalar-type |
| def masked_not_equal(x: _ArrayLike[_ScalarT], value: ArrayLike, copy: bool = True) -> _MaskedArray[_ScalarT]: ... |
| @overload # unknown array-like |
| def masked_not_equal(x: ArrayLike, value: ArrayLike, copy: bool = True) -> _MaskedArray[Incomplete]: ... |
|
|
| # keep in sync with other the `masked_*` functions |
| @overload # known array with known shape and dtype |
| def masked_equal(x: ndarray[_ShapeT, _DTypeT], value: ArrayLike, copy: bool = True) -> MaskedArray[_ShapeT, _DTypeT]: ... |
| @overload # array-like of known scalar-type |
| def masked_equal(x: _ArrayLike[_ScalarT], value: ArrayLike, copy: bool = True) -> _MaskedArray[_ScalarT]: ... |
| @overload # unknown array-like |
| def masked_equal(x: ArrayLike, value: ArrayLike, copy: bool = True) -> _MaskedArray[Incomplete]: ... |
|
|
| # keep in sync with other the `masked_*` functions |
| @overload # known array with known shape and dtype |
| def masked_inside(x: ndarray[_ShapeT, _DTypeT], v1: ArrayLike, v2: ArrayLike, copy: bool = True) -> MaskedArray[_ShapeT, _DTypeT]: ... |
| @overload # array-like of known scalar-type |
| def masked_inside(x: _ArrayLike[_ScalarT], v1: ArrayLike, v2: ArrayLike, copy: bool = True) -> _MaskedArray[_ScalarT]: ... |
| @overload # unknown array-like |
| def masked_inside(x: ArrayLike, v1: ArrayLike, v2: ArrayLike, copy: bool = True) -> _MaskedArray[Incomplete]: ... |
|
|
| # keep in sync with other the `masked_*` functions |
| @overload # known array with known shape and dtype |
| def masked_outside(x: ndarray[_ShapeT, _DTypeT], v1: ArrayLike, v2: ArrayLike, copy: bool = True) -> MaskedArray[_ShapeT, _DTypeT]: ... |
| @overload # array-like of known scalar-type |
| def masked_outside(x: _ArrayLike[_ScalarT], v1: ArrayLike, v2: ArrayLike, copy: bool = True) -> _MaskedArray[_ScalarT]: ... |
| @overload # unknown array-like |
| def masked_outside(x: ArrayLike, v1: ArrayLike, v2: ArrayLike, copy: bool = True) -> _MaskedArray[Incomplete]: ... |
|
|
| # only intended for object arrays, so we assume that's how it's always used in practice |
| @overload |
| def masked_object( |
| x: np.ndarray[_ShapeT, np.dtype[np.object_]], |
| value: object, |
| copy: bool = True, |
| shrink: bool = True, |
| ) -> MaskedArray[_ShapeT, np.dtype[np.object_]]: ... |
| @overload |
| def masked_object( |
| x: _ArrayLikeObject_co, |
| value: object, |
| copy: bool = True, |
| shrink: bool = True, |
| ) -> _MaskedArray[np.object_]: ... |
|
|
| # keep roughly in sync with `filled` |
| @overload |
| def masked_values( |
| x: np.ndarray[_ShapeT, _DTypeT], |
| value: _ScalarLike_co, |
| rtol: float = 1e-5, |
| atol: float = 1e-8, |
| copy: bool = True, |
| shrink: bool = True |
| ) -> MaskedArray[_ShapeT, _DTypeT]: ... |
| @overload |
| def masked_values( |
| x: _ArrayLike[_ScalarT], |
| value: _ScalarLike_co, |
| rtol: float = 1e-5, |
| atol: float = 1e-8, |
| copy: bool = True, |
| shrink: bool = True |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def masked_values( |
| x: ArrayLike, |
| value: _ScalarLike_co, |
| rtol: float = 1e-5, |
| atol: float = 1e-8, |
| copy: bool = True, |
| shrink: bool = True |
| ) -> _MaskedArray[Incomplete]: ... |
|
|
| # TODO: Support non-boolean mask dtypes, such as `np.void`. This will require adding an |
| # additional generic type parameter to (at least) `MaskedArray` and `MaskedIterator` to |
| # hold the dtype of the mask. |
|
|
| class MaskedIterator(Generic[_ShapeT_co, _DTypeT_co]): |
| ma: MaskedArray[_ShapeT_co, _DTypeT_co] # readonly |
| dataiter: np.flatiter[ndarray[_ShapeT_co, _DTypeT_co]] # readonly |
| maskiter: Final[np.flatiter[NDArray[np.bool]]] |
|
|
| def __init__(self, ma: MaskedArray[_ShapeT_co, _DTypeT_co]) -> None: ... |
| def __iter__(self) -> Self: ... |
|
|
| # Similar to `MaskedArray.__getitem__` but without the `void` case. |
| @overload |
| def __getitem__(self, indx: _ArrayInt_co | tuple[_ArrayInt_co, ...], /) -> MaskedArray[_AnyShape, _DTypeT_co]: ... |
| @overload |
| def __getitem__(self, indx: SupportsIndex | tuple[SupportsIndex, ...], /) -> Incomplete: ... |
| @overload |
| def __getitem__(self, indx: _ToIndices, /) -> MaskedArray[_AnyShape, _DTypeT_co]: ... |
|
|
| # Similar to `ndarray.__setitem__` but without the `void` case. |
| @overload # flexible | object_ | bool |
| def __setitem__( |
| self: MaskedIterator[Any, dtype[flexible | object_ | np.bool] | dtypes.StringDType], |
| index: _ToIndices, |
| value: object, |
| /, |
| ) -> None: ... |
| @overload # integer |
| def __setitem__( |
| self: MaskedIterator[Any, dtype[integer]], |
| index: _ToIndices, |
| value: _ConvertibleToInt | _NestedSequence[_ConvertibleToInt] | _ArrayLikeInt_co, |
| /, |
| ) -> None: ... |
| @overload # floating |
| def __setitem__( |
| self: MaskedIterator[Any, dtype[floating]], |
| index: _ToIndices, |
| value: _ConvertibleToFloat | _NestedSequence[_ConvertibleToFloat | None] | _ArrayLikeFloat_co | None, |
| /, |
| ) -> None: ... |
| @overload # complexfloating |
| def __setitem__( |
| self: MaskedIterator[Any, dtype[complexfloating]], |
| index: _ToIndices, |
| value: _ConvertibleToComplex | _NestedSequence[_ConvertibleToComplex | None] | _ArrayLikeNumber_co | None, |
| /, |
| ) -> None: ... |
| @overload # timedelta64 |
| def __setitem__( |
| self: MaskedIterator[Any, dtype[timedelta64]], |
| index: _ToIndices, |
| value: _ConvertibleToTD64 | _NestedSequence[_ConvertibleToTD64], |
| /, |
| ) -> None: ... |
| @overload # datetime64 |
| def __setitem__( |
| self: MaskedIterator[Any, dtype[datetime64]], |
| index: _ToIndices, |
| value: _ConvertibleToDT64 | _NestedSequence[_ConvertibleToDT64], |
| /, |
| ) -> None: ... |
| @overload # catch-all |
| def __setitem__(self, index: _ToIndices, value: ArrayLike, /) -> None: ... |
|
|
| # TODO: Returns `mvoid[(), _DTypeT_co]` for masks with `np.void` dtype. |
| def __next__(self: MaskedIterator[Any, np.dtype[_ScalarT]]) -> _ScalarT: ... |
|
|
| class MaskedArray(ndarray[_ShapeT_co, _DTypeT_co]): |
| __array_priority__: Final[Literal[15]] = 15 |
|
|
| @overload |
| def __new__( |
| cls, |
| data: _ArrayLike[_ScalarT], |
| mask: _ArrayLikeBool_co = nomask, |
| dtype: None = None, |
| copy: bool = False, |
| subok: bool = True, |
| ndmin: int = 0, |
| fill_value: _ScalarLike_co | None = None, |
| keep_mask: bool = True, |
| hard_mask: bool | None = None, |
| shrink: bool = True, |
| order: _OrderKACF | None = None, |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def __new__( |
| cls, |
| data: object, |
| mask: _ArrayLikeBool_co, |
| dtype: _DTypeLike[_ScalarT], |
| copy: bool = False, |
| subok: bool = True, |
| ndmin: int = 0, |
| fill_value: _ScalarLike_co | None = None, |
| keep_mask: bool = True, |
| hard_mask: bool | None = None, |
| shrink: bool = True, |
| order: _OrderKACF | None = None, |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def __new__( |
| cls, |
| data: object, |
| mask: _ArrayLikeBool_co = nomask, |
| *, |
| dtype: _DTypeLike[_ScalarT], |
| copy: bool = False, |
| subok: bool = True, |
| ndmin: int = 0, |
| fill_value: _ScalarLike_co | None = None, |
| keep_mask: bool = True, |
| hard_mask: bool | None = None, |
| shrink: bool = True, |
| order: _OrderKACF | None = None, |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def __new__( |
| cls, |
| data: object = None, |
| mask: _ArrayLikeBool_co = nomask, |
| dtype: DTypeLike | None = None, |
| copy: bool = False, |
| subok: bool = True, |
| ndmin: int = 0, |
| fill_value: _ScalarLike_co | None = None, |
| keep_mask: bool = True, |
| hard_mask: bool | None = None, |
| shrink: bool = True, |
| order: _OrderKACF | None = None, |
| ) -> _MaskedArray[Any]: ... |
|
|
| def __array_wrap__( |
| self, |
| obj: ndarray[_ShapeT, _DTypeT], |
| context: tuple[ufunc, tuple[Any, ...], int] | None = None, |
| return_scalar: bool = False, |
| ) -> MaskedArray[_ShapeT, _DTypeT]: ... |
|
|
| @overload # type: ignore[override] # () |
| def view(self, /, dtype: None = None, type: None = None, fill_value: _ScalarLike_co | None = None) -> Self: ... |
| @overload # (dtype: DTypeT) |
| def view( |
| self, |
| /, |
| dtype: _DTypeT | _HasDType[_DTypeT], |
| type: None = None, |
| fill_value: _ScalarLike_co | None = None |
| ) -> MaskedArray[_ShapeT_co, _DTypeT]: ... |
| @overload # (dtype: dtype[ScalarT]) |
| def view( |
| self, |
| /, |
| dtype: _DTypeLike[_ScalarT], |
| type: None = None, |
| fill_value: _ScalarLike_co | None = None |
| ) -> MaskedArray[_ShapeT_co, dtype[_ScalarT]]: ... |
| @overload # ([dtype: _, ]*, type: ArrayT) |
| def view( |
| self, |
| /, |
| dtype: DTypeLike | None = None, |
| *, |
| type: type[_ArrayT], |
| fill_value: _ScalarLike_co | None = None |
| ) -> _ArrayT: ... |
| @overload # (dtype: _, type: ArrayT) |
| def view(self, /, dtype: DTypeLike | None, type: type[_ArrayT], fill_value: _ScalarLike_co | None = None) -> _ArrayT: ... |
| @overload # (dtype: ArrayT, /) |
| def view(self, /, dtype: type[_ArrayT], type: None = None, fill_value: _ScalarLike_co | None = None) -> _ArrayT: ... |
| @overload # (dtype: ?) |
| def view( |
| self, |
| /, |
| # `_VoidDTypeLike | str | None` is like `DTypeLike` but without `_DTypeLike[Any]` to avoid |
| # overlaps with previous overloads. |
| dtype: _VoidDTypeLike | str | None, |
| type: None = None, |
| fill_value: _ScalarLike_co | None = None |
| ) -> MaskedArray[_ShapeT_co, dtype]: ... |
|
|
| # Keep in sync with `ndarray.__getitem__` |
| @overload |
| def __getitem__(self, key: _ArrayInt_co | tuple[_ArrayInt_co, ...], /) -> MaskedArray[_AnyShape, _DTypeT_co]: ... |
| @overload |
| def __getitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...], /) -> Any: ... |
| @overload |
| def __getitem__(self, key: _ToIndices, /) -> MaskedArray[_AnyShape, _DTypeT_co]: ... |
| @overload |
| def __getitem__(self: _MaskedArray[void], indx: str, /) -> MaskedArray[_ShapeT_co, dtype]: ... |
| @overload |
| def __getitem__(self: _MaskedArray[void], indx: list[str], /) -> MaskedArray[_ShapeT_co, dtype[void]]: ... |
|
|
| @property |
| def shape(self) -> _ShapeT_co: ... |
| @shape.setter # type: ignore[override] |
| def shape(self: MaskedArray[_ShapeT, Any], shape: _ShapeT, /) -> None: ... |
|
|
| def __setmask__(self, mask: _ArrayLikeBool_co, copy: bool = False) -> None: ... |
| @property |
| def mask(self) -> np.ndarray[_ShapeT_co, dtype[MaskType]] | MaskType: ... |
| @mask.setter |
| def mask(self, value: _ArrayLikeBool_co, /) -> None: ... |
| @property |
| def recordmask(self) -> np.ndarray[_ShapeT_co, dtype[MaskType]] | MaskType: ... |
| @recordmask.setter |
| def recordmask(self, mask: Never, /) -> NoReturn: ... |
| def harden_mask(self) -> Self: ... |
| def soften_mask(self) -> Self: ... |
| @property |
| def hardmask(self) -> bool: ... |
| def unshare_mask(self) -> Self: ... |
| @property |
| def sharedmask(self) -> bool: ... |
| def shrink_mask(self) -> Self: ... |
|
|
| @property |
| def baseclass(self) -> type[ndarray]: ... |
|
|
| @property |
| def _data(self) -> ndarray[_ShapeT_co, _DTypeT_co]: ... |
| @property |
| def data(self) -> ndarray[_ShapeT_co, _DTypeT_co]: ... # type: ignore[override] |
|
|
| @property # type: ignore[override] |
| def flat(self) -> MaskedIterator[_ShapeT_co, _DTypeT_co]: ... |
| @flat.setter |
| def flat(self, value: ArrayLike, /) -> None: ... |
|
|
| @property |
| def fill_value(self: _MaskedArray[_ScalarT]) -> _ScalarT: ... |
| @fill_value.setter |
| def fill_value(self, value: _ScalarLike_co | None = None, /) -> None: ... |
|
|
| def get_fill_value(self: _MaskedArray[_ScalarT]) -> _ScalarT: ... |
| def set_fill_value(self, /, value: _ScalarLike_co | None = None) -> None: ... |
|
|
| def filled(self, /, fill_value: _ScalarLike_co | None = None) -> ndarray[_ShapeT_co, _DTypeT_co]: ... |
| def compressed(self) -> ndarray[tuple[int], _DTypeT_co]: ... |
|
|
| # keep roughly in sync with `ma.core.compress`, but swap the first two arguments |
| @overload # type: ignore[override] |
| def compress( |
| self, |
| condition: _ArrayLikeBool_co, |
| axis: _ShapeLike | None, |
| out: _ArrayT |
| ) -> _ArrayT: ... |
| @overload |
| def compress( |
| self, |
| condition: _ArrayLikeBool_co, |
| axis: _ShapeLike | None = None, |
| *, |
| out: _ArrayT |
| ) -> _ArrayT: ... |
| @overload |
| def compress( |
| self, |
| condition: _ArrayLikeBool_co, |
| axis: None = None, |
| out: None = None |
| ) -> MaskedArray[tuple[int], _DTypeT_co]: ... |
| @overload |
| def compress( |
| self, |
| condition: _ArrayLikeBool_co, |
| axis: _ShapeLike | None = None, |
| out: None = None |
| ) -> MaskedArray[_AnyShape, _DTypeT_co]: ... |
|
|
| # TODO: How to deal with the non-commutative nature of `==` and `!=`? |
| # xref numpy/numpy#17368 |
| def __eq__(self, other: Incomplete, /) -> Incomplete: ... |
| def __ne__(self, other: Incomplete, /) -> Incomplete: ... |
|
|
| def __ge__(self, other: ArrayLike, /) -> _MaskedArray[bool_]: ... # type: ignore[override] |
| def __gt__(self, other: ArrayLike, /) -> _MaskedArray[bool_]: ... # type: ignore[override] |
| def __le__(self, other: ArrayLike, /) -> _MaskedArray[bool_]: ... # type: ignore[override] |
| def __lt__(self, other: ArrayLike, /) -> _MaskedArray[bool_]: ... # type: ignore[override] |
|
|
| # Keep in sync with `ndarray.__add__` |
| @overload # type: ignore[override] |
| def __add__(self: _MaskedArray[_NumberT], other: int | np.bool, /) -> MaskedArray[_ShapeT_co, dtype[_NumberT]]: ... |
| @overload |
| def __add__(self: _MaskedArray[_NumberT], other: _ArrayLikeBool_co, /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __add__(self: _MaskedArray[np.bool], other: _ArrayLikeBool_co, /) -> _MaskedArray[np.bool]: ... # type: ignore[overload-overlap] |
| @overload |
| def __add__(self: _MaskedArray[np.bool], other: _ArrayLike[_NumberT], /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __add__(self: _MaskedArray[float64], other: _ArrayLikeFloat64_co, /) -> _MaskedArray[float64]: ... |
| @overload |
| def __add__(self: _MaskedArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> _MaskedArray[float64]: ... |
| @overload |
| def __add__(self: _MaskedArray[complex128], other: _ArrayLikeComplex128_co, /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __add__(self: _MaskedArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __add__(self: _MaskedArrayUInt_co, other: _ArrayLikeUInt_co, /) -> _MaskedArray[unsignedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __add__(self: _MaskedArrayInt_co, other: _ArrayLikeInt_co, /) -> _MaskedArray[signedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __add__(self: _MaskedArrayFloat_co, other: _ArrayLikeFloat_co, /) -> _MaskedArray[floating]: ... # type: ignore[overload-overlap] |
| @overload |
| def __add__(self: _MaskedArrayComplex_co, other: _ArrayLikeComplex_co, /) -> _MaskedArray[complexfloating]: ... # type: ignore[overload-overlap] |
| @overload |
| def __add__(self: _MaskedArray[number], other: _ArrayLikeNumber_co, /) -> _MaskedArray[number]: ... # type: ignore[overload-overlap] |
| @overload |
| def __add__(self: _MaskedArrayTD64_co, other: _ArrayLikeTD64_co, /) -> _MaskedArray[timedelta64]: ... |
| @overload |
| def __add__(self: _MaskedArrayTD64_co, other: _ArrayLikeDT64_co, /) -> _MaskedArray[datetime64]: ... |
| @overload |
| def __add__(self: _MaskedArray[datetime64], other: _ArrayLikeTD64_co, /) -> _MaskedArray[datetime64]: ... |
| @overload |
| def __add__(self: _MaskedArray[bytes_], other: _ArrayLikeBytes_co, /) -> _MaskedArray[bytes_]: ... |
| @overload |
| def __add__(self: _MaskedArray[str_], other: _ArrayLikeStr_co, /) -> _MaskedArray[str_]: ... |
| @overload |
| def __add__( |
| self: MaskedArray[Any, dtypes.StringDType], |
| other: _ArrayLikeStr_co | _ArrayLikeString_co, |
| /, |
| ) -> MaskedArray[_AnyShape, dtypes.StringDType]: ... |
| @overload |
| def __add__(self: _MaskedArray[object_], other: Any, /) -> Any: ... |
| @overload |
| def __add__(self: _MaskedArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... |
|
|
| # Keep in sync with `ndarray.__radd__` |
| @overload # type: ignore[override] # signature equivalent to __add__ |
| def __radd__(self: _MaskedArray[_NumberT], other: int | np.bool, /) -> MaskedArray[_ShapeT_co, dtype[_NumberT]]: ... |
| @overload |
| def __radd__(self: _MaskedArray[_NumberT], other: _ArrayLikeBool_co, /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __radd__(self: _MaskedArray[np.bool], other: _ArrayLikeBool_co, /) -> _MaskedArray[np.bool]: ... # type: ignore[overload-overlap] |
| @overload |
| def __radd__(self: _MaskedArray[np.bool], other: _ArrayLike[_NumberT], /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __radd__(self: _MaskedArray[float64], other: _ArrayLikeFloat64_co, /) -> _MaskedArray[float64]: ... |
| @overload |
| def __radd__(self: _MaskedArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> _MaskedArray[float64]: ... |
| @overload |
| def __radd__(self: _MaskedArray[complex128], other: _ArrayLikeComplex128_co, /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __radd__(self: _MaskedArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __radd__(self: _MaskedArrayUInt_co, other: _ArrayLikeUInt_co, /) -> _MaskedArray[unsignedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __radd__(self: _MaskedArrayInt_co, other: _ArrayLikeInt_co, /) -> _MaskedArray[signedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __radd__(self: _MaskedArrayFloat_co, other: _ArrayLikeFloat_co, /) -> _MaskedArray[floating]: ... # type: ignore[overload-overlap] |
| @overload |
| def __radd__(self: _MaskedArrayComplex_co, other: _ArrayLikeComplex_co, /) -> _MaskedArray[complexfloating]: ... # type: ignore[overload-overlap] |
| @overload |
| def __radd__(self: _MaskedArray[number], other: _ArrayLikeNumber_co, /) -> _MaskedArray[number]: ... # type: ignore[overload-overlap] |
| @overload |
| def __radd__(self: _MaskedArrayTD64_co, other: _ArrayLikeTD64_co, /) -> _MaskedArray[timedelta64]: ... |
| @overload |
| def __radd__(self: _MaskedArrayTD64_co, other: _ArrayLikeDT64_co, /) -> _MaskedArray[datetime64]: ... |
| @overload |
| def __radd__(self: _MaskedArray[datetime64], other: _ArrayLikeTD64_co, /) -> _MaskedArray[datetime64]: ... |
| @overload |
| def __radd__(self: _MaskedArray[bytes_], other: _ArrayLikeBytes_co, /) -> _MaskedArray[bytes_]: ... |
| @overload |
| def __radd__(self: _MaskedArray[str_], other: _ArrayLikeStr_co, /) -> _MaskedArray[str_]: ... |
| @overload |
| def __radd__( |
| self: MaskedArray[Any, dtypes.StringDType], |
| other: _ArrayLikeStr_co | _ArrayLikeString_co, |
| /, |
| ) -> MaskedArray[_AnyShape, dtypes.StringDType]: ... |
| @overload |
| def __radd__(self: _MaskedArray[object_], other: Any, /) -> Any: ... |
| @overload |
| def __radd__(self: _MaskedArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... |
|
|
| # Keep in sync with `ndarray.__sub__` |
| @overload # type: ignore[override] |
| def __sub__(self: _MaskedArray[_NumberT], other: int | np.bool, /) -> MaskedArray[_ShapeT_co, dtype[_NumberT]]: ... |
| @overload |
| def __sub__(self: _MaskedArray[_NumberT], other: _ArrayLikeBool_co, /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __sub__(self: _MaskedArray[np.bool], other: _ArrayLikeBool_co, /) -> NoReturn: ... |
| @overload |
| def __sub__(self: _MaskedArray[np.bool], other: _ArrayLike[_NumberT], /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __sub__(self: _MaskedArray[float64], other: _ArrayLikeFloat64_co, /) -> _MaskedArray[float64]: ... |
| @overload |
| def __sub__(self: _MaskedArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> _MaskedArray[float64]: ... |
| @overload |
| def __sub__(self: _MaskedArray[complex128], other: _ArrayLikeComplex128_co, /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __sub__(self: _MaskedArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __sub__(self: _MaskedArrayUInt_co, other: _ArrayLikeUInt_co, /) -> _MaskedArray[unsignedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __sub__(self: _MaskedArrayInt_co, other: _ArrayLikeInt_co, /) -> _MaskedArray[signedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __sub__(self: _MaskedArrayFloat_co, other: _ArrayLikeFloat_co, /) -> _MaskedArray[floating]: ... # type: ignore[overload-overlap] |
| @overload |
| def __sub__(self: _MaskedArrayComplex_co, other: _ArrayLikeComplex_co, /) -> _MaskedArray[complexfloating]: ... # type: ignore[overload-overlap] |
| @overload |
| def __sub__(self: _MaskedArray[number], other: _ArrayLikeNumber_co, /) -> _MaskedArray[number]: ... # type: ignore[overload-overlap] |
| @overload |
| def __sub__(self: _MaskedArrayTD64_co, other: _ArrayLikeTD64_co, /) -> _MaskedArray[timedelta64]: ... |
| @overload |
| def __sub__(self: _MaskedArray[datetime64], other: _ArrayLikeTD64_co, /) -> _MaskedArray[datetime64]: ... |
| @overload |
| def __sub__(self: _MaskedArray[datetime64], other: _ArrayLikeDT64_co, /) -> _MaskedArray[timedelta64]: ... |
| @overload |
| def __sub__(self: _MaskedArray[object_], other: Any, /) -> Any: ... |
| @overload |
| def __sub__(self: _MaskedArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... |
|
|
| # Keep in sync with `ndarray.__rsub__` |
| @overload # type: ignore[override] |
| def __rsub__(self: _MaskedArray[_NumberT], other: int | np.bool, /) -> MaskedArray[_ShapeT_co, dtype[_NumberT]]: ... |
| @overload |
| def __rsub__(self: _MaskedArray[_NumberT], other: _ArrayLikeBool_co, /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rsub__(self: _MaskedArray[np.bool], other: _ArrayLikeBool_co, /) -> NoReturn: ... |
| @overload |
| def __rsub__(self: _MaskedArray[np.bool], other: _ArrayLike[_NumberT], /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rsub__(self: _MaskedArray[float64], other: _ArrayLikeFloat64_co, /) -> _MaskedArray[float64]: ... |
| @overload |
| def __rsub__(self: _MaskedArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> _MaskedArray[float64]: ... |
| @overload |
| def __rsub__(self: _MaskedArray[complex128], other: _ArrayLikeComplex128_co, /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __rsub__(self: _MaskedArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __rsub__(self: _MaskedArrayUInt_co, other: _ArrayLikeUInt_co, /) -> _MaskedArray[unsignedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rsub__(self: _MaskedArrayInt_co, other: _ArrayLikeInt_co, /) -> _MaskedArray[signedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rsub__(self: _MaskedArrayFloat_co, other: _ArrayLikeFloat_co, /) -> _MaskedArray[floating]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rsub__(self: _MaskedArrayComplex_co, other: _ArrayLikeComplex_co, /) -> _MaskedArray[complexfloating]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rsub__(self: _MaskedArray[number], other: _ArrayLikeNumber_co, /) -> _MaskedArray[number]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rsub__(self: _MaskedArrayTD64_co, other: _ArrayLikeTD64_co, /) -> _MaskedArray[timedelta64]: ... |
| @overload |
| def __rsub__(self: _MaskedArrayTD64_co, other: _ArrayLikeDT64_co, /) -> _MaskedArray[datetime64]: ... |
| @overload |
| def __rsub__(self: _MaskedArray[datetime64], other: _ArrayLikeDT64_co, /) -> _MaskedArray[timedelta64]: ... |
| @overload |
| def __rsub__(self: _MaskedArray[object_], other: Any, /) -> Any: ... |
| @overload |
| def __rsub__(self: _MaskedArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... |
|
|
| # Keep in sync with `ndarray.__mul__` |
| @overload # type: ignore[override] |
| def __mul__(self: _MaskedArray[_NumberT], other: int | np.bool, /) -> MaskedArray[_ShapeT_co, dtype[_NumberT]]: ... |
| @overload |
| def __mul__(self: _MaskedArray[_NumberT], other: _ArrayLikeBool_co, /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __mul__(self: _MaskedArray[np.bool], other: _ArrayLikeBool_co, /) -> _MaskedArray[np.bool]: ... # type: ignore[overload-overlap] |
| @overload |
| def __mul__(self: _MaskedArray[np.bool], other: _ArrayLike[_NumberT], /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __mul__(self: _MaskedArray[float64], other: _ArrayLikeFloat64_co, /) -> _MaskedArray[float64]: ... |
| @overload |
| def __mul__(self: _MaskedArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> _MaskedArray[float64]: ... |
| @overload |
| def __mul__(self: _MaskedArray[complex128], other: _ArrayLikeComplex128_co, /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __mul__(self: _MaskedArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __mul__(self: _MaskedArrayUInt_co, other: _ArrayLikeUInt_co, /) -> _MaskedArray[unsignedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __mul__(self: _MaskedArrayInt_co, other: _ArrayLikeInt_co, /) -> _MaskedArray[signedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __mul__(self: _MaskedArrayFloat_co, other: _ArrayLikeFloat_co, /) -> _MaskedArray[floating]: ... # type: ignore[overload-overlap] |
| @overload |
| def __mul__(self: _MaskedArrayComplex_co, other: _ArrayLikeComplex_co, /) -> _MaskedArray[complexfloating]: ... # type: ignore[overload-overlap] |
| @overload |
| def __mul__(self: _MaskedArray[number], other: _ArrayLikeNumber_co, /) -> _MaskedArray[number]: ... |
| @overload |
| def __mul__(self: _MaskedArray[timedelta64], other: _ArrayLikeFloat_co, /) -> _MaskedArray[timedelta64]: ... |
| @overload |
| def __mul__(self: _MaskedArrayFloat_co, other: _ArrayLike[timedelta64], /) -> _MaskedArray[timedelta64]: ... |
| @overload |
| def __mul__( |
| self: MaskedArray[Any, dtype[character] | dtypes.StringDType], |
| other: _ArrayLikeInt, |
| /, |
| ) -> MaskedArray[tuple[Any, ...], _DTypeT_co]: ... |
| @overload |
| def __mul__(self: _MaskedArray[object_], other: Any, /) -> Any: ... |
| @overload |
| def __mul__(self: _MaskedArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... |
|
|
| # Keep in sync with `ndarray.__rmul__` |
| @overload # type: ignore[override] # signature equivalent to __mul__ |
| def __rmul__(self: _MaskedArray[_NumberT], other: int | np.bool, /) -> MaskedArray[_ShapeT_co, dtype[_NumberT]]: ... |
| @overload |
| def __rmul__(self: _MaskedArray[_NumberT], other: _ArrayLikeBool_co, /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rmul__(self: _MaskedArray[np.bool], other: _ArrayLikeBool_co, /) -> _MaskedArray[np.bool]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rmul__(self: _MaskedArray[np.bool], other: _ArrayLike[_NumberT], /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rmul__(self: _MaskedArray[float64], other: _ArrayLikeFloat64_co, /) -> _MaskedArray[float64]: ... |
| @overload |
| def __rmul__(self: _MaskedArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> _MaskedArray[float64]: ... |
| @overload |
| def __rmul__(self: _MaskedArray[complex128], other: _ArrayLikeComplex128_co, /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __rmul__(self: _MaskedArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __rmul__(self: _MaskedArrayUInt_co, other: _ArrayLikeUInt_co, /) -> _MaskedArray[unsignedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rmul__(self: _MaskedArrayInt_co, other: _ArrayLikeInt_co, /) -> _MaskedArray[signedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rmul__(self: _MaskedArrayFloat_co, other: _ArrayLikeFloat_co, /) -> _MaskedArray[floating]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rmul__(self: _MaskedArrayComplex_co, other: _ArrayLikeComplex_co, /) -> _MaskedArray[complexfloating]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rmul__(self: _MaskedArray[number], other: _ArrayLikeNumber_co, /) -> _MaskedArray[number]: ... |
| @overload |
| def __rmul__(self: _MaskedArray[timedelta64], other: _ArrayLikeFloat_co, /) -> _MaskedArray[timedelta64]: ... |
| @overload |
| def __rmul__(self: _MaskedArrayFloat_co, other: _ArrayLike[timedelta64], /) -> _MaskedArray[timedelta64]: ... |
| @overload |
| def __rmul__( |
| self: MaskedArray[Any, dtype[character] | dtypes.StringDType], |
| other: _ArrayLikeInt, |
| /, |
| ) -> MaskedArray[tuple[Any, ...], _DTypeT_co]: ... |
| @overload |
| def __rmul__(self: _MaskedArray[object_], other: Any, /) -> Any: ... |
| @overload |
| def __rmul__(self: _MaskedArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... |
|
|
| # Keep in sync with `ndarray.__truediv__` |
| @overload # type: ignore[override] |
| def __truediv__(self: _MaskedArrayInt_co | _MaskedArray[float64], other: _ArrayLikeFloat64_co, /) -> _MaskedArray[float64]: ... |
| @overload |
| def __truediv__(self: _MaskedArrayFloat64_co, other: _ArrayLikeInt_co | _ArrayLike[floating[_64Bit]], /) -> _MaskedArray[float64]: ... |
| @overload |
| def __truediv__(self: _MaskedArray[complex128], other: _ArrayLikeComplex128_co, /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __truediv__(self: _MaskedArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __truediv__(self: _MaskedArray[floating], other: _ArrayLikeFloat_co, /) -> _MaskedArray[floating]: ... |
| @overload |
| def __truediv__(self: _MaskedArrayFloat_co, other: _ArrayLike[floating], /) -> _MaskedArray[floating]: ... |
| @overload |
| def __truediv__(self: _MaskedArray[complexfloating], other: _ArrayLikeNumber_co, /) -> _MaskedArray[complexfloating]: ... |
| @overload |
| def __truediv__(self: _MaskedArrayNumber_co, other: _ArrayLike[complexfloating], /) -> _MaskedArray[complexfloating]: ... |
| @overload |
| def __truediv__(self: _MaskedArray[inexact], other: _ArrayLikeNumber_co, /) -> _MaskedArray[inexact]: ... |
| @overload |
| def __truediv__(self: _MaskedArray[number], other: _ArrayLikeNumber_co, /) -> _MaskedArray[number]: ... |
| @overload |
| def __truediv__(self: _MaskedArray[timedelta64], other: _ArrayLike[timedelta64], /) -> _MaskedArray[float64]: ... |
| @overload |
| def __truediv__(self: _MaskedArray[timedelta64], other: _ArrayLikeBool_co, /) -> NoReturn: ... |
| @overload |
| def __truediv__(self: _MaskedArray[timedelta64], other: _ArrayLikeFloat_co, /) -> _MaskedArray[timedelta64]: ... |
| @overload |
| def __truediv__(self: _MaskedArray[object_], other: Any, /) -> Any: ... |
| @overload |
| def __truediv__(self: _MaskedArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... |
|
|
| # Keep in sync with `ndarray.__rtruediv__` |
| @overload # type: ignore[override] |
| def __rtruediv__(self: _MaskedArrayInt_co | _MaskedArray[float64], other: _ArrayLikeFloat64_co, /) -> _MaskedArray[float64]: ... |
| @overload |
| def __rtruediv__(self: _MaskedArrayFloat64_co, other: _ArrayLikeInt_co | _ArrayLike[floating[_64Bit]], /) -> _MaskedArray[float64]: ... |
| @overload |
| def __rtruediv__(self: _MaskedArray[complex128], other: _ArrayLikeComplex128_co, /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __rtruediv__(self: _MaskedArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __rtruediv__(self: _MaskedArray[floating], other: _ArrayLikeFloat_co, /) -> _MaskedArray[floating]: ... |
| @overload |
| def __rtruediv__(self: _MaskedArrayFloat_co, other: _ArrayLike[floating], /) -> _MaskedArray[floating]: ... |
| @overload |
| def __rtruediv__(self: _MaskedArray[complexfloating], other: _ArrayLikeNumber_co, /) -> _MaskedArray[complexfloating]: ... |
| @overload |
| def __rtruediv__(self: _MaskedArrayNumber_co, other: _ArrayLike[complexfloating], /) -> _MaskedArray[complexfloating]: ... |
| @overload |
| def __rtruediv__(self: _MaskedArray[inexact], other: _ArrayLikeNumber_co, /) -> _MaskedArray[inexact]: ... |
| @overload |
| def __rtruediv__(self: _MaskedArray[number], other: _ArrayLikeNumber_co, /) -> _MaskedArray[number]: ... |
| @overload |
| def __rtruediv__(self: _MaskedArray[timedelta64], other: _ArrayLike[timedelta64], /) -> _MaskedArray[float64]: ... |
| @overload |
| def __rtruediv__(self: _MaskedArray[integer | floating], other: _ArrayLike[timedelta64], /) -> _MaskedArray[timedelta64]: ... |
| @overload |
| def __rtruediv__(self: _MaskedArray[object_], other: Any, /) -> Any: ... |
| @overload |
| def __rtruediv__(self: _MaskedArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... |
|
|
| # Keep in sync with `ndarray.__floordiv__` |
| @overload # type: ignore[override] |
| def __floordiv__(self: _MaskedArray[_RealNumberT], other: int | np.bool, /) -> MaskedArray[_ShapeT_co, dtype[_RealNumberT]]: ... |
| @overload |
| def __floordiv__(self: _MaskedArray[_RealNumberT], other: _ArrayLikeBool_co, /) -> _MaskedArray[_RealNumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __floordiv__(self: _MaskedArray[np.bool], other: _ArrayLikeBool_co, /) -> _MaskedArray[int8]: ... # type: ignore[overload-overlap] |
| @overload |
| def __floordiv__(self: _MaskedArray[np.bool], other: _ArrayLike[_RealNumberT], /) -> _MaskedArray[_RealNumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __floordiv__(self: _MaskedArray[float64], other: _ArrayLikeFloat64_co, /) -> _MaskedArray[float64]: ... |
| @overload |
| def __floordiv__(self: _MaskedArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> _MaskedArray[float64]: ... |
| @overload |
| def __floordiv__(self: _MaskedArrayUInt_co, other: _ArrayLikeUInt_co, /) -> _MaskedArray[unsignedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __floordiv__(self: _MaskedArrayInt_co, other: _ArrayLikeInt_co, /) -> _MaskedArray[signedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __floordiv__(self: _MaskedArrayFloat_co, other: _ArrayLikeFloat_co, /) -> _MaskedArray[floating]: ... |
| @overload |
| def __floordiv__(self: _MaskedArray[timedelta64], other: _ArrayLike[timedelta64], /) -> _MaskedArray[int64]: ... |
| @overload |
| def __floordiv__(self: _MaskedArray[timedelta64], other: _ArrayLikeBool_co, /) -> NoReturn: ... |
| @overload |
| def __floordiv__(self: _MaskedArray[timedelta64], other: _ArrayLikeFloat_co, /) -> _MaskedArray[timedelta64]: ... |
| @overload |
| def __floordiv__(self: _MaskedArray[object_], other: Any, /) -> Any: ... |
| @overload |
| def __floordiv__(self: _MaskedArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... |
|
|
| # Keep in sync with `ndarray.__rfloordiv__` |
| @overload # type: ignore[override] |
| def __rfloordiv__(self: _MaskedArray[_RealNumberT], other: int | np.bool, /) -> MaskedArray[_ShapeT_co, dtype[_RealNumberT]]: ... |
| @overload |
| def __rfloordiv__(self: _MaskedArray[_RealNumberT], other: _ArrayLikeBool_co, /) -> _MaskedArray[_RealNumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rfloordiv__(self: _MaskedArray[np.bool], other: _ArrayLikeBool_co, /) -> _MaskedArray[int8]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rfloordiv__(self: _MaskedArray[np.bool], other: _ArrayLike[_RealNumberT], /) -> _MaskedArray[_RealNumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rfloordiv__(self: _MaskedArray[float64], other: _ArrayLikeFloat64_co, /) -> _MaskedArray[float64]: ... |
| @overload |
| def __rfloordiv__(self: _MaskedArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> _MaskedArray[float64]: ... |
| @overload |
| def __rfloordiv__(self: _MaskedArrayUInt_co, other: _ArrayLikeUInt_co, /) -> _MaskedArray[unsignedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rfloordiv__(self: _MaskedArrayInt_co, other: _ArrayLikeInt_co, /) -> _MaskedArray[signedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rfloordiv__(self: _MaskedArrayFloat_co, other: _ArrayLikeFloat_co, /) -> _MaskedArray[floating]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rfloordiv__(self: _MaskedArray[timedelta64], other: _ArrayLike[timedelta64], /) -> _MaskedArray[int64]: ... |
| @overload |
| def __rfloordiv__(self: _MaskedArray[floating | integer], other: _ArrayLike[timedelta64], /) -> _MaskedArray[timedelta64]: ... |
| @overload |
| def __rfloordiv__(self: _MaskedArray[object_], other: Any, /) -> Any: ... |
| @overload |
| def __rfloordiv__(self: _MaskedArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... |
|
|
| # Keep in sync with `ndarray.__pow__` (minus the `mod` parameter) |
| @overload # type: ignore[override] |
| def __pow__(self: _MaskedArray[_NumberT], other: int | np.bool, /) -> MaskedArray[_ShapeT_co, dtype[_NumberT]]: ... |
| @overload |
| def __pow__(self: _MaskedArray[_NumberT], other: _ArrayLikeBool_co, /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __pow__(self: _MaskedArray[np.bool], other: _ArrayLikeBool_co, /) -> _MaskedArray[int8]: ... # type: ignore[overload-overlap] |
| @overload |
| def __pow__(self: _MaskedArray[np.bool], other: _ArrayLike[_NumberT], /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __pow__(self: _MaskedArray[float64], other: _ArrayLikeFloat64_co, /) -> _MaskedArray[float64]: ... |
| @overload |
| def __pow__(self: _MaskedArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> _MaskedArray[float64]: ... |
| @overload |
| def __pow__(self: _MaskedArray[complex128], other: _ArrayLikeComplex128_co, /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __pow__(self: _MaskedArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __pow__(self: _MaskedArrayUInt_co, other: _ArrayLikeUInt_co, /) -> _MaskedArray[unsignedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __pow__(self: _MaskedArrayInt_co, other: _ArrayLikeInt_co, /) -> _MaskedArray[signedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __pow__(self: _MaskedArrayFloat_co, other: _ArrayLikeFloat_co, /) -> _MaskedArray[floating]: ... # type: ignore[overload-overlap] |
| @overload |
| def __pow__(self: _MaskedArrayComplex_co, other: _ArrayLikeComplex_co, /) -> _MaskedArray[complexfloating]: ... |
| @overload |
| def __pow__(self: _MaskedArray[number], other: _ArrayLikeNumber_co, /) -> _MaskedArray[number]: ... |
| @overload |
| def __pow__(self: _MaskedArray[object_], other: Any, /) -> Any: ... |
| @overload |
| def __pow__(self: _MaskedArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... |
|
|
| # Keep in sync with `ndarray.__rpow__` (minus the `mod` parameter) |
| @overload # type: ignore[override] |
| def __rpow__(self: _MaskedArray[_NumberT], other: int | np.bool, /) -> MaskedArray[_ShapeT_co, dtype[_NumberT]]: ... |
| @overload |
| def __rpow__(self: _MaskedArray[_NumberT], other: _ArrayLikeBool_co, /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rpow__(self: _MaskedArray[np.bool], other: _ArrayLikeBool_co, /) -> _MaskedArray[int8]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rpow__(self: _MaskedArray[np.bool], other: _ArrayLike[_NumberT], /) -> _MaskedArray[_NumberT]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rpow__(self: _MaskedArray[float64], other: _ArrayLikeFloat64_co, /) -> _MaskedArray[float64]: ... |
| @overload |
| def __rpow__(self: _MaskedArrayFloat64_co, other: _ArrayLike[floating[_64Bit]], /) -> _MaskedArray[float64]: ... |
| @overload |
| def __rpow__(self: _MaskedArray[complex128], other: _ArrayLikeComplex128_co, /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __rpow__(self: _MaskedArrayComplex128_co, other: _ArrayLike[complexfloating[_64Bit]], /) -> _MaskedArray[complex128]: ... |
| @overload |
| def __rpow__(self: _MaskedArrayUInt_co, other: _ArrayLikeUInt_co, /) -> _MaskedArray[unsignedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rpow__(self: _MaskedArrayInt_co, other: _ArrayLikeInt_co, /) -> _MaskedArray[signedinteger]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rpow__(self: _MaskedArrayFloat_co, other: _ArrayLikeFloat_co, /) -> _MaskedArray[floating]: ... # type: ignore[overload-overlap] |
| @overload |
| def __rpow__(self: _MaskedArrayComplex_co, other: _ArrayLikeComplex_co, /) -> _MaskedArray[complexfloating]: ... |
| @overload |
| def __rpow__(self: _MaskedArray[number], other: _ArrayLikeNumber_co, /) -> _MaskedArray[number]: ... |
| @overload |
| def __rpow__(self: _MaskedArray[object_], other: Any, /) -> Any: ... |
| @overload |
| def __rpow__(self: _MaskedArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... |
|
|
| # |
| @property # type: ignore[misc] |
| def imag(self: _HasDTypeWithRealAndImag[object, _ScalarT], /) -> MaskedArray[_ShapeT_co, dtype[_ScalarT]]: ... # type: ignore[override] |
| def get_imag(self: _HasDTypeWithRealAndImag[object, _ScalarT], /) -> MaskedArray[_ShapeT_co, dtype[_ScalarT]]: ... |
|
|
| # |
| @property # type: ignore[misc] |
| def real(self: _HasDTypeWithRealAndImag[_ScalarT, object], /) -> MaskedArray[_ShapeT_co, dtype[_ScalarT]]: ... # type: ignore[override] |
| def get_real(self: _HasDTypeWithRealAndImag[_ScalarT, object], /) -> MaskedArray[_ShapeT_co, dtype[_ScalarT]]: ... |
|
|
| # keep in sync with `np.ma.count` |
| @overload |
| def count(self, axis: None = None, keepdims: Literal[False] | _NoValueType = ...) -> int: ... |
| @overload |
| def count(self, axis: _ShapeLike, keepdims: bool | _NoValueType = ...) -> NDArray[int_]: ... |
| @overload |
| def count(self, axis: _ShapeLike | None = None, *, keepdims: Literal[True]) -> NDArray[int_]: ... |
| @overload |
| def count(self, axis: _ShapeLike | None, keepdims: Literal[True]) -> NDArray[int_]: ... |
|
|
| # Keep in sync with `ndarray.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: bool | None = None) -> Self: ... |
| @overload # (empty_sequence) |
| def reshape( # type: ignore[overload-overlap] # mypy false positive |
| self, |
| shape: Sequence[Never], |
| /, |
| *, |
| order: _OrderACF = "C", |
| copy: bool | None = None, |
| ) -> MaskedArray[tuple[()], _DTypeT_co]: ... |
| @overload # (() | (int) | (int, int) | ....) # up to 8-d |
| def reshape( |
| self, |
| shape: _AnyShapeT, |
| /, |
| *, |
| order: _OrderACF = "C", |
| copy: bool | None = None, |
| ) -> MaskedArray[_AnyShapeT, _DTypeT_co]: ... |
| @overload # (index) |
| def reshape( |
| self, |
| size1: SupportsIndex, |
| /, |
| *, |
| order: _OrderACF = "C", |
| copy: bool | None = None, |
| ) -> MaskedArray[tuple[int], _DTypeT_co]: ... |
| @overload # (index, index) |
| def reshape( |
| self, |
| size1: SupportsIndex, |
| size2: SupportsIndex, |
| /, |
| *, |
| order: _OrderACF = "C", |
| copy: bool | None = None, |
| ) -> MaskedArray[tuple[int, int], _DTypeT_co]: ... |
| @overload # (index, index, index) |
| def reshape( |
| self, |
| size1: SupportsIndex, |
| size2: SupportsIndex, |
| size3: SupportsIndex, |
| /, |
| *, |
| order: _OrderACF = "C", |
| copy: bool | None = None, |
| ) -> MaskedArray[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: bool | None = None, |
| ) -> MaskedArray[tuple[int, int, int, int], _DTypeT_co]: ... |
| @overload # (int, *(index, ...)) |
| def reshape( |
| self, |
| size0: SupportsIndex, |
| /, |
| *shape: SupportsIndex, |
| order: _OrderACF = "C", |
| copy: bool | None = None, |
| ) -> MaskedArray[_AnyShape, _DTypeT_co]: ... |
| @overload # (sequence[index]) |
| def reshape( |
| self, |
| shape: Sequence[SupportsIndex], |
| /, |
| *, |
| order: _OrderACF = "C", |
| copy: bool | None = None, |
| ) -> MaskedArray[_AnyShape, _DTypeT_co]: ... |
|
|
| def resize(self, newshape: Never, refcheck: bool = True, order: bool = False) -> NoReturn: ... # type: ignore[override] |
| def put(self, indices: _ArrayLikeInt_co, values: ArrayLike, mode: _ModeKind = "raise") -> None: ... |
| def ids(self) -> tuple[int, int]: ... |
| def iscontiguous(self) -> bool: ... |
|
|
| # Keep in sync with `ma.core.all` |
| @overload # type: ignore[override] |
| def all( |
| self, |
| axis: None = None, |
| out: None = None, |
| keepdims: Literal[False] | _NoValueType = ..., |
| ) -> bool_: ... |
| @overload |
| def all( |
| self, |
| axis: _ShapeLike | None = None, |
| out: None = None, |
| *, |
| keepdims: Literal[True], |
| ) -> _MaskedArray[bool_]: ... |
| @overload |
| def all( |
| self, |
| axis: _ShapeLike | None, |
| out: None, |
| keepdims: Literal[True], |
| ) -> _MaskedArray[bool_]: ... |
| @overload |
| def all( |
| self, |
| axis: _ShapeLike | None = None, |
| out: None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> bool_ | _MaskedArray[bool_]: ... |
| @overload |
| def all( |
| self, |
| axis: _ShapeLike | None = None, |
| *, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def all( |
| self, |
| axis: _ShapeLike | None, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # Keep in sync with `ma.core.any` |
| @overload # type: ignore[override] |
| def any( |
| self, |
| axis: None = None, |
| out: None = None, |
| keepdims: Literal[False] | _NoValueType = ..., |
| ) -> bool_: ... |
| @overload |
| def any( |
| self, |
| axis: _ShapeLike | None = None, |
| out: None = None, |
| *, |
| keepdims: Literal[True], |
| ) -> _MaskedArray[bool_]: ... |
| @overload |
| def any( |
| self, |
| axis: _ShapeLike | None, |
| out: None, |
| keepdims: Literal[True], |
| ) -> _MaskedArray[bool_]: ... |
| @overload |
| def any( |
| self, |
| axis: _ShapeLike | None = None, |
| out: None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> bool_ | _MaskedArray[bool_]: ... |
| @overload |
| def any( |
| self, |
| axis: _ShapeLike | None = None, |
| *, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def any( |
| self, |
| axis: _ShapeLike | None, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # Keep in sync with `ndarray.trace` and `ma.core.trace` |
| @overload |
| def trace( |
| self, # >= 2D MaskedArray |
| offset: SupportsIndex = 0, |
| axis1: SupportsIndex = 0, |
| axis2: SupportsIndex = 1, |
| dtype: DTypeLike | None = None, |
| out: None = None, |
| ) -> Any: ... |
| @overload |
| def trace( |
| self, # >= 2D MaskedArray |
| offset: SupportsIndex = 0, |
| axis1: SupportsIndex = 0, |
| axis2: SupportsIndex = 1, |
| dtype: DTypeLike | None = None, |
| *, |
| out: _ArrayT, |
| ) -> _ArrayT: ... |
| @overload |
| def trace( |
| self, # >= 2D MaskedArray |
| offset: SupportsIndex, |
| axis1: SupportsIndex, |
| axis2: SupportsIndex, |
| dtype: DTypeLike | None, |
| out: _ArrayT, |
| ) -> _ArrayT: ... |
|
|
| # This differs from `ndarray.dot`, in that 1D dot 1D returns a 0D array. |
| @overload |
| def dot(self, b: ArrayLike, out: None = None, strict: bool = False) -> _MaskedArray[Any]: ... |
| @overload |
| def dot(self, b: ArrayLike, out: _ArrayT, strict: bool = False) -> _ArrayT: ... |
|
|
| # Keep in sync with `ma.core.sum` |
| @overload # type: ignore[override] |
| def sum( |
| self, |
| /, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| out: None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> Any: ... |
| @overload |
| def sum( |
| self, |
| /, |
| axis: _ShapeLike | None, |
| dtype: DTypeLike | None, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def sum( |
| self, |
| /, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| *, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # Keep in sync with `ndarray.cumsum` and `ma.core.cumsum` |
| @overload # out: None (default) |
| def cumsum(self, /, axis: SupportsIndex | None = None, dtype: DTypeLike | None = None, out: None = None) -> _MaskedArray[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: ... |
|
|
| # Keep in sync with `ma.core.prod` |
| @overload # type: ignore[override] |
| def prod( |
| self, |
| /, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| out: None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> Any: ... |
| @overload |
| def prod( |
| self, |
| /, |
| axis: _ShapeLike | None, |
| dtype: DTypeLike | None, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def prod( |
| self, |
| /, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| *, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| product = prod |
|
|
| # Keep in sync with `ndarray.cumprod` and `ma.core.cumprod` |
| @overload # out: None (default) |
| def cumprod(self, /, axis: SupportsIndex | None = None, dtype: DTypeLike | None = None, out: None = None) -> _MaskedArray[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 `ma.core.mean` |
| @overload # type: ignore[override] |
| def mean( |
| self, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| out: None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> Any: ... |
| @overload |
| def mean( |
| self, |
| /, |
| axis: _ShapeLike | None, |
| dtype: DTypeLike | None, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def mean( |
| self, |
| /, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| *, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # keep roughly in sync with `ma.core.anom` |
| @overload |
| def anom(self, axis: SupportsIndex | None = None, dtype: None = None) -> Self: ... |
| @overload |
| def anom(self, axis: SupportsIndex | None = None, *, dtype: DTypeLike) -> MaskedArray[_ShapeT_co, dtype]: ... |
| @overload |
| def anom(self, axis: SupportsIndex | None, dtype: DTypeLike) -> MaskedArray[_ShapeT_co, dtype]: ... |
|
|
| # keep in sync with `std` and `ma.core.var` |
| @overload # type: ignore[override] |
| def var( |
| self, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| out: None = None, |
| ddof: float = 0, |
| keepdims: bool | _NoValueType = ..., |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., |
| ) -> Any: ... |
| @overload |
| def var( |
| self, |
| axis: _ShapeLike | None, |
| dtype: DTypeLike | None, |
| out: _ArrayT, |
| ddof: float = 0, |
| keepdims: bool | _NoValueType = ..., |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def var( |
| self, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| *, |
| out: _ArrayT, |
| ddof: float = 0, |
| keepdims: bool | _NoValueType = ..., |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # keep in sync with `var` and `ma.core.std` |
| @overload # type: ignore[override] |
| def std( |
| self, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| out: None = None, |
| ddof: float = 0, |
| keepdims: bool | _NoValueType = ..., |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., |
| ) -> Any: ... |
| @overload |
| def std( |
| self, |
| axis: _ShapeLike | None, |
| dtype: DTypeLike | None, |
| out: _ArrayT, |
| ddof: float = 0, |
| keepdims: bool | _NoValueType = ..., |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def std( |
| self, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| *, |
| out: _ArrayT, |
| ddof: float = 0, |
| keepdims: bool | _NoValueType = ..., |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # Keep in sync with `ndarray.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: ... |
|
|
| def argsort( # type: ignore[override] |
| self, |
| axis: SupportsIndex | _NoValueType = ..., |
| kind: _SortKind | None = None, |
| order: str | Sequence[str] | None = None, |
| endwith: bool = True, |
| fill_value: _ScalarLike_co | None = None, |
| *, |
| stable: bool = False, |
| ) -> _MaskedArray[intp]: ... |
|
|
| # Keep in-sync with np.ma.argmin |
| @overload # type: ignore[override] |
| def argmin( |
| self, |
| axis: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| out: None = None, |
| *, |
| keepdims: Literal[False] | _NoValueType = ..., |
| ) -> intp: ... |
| @overload |
| def argmin( |
| self, |
| axis: SupportsIndex | None = None, |
| fill_value: _ScalarLike_co | None = None, |
| out: None = None, |
| *, |
| keepdims: bool | _NoValueType = ..., |
| ) -> Any: ... |
| @overload |
| def argmin( |
| self, |
| axis: SupportsIndex | None = None, |
| fill_value: _ScalarLike_co | None = None, |
| *, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def argmin( |
| self, |
| axis: SupportsIndex | None, |
| fill_value: _ScalarLike_co | None, |
| out: _ArrayT, |
| *, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # Keep in-sync with np.ma.argmax |
| @overload # type: ignore[override] |
| def argmax( |
| self, |
| axis: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| out: None = None, |
| *, |
| keepdims: Literal[False] | _NoValueType = ..., |
| ) -> intp: ... |
| @overload |
| def argmax( |
| self, |
| axis: SupportsIndex | None = None, |
| fill_value: _ScalarLike_co | None = None, |
| out: None = None, |
| *, |
| keepdims: bool | _NoValueType = ..., |
| ) -> Any: ... |
| @overload |
| def argmax( |
| self, |
| axis: SupportsIndex | None = None, |
| fill_value: _ScalarLike_co | None = None, |
| *, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def argmax( |
| self, |
| axis: SupportsIndex | None, |
| fill_value: _ScalarLike_co | None, |
| out: _ArrayT, |
| *, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # |
| def sort( # type: ignore[override] |
| self, |
| axis: SupportsIndex = -1, |
| kind: _SortKind | None = None, |
| order: str | Sequence[str] | None = None, |
| endwith: bool | None = True, |
| fill_value: _ScalarLike_co | None = None, |
| *, |
| stable: Literal[False] | None = False, |
| ) -> None: ... |
|
|
| # |
| @overload # type: ignore[override] |
| def min( |
| self: _MaskedArray[_ScalarT], |
| axis: None = None, |
| out: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: Literal[False] | _NoValueType = ..., |
| ) -> _ScalarT: ... |
| @overload |
| def min( |
| self, |
| axis: _ShapeLike | None = None, |
| out: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool | _NoValueType = ... |
| ) -> Any: ... |
| @overload |
| def min( |
| self, |
| axis: _ShapeLike | None, |
| out: _ArrayT, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def min( |
| self, |
| axis: _ShapeLike | None = None, |
| *, |
| out: _ArrayT, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # |
| @overload # type: ignore[override] |
| def max( |
| self: _MaskedArray[_ScalarT], |
| axis: None = None, |
| out: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: Literal[False] | _NoValueType = ..., |
| ) -> _ScalarT: ... |
| @overload |
| def max( |
| self, |
| axis: _ShapeLike | None = None, |
| out: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool | _NoValueType = ... |
| ) -> Any: ... |
| @overload |
| def max( |
| self, |
| axis: _ShapeLike | None, |
| out: _ArrayT, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def max( |
| self, |
| axis: _ShapeLike | None = None, |
| *, |
| out: _ArrayT, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # |
| @overload |
| def ptp( |
| self: _MaskedArray[_ScalarT], |
| axis: None = None, |
| out: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: Literal[False] = False, |
| ) -> _ScalarT: ... |
| @overload |
| def ptp( |
| self, |
| axis: _ShapeLike | None = None, |
| out: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool = False, |
| ) -> Any: ... |
| @overload |
| def ptp( |
| self, |
| axis: _ShapeLike | None, |
| out: _ArrayT, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool = False, |
| ) -> _ArrayT: ... |
| @overload |
| def ptp( |
| self, |
| axis: _ShapeLike | None = None, |
| *, |
| out: _ArrayT, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool = False, |
| ) -> _ArrayT: ... |
|
|
| # |
| @overload |
| def partition( |
| self, |
| /, |
| kth: _ArrayLikeInt, |
| axis: SupportsIndex = -1, |
| kind: _PartitionKind = "introselect", |
| order: None = None |
| ) -> None: ... |
| @overload |
| def partition( |
| self: _MaskedArray[np.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, |
| ) -> _MaskedArray[intp]: ... |
| @overload |
| def argpartition( |
| self: _MaskedArray[np.void], |
| /, |
| kth: _ArrayLikeInt, |
| axis: SupportsIndex | None = -1, |
| kind: _PartitionKind = "introselect", |
| order: str | Sequence[str] | None = None, |
| ) -> _MaskedArray[intp]: ... |
|
|
| # Keep in-sync with np.ma.take |
| @overload # type: ignore[override] |
| def take( # type: ignore[overload-overlap] |
| self: _MaskedArray[_ScalarT], |
| indices: _IntLike_co, |
| axis: None = None, |
| out: None = None, |
| mode: _ModeKind = "raise" |
| ) -> _ScalarT: ... |
| @overload |
| def take( |
| self: _MaskedArray[_ScalarT], |
| indices: _ArrayLikeInt_co, |
| axis: SupportsIndex | None = None, |
| out: None = None, |
| mode: _ModeKind = "raise", |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def take( |
| self, |
| indices: _ArrayLikeInt_co, |
| axis: SupportsIndex | None, |
| out: _ArrayT, |
| mode: _ModeKind = "raise", |
| ) -> _ArrayT: ... |
| @overload |
| def take( |
| self, |
| indices: _ArrayLikeInt_co, |
| axis: SupportsIndex | None = None, |
| *, |
| out: _ArrayT, |
| mode: _ModeKind = "raise", |
| ) -> _ArrayT: ... |
|
|
| # keep in sync with `ndarray.diagonal` |
| @override |
| def diagonal( |
| self, |
| /, |
| offset: SupportsIndex = 0, |
| axis1: SupportsIndex = 0, |
| axis2: SupportsIndex = 1, |
| ) -> MaskedArray[_AnyShape, _DTypeT_co]: ... |
|
|
| # keep in sync with `ndarray.repeat` |
| @override |
| @overload |
| def repeat( |
| self, |
| /, |
| repeats: _ArrayLikeInt_co, |
| axis: None = None, |
| ) -> MaskedArray[tuple[int], _DTypeT_co]: ... |
| @overload |
| def repeat( |
| self, |
| /, |
| repeats: _ArrayLikeInt_co, |
| axis: SupportsIndex, |
| ) -> MaskedArray[_AnyShape, _DTypeT_co]: ... |
|
|
| # keep in sync with `ndarray.flatten` and `ndarray.ravel` |
| @override |
| def flatten(self, /, order: _OrderKACF = "C") -> MaskedArray[tuple[int], _DTypeT_co]: ... |
| @override |
| def ravel(self, order: _OrderKACF = "C") -> MaskedArray[tuple[int], _DTypeT_co]: ... |
|
|
| # keep in sync with `ndarray.squeeze` |
| @override |
| def squeeze( |
| self, |
| /, |
| axis: SupportsIndex | tuple[SupportsIndex, ...] | None = None, |
| ) -> MaskedArray[_AnyShape, _DTypeT_co]: ... |
|
|
| # |
| def toflex(self) -> MaskedArray[_ShapeT_co, np.dtype[np.void]]: ... |
| def torecords(self) -> MaskedArray[_ShapeT_co, np.dtype[np.void]]: ... |
|
|
| # |
| @override |
| def tobytes(self, /, fill_value: Incomplete | None = None, order: _OrderKACF = "C") -> bytes: ... # type: ignore[override] |
|
|
| # keep in sync with `ndarray.tolist` |
| @override |
| @overload |
| def tolist(self: MaskedArray[tuple[Never], dtype[generic[_T]]], /, fill_value: _ScalarLike_co | None = None) -> Any: ... |
| @overload |
| def tolist(self: MaskedArray[tuple[()], dtype[generic[_T]]], /, fill_value: _ScalarLike_co | None = None) -> _T: ... |
| @overload |
| def tolist(self: MaskedArray[tuple[int], dtype[generic[_T]]], /, fill_value: _ScalarLike_co | None = None) -> list[_T]: ... |
| @overload |
| def tolist( |
| self: MaskedArray[tuple[int, int], dtype[generic[_T]]], /, fill_value: _ScalarLike_co | None = None |
| ) -> list[list[_T]]: ... |
| @overload |
| def tolist( |
| self: MaskedArray[tuple[int, int, int], dtype[generic[_T]]], /, fill_value: _ScalarLike_co | None = None |
| ) -> list[list[list[_T]]]: ... |
| @overload |
| def tolist(self, /, fill_value: _ScalarLike_co | None = None) -> Any: ... |
|
|
| # NOTE: will raise `NotImplementedError` |
| @override |
| def tofile(self, /, fid: Never, sep: str = "", format: str = "%s") -> NoReturn: ... # type: ignore[override] |
|
|
| # |
| @override |
| def __deepcopy__(self, memo: dict[int, Any] | None = None) -> Self: ... |
|
|
| # Keep `dtype` at the bottom to avoid name conflicts with `np.dtype` |
| @property |
| def dtype(self) -> _DTypeT_co: ... |
| @dtype.setter |
| def dtype(self: MaskedArray[_AnyShape, _DTypeT], dtype: _DTypeT, /) -> None: ... |
|
|
| class mvoid(MaskedArray[_ShapeT_co, _DTypeT_co]): |
| def __new__( |
| self, # pyright: ignore[reportSelfClsParameterName] |
| data, |
| mask=..., |
| dtype=..., |
| fill_value=..., |
| hardmask=..., |
| copy=..., |
| subok=..., |
| ): ... |
| def __getitem__(self, indx): ... |
| def __setitem__(self, indx, value): ... |
| def __iter__(self): ... |
| def __len__(self): ... |
| def filled(self, fill_value=None): ... |
| def tolist(self): ... # type: ignore[override] |
|
|
| def isMaskedArray(x: object) -> TypeIs[MaskedArray]: ... |
| def isarray(x: object) -> TypeIs[MaskedArray]: ... # alias to isMaskedArray |
| def isMA(x: object) -> TypeIs[MaskedArray]: ... # alias to isMaskedArray |
|
|
| # 0D float64 array |
| class MaskedConstant(MaskedArray[tuple[()], dtype[float64]]): |
| def __new__(cls) -> Self: ... |
|
|
| # these overrides are no-ops |
| @override |
| def __iadd__(self, other: _Ignored, /) -> Self: ... # type: ignore[override] |
| @override |
| def __isub__(self, other: _Ignored, /) -> Self: ... # type: ignore[override] |
| @override |
| def __imul__(self, other: _Ignored, /) -> Self: ... # type: ignore[override] |
| @override |
| def __ifloordiv__(self, other: _Ignored, /) -> Self: ... |
| @override |
| def __itruediv__(self, other: _Ignored, /) -> Self: ... # type: ignore[override] |
| @override |
| def __ipow__(self, other: _Ignored, /) -> Self: ... # type: ignore[override] |
| @override |
| def __deepcopy__(self, /, memo: _Ignored) -> Self: ... # type: ignore[override] |
| @override |
| def copy(self, /, *args: _Ignored, **kwargs: _Ignored) -> Self: ... |
|
|
| masked: Final[MaskedConstant] = ... |
| masked_singleton: Final[MaskedConstant] = ... |
|
|
| masked_array: TypeAlias = MaskedArray |
|
|
| # keep in sync with `MaskedArray.__new__` |
| @overload |
| def array( |
| data: _ArrayLike[_ScalarT], |
| dtype: None = None, |
| copy: bool = False, |
| order: _OrderKACF | None = None, |
| mask: _ArrayLikeBool_co = nomask, |
| fill_value: _ScalarLike_co | None = None, |
| keep_mask: bool = True, |
| hard_mask: bool = False, |
| shrink: bool = True, |
| subok: bool = True, |
| ndmin: int = 0, |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def array( |
| data: object, |
| dtype: _DTypeLike[_ScalarT], |
| copy: bool = False, |
| order: _OrderKACF | None = None, |
| mask: _ArrayLikeBool_co = nomask, |
| fill_value: _ScalarLike_co | None = None, |
| keep_mask: bool = True, |
| hard_mask: bool = False, |
| shrink: bool = True, |
| subok: bool = True, |
| ndmin: int = 0, |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def array( |
| data: object, |
| dtype: DTypeLike | None = None, |
| copy: bool = False, |
| order: _OrderKACF | None = None, |
| mask: _ArrayLikeBool_co = nomask, |
| fill_value: _ScalarLike_co | None = None, |
| keep_mask: bool = True, |
| hard_mask: bool = False, |
| shrink: bool = True, |
| subok: bool = True, |
| ndmin: int = 0, |
| ) -> _MaskedArray[_ScalarT]: ... |
|
|
| # keep in sync with `array` |
| @overload |
| def asarray(a: _ArrayLike[_ScalarT], dtype: None = None, order: _OrderKACF | None = None) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def asarray(a: object, dtype: _DTypeLike[_ScalarT], order: _OrderKACF | None = None) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def asarray(a: object, dtype: DTypeLike | None = None, order: _OrderKACF | None = None) -> _MaskedArray[_ScalarT]: ... |
|
|
| # keep in sync with `asarray` (but note the additional first overload) |
| @overload |
| def asanyarray(a: _MArrayT, dtype: None = None, order: _OrderKACF | None = None) -> _MArrayT: ... |
| @overload |
| def asanyarray(a: _ArrayLike[_ScalarT], dtype: None = None, order: _OrderKACF | None = None) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def asanyarray(a: object, dtype: _DTypeLike[_ScalarT], order: _OrderKACF | None = None) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def asanyarray(a: object, dtype: DTypeLike | None = None, order: _OrderKACF | None = None) -> _MaskedArray[_ScalarT]: ... |
|
|
| # |
| def is_masked(x: object) -> bool: ... |
|
|
| @overload |
| def min( |
| obj: _ArrayLike[_ScalarT], |
| axis: None = None, |
| out: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: Literal[False] | _NoValueType = ..., |
| ) -> _ScalarT: ... |
| @overload |
| def min( |
| obj: ArrayLike, |
| axis: _ShapeLike | None = None, |
| out: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool | _NoValueType = ... |
| ) -> Any: ... |
| @overload |
| def min( |
| obj: ArrayLike, |
| axis: _ShapeLike | None, |
| out: _ArrayT, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def min( |
| obj: ArrayLike, |
| axis: _ShapeLike | None = None, |
| *, |
| out: _ArrayT, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| @overload |
| def max( |
| obj: _ArrayLike[_ScalarT], |
| axis: None = None, |
| out: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: Literal[False] | _NoValueType = ..., |
| ) -> _ScalarT: ... |
| @overload |
| def max( |
| obj: ArrayLike, |
| axis: _ShapeLike | None = None, |
| out: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool | _NoValueType = ... |
| ) -> Any: ... |
| @overload |
| def max( |
| obj: ArrayLike, |
| axis: _ShapeLike | None, |
| out: _ArrayT, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def max( |
| obj: ArrayLike, |
| axis: _ShapeLike | None = None, |
| *, |
| out: _ArrayT, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| @overload |
| def ptp( |
| obj: _ArrayLike[_ScalarT], |
| axis: None = None, |
| out: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: Literal[False] | _NoValueType = ..., |
| ) -> _ScalarT: ... |
| @overload |
| def ptp( |
| obj: ArrayLike, |
| axis: _ShapeLike | None = None, |
| out: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool | _NoValueType = ... |
| ) -> Any: ... |
| @overload |
| def ptp( |
| obj: ArrayLike, |
| axis: _ShapeLike | None, |
| out: _ArrayT, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def ptp( |
| obj: ArrayLike, |
| axis: _ShapeLike | None = None, |
| *, |
| out: _ArrayT, |
| fill_value: _ScalarLike_co | None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # we cannot meaningfully annotate `frommethod` further, because the callable signature |
| # of the return type fully depends on the *value* of `methodname` and `reversed` in |
| # a way that cannot be expressed in the Python type system. |
| def _frommethod(methodname: str, reversed: bool = False) -> types.FunctionType: ... |
|
|
| # NOTE: The following `*_mask` functions will accept any array-like input runtime, but |
| # since their use-cases are specific to masks, they only accept `MaskedArray` inputs. |
|
|
| # keep in sync with `MaskedArray.harden_mask` |
| def harden_mask(a: _MArrayT) -> _MArrayT: ... |
| # keep in sync with `MaskedArray.soften_mask` |
| def soften_mask(a: _MArrayT) -> _MArrayT: ... |
| # keep in sync with `MaskedArray.shrink_mask` |
| def shrink_mask(a: _MArrayT) -> _MArrayT: ... |
|
|
| # keep in sync with `MaskedArray.ids` |
| def ids(a: ArrayLike) -> tuple[int, int]: ... |
|
|
| # keep in sync with `ndarray.nonzero` |
| def nonzero(a: ArrayLike) -> tuple[ndarray[tuple[int], np.dtype[intp]], ...]: ... |
|
|
| # keep first overload in sync with `MaskedArray.ravel` |
| @overload |
| def ravel(a: np.ndarray[Any, _DTypeT], order: _OrderKACF = "C") -> MaskedArray[tuple[int], _DTypeT]: ... |
| @overload |
| def ravel(a: _ArrayLike[_ScalarT], order: _OrderKACF = "C") -> MaskedArray[tuple[int], np.dtype[_ScalarT]]: ... |
| @overload |
| def ravel(a: ArrayLike, order: _OrderKACF = "C") -> MaskedArray[tuple[int], _DTypeT_co]: ... |
|
|
| # keep roughly in sync with `lib._function_base_impl.copy` |
| @overload |
| def copy(a: _MArrayT, order: _OrderKACF = "C") -> _MArrayT: ... |
| @overload |
| def copy(a: np.ndarray[_ShapeT, _DTypeT], order: _OrderKACF = "C") -> MaskedArray[_ShapeT, _DTypeT]: ... |
| @overload |
| def copy(a: _ArrayLike[_ScalarT], order: _OrderKACF = "C") -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def copy(a: ArrayLike, order: _OrderKACF = "C") -> _MaskedArray[Incomplete]: ... |
|
|
| # keep in sync with `_core.fromnumeric.diagonal` |
| @overload |
| def diagonal( |
| a: _ArrayLike[_ScalarT], |
| offset: SupportsIndex = 0, |
| axis1: SupportsIndex = 0, |
| axis2: SupportsIndex = 1, |
| ) -> NDArray[_ScalarT]: ... |
| @overload |
| def diagonal( |
| a: ArrayLike, |
| offset: SupportsIndex = 0, |
| axis1: SupportsIndex = 0, |
| axis2: SupportsIndex = 1, |
| ) -> NDArray[Incomplete]: ... |
|
|
| # keep in sync with `_core.fromnumeric.repeat` |
| @overload |
| def repeat(a: _ArrayLike[_ScalarT], repeats: _ArrayLikeInt_co, axis: None = None) -> MaskedArray[tuple[int], dtype[_ScalarT]]: ... |
| @overload |
| def repeat(a: _ArrayLike[_ScalarT], repeats: _ArrayLikeInt_co, axis: SupportsIndex) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def repeat(a: ArrayLike, repeats: _ArrayLikeInt_co, axis: None = None) -> MaskedArray[tuple[int], dtype[Incomplete]]: ... |
| @overload |
| def repeat(a: ArrayLike, repeats: _ArrayLikeInt_co, axis: SupportsIndex) -> _MaskedArray[Incomplete]: ... |
|
|
| # keep in sync with `_core.fromnumeric.swapaxes` |
| @overload |
| def swapaxes(a: _MArrayT, axis1: SupportsIndex, axis2: SupportsIndex) -> _MArrayT: ... |
| @overload |
| def swapaxes(a: _ArrayLike[_ScalarT], axis1: SupportsIndex, axis2: SupportsIndex) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def swapaxes(a: ArrayLike, axis1: SupportsIndex, axis2: SupportsIndex) -> _MaskedArray[Incomplete]: ... |
|
|
| # NOTE: The `MaskedArray.anom` definition is specific to `MaskedArray`, so we need |
| # additional overloads to cover the array-like input here. |
| @overload # a: MaskedArray, dtype=None |
| def anom(a: _MArrayT, axis: SupportsIndex | None = None, dtype: None = None) -> _MArrayT: ... |
| @overload # a: array-like, dtype=None |
| def anom(a: _ArrayLike[_ScalarT], axis: SupportsIndex | None = None, dtype: None = None) -> _MaskedArray[_ScalarT]: ... |
| @overload # a: unknown array-like, dtype: dtype-like (positional) |
| def anom(a: ArrayLike, axis: SupportsIndex | None, dtype: _DTypeLike[_ScalarT]) -> _MaskedArray[_ScalarT]: ... |
| @overload # a: unknown array-like, dtype: dtype-like (keyword) |
| def anom(a: ArrayLike, axis: SupportsIndex | None = None, *, dtype: _DTypeLike[_ScalarT]) -> _MaskedArray[_ScalarT]: ... |
| @overload # a: unknown array-like, dtype: unknown dtype-like (positional) |
| def anom(a: ArrayLike, axis: SupportsIndex | None, dtype: DTypeLike) -> _MaskedArray[Incomplete]: ... |
| @overload # a: unknown array-like, dtype: unknown dtype-like (keyword) |
| def anom(a: ArrayLike, axis: SupportsIndex | None = None, *, dtype: DTypeLike) -> _MaskedArray[Incomplete]: ... |
|
|
| anomalies = anom |
|
|
| # Keep in sync with `any` and `MaskedArray.all` |
| @overload |
| def all(a: ArrayLike, axis: None = None, out: None = None, keepdims: Literal[False] | _NoValueType = ...) -> np.bool: ... |
| @overload |
| def all(a: ArrayLike, axis: _ShapeLike | None, out: None, keepdims: Literal[True]) -> _MaskedArray[np.bool]: ... |
| @overload |
| def all(a: ArrayLike, axis: _ShapeLike | None = None, out: None = None, *, keepdims: Literal[True]) -> _MaskedArray[np.bool]: ... |
| @overload |
| def all( |
| a: ArrayLike, axis: _ShapeLike | None = None, out: None = None, keepdims: bool | _NoValueType = ... |
| ) -> np.bool | _MaskedArray[np.bool]: ... |
| @overload |
| def all(a: ArrayLike, axis: _ShapeLike | None, out: _ArrayT, keepdims: bool | _NoValueType = ...) -> _ArrayT: ... |
| @overload |
| def all(a: ArrayLike, axis: _ShapeLike | None = None, *, out: _ArrayT, keepdims: bool | _NoValueType = ...) -> _ArrayT: ... |
|
|
| # Keep in sync with `all` and `MaskedArray.any` |
| @overload |
| def any(a: ArrayLike, axis: None = None, out: None = None, keepdims: Literal[False] | _NoValueType = ...) -> np.bool: ... |
| @overload |
| def any(a: ArrayLike, axis: _ShapeLike | None, out: None, keepdims: Literal[True]) -> _MaskedArray[np.bool]: ... |
| @overload |
| def any(a: ArrayLike, axis: _ShapeLike | None = None, out: None = None, *, keepdims: Literal[True]) -> _MaskedArray[np.bool]: ... |
| @overload |
| def any( |
| a: ArrayLike, axis: _ShapeLike | None = None, out: None = None, keepdims: bool | _NoValueType = ... |
| ) -> np.bool | _MaskedArray[np.bool]: ... |
| @overload |
| def any(a: ArrayLike, axis: _ShapeLike | None, out: _ArrayT, keepdims: bool | _NoValueType = ...) -> _ArrayT: ... |
| @overload |
| def any(a: ArrayLike, axis: _ShapeLike | None = None, *, out: _ArrayT, keepdims: bool | _NoValueType = ...) -> _ArrayT: ... |
|
|
| # NOTE: The `MaskedArray.compress` definition uses its `DTypeT_co` type parameter, |
| # which wouldn't work here for array-like inputs, so we need additional overloads. |
| @overload |
| def compress( |
| condition: _ArrayLikeBool_co, a: _ArrayLike[_ScalarT], axis: None = None, out: None = None |
| ) -> MaskedArray[tuple[int], np.dtype[_ScalarT]]: ... |
| @overload |
| def compress( |
| condition: _ArrayLikeBool_co, a: _ArrayLike[_ScalarT], axis: _ShapeLike | None = None, out: None = None |
| ) -> MaskedArray[_AnyShape, np.dtype[_ScalarT]]: ... |
| @overload |
| def compress(condition: _ArrayLikeBool_co, a: ArrayLike, axis: None = None, out: None = None) -> MaskedArray[tuple[int]]: ... |
| @overload |
| def compress( |
| condition: _ArrayLikeBool_co, a: ArrayLike, axis: _ShapeLike | None = None, out: None = None |
| ) -> _MaskedArray[Incomplete]: ... |
| @overload |
| def compress(condition: _ArrayLikeBool_co, a: ArrayLike, axis: _ShapeLike | None, out: _ArrayT) -> _ArrayT: ... |
| @overload |
| def compress(condition: _ArrayLikeBool_co, a: ArrayLike, axis: _ShapeLike | None = None, *, out: _ArrayT) -> _ArrayT: ... |
|
|
| # Keep in sync with `cumprod` and `MaskedArray.cumsum` |
| @overload # out: None (default) |
| def cumsum( |
| a: ArrayLike, axis: SupportsIndex | None = None, dtype: DTypeLike | None = None, out: None = None |
| ) -> _MaskedArray[Incomplete]: ... |
| @overload # out: ndarray (positional) |
| def cumsum(a: ArrayLike, axis: SupportsIndex | None, dtype: DTypeLike | None, out: _ArrayT) -> _ArrayT: ... |
| @overload # out: ndarray (kwarg) |
| def cumsum(a: ArrayLike, axis: SupportsIndex | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT) -> _ArrayT: ... |
|
|
| # Keep in sync with `cumsum` and `MaskedArray.cumsum` |
| @overload # out: None (default) |
| def cumprod( |
| a: ArrayLike, axis: SupportsIndex | None = None, dtype: DTypeLike | None = None, out: None = None |
| ) -> _MaskedArray[Incomplete]: ... |
| @overload # out: ndarray (positional) |
| def cumprod(a: ArrayLike, axis: SupportsIndex | None, dtype: DTypeLike | None, out: _ArrayT) -> _ArrayT: ... |
| @overload # out: ndarray (kwarg) |
| def cumprod(a: ArrayLike, axis: SupportsIndex | None = None, dtype: DTypeLike | None = None, *, out: _ArrayT) -> _ArrayT: ... |
|
|
| # Keep in sync with `sum`, `prod`, `product`, and `MaskedArray.mean` |
| @overload |
| def mean( |
| a: ArrayLike, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| out: None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> Incomplete: ... |
| @overload |
| def mean( |
| a: ArrayLike, |
| axis: _ShapeLike | None, |
| dtype: DTypeLike | None, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def mean( |
| a: ArrayLike, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| *, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # Keep in sync with `mean`, `prod`, `product`, and `MaskedArray.sum` |
| @overload |
| def sum( |
| a: ArrayLike, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| out: None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> Incomplete: ... |
| @overload |
| def sum( |
| a: ArrayLike, |
| axis: _ShapeLike | None, |
| dtype: DTypeLike | None, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def sum( |
| a: ArrayLike, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| *, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # Keep in sync with `product` and `MaskedArray.prod` |
| @overload |
| def prod( |
| a: ArrayLike, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| out: None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> Incomplete: ... |
| @overload |
| def prod( |
| a: ArrayLike, |
| axis: _ShapeLike | None, |
| dtype: DTypeLike | None, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def prod( |
| a: ArrayLike, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| *, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # Keep in sync with `prod` and `MaskedArray.prod` |
| @overload |
| def product( |
| a: ArrayLike, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| out: None = None, |
| keepdims: bool | _NoValueType = ..., |
| ) -> Incomplete: ... |
| @overload |
| def product( |
| a: ArrayLike, |
| axis: _ShapeLike | None, |
| dtype: DTypeLike | None, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def product( |
| a: ArrayLike, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| *, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # Keep in sync with `MaskedArray.trace` and `_core.fromnumeric.trace` |
| @overload |
| def trace( |
| a: ArrayLike, |
| offset: SupportsIndex = 0, |
| axis1: SupportsIndex = 0, |
| axis2: SupportsIndex = 1, |
| dtype: DTypeLike | None = None, |
| out: None = None, |
| ) -> Incomplete: ... |
| @overload |
| def trace( |
| a: ArrayLike, |
| offset: SupportsIndex, |
| axis1: SupportsIndex, |
| axis2: SupportsIndex, |
| dtype: DTypeLike | None, |
| out: _ArrayT, |
| ) -> _ArrayT: ... |
| @overload |
| def trace( |
| a: ArrayLike, |
| offset: SupportsIndex = 0, |
| axis1: SupportsIndex = 0, |
| axis2: SupportsIndex = 1, |
| dtype: DTypeLike | None = None, |
| *, |
| out: _ArrayT, |
| ) -> _ArrayT: ... |
|
|
| # keep in sync with `std` and `MaskedArray.var` |
| @overload |
| def std( |
| a: ArrayLike, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| out: None = None, |
| ddof: float = 0, |
| keepdims: bool | _NoValueType = ..., |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., |
| ) -> Incomplete: ... |
| @overload |
| def std( |
| a: ArrayLike, |
| axis: _ShapeLike | None, |
| dtype: DTypeLike | None, |
| out: _ArrayT, |
| ddof: float = 0, |
| keepdims: bool | _NoValueType = ..., |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def std( |
| a: ArrayLike, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| *, |
| out: _ArrayT, |
| ddof: float = 0, |
| keepdims: bool | _NoValueType = ..., |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # keep in sync with `std` and `MaskedArray.var` |
| @overload |
| def var( |
| a: ArrayLike, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| out: None = None, |
| ddof: float = 0, |
| keepdims: bool | _NoValueType = ..., |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., |
| ) -> Incomplete: ... |
| @overload |
| def var( |
| a: ArrayLike, |
| axis: _ShapeLike | None, |
| dtype: DTypeLike | None, |
| out: _ArrayT, |
| ddof: float = 0, |
| keepdims: bool | _NoValueType = ..., |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def var( |
| a: ArrayLike, |
| axis: _ShapeLike | None = None, |
| dtype: DTypeLike | None = None, |
| *, |
| out: _ArrayT, |
| ddof: float = 0, |
| keepdims: bool | _NoValueType = ..., |
| mean: _ArrayLikeNumber_co | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # (a, b) |
| minimum: _extrema_operation = ... |
| maximum: _extrema_operation = ... |
|
|
| # NOTE: this is a `_frommethod` instance at runtime |
| @overload |
| def count(a: ArrayLike, axis: None = None, keepdims: Literal[False] | _NoValueType = ...) -> int: ... |
| @overload |
| def count(a: ArrayLike, axis: _ShapeLike, keepdims: bool | _NoValueType = ...) -> NDArray[int_]: ... |
| @overload |
| def count(a: ArrayLike, axis: _ShapeLike | None = None, *, keepdims: Literal[True]) -> NDArray[int_]: ... |
| @overload |
| def count(a: ArrayLike, axis: _ShapeLike | None, keepdims: Literal[True]) -> NDArray[int_]: ... |
|
|
| # NOTE: this is a `_frommethod` instance at runtime |
| @overload |
| def argmin( |
| a: ArrayLike, |
| axis: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| out: None = None, |
| *, |
| keepdims: Literal[False] | _NoValueType = ..., |
| ) -> intp: ... |
| @overload |
| def argmin( |
| a: ArrayLike, |
| axis: SupportsIndex | None = None, |
| fill_value: _ScalarLike_co | None = None, |
| out: None = None, |
| *, |
| keepdims: bool | _NoValueType = ..., |
| ) -> Any: ... |
| @overload |
| def argmin( |
| a: ArrayLike, |
| axis: SupportsIndex | None = None, |
| fill_value: _ScalarLike_co | None = None, |
| *, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def argmin( |
| a: ArrayLike, |
| axis: SupportsIndex | None, |
| fill_value: _ScalarLike_co | None, |
| out: _ArrayT, |
| *, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| # keep in sync with `argmin` |
| @overload |
| def argmax( |
| a: ArrayLike, |
| axis: None = None, |
| fill_value: _ScalarLike_co | None = None, |
| out: None = None, |
| *, |
| keepdims: Literal[False] | _NoValueType = ..., |
| ) -> intp: ... |
| @overload |
| def argmax( |
| a: ArrayLike, |
| axis: SupportsIndex | None = None, |
| fill_value: _ScalarLike_co | None = None, |
| out: None = None, |
| *, |
| keepdims: bool | _NoValueType = ..., |
| ) -> Any: ... |
| @overload |
| def argmax( |
| a: ArrayLike, |
| axis: SupportsIndex | None = None, |
| fill_value: _ScalarLike_co | None = None, |
| *, |
| out: _ArrayT, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
| @overload |
| def argmax( |
| a: ArrayLike, |
| axis: SupportsIndex | None, |
| fill_value: _ScalarLike_co | None, |
| out: _ArrayT, |
| *, |
| keepdims: bool | _NoValueType = ..., |
| ) -> _ArrayT: ... |
|
|
| @overload |
| def take( |
| a: _ArrayLike[_ScalarT], |
| indices: _IntLike_co, |
| axis: None = None, |
| out: None = None, |
| mode: _ModeKind = "raise" |
| ) -> _ScalarT: ... |
| @overload |
| def take( |
| a: _ArrayLike[_ScalarT], |
| indices: _ArrayLikeInt_co, |
| axis: SupportsIndex | None = None, |
| out: None = None, |
| mode: _ModeKind = "raise", |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def take( |
| a: ArrayLike, |
| indices: _IntLike_co, |
| axis: SupportsIndex | None = None, |
| out: None = None, |
| mode: _ModeKind = "raise", |
| ) -> Any: ... |
| @overload |
| def take( |
| a: ArrayLike, |
| indices: _ArrayLikeInt_co, |
| axis: SupportsIndex | None = None, |
| out: None = None, |
| mode: _ModeKind = "raise", |
| ) -> _MaskedArray[Any]: ... |
| @overload |
| def take( |
| a: ArrayLike, |
| indices: _ArrayLikeInt_co, |
| axis: SupportsIndex | None, |
| out: _ArrayT, |
| mode: _ModeKind = "raise", |
| ) -> _ArrayT: ... |
| @overload |
| def take( |
| a: ArrayLike, |
| indices: _ArrayLikeInt_co, |
| axis: SupportsIndex | None = None, |
| *, |
| out: _ArrayT, |
| mode: _ModeKind = "raise", |
| ) -> _ArrayT: ... |
|
|
| def power(a, b, third=None): ... |
| def argsort(a, axis=..., kind=None, order=None, endwith=True, fill_value=None, *, stable=None): ... |
| @overload |
| def sort( |
| a: _ArrayT, |
| axis: SupportsIndex = -1, |
| kind: _SortKind | None = None, |
| order: str | Sequence[str] | None = None, |
| endwith: bool | None = True, |
| fill_value: _ScalarLike_co | None = None, |
| *, |
| stable: Literal[False] | None = None, |
| ) -> _ArrayT: ... |
| @overload |
| def sort( |
| a: ArrayLike, |
| axis: SupportsIndex = -1, |
| kind: _SortKind | None = None, |
| order: str | Sequence[str] | None = None, |
| endwith: bool | None = True, |
| fill_value: _ScalarLike_co | None = None, |
| *, |
| stable: Literal[False] | None = None, |
| ) -> NDArray[Any]: ... |
| @overload |
| def compressed(x: _ArrayLike[_ScalarT_co]) -> _Array1D[_ScalarT_co]: ... |
| @overload |
| def compressed(x: ArrayLike) -> _Array1D[Any]: ... |
| def concatenate(arrays, axis=0): ... |
| def diag(v, k=0): ... |
| def left_shift(a, n): ... |
| def right_shift(a, n): ... |
| def put(a: NDArray[Any], indices: _ArrayLikeInt_co, values: ArrayLike, mode: _ModeKind = "raise") -> None: ... |
| def putmask(a: NDArray[Any], mask: _ArrayLikeBool_co, values: ArrayLike) -> None: ... |
| def transpose(a, axes=None): ... |
| def reshape(a, new_shape, order="C"): ... |
| def resize(x, new_shape): ... |
| def ndim(obj: ArrayLike) -> int: ... |
| def shape(obj): ... |
| def size(obj: ArrayLike, axis: SupportsIndex | None = None) -> int: ... |
| def diff(a, /, n=1, axis=-1, prepend=..., append=...): ... |
| def where(condition, x=..., y=...): ... |
| def choose(indices, choices, out=None, mode="raise"): ... |
| def round_(a, decimals=0, out=None): ... |
| round = round_ |
|
|
| def inner(a, b): ... |
| innerproduct = inner |
|
|
| def outer(a, b): ... |
| outerproduct = outer |
|
|
| def correlate(a, v, mode="valid", propagate_mask=True): ... |
| def convolve(a, v, mode="full", propagate_mask=True): ... |
|
|
| def allequal(a: ArrayLike, b: ArrayLike, fill_value: bool = True) -> bool: ... |
|
|
| def allclose(a: ArrayLike, b: ArrayLike, masked_equal: bool = True, rtol: float = 1e-5, atol: float = 1e-8) -> bool: ... |
|
|
| def fromflex(fxarray): ... |
|
|
| def append(a, b, axis=None): ... |
| def dot(a, b, strict=False, out=None): ... |
|
|
| # internal wrapper functions for the functions below |
| def _convert2ma( |
| funcname: str, |
| np_ret: str, |
| np_ma_ret: str, |
| params: dict[str, Any] | None = None, |
| ) -> Callable[..., Any]: ... |
|
|
| # keep in sync with `_core.multiarray.arange` |
| @overload # dtype=<known> |
| def arange( |
| start_or_stop: _ArangeScalar | float, |
| /, |
| stop: _ArangeScalar | float | None = None, |
| step: _ArangeScalar | float | None = 1, |
| *, |
| dtype: _DTypeLike[_ArangeScalarT], |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _Masked1D[_ArangeScalarT]: ... |
| @overload # (int-like, int-like?, int-like?) |
| def arange( |
| start_or_stop: _IntLike_co, |
| /, |
| stop: _IntLike_co | None = None, |
| step: _IntLike_co | None = 1, |
| *, |
| dtype: type[int] | _DTypeLike[np.int_] | None = None, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _Masked1D[np.int_]: ... |
| @overload # (float, float-like?, float-like?) |
| def arange( |
| start_or_stop: float | floating, |
| /, |
| stop: _FloatLike_co | None = None, |
| step: _FloatLike_co | None = 1, |
| *, |
| dtype: type[float] | _DTypeLike[np.float64] | None = None, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _Masked1D[np.float64 | Any]: ... |
| @overload # (float-like, float, float-like?) |
| def arange( |
| start_or_stop: _FloatLike_co, |
| /, |
| stop: float | floating, |
| step: _FloatLike_co | None = 1, |
| *, |
| dtype: type[float] | _DTypeLike[np.float64] | None = None, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _Masked1D[np.float64 | Any]: ... |
| @overload # (timedelta, timedelta-like?, timedelta-like?) |
| def arange( |
| start_or_stop: np.timedelta64, |
| /, |
| stop: _TD64Like_co | None = None, |
| step: _TD64Like_co | None = 1, |
| *, |
| dtype: _DTypeLike[np.timedelta64] | None = None, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _Masked1D[np.timedelta64[Incomplete]]: ... |
| @overload # (timedelta-like, timedelta, timedelta-like?) |
| def arange( |
| start_or_stop: _TD64Like_co, |
| /, |
| stop: np.timedelta64, |
| step: _TD64Like_co | None = 1, |
| *, |
| dtype: _DTypeLike[np.timedelta64] | None = None, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _Masked1D[np.timedelta64[Incomplete]]: ... |
| @overload # (datetime, datetime, timedelta-like) (requires both start and stop) |
| def arange( |
| start_or_stop: np.datetime64, |
| /, |
| stop: np.datetime64, |
| step: _TD64Like_co | None = 1, |
| *, |
| dtype: _DTypeLike[np.datetime64] | None = None, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _Masked1D[np.datetime64[Incomplete]]: ... |
| @overload # (str, str, timedelta-like, dtype=dt64-like) (requires both start and stop) |
| def arange( |
| start_or_stop: str, |
| /, |
| stop: str, |
| step: _TD64Like_co | None = 1, |
| *, |
| dtype: _DTypeLike[np.datetime64] | _DT64Codes, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _Masked1D[np.datetime64[Incomplete]]: ... |
| @overload # dtype=<unknown> |
| def arange( |
| start_or_stop: _ArangeScalar | float | str, |
| /, |
| stop: _ArangeScalar | float | str | None = None, |
| step: _ArangeScalar | float | None = 1, |
| *, |
| dtype: DTypeLike | None = None, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _Masked1D[Incomplete]: ... |
|
|
| # based on `_core.fromnumeric.clip` |
| @overload |
| def clip( |
| a: _ScalarT, |
| a_min: ArrayLike | _NoValueType | None = ..., |
| a_max: ArrayLike | _NoValueType | None = ..., |
| out: None = None, |
| *, |
| min: ArrayLike | _NoValueType | None = ..., |
| max: ArrayLike | _NoValueType | None = ..., |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| dtype: None = None, |
| **kwargs: Unpack[_UFuncKwargs], |
| ) -> _ScalarT: ... |
| @overload |
| def clip( |
| a: NDArray[_ScalarT], |
| a_min: ArrayLike | _NoValueType | None = ..., |
| a_max: ArrayLike | _NoValueType | None = ..., |
| out: None = None, |
| *, |
| min: ArrayLike | _NoValueType | None = ..., |
| max: ArrayLike | _NoValueType | None = ..., |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| dtype: None = None, |
| **kwargs: Unpack[_UFuncKwargs], |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def clip( |
| a: ArrayLike, |
| a_min: ArrayLike | None, |
| a_max: ArrayLike | None, |
| out: _MArrayT, |
| *, |
| min: ArrayLike | _NoValueType | None = ..., |
| max: ArrayLike | _NoValueType | None = ..., |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| dtype: DTypeLike | None = None, |
| **kwargs: Unpack[_UFuncKwargs], |
| ) -> _MArrayT: ... |
| @overload |
| def clip( |
| a: ArrayLike, |
| a_min: ArrayLike | _NoValueType | None = ..., |
| a_max: ArrayLike | _NoValueType | None = ..., |
| *, |
| out: _MArrayT, |
| min: ArrayLike | _NoValueType | None = ..., |
| max: ArrayLike | _NoValueType | None = ..., |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| dtype: DTypeLike | None = None, |
| **kwargs: Unpack[_UFuncKwargs], |
| ) -> _MArrayT: ... |
| @overload |
| def clip( |
| a: ArrayLike, |
| a_min: ArrayLike | _NoValueType | None = ..., |
| a_max: ArrayLike | _NoValueType | None = ..., |
| out: None = None, |
| *, |
| min: ArrayLike | _NoValueType | None = ..., |
| max: ArrayLike | _NoValueType | None = ..., |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| dtype: DTypeLike | None = None, |
| **kwargs: Unpack[_UFuncKwargs], |
| ) -> Incomplete: ... |
|
|
| # keep in sync with `_core.multiarray.ones` |
| @overload |
| def empty( |
| shape: SupportsIndex, |
| dtype: None = None, |
| order: _OrderCF = "C", |
| *, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> MaskedArray[tuple[int], np.dtype[np.float64]]: ... |
| @overload |
| def empty( |
| shape: SupportsIndex, |
| dtype: _DTypeT | _SupportsDType[_DTypeT], |
| order: _OrderCF = "C", |
| *, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> MaskedArray[tuple[int], _DTypeT]: ... |
| @overload |
| def empty( |
| shape: SupportsIndex, |
| dtype: type[_ScalarT], |
| order: _OrderCF = "C", |
| *, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> MaskedArray[tuple[int], np.dtype[_ScalarT]]: ... |
| @overload |
| def empty( |
| shape: SupportsIndex, |
| dtype: DTypeLike | None = None, |
| order: _OrderCF = "C", |
| *, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> MaskedArray[tuple[int]]: ... |
| @overload # known shape |
| def empty( |
| shape: _AnyShapeT, |
| dtype: None = None, |
| order: _OrderCF = "C", |
| *, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> MaskedArray[_AnyShapeT, np.dtype[np.float64]]: ... |
| @overload |
| def empty( |
| shape: _AnyShapeT, |
| dtype: _DTypeT | _SupportsDType[_DTypeT], |
| order: _OrderCF = "C", |
| *, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> MaskedArray[_AnyShapeT, _DTypeT]: ... |
| @overload |
| def empty( |
| shape: _AnyShapeT, |
| dtype: type[_ScalarT], |
| order: _OrderCF = "C", |
| *, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> MaskedArray[_AnyShapeT, np.dtype[_ScalarT]]: ... |
| @overload |
| def empty( |
| shape: _AnyShapeT, |
| dtype: DTypeLike | None = None, |
| order: _OrderCF = "C", |
| *, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> MaskedArray[_AnyShapeT]: ... |
| @overload # unknown shape |
| def empty( |
| shape: _ShapeLike, |
| dtype: None = None, |
| order: _OrderCF = "C", |
| *, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _MaskedArray[np.float64]: ... |
| @overload |
| def empty( |
| shape: _ShapeLike, |
| dtype: _DTypeT | _SupportsDType[_DTypeT], |
| order: _OrderCF = "C", |
| *, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> MaskedArray[_AnyShape, _DTypeT]: ... |
| @overload |
| def empty( |
| shape: _ShapeLike, |
| dtype: type[_ScalarT], |
| order: _OrderCF = "C", |
| *, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def empty( |
| shape: _ShapeLike, |
| dtype: DTypeLike | None = None, |
| *, |
| device: Literal["cpu"] | None = None, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> MaskedArray: ... |
|
|
| # keep in sync with `_core.multiarray.empty_like` |
| @overload |
| def empty_like( |
| a: _MArrayT, |
| /, |
| dtype: None = None, |
| order: _OrderKACF = "K", |
| subok: bool = True, |
| shape: _ShapeLike | None = None, |
| *, |
| device: Literal["cpu"] | None = None, |
| ) -> _MArrayT: ... |
| @overload |
| def empty_like( |
| a: _ArrayLike[_ScalarT], |
| /, |
| dtype: None = None, |
| order: _OrderKACF = "K", |
| subok: bool = True, |
| shape: _ShapeLike | None = None, |
| *, |
| device: Literal["cpu"] | None = None, |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def empty_like( |
| a: Incomplete, |
| /, |
| dtype: _DTypeLike[_ScalarT], |
| order: _OrderKACF = "K", |
| subok: bool = True, |
| shape: _ShapeLike | None = None, |
| *, |
| device: Literal["cpu"] | None = None, |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def empty_like( |
| a: Incomplete, |
| /, |
| dtype: DTypeLike | None = None, |
| order: _OrderKACF = "K", |
| subok: bool = True, |
| shape: _ShapeLike | None = None, |
| *, |
| device: Literal["cpu"] | None = None, |
| ) -> _MaskedArray[Incomplete]: ... |
|
|
| # This is a bit of a hack to avoid having to duplicate all those `empty` overloads for |
| # `ones` and `zeros`, that relies on the fact that empty/zeros/ones have identical |
| # type signatures, but may cause some type-checkers to report incorrect names in case |
| # of user errors. Mypy and Pyright seem to handle this just fine. |
| ones = empty |
| ones_like = empty_like |
| zeros = empty |
| zeros_like = empty_like |
|
|
| # keep in sync with `_core.multiarray.frombuffer` |
| @overload |
| def frombuffer( |
| buffer: Buffer, |
| *, |
| count: SupportsIndex = -1, |
| offset: SupportsIndex = 0, |
| like: _SupportsArrayFunc | None = None, |
| ) -> _MaskedArray[np.float64]: ... |
| @overload |
| def frombuffer( |
| buffer: Buffer, |
| dtype: _DTypeLike[_ScalarT], |
| count: SupportsIndex = -1, |
| offset: SupportsIndex = 0, |
| *, |
| like: _SupportsArrayFunc | None = None, |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def frombuffer( |
| buffer: Buffer, |
| dtype: DTypeLike | None = float, |
| count: SupportsIndex = -1, |
| offset: SupportsIndex = 0, |
| *, |
| like: _SupportsArrayFunc | None = None, |
| ) -> _MaskedArray[Incomplete]: ... |
|
|
| # keep roughly in sync with `_core.numeric.fromfunction` |
| def fromfunction( |
| function: Callable[..., np.ndarray[_ShapeT, _DTypeT]], |
| shape: Sequence[int], |
| *, |
| dtype: DTypeLike | None = float, |
| like: _SupportsArrayFunc | None = None, |
| **kwargs: object, |
| ) -> MaskedArray[_ShapeT, _DTypeT]: ... |
|
|
| # keep roughly in sync with `_core.numeric.identity` |
| @overload |
| def identity( |
| n: int, |
| dtype: None = None, |
| *, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> MaskedArray[tuple[int, int], np.dtype[np.float64]]: ... |
| @overload |
| def identity( |
| n: int, |
| dtype: _DTypeLike[_ScalarT], |
| *, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> MaskedArray[tuple[int, int], np.dtype[_ScalarT]]: ... |
| @overload |
| def identity( |
| n: int, |
| dtype: DTypeLike | None = None, |
| *, |
| like: _SupportsArrayFunc | None = None, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> MaskedArray[tuple[int, int], np.dtype[Incomplete]]: ... |
|
|
| # keep roughly in sync with `_core.numeric.indices` |
| @overload |
| def indices( |
| dimensions: Sequence[int], |
| dtype: type[int] = int, |
| sparse: Literal[False] = False, |
| *, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _MaskedArray[np.intp]: ... |
| @overload |
| def indices( |
| dimensions: Sequence[int], |
| dtype: type[int], |
| sparse: Literal[True], |
| *, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> tuple[_MaskedArray[np.intp], ...]: ... |
| @overload |
| def indices( |
| dimensions: Sequence[int], |
| dtype: type[int] = int, |
| *, |
| sparse: Literal[True], |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> tuple[_MaskedArray[np.intp], ...]: ... |
| @overload |
| def indices( |
| dimensions: Sequence[int], |
| dtype: _DTypeLike[_ScalarT], |
| sparse: Literal[False] = False, |
| *, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def indices( |
| dimensions: Sequence[int], |
| dtype: _DTypeLike[_ScalarT], |
| sparse: Literal[True], |
| *, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> tuple[_MaskedArray[_ScalarT], ...]: ... |
| @overload |
| def indices( |
| dimensions: Sequence[int], |
| dtype: DTypeLike | None = int, |
| sparse: Literal[False] = False, |
| *, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _MaskedArray[Incomplete]: ... |
| @overload |
| def indices( |
| dimensions: Sequence[int], |
| dtype: DTypeLike | None, |
| sparse: Literal[True], |
| *, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> tuple[_MaskedArray[Incomplete], ...]: ... |
| @overload |
| def indices( |
| dimensions: Sequence[int], |
| dtype: DTypeLike | None = int, |
| *, |
| sparse: Literal[True], |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> tuple[_MaskedArray[Incomplete], ...]: ... |
|
|
| # keep roughly in sync with `_core.fromnumeric.squeeze` |
| @overload |
| def squeeze( |
| a: _ArrayLike[_ScalarT], |
| axis: _ShapeLike | None = None, |
| *, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _MaskedArray[_ScalarT]: ... |
| @overload |
| def squeeze( |
| a: ArrayLike, |
| axis: _ShapeLike | None = None, |
| *, |
| fill_value: _FillValue | None = None, |
| hardmask: bool = False, |
| ) -> _MaskedArray[Incomplete]: ... |
|
|
