diff --git a/src/numpy-stubs/__init__.pyi b/src/numpy-stubs/__init__.pyi index 5a00b538..c2475ea6 100644 --- a/src/numpy-stubs/__init__.pyi +++ b/src/numpy-stubs/__init__.pyi @@ -2135,11 +2135,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeT_co, _DType_co]): args: Iterable[Any], kwargs: Mapping[str, Any], ) -> Any: ... - - # NOTE: In practice any object is accepted by `obj`, but as `__array_finalize__` - # is a pseudo-abstract method the type has been narrowed down in order to - # grant subclasses a bit more flexibility - def __array_finalize__(self, obj: NDArray[Any] | None, /) -> None: ... + def __array_finalize__(self, obj: NDArray[Any] | Any, /) -> None: ... def __array_wrap__( self, array: ndarray[_ShapeT, _DType], @@ -5358,9 +5354,6 @@ class matrix(ndarray[_2DShapeT_co, _DType_co]): # def __new__(cls, data: ArrayLike, dtype: DTypeLike = ..., copy: builtins.bool = ...) -> matrix[_2D, Any]: ... - # - def __array_finalize__(self, obj: object) -> None: ... - # @overload def __getitem__(self, key: (SupportsIndex | _ArrayLikeInt_co | tuple[SupportsIndex | _ArrayLikeInt_co, ...]), /) -> Any: ... diff --git a/src/numpy-stubs/_core/defchararray.pyi b/src/numpy-stubs/_core/defchararray.pyi index afcedf83..53a78d8f 100644 --- a/src/numpy-stubs/_core/defchararray.pyi +++ b/src/numpy-stubs/_core/defchararray.pyi @@ -1,21 +1,26 @@ -from typing import Any, Literal as L, SupportsIndex, SupportsInt, TypeAlias, overload -from typing_extensions import TypeVar +from _typeshed import ConvertibleToInt +from typing import Any, Literal as L, SupportsIndex, TypeAlias, overload +from typing_extensions import Self, TypeVar import numpy as np -from numpy._core.multiarray import compare_chararrays +import numpy.typing as npt +from numpy import _OrderKACF, _SupportsBuffer # noqa: ICN003 from numpy._typing import ( - NDArray, - _ArrayLikeAnyString_co as UST_co, - _ArrayLikeBool_co as b_co, - _ArrayLikeBytes_co as S_co, - _ArrayLikeInt_co as i_co, - _ArrayLikeStr_co as U_co, - _ArrayLikeString_co as T_co, + _ArrayLikeAnyString_co as _ToAnyCharND, + _ArrayLikeBool_co as _ToBoolND, + _ArrayLikeBytes_co as _ToBytesND, + _ArrayLikeInt_co as _ToIntND, + _ArrayLikeStr_co as _ToStrND, + _ArrayLikeString_co as _ToStringND, + _IntLike_co as _ToInt, _Shape, - _ShapeLike, - _SupportsArray, + _ShapeLike as _ToShape, + _SupportsArray as _CanArray, ) +from ._multiarray_umath import compare_chararrays +from .strings import str_len + __all__ = [ "add", "array", @@ -72,223 +77,362 @@ __all__ = [ "zfill", ] +### + _ShapeT_co = TypeVar("_ShapeT_co", bound=tuple[int, ...], covariant=True) -_CharDType_co = TypeVar("_CharDType_co", bound=np.dtype[np.character], covariant=True) -_SCT = TypeVar("_SCT", bound=np.character) +_DTypeT_co = TypeVar("_DTypeT_co", bound=np.dtype[np.character], covariant=True) +_CharT = TypeVar("_CharT", bound=np.character) -_CharArray: TypeAlias = chararray[tuple[int, ...], np.dtype[_SCT]] +_CharArray: TypeAlias = chararray[tuple[int, ...], np.dtype[_CharT]] +_CharArray1D: TypeAlias = chararray[tuple[int], np.dtype[_CharT]] -_StringDTypeArray: TypeAlias = np.ndarray[_Shape, np.dtypes.StringDType] -_StringDTypeSupportsArray: TypeAlias = _SupportsArray[np.dtypes.StringDType] -_StringDTypeOrUnicodeArray: TypeAlias = np.ndarray[_Shape, np.dtype[np.str_]] | np.ndarray[_Shape, np.dtypes.StringDType] +_ToCharND: TypeAlias = _ToStrND | _ToBytesND -class chararray(np.ndarray[_ShapeT_co, _CharDType_co]): - @overload +_StrND: TypeAlias = npt.NDArray[np.str_] +_StringND: TypeAlias = np.ndarray[_Shape, np.dtypes.StringDType] +_CanStringND: TypeAlias = _CanArray[np.dtypes.StringDType] + +### + +# re-exported in `numpy.char` +class chararray(np.ndarray[_ShapeT_co, _DTypeT_co]): + __module__: L["numpy.char"] = "numpy.char" + + @overload # unicode=False (default) def __new__( cls, - shape: _ShapeLike, - itemsize: SupportsIndex | SupportsInt = ..., - unicode: L[False] = ..., - buffer: np._SupportsBuffer = ..., - offset: SupportsIndex = ..., - strides: _ShapeLike = ..., - order: np._OrderKACF = ..., + shape: _ToShape, + itemsize: ConvertibleToInt = 1, + unicode: L[False] = False, + buffer: _SupportsBuffer | None = None, + offset: SupportsIndex = 0, + strides: _ToShape | None = None, + order: _OrderKACF = "C", ) -> chararray[_Shape, np.dtype[np.bytes_]]: ... - @overload + @overload # unicode=True (positional) def __new__( cls, - shape: _ShapeLike, - itemsize: SupportsIndex | SupportsInt = ..., - unicode: L[True] = ..., - buffer: np._SupportsBuffer = ..., - offset: SupportsIndex = ..., - strides: _ShapeLike = ..., - order: np._OrderKACF = ..., + shape: _ToShape, + itemsize: ConvertibleToInt, + unicode: L[True], + buffer: _SupportsBuffer | None = None, + offset: SupportsIndex = 0, + strides: _ToShape | None = None, + order: _OrderKACF = "C", + ) -> chararray[_Shape, np.dtype[np.str_]]: ... + @overload # unicode=True (keyword) + def __new__( + cls, + shape: _ToShape, + itemsize: ConvertibleToInt = 1, + *, + unicode: L[True], + buffer: _SupportsBuffer | None = None, + offset: SupportsIndex = 0, + strides: _ToShape | None = None, + order: _OrderKACF = "C", ) -> chararray[_Shape, np.dtype[np.str_]]: ... - def __array_finalize__(self, obj: object) -> None: ... - - # - def __mul__(self, other: i_co, /) -> chararray[_Shape, _CharDType_co]: ... - def __rmul__(self, other: i_co, /) -> chararray[_Shape, _CharDType_co]: ... # - def __mod__(self, i: Any, /) -> chararray[_Shape, _CharDType_co]: ... + def __eq__(self, other: _ToCharND, /) -> npt.NDArray[np.bool]: ... # type: ignore[override] + def __ne__(self, other: _ToCharND, /) -> npt.NDArray[np.bool]: ... # type: ignore[override] + def __ge__(self, other: _ToCharND, /) -> npt.NDArray[np.bool]: ... # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] + def __gt__(self, other: _ToCharND, /) -> npt.NDArray[np.bool]: ... # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] + def __lt__(self, other: _ToCharND, /) -> npt.NDArray[np.bool]: ... # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] + def __le__(self, other: _ToCharND, /) -> npt.NDArray[np.bool]: ... # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] # + @overload # type: ignore[override] + def __add__(self: _CharArray[np.str_], rhs: _ToStrND, /) -> _CharArray[np.str_]: ... @overload - def __eq__(self: _CharArray[np.str_], other: U_co, /) -> NDArray[np.bool]: ... - @overload - def __eq__(self: _CharArray[np.bytes_], other: S_co, /) -> NDArray[np.bool]: ... - @overload - def __ne__(self: _CharArray[np.str_], other: U_co, /) -> NDArray[np.bool]: ... + def __add__(self: _CharArray[np.bytes_], rhs: _ToBytesND, /) -> _CharArray[np.bytes_]: ... # pyright: ignore[reportIncompatibleMethodOverride] + # + @overload # type: ignore[override] + def __radd__(self: _CharArray[np.str_], lhs: _ToStrND, /) -> _CharArray[np.str_]: ... @overload - def __ne__(self: _CharArray[np.bytes_], other: S_co, /) -> NDArray[np.bool]: ... + def __radd__(self: _CharArray[np.bytes_], lhs: _ToBytesND, /) -> _CharArray[np.bytes_]: ... # pyright: ignore[reportIncompatibleMethodOverride] # - @overload - def __ge__(self: _CharArray[np.str_], other: U_co, /) -> NDArray[np.bool]: ... - @overload - def __ge__(self: _CharArray[np.bytes_], other: S_co, /) -> NDArray[np.bool]: ... - @overload - def __le__(self: _CharArray[np.str_], other: U_co, /) -> NDArray[np.bool]: ... - @overload - def __le__(self: _CharArray[np.bytes_], other: S_co, /) -> NDArray[np.bool]: ... - @overload - def __gt__(self: _CharArray[np.str_], other: U_co, /) -> NDArray[np.bool]: ... - @overload - def __gt__(self: _CharArray[np.bytes_], other: S_co, /) -> NDArray[np.bool]: ... - @overload - def __lt__(self: _CharArray[np.str_], other: U_co, /) -> NDArray[np.bool]: ... - @overload - def __lt__(self: _CharArray[np.bytes_], other: S_co, /) -> NDArray[np.bool]: ... + def __mul__(self, rhs: _ToIntND, /) -> chararray[_Shape, _DTypeT_co]: ... # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] + def __rmul__(self, lhs: _ToIntND, /) -> chararray[_Shape, _DTypeT_co]: ... # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] + def __mod__(self, rhs: object, /) -> Self: ... # pyright: ignore[reportIncompatibleMethodOverride] # - @overload - def __add__(self: _CharArray[np.str_], other: U_co, /) -> _CharArray[np.str_]: ... - @overload - def __add__(self: _CharArray[np.bytes_], other: S_co, /) -> _CharArray[np.bytes_]: ... - @overload - def __radd__(self: _CharArray[np.str_], other: U_co, /) -> _CharArray[np.str_]: ... - @overload - def __radd__(self: _CharArray[np.bytes_], other: S_co, /) -> _CharArray[np.bytes_]: ... + def decode( + self: _CharArray[np.bytes_], + /, + encoding: str | None = None, + errors: str | None = None, + ) -> chararray[_ShapeT_co, np.dtype[np.str_]]: ... + def encode( + self: _CharArray[np.str_], + /, + encoding: str | None = None, + errors: str | None = None, + ) -> chararray[_ShapeT_co, np.dtype[np.bytes_]]: ... # @overload - def center(self: _CharArray[np.str_], width: i_co, fillchar: U_co = ...) -> _CharArray[np.str_]: ... + def center(self: _CharArray[np.str_], /, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> _CharArray[np.str_]: ... @overload - def center(self: _CharArray[np.bytes_], width: i_co, fillchar: S_co = ...) -> _CharArray[np.bytes_]: ... + def center(self: _CharArray[np.bytes_], /, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> _CharArray[np.bytes_]: ... # @overload - def count(self: _CharArray[np.str_], sub: U_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... - @overload - def count(self: _CharArray[np.bytes_], sub: S_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... + def count( + self: _CharArray[np.str_], + /, + sub: _ToStrND, + start: _ToIntND = 0, + end: _ToIntND | None = None, + ) -> npt.NDArray[np.int_]: ... + @overload + def count( + self: _CharArray[np.bytes_], + /, + sub: _ToBytesND, + start: _ToIntND = 0, + end: _ToIntND | None = None, + ) -> npt.NDArray[np.int_]: ... # - def decode(self: _CharArray[np.bytes_], encoding: str | None = ..., errors: str | None = ...) -> _CharArray[np.str_]: ... - def encode(self: _CharArray[np.str_], encoding: str | None = ..., errors: str | None = ...) -> _CharArray[np.bytes_]: ... + @overload + def endswith( + self: _CharArray[np.str_], + /, + suffix: _ToStrND, + start: _ToIntND = 0, + end: _ToIntND | None = None, + ) -> npt.NDArray[np.bool]: ... + @overload + def endswith( + self: _CharArray[np.bytes_], + /, + suffix: _ToBytesND, + start: _ToIntND = 0, + end: _ToIntND | None = None, + ) -> npt.NDArray[np.bool]: ... # @overload - def endswith(self: _CharArray[np.str_], suffix: U_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.bool]: ... + def expandtabs(self, /, tabsize: _ToInt = 8) -> chararray[_ShapeT_co, _DTypeT_co]: ... @overload - def endswith(self: _CharArray[np.bytes_], suffix: S_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.bool]: ... + def expandtabs(self, /, tabsize: _ToIntND) -> chararray[_Shape, _DTypeT_co]: ... # - def expandtabs(self, tabsize: i_co = ...) -> chararray[_Shape, _CharDType_co]: ... - - # - @overload - def find(self: _CharArray[np.str_], sub: U_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... @overload - def find(self: _CharArray[np.bytes_], sub: S_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... + def find( + self: _CharArray[np.str_], + /, + sub: _ToStrND, + start: _ToIntND = 0, + end: _ToIntND | None = None, + ) -> npt.NDArray[np.int_]: ... + @overload + def find( + self: _CharArray[np.bytes_], + /, + sub: _ToBytesND, + start: _ToIntND = 0, + end: _ToIntND | None = None, + ) -> npt.NDArray[np.int_]: ... # @overload - def index(self: _CharArray[np.str_], sub: U_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... - @overload - def index(self: _CharArray[np.bytes_], sub: S_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... + def index( + self: _CharArray[np.str_], + /, + sub: _ToStrND, + start: _ToIntND = 0, + end: _ToIntND | None = None, + ) -> npt.NDArray[np.int_]: ... + @overload + def index( + self: _CharArray[np.bytes_], + /, + sub: _ToBytesND, + start: _ToIntND = 0, + end: _ToIntND | None = None, + ) -> npt.NDArray[np.int_]: ... # @overload - def join(self: _CharArray[np.str_], seq: U_co) -> _CharArray[np.str_]: ... + def join(self: _CharArray[np.str_], /, seq: _ToStrND) -> _CharArray[np.str_]: ... @overload - def join(self: _CharArray[np.bytes_], seq: S_co) -> _CharArray[np.bytes_]: ... + def join(self: _CharArray[np.bytes_], /, seq: _ToBytesND) -> _CharArray[np.bytes_]: ... # @overload - def ljust(self: _CharArray[np.str_], width: i_co, fillchar: U_co = ...) -> _CharArray[np.str_]: ... + def ljust(self: _CharArray[np.str_], /, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> _CharArray[np.str_]: ... @overload - def ljust(self: _CharArray[np.bytes_], width: i_co, fillchar: S_co = ...) -> _CharArray[np.bytes_]: ... + def ljust(self: _CharArray[np.bytes_], /, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> _CharArray[np.bytes_]: ... # @overload - def lstrip(self: _CharArray[np.str_], chars: U_co | None = ...) -> _CharArray[np.str_]: ... + def lstrip(self: _CharArray[np.str_], /, chars: _ToStrND | None = None) -> _CharArray[np.str_]: ... @overload - def lstrip(self: _CharArray[np.bytes_], chars: S_co | None = ...) -> _CharArray[np.bytes_]: ... + def lstrip(self: _CharArray[np.bytes_], /, chars: _ToBytesND | None = None) -> _CharArray[np.bytes_]: ... # + @overload # type: ignore[override] + def partition(self: _CharArray[np.str_], /, sep: _ToStrND) -> _CharArray[np.str_]: ... @overload - def partition(self: _CharArray[np.str_], sep: U_co) -> _CharArray[np.str_]: ... - @overload - def partition(self: _CharArray[np.bytes_], sep: S_co) -> _CharArray[np.bytes_]: ... + def partition(self: _CharArray[np.bytes_], /, sep: _ToBytesND) -> _CharArray[np.bytes_]: ... # pyright: ignore[reportIncompatibleMethodOverride] # @overload - def replace(self: _CharArray[np.str_], old: U_co, new: U_co, count: i_co | None = ...) -> _CharArray[np.str_]: ... - @overload - def replace(self: _CharArray[np.bytes_], old: S_co, new: S_co, count: i_co | None = ...) -> _CharArray[np.bytes_]: ... + def replace( + self: _CharArray[np.str_], + /, + old: _ToStrND, + new: _ToStrND, + count: _ToIntND | None = None, + ) -> _CharArray[np.str_]: ... + @overload + def replace( + self: _CharArray[np.bytes_], + /, + old: _ToBytesND, + new: _ToBytesND, + count: _ToIntND | None = None, + ) -> _CharArray[np.bytes_]: ... # @overload - def rfind(self: _CharArray[np.str_], sub: U_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... - @overload - def rfind(self: _CharArray[np.bytes_], sub: S_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... + def rfind( + self: _CharArray[np.str_], + /, + sub: _ToStrND, + start: _ToIntND = 0, + end: _ToIntND | None = None, + ) -> npt.NDArray[np.int_]: ... + @overload + def rfind( + self: _CharArray[np.bytes_], + /, + sub: _ToBytesND, + start: _ToIntND = 0, + end: _ToIntND | None = None, + ) -> npt.NDArray[np.int_]: ... # @overload - def rindex(self: _CharArray[np.str_], sub: U_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... - @overload - def rindex(self: _CharArray[np.bytes_], sub: S_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... + def rindex( + self: _CharArray[np.str_], + /, + sub: _ToStrND, + start: _ToIntND = 0, + end: _ToIntND | None = None, + ) -> npt.NDArray[np.int_]: ... + @overload + def rindex( + self: _CharArray[np.bytes_], + /, + sub: _ToBytesND, + start: _ToIntND = 0, + end: _ToIntND | None = None, + ) -> npt.NDArray[np.int_]: ... # @overload - def rjust(self: _CharArray[np.str_], width: i_co, fillchar: U_co = ...) -> _CharArray[np.str_]: ... + def rjust(self: _CharArray[np.str_], /, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> _CharArray[np.str_]: ... @overload - def rjust(self: _CharArray[np.bytes_], width: i_co, fillchar: S_co = ...) -> _CharArray[np.bytes_]: ... + def rjust(self: _CharArray[np.bytes_], /, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> _CharArray[np.bytes_]: ... # @overload - def rpartition(self: _CharArray[np.str_], sep: U_co) -> _CharArray[np.str_]: ... + def rpartition(self: _CharArray[np.str_], /, sep: _ToStrND) -> _CharArray[np.str_]: ... @overload - def rpartition(self: _CharArray[np.bytes_], sep: S_co) -> _CharArray[np.bytes_]: ... + def rpartition(self: _CharArray[np.bytes_], /, sep: _ToBytesND) -> _CharArray[np.bytes_]: ... # @overload - def rsplit(self: _CharArray[np.str_], sep: U_co | None = ..., maxsplit: i_co | None = ...) -> NDArray[np.object_]: ... + def rsplit( + self: _CharArray[np.str_], + /, + sep: _ToStrND | None = None, + maxsplit: _ToIntND | None = None, + ) -> npt.NDArray[np.object_]: ... @overload - def rsplit(self: _CharArray[np.bytes_], sep: S_co | None = ..., maxsplit: i_co | None = ...) -> NDArray[np.object_]: ... + def rsplit( + self: _CharArray[np.bytes_], + /, + sep: _ToBytesND | None = None, + maxsplit: _ToIntND | None = None, + ) -> npt.NDArray[np.object_]: ... # @overload - def rstrip(self: _CharArray[np.str_], chars: U_co | None = ...) -> _CharArray[np.str_]: ... + def rstrip(self: _CharArray[np.str_], /, chars: _ToStrND | None = None) -> _CharArray[np.str_]: ... @overload - def rstrip(self: _CharArray[np.bytes_], chars: S_co | None = ...) -> _CharArray[np.bytes_]: ... + def rstrip(self: _CharArray[np.bytes_], /, chars: _ToBytesND | None = None) -> _CharArray[np.bytes_]: ... # @overload - def split(self: _CharArray[np.str_], sep: U_co | None = ..., maxsplit: i_co | None = ...) -> NDArray[np.object_]: ... + def split( + self: _CharArray[np.str_], + /, + sep: _ToStrND | None = None, + maxsplit: _ToIntND | None = None, + ) -> npt.NDArray[np.object_]: ... @overload - def split(self: _CharArray[np.bytes_], sep: S_co | None = ..., maxsplit: i_co | None = ...) -> NDArray[np.object_]: ... + def split( + self: _CharArray[np.bytes_], + /, + sep: _ToBytesND | None = None, + maxsplit: _ToIntND | None = None, + ) -> npt.NDArray[np.object_]: ... # - def splitlines(self, keepends: b_co | None = ...) -> NDArray[np.object_]: ... + def splitlines(self, /, keepends: _ToBoolND | None = ...) -> npt.NDArray[np.object_]: ... # @overload - def startswith(self: _CharArray[np.str_], prefix: U_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.bool]: ... - @overload - def startswith(self: _CharArray[np.bytes_], prefix: S_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.bool]: ... + def startswith( + self: _CharArray[np.str_], + /, + prefix: _ToStrND, + start: _ToIntND = 0, + end: _ToIntND | None = None, + ) -> npt.NDArray[np.bool]: ... + @overload + def startswith( + self: _CharArray[np.bytes_], + /, + prefix: _ToBytesND, + start: _ToIntND = 0, + end: _ToIntND | None = None, + ) -> npt.NDArray[np.bool]: ... # @overload - def strip(self: _CharArray[np.str_], chars: U_co | None = ...) -> _CharArray[np.str_]: ... + def strip(self: _CharArray[np.str_], /, chars: _ToStrND | None = None) -> _CharArray[np.str_]: ... @overload - def strip(self: _CharArray[np.bytes_], chars: S_co | None = ...) -> _CharArray[np.bytes_]: ... + def strip(self: _CharArray[np.bytes_], /, chars: _ToBytesND | None = None) -> _CharArray[np.bytes_]: ... # @overload - def translate(self: _CharArray[np.str_], table: U_co, deletechars: U_co | None = ...) -> _CharArray[np.str_]: ... + def translate( + self: _CharArray[np.str_], + /, + table: _ToStrND, + deletechars: _ToStrND | None = None, + ) -> _CharArray[np.str_]: ... @overload - def translate(self: _CharArray[np.bytes_], table: S_co, deletechars: S_co | None = ...) -> _CharArray[np.bytes_]: ... + def translate( + self: _CharArray[np.bytes_], + /, + table: _ToBytesND, + deletechars: _ToBytesND | None = None, + ) -> _CharArray[np.bytes_]: ... # - def zfill(self, width: i_co) -> chararray[_Shape, _CharDType_co]: ... - def capitalize(self) -> chararray[_ShapeT_co, _CharDType_co]: ... - def title(self) -> chararray[_ShapeT_co, _CharDType_co]: ... - def swapcase(self) -> chararray[_ShapeT_co, _CharDType_co]: ... - def lower(self) -> chararray[_ShapeT_co, _CharDType_co]: ... - def upper(self) -> chararray[_ShapeT_co, _CharDType_co]: ... + def zfill(self, /, width: _ToIntND) -> chararray[_Shape, _DTypeT_co]: ... + def capitalize(self) -> chararray[_ShapeT_co, _DTypeT_co]: ... + def title(self) -> chararray[_ShapeT_co, _DTypeT_co]: ... + def swapcase(self) -> chararray[_ShapeT_co, _DTypeT_co]: ... + def lower(self) -> chararray[_ShapeT_co, _DTypeT_co]: ... + def upper(self) -> chararray[_ShapeT_co, _DTypeT_co]: ... # def isalnum(self) -> np.ndarray[_ShapeT_co, np.dtype[np.bool]]: ... @@ -303,427 +447,433 @@ class chararray(np.ndarray[_ShapeT_co, _CharDType_co]): # Comparison @overload -def equal(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +def equal(x1: _ToStrND, x2: _ToStrND) -> npt.NDArray[np.bool]: ... @overload -def equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... +def equal(x1: _ToBytesND, x2: _ToBytesND) -> npt.NDArray[np.bool]: ... @overload -def equal(x1: T_co, x2: T_co) -> NDArray[np.bool]: ... +def equal(x1: _ToStringND, x2: _ToStringND) -> npt.NDArray[np.bool]: ... # @overload -def not_equal(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +def not_equal(x1: _ToStrND, x2: _ToStrND) -> npt.NDArray[np.bool]: ... @overload -def not_equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... +def not_equal(x1: _ToBytesND, x2: _ToBytesND) -> npt.NDArray[np.bool]: ... @overload -def not_equal(x1: T_co, x2: T_co) -> NDArray[np.bool]: ... +def not_equal(x1: _ToStringND, x2: _ToStringND) -> npt.NDArray[np.bool]: ... # @overload -def greater_equal(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +def greater_equal(x1: _ToStrND, x2: _ToStrND) -> npt.NDArray[np.bool]: ... @overload -def greater_equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... +def greater_equal(x1: _ToBytesND, x2: _ToBytesND) -> npt.NDArray[np.bool]: ... @overload -def greater_equal(x1: T_co, x2: T_co) -> NDArray[np.bool]: ... +def greater_equal(x1: _ToStringND, x2: _ToStringND) -> npt.NDArray[np.bool]: ... # @overload -def less_equal(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +def less_equal(x1: _ToStrND, x2: _ToStrND) -> npt.NDArray[np.bool]: ... @overload -def less_equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... +def less_equal(x1: _ToBytesND, x2: _ToBytesND) -> npt.NDArray[np.bool]: ... @overload -def less_equal(x1: T_co, x2: T_co) -> NDArray[np.bool]: ... +def less_equal(x1: _ToStringND, x2: _ToStringND) -> npt.NDArray[np.bool]: ... # @overload -def greater(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +def greater(x1: _ToStrND, x2: _ToStrND) -> npt.NDArray[np.bool]: ... @overload -def greater(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... +def greater(x1: _ToBytesND, x2: _ToBytesND) -> npt.NDArray[np.bool]: ... @overload -def greater(x1: T_co, x2: T_co) -> NDArray[np.bool]: ... +def greater(x1: _ToStringND, x2: _ToStringND) -> npt.NDArray[np.bool]: ... # @overload -def less(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +def less(x1: _ToStrND, x2: _ToStrND) -> npt.NDArray[np.bool]: ... @overload -def less(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... +def less(x1: _ToBytesND, x2: _ToBytesND) -> npt.NDArray[np.bool]: ... @overload -def less(x1: T_co, x2: T_co) -> NDArray[np.bool]: ... +def less(x1: _ToStringND, x2: _ToStringND) -> npt.NDArray[np.bool]: ... # @overload -def add(x1: U_co, x2: U_co) -> NDArray[np.str_]: ... +def add(x1: _ToStrND, x2: _ToStrND) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def add(x1: S_co, x2: S_co) -> NDArray[np.bytes_]: ... +def add(x1: _ToBytesND, x2: _ToBytesND) -> npt.NDArray[np.bytes_]: ... @overload -def add(x1: _StringDTypeSupportsArray, x2: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def add(x1: _CanStringND, x2: _CanStringND) -> _StringND: ... @overload -def add(x1: T_co, x2: T_co) -> _StringDTypeOrUnicodeArray: ... +def add(x1: _ToStringND, x2: _ToStringND) -> _StrND | _StringND: ... # @overload -def multiply(a: U_co, i: i_co) -> NDArray[np.str_]: ... +def multiply(a: _ToStrND, i: _ToIntND) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def multiply(a: S_co, i: i_co) -> NDArray[np.bytes_]: ... +def multiply(a: _ToBytesND, i: _ToIntND) -> npt.NDArray[np.bytes_]: ... @overload -def multiply(a: _StringDTypeSupportsArray, i: i_co) -> _StringDTypeArray: ... +def multiply(a: _CanStringND, i: _ToIntND) -> _StringND: ... @overload -def multiply(a: T_co, i: i_co) -> _StringDTypeOrUnicodeArray: ... +def multiply(a: _ToStringND, i: _ToIntND) -> _StrND | _StringND: ... # @overload -def mod(a: U_co, value: Any) -> NDArray[np.str_]: ... +def mod(a: _ToStrND, value: Any) -> npt.NDArray[np.str_]: ... @overload -def mod(a: S_co, value: Any) -> NDArray[np.bytes_]: ... +def mod(a: _ToBytesND, value: Any) -> npt.NDArray[np.bytes_]: ... @overload -def mod(a: _StringDTypeSupportsArray, value: Any) -> _StringDTypeArray: ... +def mod(a: _CanStringND, value: Any) -> _StringND: ... @overload -def mod(a: T_co, value: Any) -> _StringDTypeOrUnicodeArray: ... +def mod(a: _ToStringND, value: Any) -> _StrND | _StringND: ... # @overload -def capitalize(a: U_co) -> NDArray[np.str_]: ... +def capitalize(a: _ToStrND) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def capitalize(a: S_co) -> NDArray[np.bytes_]: ... +def capitalize(a: _ToBytesND) -> npt.NDArray[np.bytes_]: ... @overload -def capitalize(a: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def capitalize(a: _CanStringND) -> _StringND: ... @overload -def capitalize(a: T_co) -> _StringDTypeOrUnicodeArray: ... +def capitalize(a: _ToStringND) -> _StrND | _StringND: ... # @overload -def center(a: U_co, width: i_co, fillchar: U_co = ...) -> NDArray[np.str_]: ... +def center(a: _ToStrND, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def center(a: S_co, width: i_co, fillchar: S_co = ...) -> NDArray[np.bytes_]: ... +def center(a: _ToBytesND, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> npt.NDArray[np.bytes_]: ... @overload -def center(a: _StringDTypeSupportsArray, width: i_co, fillchar: _StringDTypeSupportsArray = ...) -> _StringDTypeArray: ... +def center(a: _CanStringND, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> _StringND: ... @overload -def center(a: T_co, width: i_co, fillchar: T_co = ...) -> _StringDTypeOrUnicodeArray: ... +def center(a: _ToStringND, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> _StrND | _StringND: ... # -def decode(a: S_co, encoding: str | None = ..., errors: str | None = ...) -> NDArray[np.str_]: ... -def encode(a: U_co | T_co, encoding: str | None = ..., errors: str | None = ...) -> NDArray[np.bytes_]: ... +def decode(a: _ToBytesND, encoding: str | None = None, errors: str | None = None) -> npt.NDArray[np.str_]: ... +def encode(a: _ToStrND | _ToStringND, encoding: str | None = None, errors: str | None = None) -> npt.NDArray[np.bytes_]: ... # @overload -def expandtabs(a: U_co, tabsize: i_co = ...) -> NDArray[np.str_]: ... +def expandtabs(a: _ToStrND, tabsize: _ToIntND = 8) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def expandtabs(a: S_co, tabsize: i_co = ...) -> NDArray[np.bytes_]: ... +def expandtabs(a: _ToBytesND, tabsize: _ToIntND = 8) -> npt.NDArray[np.bytes_]: ... @overload -def expandtabs(a: _StringDTypeSupportsArray, tabsize: i_co = ...) -> _StringDTypeArray: ... +def expandtabs(a: _CanStringND, tabsize: _ToIntND = 8) -> _StringND: ... @overload -def expandtabs(a: T_co, tabsize: i_co = ...) -> _StringDTypeOrUnicodeArray: ... +def expandtabs(a: _ToStringND, tabsize: _ToIntND = 8) -> _StrND | _StringND: ... # @overload -def join(sep: U_co, seq: U_co) -> NDArray[np.str_]: ... +def join(sep: _ToStrND, seq: _ToStrND) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def join(sep: S_co, seq: S_co) -> NDArray[np.bytes_]: ... +def join(sep: _ToBytesND, seq: _ToBytesND) -> npt.NDArray[np.bytes_]: ... @overload -def join(sep: _StringDTypeSupportsArray, seq: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def join(sep: _CanStringND, seq: _CanStringND) -> _StringND: ... @overload -def join(sep: T_co, seq: T_co) -> _StringDTypeOrUnicodeArray: ... +def join(sep: _ToStringND, seq: _ToStringND) -> _StrND | _StringND: ... # @overload -def ljust(a: U_co, width: i_co, fillchar: U_co = ...) -> NDArray[np.str_]: ... +def ljust(a: _ToStrND, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def ljust(a: S_co, width: i_co, fillchar: S_co = ...) -> NDArray[np.bytes_]: ... +def ljust(a: _ToBytesND, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> npt.NDArray[np.bytes_]: ... @overload -def ljust(a: _StringDTypeSupportsArray, width: i_co, fillchar: _StringDTypeSupportsArray = ...) -> _StringDTypeArray: ... +def ljust(a: _CanStringND, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> _StringND: ... @overload -def ljust(a: T_co, width: i_co, fillchar: T_co = ...) -> _StringDTypeOrUnicodeArray: ... +def ljust(a: _ToStringND, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> _StrND | _StringND: ... # @overload -def lower(a: U_co) -> NDArray[np.str_]: ... +def lower(a: _ToStrND) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def lower(a: S_co) -> NDArray[np.bytes_]: ... +def lower(a: _ToBytesND) -> npt.NDArray[np.bytes_]: ... @overload -def lower(a: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def lower(a: _CanStringND) -> _StringND: ... @overload -def lower(a: T_co) -> _StringDTypeOrUnicodeArray: ... +def lower(a: _ToStringND) -> _StrND | _StringND: ... # @overload -def lstrip(a: U_co, chars: U_co | None = ...) -> NDArray[np.str_]: ... +def lstrip(a: _ToStrND, chars: _ToStrND | None = None) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def lstrip(a: S_co, chars: S_co | None = ...) -> NDArray[np.bytes_]: ... +def lstrip(a: _ToBytesND, chars: _ToBytesND | None = None) -> npt.NDArray[np.bytes_]: ... @overload -def lstrip(a: _StringDTypeSupportsArray, chars: _StringDTypeSupportsArray | None = ...) -> _StringDTypeArray: ... +def lstrip(a: _CanStringND, chars: _CanStringND | None = None) -> _StringND: ... @overload -def lstrip(a: T_co, chars: T_co | None = ...) -> _StringDTypeOrUnicodeArray: ... +def lstrip(a: _ToStringND, chars: _ToStringND | None = None) -> _StrND | _StringND: ... # @overload -def partition(a: U_co, sep: U_co) -> NDArray[np.str_]: ... +def partition(a: _ToStrND, sep: _ToStrND) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def partition(a: S_co, sep: S_co) -> NDArray[np.bytes_]: ... +def partition(a: _ToBytesND, sep: _ToBytesND) -> npt.NDArray[np.bytes_]: ... @overload -def partition(a: _StringDTypeSupportsArray, sep: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def partition(a: _CanStringND, sep: _CanStringND) -> _StringND: ... @overload -def partition(a: T_co, sep: T_co) -> _StringDTypeOrUnicodeArray: ... +def partition(a: _ToStringND, sep: _ToStringND) -> _StrND | _StringND: ... # @overload -def replace(a: U_co, old: U_co, new: U_co, count: i_co | None = ...) -> NDArray[np.str_]: ... +def replace(a: _ToStrND, old: _ToStrND, new: _ToStrND, count: _ToIntND | None = None) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def replace(a: S_co, old: S_co, new: S_co, count: i_co | None = ...) -> NDArray[np.bytes_]: ... +def replace(a: _ToBytesND, old: _ToBytesND, new: _ToBytesND, count: _ToIntND | None = None) -> npt.NDArray[np.bytes_]: ... @overload -def replace( - a: _StringDTypeSupportsArray, old: _StringDTypeSupportsArray, new: _StringDTypeSupportsArray, count: i_co = ... -) -> _StringDTypeArray: ... +def replace(a: _CanStringND, old: _CanStringND, new: _CanStringND, count: _ToIntND = ...) -> _StringND: ... @overload -def replace(a: T_co, old: T_co, new: T_co, count: i_co = ...) -> _StringDTypeOrUnicodeArray: ... +def replace(a: _ToStringND, old: _ToStringND, new: _ToStringND, count: _ToIntND = ...) -> _StrND | _StringND: ... # @overload -def rjust(a: U_co, width: i_co, fillchar: U_co = ...) -> NDArray[np.str_]: ... +def rjust(a: _ToStrND, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def rjust(a: S_co, width: i_co, fillchar: S_co = ...) -> NDArray[np.bytes_]: ... +def rjust(a: _ToBytesND, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> npt.NDArray[np.bytes_]: ... @overload -def rjust(a: _StringDTypeSupportsArray, width: i_co, fillchar: _StringDTypeSupportsArray = ...) -> _StringDTypeArray: ... +def rjust(a: _CanStringND, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> _StringND: ... @overload -def rjust(a: T_co, width: i_co, fillchar: T_co = ...) -> _StringDTypeOrUnicodeArray: ... +def rjust(a: _ToStringND, width: _ToIntND, fillchar: _ToAnyCharND = " ") -> _StrND | _StringND: ... # @overload -def rpartition(a: U_co, sep: U_co) -> NDArray[np.str_]: ... +def rpartition(a: _ToStrND, sep: _ToStrND) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def rpartition(a: S_co, sep: S_co) -> NDArray[np.bytes_]: ... +def rpartition(a: _ToBytesND, sep: _ToBytesND) -> npt.NDArray[np.bytes_]: ... @overload -def rpartition(a: _StringDTypeSupportsArray, sep: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def rpartition(a: _CanStringND, sep: _CanStringND) -> _StringND: ... @overload -def rpartition(a: T_co, sep: T_co) -> _StringDTypeOrUnicodeArray: ... +def rpartition(a: _ToStringND, sep: _ToStringND) -> _StrND | _StringND: ... # @overload -def rsplit(a: U_co, sep: U_co | None = ..., maxsplit: i_co | None = ...) -> NDArray[np.object_]: ... +def rsplit(a: _ToStrND, sep: _ToStrND | None = None, maxsplit: _ToIntND | None = None) -> npt.NDArray[np.object_]: ... @overload -def rsplit(a: S_co, sep: S_co | None = ..., maxsplit: i_co | None = ...) -> NDArray[np.object_]: ... +def rsplit(a: _ToBytesND, sep: _ToBytesND | None = None, maxsplit: _ToIntND | None = None) -> npt.NDArray[np.object_]: ... @overload -def rsplit( - a: _StringDTypeSupportsArray, sep: _StringDTypeSupportsArray | None = ..., maxsplit: i_co | None = ... -) -> NDArray[np.object_]: ... +def rsplit(a: _CanStringND, sep: _CanStringND | None = ..., maxsplit: _ToIntND | None = None) -> npt.NDArray[np.object_]: ... @overload -def rsplit(a: T_co, sep: T_co | None = ..., maxsplit: i_co | None = ...) -> NDArray[np.object_]: ... +def rsplit(a: _ToStringND, sep: _ToStringND | None = ..., maxsplit: _ToIntND | None = None) -> npt.NDArray[np.object_]: ... # @overload -def rstrip(a: U_co, chars: U_co | None = ...) -> NDArray[np.str_]: ... +def rstrip(a: _ToStrND, chars: _ToStrND | None = None) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def rstrip(a: S_co, chars: S_co | None = ...) -> NDArray[np.bytes_]: ... +def rstrip(a: _ToBytesND, chars: _ToBytesND | None = None) -> npt.NDArray[np.bytes_]: ... @overload -def rstrip(a: _StringDTypeSupportsArray, chars: _StringDTypeSupportsArray | None = ...) -> _StringDTypeArray: ... +def rstrip(a: _CanStringND, chars: _CanStringND | None = None) -> _StringND: ... @overload -def rstrip(a: T_co, chars: T_co | None = ...) -> _StringDTypeOrUnicodeArray: ... +def rstrip(a: _ToStringND, chars: _ToStringND | None = None) -> _StrND | _StringND: ... # @overload -def split(a: U_co, sep: U_co | None = ..., maxsplit: i_co | None = ...) -> NDArray[np.object_]: ... +def split(a: _ToStrND, sep: _ToStrND | None = None, maxsplit: _ToIntND | None = None) -> npt.NDArray[np.object_]: ... @overload -def split(a: S_co, sep: S_co | None = ..., maxsplit: i_co | None = ...) -> NDArray[np.object_]: ... +def split(a: _ToBytesND, sep: _ToBytesND | None = None, maxsplit: _ToIntND | None = None) -> npt.NDArray[np.object_]: ... @overload -def split( - a: _StringDTypeSupportsArray, sep: _StringDTypeSupportsArray | None = ..., maxsplit: i_co | None = ... -) -> NDArray[np.object_]: ... +def split(a: _CanStringND, sep: _CanStringND | None = ..., maxsplit: _ToIntND | None = None) -> npt.NDArray[np.object_]: ... @overload -def split(a: T_co, sep: T_co | None = ..., maxsplit: i_co | None = ...) -> NDArray[np.object_]: ... +def split(a: _ToStringND, sep: _ToStringND | None = ..., maxsplit: _ToIntND | None = None) -> npt.NDArray[np.object_]: ... # -def splitlines(a: UST_co, keepends: b_co | None = ...) -> NDArray[np.object_]: ... +def splitlines(a: _ToAnyCharND, keepends: _ToBoolND | None = ...) -> npt.NDArray[np.object_]: ... # @overload -def strip(a: U_co, chars: U_co | None = ...) -> NDArray[np.str_]: ... +def strip(a: _ToStrND, chars: _ToStrND | None = None) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def strip(a: S_co, chars: S_co | None = ...) -> NDArray[np.bytes_]: ... +def strip(a: _ToBytesND, chars: _ToBytesND | None = None) -> npt.NDArray[np.bytes_]: ... @overload -def strip(a: _StringDTypeSupportsArray, chars: _StringDTypeSupportsArray | None = ...) -> _StringDTypeArray: ... +def strip(a: _CanStringND, chars: _CanStringND | None = None) -> _StringND: ... @overload -def strip(a: T_co, chars: T_co | None = ...) -> _StringDTypeOrUnicodeArray: ... +def strip(a: _ToStringND, chars: _ToStringND | None = None) -> _StrND | _StringND: ... # @overload -def swapcase(a: U_co) -> NDArray[np.str_]: ... +def swapcase(a: _ToStrND) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def swapcase(a: S_co) -> NDArray[np.bytes_]: ... +def swapcase(a: _ToBytesND) -> npt.NDArray[np.bytes_]: ... @overload -def swapcase(a: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def swapcase(a: _CanStringND) -> _StringND: ... @overload -def swapcase(a: T_co) -> _StringDTypeOrUnicodeArray: ... +def swapcase(a: _ToStringND) -> _StrND | _StringND: ... # @overload -def title(a: U_co) -> NDArray[np.str_]: ... +def title(a: _ToStrND) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def title(a: S_co) -> NDArray[np.bytes_]: ... +def title(a: _ToBytesND) -> npt.NDArray[np.bytes_]: ... @overload -def title(a: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def title(a: _CanStringND) -> _StringND: ... @overload -def title(a: T_co) -> _StringDTypeOrUnicodeArray: ... +def title(a: _ToStringND) -> _StrND | _StringND: ... # @overload -def translate(a: U_co, table: str, deletechars: str | None = ...) -> NDArray[np.str_]: ... +def translate(a: _ToStrND, table: str, deletechars: str | None = ...) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def translate(a: S_co, table: str, deletechars: str | None = ...) -> NDArray[np.bytes_]: ... +def translate(a: _ToBytesND, table: str, deletechars: str | None = ...) -> npt.NDArray[np.bytes_]: ... @overload -def translate(a: _StringDTypeSupportsArray, table: str, deletechars: str | None = ...) -> _StringDTypeArray: ... +def translate(a: _CanStringND, table: str, deletechars: str | None = ...) -> _StringND: ... @overload -def translate(a: T_co, table: str, deletechars: str | None = ...) -> _StringDTypeOrUnicodeArray: ... +def translate(a: _ToStringND, table: str, deletechars: str | None = ...) -> _StrND | _StringND: ... # @overload -def upper(a: U_co) -> NDArray[np.str_]: ... +def upper(a: _ToStrND) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def upper(a: S_co) -> NDArray[np.bytes_]: ... +def upper(a: _ToBytesND) -> npt.NDArray[np.bytes_]: ... @overload -def upper(a: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def upper(a: _CanStringND) -> _StringND: ... @overload -def upper(a: T_co) -> _StringDTypeOrUnicodeArray: ... +def upper(a: _ToStringND) -> _StrND | _StringND: ... # @overload -def zfill(a: U_co, width: i_co) -> NDArray[np.str_]: ... +def zfill(a: _ToStrND, width: _ToIntND) -> npt.NDArray[np.str_]: ... # type: ignore[overload-overlap] @overload -def zfill(a: S_co, width: i_co) -> NDArray[np.bytes_]: ... +def zfill(a: _ToBytesND, width: _ToIntND) -> npt.NDArray[np.bytes_]: ... @overload -def zfill(a: _StringDTypeSupportsArray, width: i_co) -> _StringDTypeArray: ... +def zfill(a: _CanStringND, width: _ToIntND) -> _StringND: ... @overload -def zfill(a: T_co, width: i_co) -> _StringDTypeOrUnicodeArray: ... +def zfill(a: _ToStringND, width: _ToIntND) -> _StrND | _StringND: ... # String information @overload -def count(a: U_co, sub: U_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... +def count(a: _ToStrND, sub: _ToStrND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.int_]: ... @overload -def count(a: S_co, sub: S_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... +def count(a: _ToBytesND, sub: _ToBytesND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.int_]: ... @overload -def count(a: T_co, sub: T_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... +def count(a: _ToStringND, sub: _ToStringND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.int_]: ... # @overload -def endswith(a: U_co, suffix: U_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.bool]: ... +def endswith(a: _ToStrND, suffix: _ToStrND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.bool]: ... @overload -def endswith(a: S_co, suffix: S_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.bool]: ... +def endswith(a: _ToBytesND, suffix: _ToBytesND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.bool]: ... @overload -def endswith(a: T_co, suffix: T_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.bool]: ... +def endswith(a: _ToStringND, suffix: _ToStringND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.bool]: ... # @overload -def find(a: U_co, sub: U_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... +def find(a: _ToStrND, sub: _ToStrND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.int_]: ... @overload -def find(a: S_co, sub: S_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... +def find(a: _ToBytesND, sub: _ToBytesND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.int_]: ... @overload -def find(a: T_co, sub: T_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... +def find(a: _ToStringND, sub: _ToStringND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.int_]: ... # @overload -def index(a: U_co, sub: U_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... +def index(a: _ToStrND, sub: _ToStrND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.int_]: ... @overload -def index(a: S_co, sub: S_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... +def index(a: _ToBytesND, sub: _ToBytesND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.int_]: ... @overload -def index(a: T_co, sub: T_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... +def index(a: _ToStringND, sub: _ToStringND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.int_]: ... # -def isalpha(a: UST_co) -> NDArray[np.bool]: ... -def isalnum(a: UST_co) -> NDArray[np.bool]: ... -def isdecimal(a: U_co | T_co) -> NDArray[np.bool]: ... -def isdigit(a: UST_co) -> NDArray[np.bool]: ... -def islower(a: UST_co) -> NDArray[np.bool]: ... -def isnumeric(a: U_co | T_co) -> NDArray[np.bool]: ... -def isspace(a: UST_co) -> NDArray[np.bool]: ... -def istitle(a: UST_co) -> NDArray[np.bool]: ... -def isupper(a: UST_co) -> NDArray[np.bool]: ... +def isalpha(a: _ToAnyCharND) -> npt.NDArray[np.bool]: ... +def isalnum(a: _ToAnyCharND) -> npt.NDArray[np.bool]: ... +def isdecimal(a: _ToStrND | _ToStringND) -> npt.NDArray[np.bool]: ... +def isdigit(a: _ToAnyCharND) -> npt.NDArray[np.bool]: ... +def islower(a: _ToAnyCharND) -> npt.NDArray[np.bool]: ... +def isnumeric(a: _ToStrND | _ToStringND) -> npt.NDArray[np.bool]: ... +def isspace(a: _ToAnyCharND) -> npt.NDArray[np.bool]: ... +def istitle(a: _ToAnyCharND) -> npt.NDArray[np.bool]: ... +def isupper(a: _ToAnyCharND) -> npt.NDArray[np.bool]: ... # @overload -def rfind(a: U_co, sub: U_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... +def rfind(a: _ToStrND, sub: _ToStrND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.int_]: ... @overload -def rfind(a: S_co, sub: S_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... +def rfind(a: _ToBytesND, sub: _ToBytesND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.int_]: ... @overload -def rfind(a: T_co, sub: T_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... +def rfind(a: _ToStringND, sub: _ToStringND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.int_]: ... # @overload -def rindex(a: U_co, sub: U_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... +def rindex(a: _ToStrND, sub: _ToStrND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.int_]: ... @overload -def rindex(a: S_co, sub: S_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... +def rindex(a: _ToBytesND, sub: _ToBytesND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.int_]: ... @overload -def rindex(a: T_co, sub: T_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.int_]: ... +def rindex(a: _ToStringND, sub: _ToStringND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.int_]: ... # @overload -def startswith(a: U_co, prefix: U_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.bool]: ... +def startswith(a: _ToStrND, prefix: _ToStrND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.bool]: ... @overload -def startswith(a: S_co, prefix: S_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.bool]: ... +def startswith(a: _ToBytesND, prefix: _ToBytesND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.bool]: ... @overload -def startswith(a: T_co, suffix: T_co, start: i_co = ..., end: i_co | None = ...) -> NDArray[np.bool]: ... - -# -def str_len(A: UST_co) -> NDArray[np.int_]: ... - -# Overload 1 and 2: str- or bytes-based array-likes -# overload 3: arbitrary object with unicode=False (-> np.bytes_) -# overload 4: arbitrary object with unicode=True (-> np.str_) -@overload -def array( - obj: U_co, - itemsize: int | None = ..., - copy: bool = ..., - unicode: L[False] = ..., - order: np._OrderKACF = ..., +def startswith(a: _ToStringND, suffix: _ToStringND, start: _ToIntND = 0, end: _ToIntND | None = None) -> npt.NDArray[np.bool]: ... +@overload # str array-like +def array( # type: ignore[overload-overlap] + obj: _ToStrND, + itemsize: int | None = None, + copy: bool = True, + unicode: bool | None = None, + order: _OrderKACF | None = None, ) -> _CharArray[np.str_]: ... -@overload -def array( - obj: S_co, - itemsize: int | None = ..., - copy: bool = ..., - unicode: L[False] = ..., - order: np._OrderKACF = ..., +@overload # bytes array-like +def array( # type: ignore[overload-overlap] + obj: _ToBytesND, + itemsize: int | None = None, + copy: bool = True, + unicode: bool | None = None, + order: _OrderKACF | None = None, ) -> _CharArray[np.bytes_]: ... -@overload +@overload # unicode=False def array( obj: object, - itemsize: int | None = ..., - copy: bool = ..., - unicode: L[False] = ..., - order: np._OrderKACF = ..., + itemsize: int | None = None, + copy: bool = True, + *, + unicode: L[False], + order: _OrderKACF | None = None, ) -> _CharArray[np.bytes_]: ... -@overload +@overload # unicode=True def array( obj: object, - itemsize: int | None = ..., - copy: bool = ..., - unicode: L[True] = ..., - order: np._OrderKACF = ..., + itemsize: int | None = None, + copy: bool = True, + *, + unicode: L[True], + order: _OrderKACF | None = None, ) -> _CharArray[np.str_]: ... - -# -@overload -def asarray( - obj: U_co, - itemsize: int | None = ..., - unicode: L[False] = ..., - order: np._OrderKACF = ..., +@overload # fallback +def array( + obj: object, + itemsize: int | None = None, + copy: bool = True, + unicode: bool | None = None, + order: _OrderKACF | None = None, +) -> _CharArray[np.bytes_ | np.str_]: ... + +# +@overload # str array-like +def asarray( # type: ignore[overload-overlap] + obj: _ToStrND, + itemsize: int | None = None, + unicode: bool | None = None, + order: _OrderKACF | None = None, ) -> _CharArray[np.str_]: ... -@overload -def asarray( - obj: S_co, - itemsize: int | None = ..., - unicode: L[False] = ..., - order: np._OrderKACF = ..., +@overload # bytes array-like +def asarray( # type: ignore[overload-overlap] + obj: _ToBytesND, + itemsize: int | None = None, + unicode: bool | None = None, + order: _OrderKACF | None = None, ) -> _CharArray[np.bytes_]: ... -@overload +@overload # unicode=False def asarray( obj: object, - itemsize: int | None = ..., - unicode: L[False] = ..., - order: np._OrderKACF = ..., + itemsize: int | None = None, + *, + unicode: L[False], + order: _OrderKACF | None = None, ) -> _CharArray[np.bytes_]: ... -@overload +@overload # unicode=True def asarray( obj: object, - itemsize: int | None = ..., - unicode: L[True] = ..., - order: np._OrderKACF = ..., + itemsize: int | None = None, + *, + unicode: L[True], + order: _OrderKACF | None = None, ) -> _CharArray[np.str_]: ... +@overload # falback +def asarray( + obj: object, + itemsize: int | None = None, + unicode: bool | None = None, + order: _OrderKACF | None = None, +) -> _CharArray[np.bytes_ | np.str_]: ... diff --git a/test/static/accept/char.pyi b/test/static/accept/char.pyi index a26be0e2..d974887d 100644 --- a/test/static/accept/char.pyi +++ b/test/static/accept/char.pyi @@ -2,15 +2,16 @@ from typing import TypeAlias from typing_extensions import assert_type import numpy as np -import numpy._typing as np_t import numpy.typing as npt -AR_U: npt.NDArray[np.str_] -AR_S: npt.NDArray[np.bytes_] -AR_T: np.ndarray[np_t._Shape, np.dtypes.StringDType] +BytesArray: TypeAlias = npt.NDArray[np.bytes_] +StrArray: TypeAlias = npt.NDArray[np.str_] +StringArray: TypeAlias = np.ndarray[tuple[int, ...], np.dtypes.StringDType] -AR_T_alias: TypeAlias = np.ndarray[np_t._Shape, np.dtypes.StringDType] -AR_TU_alias: TypeAlias = AR_T_alias | npt.NDArray[np.str_] +AR_S: BytesArray +AR_U: StrArray +AR_T: StringArray +AR_SUT: BytesArray | StrArray | StringArray assert_type(np.char.equal(AR_U, AR_U), npt.NDArray[np.bool]) assert_type(np.char.equal(AR_S, AR_S), npt.NDArray[np.bool]) @@ -36,75 +37,76 @@ assert_type(np.char.less(AR_U, AR_U), npt.NDArray[np.bool]) assert_type(np.char.less(AR_S, AR_S), npt.NDArray[np.bool]) assert_type(np.char.less(AR_T, AR_T), npt.NDArray[np.bool]) -assert_type(np.char.multiply(AR_U, 5), npt.NDArray[np.str_]) -assert_type(np.char.multiply(AR_S, [5, 4, 3]), npt.NDArray[np.bytes_]) -assert_type(np.char.multiply(AR_T, 5), AR_T_alias) +assert_type(np.char.multiply(AR_U, 5), StrArray) +assert_type(np.char.multiply(AR_U, 5), StrArray) +assert_type(np.char.multiply(AR_S, [5, 4, 3]), BytesArray) +assert_type(np.char.multiply(AR_T, 5), StringArray) -assert_type(np.char.mod(AR_U, "test"), npt.NDArray[np.str_]) -assert_type(np.char.mod(AR_S, "test"), npt.NDArray[np.bytes_]) -assert_type(np.char.mod(AR_T, "test"), AR_T_alias) +assert_type(np.char.mod(AR_U, "test"), StrArray) +assert_type(np.char.mod(AR_S, "test"), BytesArray) +assert_type(np.char.mod(AR_T, "test"), StringArray) -assert_type(np.char.capitalize(AR_U), npt.NDArray[np.str_]) -assert_type(np.char.capitalize(AR_S), npt.NDArray[np.bytes_]) -assert_type(np.char.capitalize(AR_T), AR_T_alias) +assert_type(np.char.capitalize(AR_U), StrArray) +assert_type(np.char.capitalize(AR_S), BytesArray) +assert_type(np.char.capitalize(AR_T), StringArray) -assert_type(np.char.center(AR_U, 5), npt.NDArray[np.str_]) -assert_type(np.char.center(AR_S, [2, 3, 4], b"a"), npt.NDArray[np.bytes_]) -assert_type(np.char.center(AR_T, 5), AR_T_alias) +assert_type(np.char.center(AR_U, 5), StrArray) +assert_type(np.char.center(AR_S, [2, 3, 4], b"a"), BytesArray) +assert_type(np.char.center(AR_T, 5), StringArray) -assert_type(np.char.encode(AR_U), npt.NDArray[np.bytes_]) -assert_type(np.char.encode(AR_T), npt.NDArray[np.bytes_]) -assert_type(np.char.decode(AR_S), npt.NDArray[np.str_]) +assert_type(np.char.encode(AR_U), BytesArray) +assert_type(np.char.encode(AR_T), BytesArray) +assert_type(np.char.decode(AR_S), StrArray) -assert_type(np.char.expandtabs(AR_U), npt.NDArray[np.str_]) -assert_type(np.char.expandtabs(AR_S, tabsize=4), npt.NDArray[np.bytes_]) -assert_type(np.char.expandtabs(AR_T), AR_T_alias) +assert_type(np.char.expandtabs(AR_U), StrArray) +assert_type(np.char.expandtabs(AR_S, tabsize=4), BytesArray) +assert_type(np.char.expandtabs(AR_T), StringArray) -assert_type(np.char.join(AR_U, "_"), npt.NDArray[np.str_]) -assert_type(np.char.join(AR_S, [b"_", b""]), npt.NDArray[np.bytes_]) -assert_type(np.char.join(AR_T, "_"), AR_TU_alias) +assert_type(np.char.join(AR_U, "_"), StrArray) +assert_type(np.char.join(AR_S, [b"_", b""]), BytesArray) +assert_type(np.char.join(AR_T, "_"), StrArray | StringArray) -assert_type(np.char.ljust(AR_U, 5), npt.NDArray[np.str_]) -assert_type(np.char.ljust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"]), npt.NDArray[np.bytes_]) -assert_type(np.char.ljust(AR_T, 5), AR_T_alias) -assert_type(np.char.ljust(AR_T, [4, 2, 1], fillchar=["a", "b", "c"]), AR_TU_alias) +assert_type(np.char.ljust(AR_U, 5), StrArray) +assert_type(np.char.ljust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"]), BytesArray) +assert_type(np.char.ljust(AR_T, 5), StringArray) +assert_type(np.char.ljust(AR_T, [4, 2, 1], fillchar=["a", "b", "c"]), StringArray) -assert_type(np.char.rjust(AR_U, 5), npt.NDArray[np.str_]) -assert_type(np.char.rjust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"]), npt.NDArray[np.bytes_]) -assert_type(np.char.rjust(AR_T, 5), AR_T_alias) -assert_type(np.char.rjust(AR_T, [4, 2, 1], fillchar=["a", "b", "c"]), AR_TU_alias) +assert_type(np.char.rjust(AR_U, 5), StrArray) +assert_type(np.char.rjust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"]), BytesArray) +assert_type(np.char.rjust(AR_T, 5), StringArray) +assert_type(np.char.rjust(AR_T, [4, 2, 1], fillchar=["a", "b", "c"]), StringArray) -assert_type(np.char.lstrip(AR_U), npt.NDArray[np.str_]) -assert_type(np.char.lstrip(AR_S, b"_"), npt.NDArray[np.bytes_]) -assert_type(np.char.lstrip(AR_T), AR_T_alias) -assert_type(np.char.lstrip(AR_T, "_"), AR_TU_alias) +assert_type(np.char.lstrip(AR_U), StrArray) +assert_type(np.char.lstrip(AR_S, b"_"), BytesArray) +assert_type(np.char.lstrip(AR_T), StringArray) +assert_type(np.char.lstrip(AR_T, "_"), StrArray | StringArray) -assert_type(np.char.rstrip(AR_U), npt.NDArray[np.str_]) -assert_type(np.char.rstrip(AR_S, b"_"), npt.NDArray[np.bytes_]) -assert_type(np.char.rstrip(AR_T), AR_T_alias) -assert_type(np.char.rstrip(AR_T, "_"), AR_TU_alias) +assert_type(np.char.rstrip(AR_U), StrArray) +assert_type(np.char.rstrip(AR_S, b"_"), BytesArray) +assert_type(np.char.rstrip(AR_T), StringArray) +assert_type(np.char.rstrip(AR_T, "_"), StrArray | StringArray) -assert_type(np.char.strip(AR_U), npt.NDArray[np.str_]) -assert_type(np.char.strip(AR_S, b"_"), npt.NDArray[np.bytes_]) -assert_type(np.char.strip(AR_T), AR_T_alias) -assert_type(np.char.strip(AR_T, "_"), AR_TU_alias) +assert_type(np.char.strip(AR_U), StrArray) +assert_type(np.char.strip(AR_S, b"_"), BytesArray) +assert_type(np.char.strip(AR_T), StringArray) +assert_type(np.char.strip(AR_T, "_"), StrArray | StringArray) assert_type(np.char.count(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_]) assert_type(np.char.count(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_]) assert_type(np.char.count(AR_T, AR_T, start=[1, 2, 3]), npt.NDArray[np.int_]) assert_type(np.char.count(AR_T, ["a", "b", "c"], end=9), npt.NDArray[np.int_]) -assert_type(np.char.partition(AR_U, "\n"), npt.NDArray[np.str_]) -assert_type(np.char.partition(AR_S, [b"a", b"b", b"c"]), npt.NDArray[np.bytes_]) -assert_type(np.char.partition(AR_T, "\n"), AR_TU_alias) +assert_type(np.char.partition(AR_U, "\n"), StrArray) +assert_type(np.char.partition(AR_S, [b"a", b"b", b"c"]), BytesArray) +assert_type(np.char.partition(AR_T, "\n"), StrArray | StringArray) -assert_type(np.char.rpartition(AR_U, "\n"), npt.NDArray[np.str_]) -assert_type(np.char.rpartition(AR_S, [b"a", b"b", b"c"]), npt.NDArray[np.bytes_]) -assert_type(np.char.rpartition(AR_T, "\n"), AR_TU_alias) +assert_type(np.char.rpartition(AR_U, "\n"), StrArray) +assert_type(np.char.rpartition(AR_S, [b"a", b"b", b"c"]), BytesArray) +assert_type(np.char.rpartition(AR_T, "\n"), StrArray | StringArray) -assert_type(np.char.replace(AR_U, "_", "-"), npt.NDArray[np.str_]) -assert_type(np.char.replace(AR_S, [b"_", b""], [b"a", b"b"]), npt.NDArray[np.bytes_]) -assert_type(np.char.replace(AR_T, "_", "_"), AR_TU_alias) +assert_type(np.char.replace(AR_U, "_", "-"), StrArray) +assert_type(np.char.replace(AR_S, [b"_", b""], [b"a", b"b"]), BytesArray) +assert_type(np.char.replace(AR_T, "_", "_"), StrArray | StringArray) assert_type(np.char.split(AR_U, "_"), npt.NDArray[np.object_]) assert_type(np.char.split(AR_S, maxsplit=[1, 2, 3]), npt.NDArray[np.object_]) @@ -118,25 +120,29 @@ assert_type(np.char.splitlines(AR_U), npt.NDArray[np.object_]) assert_type(np.char.splitlines(AR_S, keepends=[True, True, False]), npt.NDArray[np.object_]) assert_type(np.char.splitlines(AR_T), npt.NDArray[np.object_]) -assert_type(np.char.lower(AR_U), npt.NDArray[np.str_]) -assert_type(np.char.lower(AR_S), npt.NDArray[np.bytes_]) -assert_type(np.char.lower(AR_T), AR_T_alias) +assert_type(np.char.lower(AR_U), StrArray) +assert_type(np.char.lower(AR_S), BytesArray) +assert_type(np.char.lower(AR_T), StringArray) -assert_type(np.char.upper(AR_U), npt.NDArray[np.str_]) -assert_type(np.char.upper(AR_S), npt.NDArray[np.bytes_]) -assert_type(np.char.upper(AR_T), AR_T_alias) +assert_type(np.char.upper(AR_U), StrArray) +assert_type(np.char.upper(AR_S), BytesArray) +assert_type(np.char.upper(AR_T), StringArray) -assert_type(np.char.swapcase(AR_U), npt.NDArray[np.str_]) -assert_type(np.char.swapcase(AR_S), npt.NDArray[np.bytes_]) -assert_type(np.char.swapcase(AR_T), AR_T_alias) +assert_type(np.char.swapcase(AR_U), StrArray) +assert_type(np.char.swapcase(AR_S), BytesArray) +assert_type(np.char.swapcase(AR_T), StringArray) -assert_type(np.char.title(AR_U), npt.NDArray[np.str_]) -assert_type(np.char.title(AR_S), npt.NDArray[np.bytes_]) -assert_type(np.char.title(AR_T), AR_T_alias) +assert_type(np.char.title(AR_U), StrArray) +assert_type(np.char.title(AR_S), BytesArray) +assert_type(np.char.title(AR_T), StringArray) -assert_type(np.char.zfill(AR_U, 5), npt.NDArray[np.str_]) -assert_type(np.char.zfill(AR_S, [2, 3, 4]), npt.NDArray[np.bytes_]) -assert_type(np.char.zfill(AR_T, 5), AR_T_alias) +assert_type(np.char.translate(AR_U, ""), StrArray) +assert_type(np.char.translate(AR_S, ""), BytesArray) +assert_type(np.char.translate(AR_T, ""), StringArray) + +assert_type(np.char.zfill(AR_U, 5), StrArray) +assert_type(np.char.zfill(AR_S, [2, 3, 4]), BytesArray) +assert_type(np.char.zfill(AR_T, 5), StringArray) assert_type(np.char.endswith(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.bool]) assert_type(np.char.endswith(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.bool]) @@ -162,47 +168,20 @@ assert_type(np.char.rindex(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_]) assert_type(np.char.rindex(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_]) assert_type(np.char.rindex(AR_T, "a", start=[1, 2, 3]), npt.NDArray[np.int_]) -assert_type(np.char.isalpha(AR_U), npt.NDArray[np.bool]) -assert_type(np.char.isalpha(AR_S), npt.NDArray[np.bool]) -assert_type(np.char.isalpha(AR_T), npt.NDArray[np.bool]) - -assert_type(np.char.isalnum(AR_U), npt.NDArray[np.bool]) -assert_type(np.char.isalnum(AR_S), npt.NDArray[np.bool]) -assert_type(np.char.isalnum(AR_T), npt.NDArray[np.bool]) - assert_type(np.char.isdecimal(AR_U), npt.NDArray[np.bool]) assert_type(np.char.isdecimal(AR_T), npt.NDArray[np.bool]) -assert_type(np.char.isdigit(AR_U), npt.NDArray[np.bool]) -assert_type(np.char.isdigit(AR_S), npt.NDArray[np.bool]) -assert_type(np.char.isdigit(AR_T), npt.NDArray[np.bool]) - -assert_type(np.char.islower(AR_U), npt.NDArray[np.bool]) -assert_type(np.char.islower(AR_S), npt.NDArray[np.bool]) -assert_type(np.char.islower(AR_T), npt.NDArray[np.bool]) - assert_type(np.char.isnumeric(AR_U), npt.NDArray[np.bool]) assert_type(np.char.isnumeric(AR_T), npt.NDArray[np.bool]) -assert_type(np.char.isspace(AR_U), npt.NDArray[np.bool]) -assert_type(np.char.isspace(AR_S), npt.NDArray[np.bool]) -assert_type(np.char.isspace(AR_T), npt.NDArray[np.bool]) - -assert_type(np.char.istitle(AR_U), npt.NDArray[np.bool]) -assert_type(np.char.istitle(AR_S), npt.NDArray[np.bool]) -assert_type(np.char.istitle(AR_T), npt.NDArray[np.bool]) - -assert_type(np.char.isupper(AR_U), npt.NDArray[np.bool]) -assert_type(np.char.isupper(AR_S), npt.NDArray[np.bool]) -assert_type(np.char.isupper(AR_T), npt.NDArray[np.bool]) - -assert_type(np.char.str_len(AR_U), npt.NDArray[np.int_]) -assert_type(np.char.str_len(AR_S), npt.NDArray[np.int_]) -assert_type(np.char.str_len(AR_T), npt.NDArray[np.int_]) - -assert_type(np.char.translate(AR_U, ""), npt.NDArray[np.str_]) -assert_type(np.char.translate(AR_S, ""), npt.NDArray[np.bytes_]) -assert_type(np.char.translate(AR_T, ""), AR_T_alias) +assert_type(np.char.isalpha(AR_SUT), npt.NDArray[np.bool]) +assert_type(np.char.isalnum(AR_SUT), npt.NDArray[np.bool]) +assert_type(np.char.isdigit(AR_SUT), npt.NDArray[np.bool]) +assert_type(np.char.islower(AR_SUT), npt.NDArray[np.bool]) +assert_type(np.char.isspace(AR_SUT), npt.NDArray[np.bool]) +assert_type(np.char.istitle(AR_SUT), npt.NDArray[np.bool]) +assert_type(np.char.isupper(AR_SUT), npt.NDArray[np.bool]) +assert_type(np.char.str_len(AR_SUT), npt.NDArray[np.int_]) assert_type(np.char.array(AR_U), np.char.chararray[tuple[int, ...], np.dtype[np.str_]]) assert_type(np.char.array(AR_S, order="K"), np.char.chararray[tuple[int, ...], np.dtype[np.bytes_]]) diff --git a/test/static/reject/char.pyi b/test/static/reject/char.pyi index 49f4d3bb..12c3f2d6 100644 --- a/test/static/reject/char.pyi +++ b/test/static/reject/char.pyi @@ -17,12 +17,6 @@ np.char.decode(AR_U) # type: ignore[arg-type] # pyright: ignore[reportArgument np.char.join(AR_U, b"_") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] np.char.join(AR_S, "_") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] -np.char.ljust(AR_U, 5, fillchar=b"a") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] -np.char.rjust(AR_U, 5, fillchar=b"a") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] - -np.char.ljust(AR_S, 5, fillchar="a") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] -np.char.rjust(AR_S, 5, fillchar="a") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] - np.char.strip(AR_U, chars=b"a") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] np.char.lstrip(AR_U, chars=b"a") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] np.char.rstrip(AR_U, chars=b"a") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] diff --git a/test/static/reject/chararray.pyi b/test/static/reject/chararray.pyi index 25e38942..6ee863f2 100644 --- a/test/static/reject/chararray.pyi +++ b/test/static/reject/chararray.pyi @@ -11,11 +11,6 @@ AR_U.decode() # type: ignore[misc] # pyright: ignore[reportAttributeAccessIssu AR_U.join(b"_") # type: ignore[arg-type] # pyright: ignore[reportArgumentType] AR_S.join("_") # type: ignore[arg-type] # pyright: ignore[reportArgumentType] -AR_U.ljust(5, fillchar=b"a") # type: ignore[arg-type] # pyright: ignore[reportArgumentType] -AR_S.ljust(5, fillchar="a") # type: ignore[arg-type] # pyright: ignore[reportArgumentType] -AR_U.rjust(5, fillchar=b"a") # type: ignore[arg-type] # pyright: ignore[reportArgumentType] -AR_S.rjust(5, fillchar="a") # type: ignore[arg-type] # pyright: ignore[reportArgumentType] - AR_U.lstrip(chars=b"a") # type: ignore[arg-type] # pyright: ignore[reportArgumentType] AR_S.lstrip(chars="a") # type: ignore[arg-type] # pyright: ignore[reportArgumentType] AR_U.strip(chars=b"a") # type: ignore[arg-type] # pyright: ignore[reportArgumentType] @@ -54,10 +49,3 @@ AR_U.index(b"a", start=[1, 2, 3]) # type: ignore[arg-type] # pyright: ignore[r AR_S.index("a", end=9) # type: ignore[arg-type] # pyright: ignore[reportArgumentType] AR_U.rindex(b"a", start=[1, 2, 3]) # type: ignore[arg-type] # pyright: ignore[reportArgumentType] AR_S.rindex("a", end=9) # type: ignore[arg-type] # pyright: ignore[reportArgumentType] - -AR_U == AR_S # type: ignore[operator] # pyright: ignore[reportOperatorIssue] -AR_U != AR_S # type: ignore[operator] # pyright: ignore[reportOperatorIssue] -AR_U >= AR_S # type: ignore[operator] # pyright: ignore[reportOperatorIssue] -AR_U <= AR_S # type: ignore[operator] # pyright: ignore[reportOperatorIssue] -AR_U > AR_S # type: ignore[operator] # pyright: ignore[reportOperatorIssue] -AR_U < AR_S # type: ignore[operator] # pyright: ignore[reportOperatorIssue] diff --git a/test/static/reject/ndarray_misc.pyi b/test/static/reject/ndarray_misc.pyi index 37a37888..43a45c4a 100644 --- a/test/static/reject/ndarray_misc.pyi +++ b/test/static/reject/ndarray_misc.pyi @@ -30,5 +30,3 @@ AR_b.__index__() # type: ignore[misc] # pyright: ignore[reportAttributeAccessI AR_f8[1.5] # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportArgumentType] AR_f8["field_a"] # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportArgumentType] AR_f8[["field_a", "field_b"]] # type: ignore[index] # pyright: ignore[reportCallIssue,reportArgumentType] - -AR_f8.__array_finalize__(object()) # type: ignore[arg-type] # pyright: ignore[reportArgumentType]