diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 85ca1752..8a9fd2a1 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -105,6 +105,7 @@ jobs: src/numpy-stubs/_core/arrayprint.pyi src/numpy-stubs/_core/numerictypes.pyi src/numpy-stubs/_core/shape_base.pyi + src/numpy-stubs/_core/strings.pyi src/numpy-stubs/_typing src/numpy-stubs/char src/numpy-stubs/core diff --git a/src/numpy-stubs/_core/strings.pyi b/src/numpy-stubs/_core/strings.pyi index 6e36c16d..a6374532 100644 --- a/src/numpy-stubs/_core/strings.pyi +++ b/src/numpy-stubs/_core/strings.pyi @@ -1,441 +1,411 @@ -from typing import Any, TypeAlias, overload +from typing import TypeAlias, overload import numpy as np from numpy._typing import ( NDArray, - _ArrayLikeAnyString_co as UST_co, - _ArrayLikeBytes_co as S_co, - _ArrayLikeInt_co as i_co, - _ArrayLikeStr_co as U_co, - _ArrayLikeString_co as T_co, - _Shape, + _ArrayLikeAnyString_co as ToAnyStringND, + _ArrayLikeBytes_co as ToBytesND, + _ArrayLikeInt_co as ToIntND, + _ArrayLikeStr_co as ToStrND, + _ArrayLikeString_co as ToStringND, + _NestedSequence, _SupportsArray, ) -_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] +__all__ = [ + "add", + "capitalize", + "center", + "count", + "decode", + "encode", + "endswith", + "equal", + "expandtabs", + "find", + "greater", + "greater_equal", + "index", + "isalnum", + "isalpha", + "isdecimal", + "isdigit", + "islower", + "isnumeric", + "isspace", + "istitle", + "isupper", + "less", + "less_equal", + "ljust", + "lower", + "lstrip", + "mod", + "multiply", + "not_equal", + "partition", + "replace", + "rfind", + "rindex", + "rjust", + "rpartition", + "rstrip", + "startswith", + "str_len", + "strip", + "swapcase", + "title", + "translate", + "upper", + "zfill", +] +### + +_StringArrayLike: TypeAlias = _SupportsArray[np.dtypes.StringDType] | _NestedSequence[_SupportsArray[np.dtypes.StringDType]] + +_BoolArray: TypeAlias = NDArray[np.bool] +_IntArray: TypeAlias = NDArray[np.int_] +_BytesArray: TypeAlias = NDArray[np.bytes_] +_StrArray: TypeAlias = NDArray[np.str_] +_StringArray: TypeAlias = np.ndarray[tuple[int, ...], np.dtypes.StringDType] + +### + +# TODO(jorenham): Move to `.umath`, rewrite as `ufunc`, and re-export. +# https://github.com/numpy/numtype/issues/46 +def isdecimal(x: ToStrND | ToStringND) -> _BoolArray: ... +def isnumeric(x: ToStrND | ToStringND) -> _BoolArray: ... +def isalnum(a: ToAnyStringND) -> _BoolArray: ... +def isalpha(x: ToAnyStringND) -> _BoolArray: ... +def isdigit(x: ToAnyStringND) -> _BoolArray: ... +def isspace(x: ToAnyStringND) -> _BoolArray: ... +def islower(a: ToAnyStringND) -> _BoolArray: ... +def istitle(a: ToAnyStringND) -> _BoolArray: ... +def isupper(a: ToAnyStringND) -> _BoolArray: ... +def str_len(x: ToAnyStringND) -> _IntArray: ... + +# +@overload +def equal(x1: ToStrND, x2: ToStrND) -> _BoolArray: ... @overload -def equal(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +def equal(x1: ToBytesND, x2: ToBytesND) -> _BoolArray: ... @overload -def equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... +def equal(x1: ToStringND, x2: ToStringND) -> _BoolArray: ... + +# @overload -def equal(x1: T_co, x2: T_co) -> NDArray[np.bool]: ... +def not_equal(x1: ToStrND, x2: ToStrND) -> _BoolArray: ... @overload -def not_equal(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +def not_equal(x1: ToBytesND, x2: ToBytesND) -> _BoolArray: ... @overload -def not_equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... +def not_equal(x1: ToStringND, x2: ToStringND) -> _BoolArray: ... + +# @overload -def not_equal(x1: T_co, x2: T_co) -> NDArray[np.bool]: ... +def greater_equal(x1: ToStrND, x2: ToStrND) -> _BoolArray: ... +@overload +def greater_equal(x1: ToBytesND, x2: ToBytesND) -> _BoolArray: ... +@overload +def greater_equal(x1: ToStringND, x2: ToStringND) -> _BoolArray: ... + +# +@overload +def less_equal(x1: ToStrND, x2: ToStrND) -> _BoolArray: ... +@overload +def less_equal(x1: ToBytesND, x2: ToBytesND) -> _BoolArray: ... +@overload +def less_equal(x1: ToStringND, x2: ToStringND) -> _BoolArray: ... + +# @overload -def greater_equal(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +def greater(x1: ToStrND, x2: ToStrND) -> _BoolArray: ... @overload -def greater_equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... +def greater(x1: ToBytesND, x2: ToBytesND) -> _BoolArray: ... +@overload +def greater(x1: ToStringND, x2: ToStringND) -> _BoolArray: ... + +# +@overload +def less(x1: ToStrND, x2: ToStrND) -> _BoolArray: ... +@overload +def less(x1: ToBytesND, x2: ToBytesND) -> _BoolArray: ... +@overload +def less(x1: ToStringND, x2: ToStringND) -> _BoolArray: ... + +# +@overload +def startswith(a: ToStrND, prefix: ToStrND, start: ToIntND = 0, end: ToIntND | None = None) -> _BoolArray: ... +@overload +def startswith(a: ToBytesND, prefix: ToBytesND, start: ToIntND = 0, end: ToIntND | None = None) -> _BoolArray: ... +@overload +def startswith(a: ToStringND, suffix: ToStringND, start: ToIntND = 0, end: ToIntND | None = None) -> _BoolArray: ... + +# +@overload +def endswith(a: ToStrND, suffix: ToStrND, start: ToIntND = 0, end: ToIntND | None = None) -> _BoolArray: ... +@overload +def endswith(a: ToBytesND, suffix: ToBytesND, start: ToIntND = 0, end: ToIntND | None = None) -> _BoolArray: ... +@overload +def endswith(a: ToStringND, suffix: ToStringND, start: ToIntND = 0, end: ToIntND | None = None) -> _BoolArray: ... + +### + +# @overload -def greater_equal(x1: T_co, x2: T_co) -> NDArray[np.bool]: ... +def find(a: ToStrND, sub: ToStrND, start: ToIntND = 0, end: ToIntND | None = None) -> _IntArray: ... @overload -def less_equal(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +def find(a: ToBytesND, sub: ToBytesND, start: ToIntND = 0, end: ToIntND | None = None) -> _IntArray: ... @overload -def less_equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... +def find(a: ToStringND, sub: ToStringND, start: ToIntND = 0, end: ToIntND | None = None) -> _IntArray: ... + +# @overload -def less_equal(x1: T_co, x2: T_co) -> NDArray[np.bool]: ... +def rfind(a: ToStrND, sub: ToStrND, start: ToIntND = 0, end: ToIntND | None = None) -> _IntArray: ... @overload -def greater(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +def rfind(a: ToBytesND, sub: ToBytesND, start: ToIntND = 0, end: ToIntND | None = None) -> _IntArray: ... @overload -def greater(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... +def rfind(a: ToStringND, sub: ToStringND, start: ToIntND = 0, end: ToIntND | None = None) -> _IntArray: ... + +# @overload -def greater(x1: T_co, x2: T_co) -> NDArray[np.bool]: ... +def index(a: ToStrND, sub: ToStrND, start: ToIntND = 0, end: ToIntND | None = None) -> _IntArray: ... @overload -def less(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +def index(a: ToBytesND, sub: ToBytesND, start: ToIntND = 0, end: ToIntND | None = None) -> _IntArray: ... @overload -def less(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... +def index(a: ToStringND, sub: ToStringND, start: ToIntND = 0, end: ToIntND | None = None) -> _IntArray: ... + +# @overload -def less(x1: T_co, x2: T_co) -> NDArray[np.bool]: ... +def rindex(a: ToStrND, sub: ToStrND, start: ToIntND = 0, end: ToIntND | None = None) -> _IntArray: ... @overload -def add(x1: U_co, x2: U_co) -> NDArray[np.str_]: ... +def rindex(a: ToBytesND, sub: ToBytesND, start: ToIntND = 0, end: ToIntND | None = None) -> _IntArray: ... @overload -def add(x1: S_co, x2: S_co) -> NDArray[np.bytes_]: ... +def rindex(a: ToStringND, sub: ToStringND, start: ToIntND = 0, end: ToIntND | None = None) -> _IntArray: ... + +# @overload -def add(x1: _StringDTypeSupportsArray, x2: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def count(a: ToStrND, sub: ToStrND, start: ToIntND = 0, end: ToIntND | None = None) -> _IntArray: ... @overload -def add(x1: T_co, x2: T_co) -> _StringDTypeOrUnicodeArray: ... +def count(a: ToBytesND, sub: ToBytesND, start: ToIntND = 0, end: ToIntND | None = None) -> _IntArray: ... @overload -def multiply(a: U_co, i: i_co) -> NDArray[np.str_]: ... +def count(a: ToStringND, sub: ToStringND, start: ToIntND = 0, end: ToIntND | None = None) -> _IntArray: ... + +### + +# +def decode(a: ToBytesND, encoding: str | None = None, errors: str | None = None) -> _StrArray: ... +def encode(a: ToStrND | ToStringND, encoding: str | None = None, errors: str | None = None) -> _BytesArray: ... + +### +# NOTE: The ignored `overload-overlap` mypy errors are false positives + +# @overload -def multiply(a: S_co, i: i_co) -> NDArray[np.bytes_]: ... +def add(x1: ToStrND, x2: ToStrND) -> _StrArray: ... # type: ignore[overload-overlap] @overload -def multiply(a: _StringDTypeSupportsArray, i: i_co) -> _StringDTypeArray: ... +def add(x1: ToBytesND, x2: ToBytesND) -> _BytesArray: ... @overload -def multiply(a: T_co, i: i_co) -> _StringDTypeOrUnicodeArray: ... +def add(x1: _StringArrayLike, x2: _StringArrayLike) -> _StringArray: ... @overload -def mod(a: U_co, value: Any) -> NDArray[np.str_]: ... +def add(x1: ToStringND, x2: ToStringND) -> _StrArray | _StringArray: ... + +# @overload -def mod(a: S_co, value: Any) -> NDArray[np.bytes_]: ... +def multiply(a: ToStrND, i: ToIntND) -> _StrArray: ... # type: ignore[overload-overlap] @overload -def mod(a: _StringDTypeSupportsArray, value: Any) -> _StringDTypeArray: ... +def multiply(a: ToBytesND, i: ToIntND) -> _BytesArray: ... @overload -def mod(a: T_co, value: Any) -> _StringDTypeOrUnicodeArray: ... -def isalpha(x: UST_co) -> NDArray[np.bool]: ... -def isalnum(a: UST_co) -> NDArray[np.bool]: ... -def isdigit(x: UST_co) -> NDArray[np.bool]: ... -def isspace(x: UST_co) -> NDArray[np.bool]: ... -def isdecimal(x: U_co | T_co) -> NDArray[np.bool]: ... -def isnumeric(x: U_co | T_co) -> NDArray[np.bool]: ... -def islower(a: UST_co) -> NDArray[np.bool]: ... -def istitle(a: UST_co) -> NDArray[np.bool]: ... -def isupper(a: UST_co) -> NDArray[np.bool]: ... -def str_len(x: UST_co) -> NDArray[np.int_]: ... +def multiply(a: _StringArrayLike, i: ToIntND) -> _StringArray: ... @overload -def find( - a: U_co, - sub: U_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.int_]: ... +def multiply(a: ToStringND, i: ToIntND) -> _StrArray | _StringArray: ... + +# @overload -def find( - a: S_co, - sub: S_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.int_]: ... +def mod(a: ToStrND, values: object) -> _StrArray: ... # type: ignore[overload-overlap] @overload -def find( - a: T_co, - sub: T_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.int_]: ... +def mod(a: ToBytesND, values: object) -> _BytesArray: ... @overload -def rfind( - a: U_co, - sub: U_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.int_]: ... +def mod(a: _StringArrayLike, values: object) -> _StringArray: ... @overload -def rfind( - a: S_co, - sub: S_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.int_]: ... -@overload -def rfind( - a: T_co, - sub: T_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.int_]: ... -@overload -def index( - a: U_co, - sub: U_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.int_]: ... -@overload -def index( - a: S_co, - sub: S_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.int_]: ... -@overload -def index( - a: T_co, - sub: T_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.int_]: ... -@overload -def rindex( - a: U_co, - sub: U_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.int_]: ... -@overload -def rindex( - a: S_co, - sub: S_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.int_]: ... -@overload -def rindex( - a: T_co, - sub: T_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.int_]: ... -@overload -def count( - a: U_co, - sub: U_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.int_]: ... -@overload -def count( - a: S_co, - sub: S_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.int_]: ... -@overload -def count( - a: T_co, - sub: T_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.int_]: ... -@overload -def startswith( - a: U_co, - prefix: U_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.bool]: ... -@overload -def startswith( - a: S_co, - prefix: S_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.bool]: ... -@overload -def startswith( - a: T_co, - suffix: T_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.bool]: ... -@overload -def endswith( - a: U_co, - suffix: U_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.bool]: ... -@overload -def endswith( - a: S_co, - suffix: S_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.bool]: ... -@overload -def endswith( - a: T_co, - suffix: T_co, - start: i_co = ..., - end: i_co | None = ..., -) -> NDArray[np.bool]: ... -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 mod(a: ToStringND, values: object) -> _StrArray | _StringArray: ... + +# @overload -def expandtabs(a: U_co, tabsize: i_co = ...) -> NDArray[np.str_]: ... +def expandtabs(a: ToStrND, tabsize: ToIntND = 8) -> _StrArray: ... # type: ignore[overload-overlap] @overload -def expandtabs(a: S_co, tabsize: i_co = ...) -> NDArray[np.bytes_]: ... +def expandtabs(a: ToBytesND, tabsize: ToIntND = 8) -> _BytesArray: ... @overload -def expandtabs(a: _StringDTypeSupportsArray, tabsize: i_co = ...) -> _StringDTypeArray: ... +def expandtabs(a: _StringArrayLike, tabsize: ToIntND = 8) -> _StringArray: ... @overload -def expandtabs(a: T_co, tabsize: i_co = ...) -> _StringDTypeOrUnicodeArray: ... +def expandtabs(a: ToStringND, tabsize: ToIntND = 8) -> _StrArray | _StringArray: ... + +# @overload -def center(a: U_co, width: i_co, fillchar: U_co = ...) -> NDArray[np.str_]: ... +def center(a: ToStrND, width: ToIntND, fillchar: ToAnyStringND = " ") -> _StrArray: ... # 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: ToAnyStringND = " ") -> _BytesArray: ... @overload -def center(a: _StringDTypeSupportsArray, width: i_co, fillchar: _StringDTypeSupportsArray = ...) -> _StringDTypeArray: ... +def center(a: _StringArrayLike, width: ToIntND, fillchar: ToAnyStringND = " ") -> _StringArray: ... @overload -def center(a: T_co, width: i_co, fillchar: T_co = ...) -> _StringDTypeOrUnicodeArray: ... +def center(a: ToStringND, width: ToIntND, fillchar: ToAnyStringND = " ") -> _StrArray | _StringArray: ... + +# @overload -def ljust(a: U_co, width: i_co, fillchar: U_co = ...) -> NDArray[np.str_]: ... +def ljust(a: ToStrND, width: ToIntND, fillchar: ToAnyStringND = " ") -> _StrArray: ... # 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: ToAnyStringND = " ") -> _BytesArray: ... @overload -def ljust(a: _StringDTypeSupportsArray, width: i_co, fillchar: _StringDTypeSupportsArray = ...) -> _StringDTypeArray: ... +def ljust(a: _StringArrayLike, width: ToIntND, fillchar: ToAnyStringND = " ") -> _StringArray: ... @overload -def ljust(a: T_co, width: i_co, fillchar: T_co = ...) -> _StringDTypeOrUnicodeArray: ... +def ljust(a: ToStringND, width: ToIntND, fillchar: ToAnyStringND = " ") -> _StrArray | _StringArray: ... + +# @overload -def rjust( - a: U_co, - width: i_co, - fillchar: U_co = ..., -) -> NDArray[np.str_]: ... +def rjust(a: ToStrND, width: ToIntND, fillchar: ToAnyStringND = " ") -> _StrArray: ... # 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: ToAnyStringND = " ") -> _BytesArray: ... @overload -def rjust( - a: _StringDTypeSupportsArray, - width: i_co, - fillchar: _StringDTypeSupportsArray = ..., -) -> _StringDTypeArray: ... +def rjust(a: _StringArrayLike, width: ToIntND, fillchar: ToAnyStringND = " ") -> _StringArray: ... @overload -def rjust( - a: T_co, - width: i_co, - fillchar: T_co = ..., -) -> _StringDTypeOrUnicodeArray: ... +def rjust(a: ToStringND, width: ToIntND, fillchar: ToAnyStringND = " ") -> _StrArray | _StringArray: ... + +# @overload -def lstrip(a: U_co, chars: U_co | None = ...) -> NDArray[np.str_]: ... +def lstrip(a: ToStrND, chars: ToStrND | None = None) -> _StrArray: ... # 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) -> _BytesArray: ... @overload -def lstrip(a: _StringDTypeSupportsArray, chars: _StringDTypeSupportsArray | None = ...) -> _StringDTypeArray: ... +def lstrip(a: _StringArrayLike, chars: ToStringND | None = None) -> _StringArray: ... @overload -def lstrip(a: T_co, chars: T_co | None = ...) -> _StringDTypeOrUnicodeArray: ... +def lstrip(a: ToStringND, chars: ToStringND | None = None) -> _StrArray | _StringArray: ... + +# Huh; why isn't there a (false positive) mypy error here? @overload -def rstrip(a: U_co, char: U_co | None = ...) -> NDArray[np.str_]: ... +def rstrip(a: ToStrND, char: ToStrND | None = None) -> _StrArray: ... @overload -def rstrip(a: S_co, char: S_co | None = ...) -> NDArray[np.bytes_]: ... +def rstrip(a: ToBytesND, char: ToBytesND | None = None) -> _BytesArray: ... @overload -def rstrip(a: _StringDTypeSupportsArray, chars: _StringDTypeSupportsArray | None = ...) -> _StringDTypeArray: ... +def rstrip(a: _StringArrayLike, chars: ToStringND | None = None) -> _StringArray: ... @overload -def rstrip(a: T_co, chars: T_co | None = ...) -> _StringDTypeOrUnicodeArray: ... +def rstrip(a: ToStringND, chars: ToStringND | None = None) -> _StrArray | _StringArray: ... + +# @overload -def strip(a: U_co, chars: U_co | None = ...) -> NDArray[np.str_]: ... +def strip(a: ToStrND, chars: ToStrND | None = None) -> _StrArray: ... # 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) -> _BytesArray: ... @overload -def strip(a: _StringDTypeSupportsArray, chars: _StringDTypeSupportsArray | None = ...) -> _StringDTypeArray: ... +def strip(a: _StringArrayLike, chars: ToStringND | None = None) -> _StringArray: ... @overload -def strip(a: T_co, chars: T_co | None = ...) -> _StringDTypeOrUnicodeArray: ... +def strip(a: ToStringND, chars: ToStringND | None = None) -> _StrArray | _StringArray: ... + +# @overload -def zfill(a: U_co, width: i_co) -> NDArray[np.str_]: ... +def zfill(a: ToStrND, width: ToIntND) -> _StrArray: ... # type: ignore[overload-overlap] @overload -def zfill(a: S_co, width: i_co) -> NDArray[np.bytes_]: ... +def zfill(a: ToBytesND, width: ToIntND) -> _BytesArray: ... @overload -def zfill(a: _StringDTypeSupportsArray, width: i_co) -> _StringDTypeArray: ... +def zfill(a: _StringArrayLike, width: ToIntND) -> _StringArray: ... @overload -def zfill(a: T_co, width: i_co) -> _StringDTypeOrUnicodeArray: ... +def zfill(a: ToStringND, width: ToIntND) -> _StrArray | _StringArray: ... + +# @overload -def upper(a: U_co) -> NDArray[np.str_]: ... +def upper(a: ToStrND) -> _StrArray: ... # type: ignore[overload-overlap] @overload -def upper(a: S_co) -> NDArray[np.bytes_]: ... +def upper(a: ToBytesND) -> _BytesArray: ... @overload -def upper(a: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def upper(a: _StringArrayLike) -> _StringArray: ... @overload -def upper(a: T_co) -> _StringDTypeOrUnicodeArray: ... +def upper(a: ToStringND) -> _StrArray | _StringArray: ... + +# @overload -def lower(a: U_co) -> NDArray[np.str_]: ... +def lower(a: ToStrND) -> _StrArray: ... # type: ignore[overload-overlap] @overload -def lower(a: S_co) -> NDArray[np.bytes_]: ... +def lower(a: ToBytesND) -> _BytesArray: ... @overload -def lower(a: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def lower(a: _StringArrayLike) -> _StringArray: ... @overload -def lower(a: T_co) -> _StringDTypeOrUnicodeArray: ... +def lower(a: ToStringND) -> _StrArray | _StringArray: ... + +# @overload -def swapcase(a: U_co) -> NDArray[np.str_]: ... +def swapcase(a: ToStrND) -> _StrArray: ... # type: ignore[overload-overlap] @overload -def swapcase(a: S_co) -> NDArray[np.bytes_]: ... +def swapcase(a: ToBytesND) -> _BytesArray: ... @overload -def swapcase(a: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def swapcase(a: _StringArrayLike) -> _StringArray: ... @overload -def swapcase(a: T_co) -> _StringDTypeOrUnicodeArray: ... +def swapcase(a: ToStringND) -> _StrArray | _StringArray: ... + +# @overload -def capitalize(a: U_co) -> NDArray[np.str_]: ... +def capitalize(a: ToStrND) -> _StrArray: ... # type: ignore[overload-overlap] @overload -def capitalize(a: S_co) -> NDArray[np.bytes_]: ... +def capitalize(a: ToBytesND) -> _BytesArray: ... @overload -def capitalize(a: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def capitalize(a: _StringArrayLike) -> _StringArray: ... @overload -def capitalize(a: T_co) -> _StringDTypeOrUnicodeArray: ... +def capitalize(a: ToStringND) -> _StrArray | _StringArray: ... + +# @overload -def title(a: U_co) -> NDArray[np.str_]: ... +def title(a: ToStrND) -> _StrArray: ... # type: ignore[overload-overlap] @overload -def title(a: S_co) -> NDArray[np.bytes_]: ... +def title(a: ToBytesND) -> _BytesArray: ... @overload -def title(a: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def title(a: _StringArrayLike) -> _StringArray: ... @overload -def title(a: T_co) -> _StringDTypeOrUnicodeArray: ... +def title(a: ToStringND) -> _StrArray | _StringArray: ... + +# @overload -def replace( - a: U_co, - old: U_co, - new: U_co, - count: i_co = ..., -) -> NDArray[np.str_]: ... +def replace(a: ToStrND, old: ToStrND, new: ToStrND, count: ToIntND = -1) -> _StrArray: ... # type: ignore[overload-overlap] @overload -def replace( - a: S_co, - old: S_co, - new: S_co, - count: i_co = ..., -) -> NDArray[np.bytes_]: ... +def replace(a: ToBytesND, old: ToBytesND, new: ToBytesND, count: ToIntND = -1) -> _BytesArray: ... @overload -def replace( - a: _StringDTypeSupportsArray, - old: _StringDTypeSupportsArray, - new: _StringDTypeSupportsArray, - count: i_co = ..., -) -> _StringDTypeArray: ... +def replace(a: _StringArrayLike, old: ToStringND, new: ToStringND, count: ToIntND = -1) -> _StringArray: ... @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 = -1) -> _StrArray | _StringArray: ... + +# @overload -def join(sep: U_co, seq: U_co) -> NDArray[np.str_]: ... +def join(sep: ToStrND, seq: ToStrND) -> _StrArray: ... # type: ignore[overload-overlap] @overload -def join(sep: S_co, seq: S_co) -> NDArray[np.bytes_]: ... +def join(sep: ToBytesND, seq: ToBytesND) -> _BytesArray: ... @overload -def join(sep: _StringDTypeSupportsArray, seq: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def join(sep: _StringArrayLike, seq: _StringArrayLike) -> _StringArray: ... @overload -def join(sep: T_co, seq: T_co) -> _StringDTypeOrUnicodeArray: ... +def join(sep: ToStringND, seq: ToStringND) -> _StrArray | _StringArray: ... + +# @overload -def partition(a: U_co, sep: U_co) -> NDArray[np.str_]: ... +def partition(a: ToStrND, sep: ToStrND) -> _StrArray: ... # type: ignore[overload-overlap] @overload -def partition(a: S_co, sep: S_co) -> NDArray[np.bytes_]: ... +def partition(a: ToBytesND, sep: ToBytesND) -> _BytesArray: ... @overload -def partition(a: _StringDTypeSupportsArray, sep: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def partition(a: _StringArrayLike, sep: ToStringND) -> _StringArray: ... @overload -def partition(a: T_co, sep: T_co) -> _StringDTypeOrUnicodeArray: ... +def partition(a: ToStringND, sep: ToStringND) -> _StrArray | _StringArray: ... + +# @overload -def rpartition(a: U_co, sep: U_co) -> NDArray[np.str_]: ... +def rpartition(a: ToStrND, sep: ToStrND) -> _StrArray: ... # type: ignore[overload-overlap] @overload -def rpartition(a: S_co, sep: S_co) -> NDArray[np.bytes_]: ... +def rpartition(a: ToBytesND, sep: ToBytesND) -> _BytesArray: ... @overload -def rpartition(a: _StringDTypeSupportsArray, sep: _StringDTypeSupportsArray) -> _StringDTypeArray: ... +def rpartition(a: _StringArrayLike, sep: ToStringND) -> _StringArray: ... @overload -def rpartition(a: T_co, sep: T_co) -> _StringDTypeOrUnicodeArray: ... +def rpartition(a: ToStringND, sep: ToStringND) -> _StrArray | _StringArray: ... + +# @overload -def translate( - a: U_co, - table: str, - deletechars: str | None = ..., -) -> NDArray[np.str_]: ... +def translate(a: ToStrND, table: str, deletechars: str | None = None) -> _StrArray: ... # 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 = None) -> _BytesArray: ... @overload -def translate( - a: _StringDTypeSupportsArray, - table: str, - deletechars: str | None = ..., -) -> _StringDTypeArray: ... +def translate(a: _StringArrayLike, table: str, deletechars: str | None = None) -> _StringArray: ... @overload -def translate( - a: T_co, - table: str, - deletechars: str | None = ..., -) -> _StringDTypeOrUnicodeArray: ... +def translate(a: ToStringND, table: str, deletechars: str | None = None) -> _StrArray | _StringArray: ... diff --git a/test/static/accept/strings.pyi b/test/static/accept/strings.pyi index 75b28d0b..93d48b3a 100644 --- a/test/static/accept/strings.pyi +++ b/test/static/accept/strings.pyi @@ -2,192 +2,194 @@ 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] - -AR_T_alias: TypeAlias = np.ndarray[np_t._Shape, np.dtypes.StringDType] -AR_TU_alias: TypeAlias = AR_T_alias | npt.NDArray[np.str_] - -assert_type(np.strings.equal(AR_U, AR_U), npt.NDArray[np.bool]) -assert_type(np.strings.equal(AR_S, AR_S), npt.NDArray[np.bool]) -assert_type(np.strings.equal(AR_T, AR_T), npt.NDArray[np.bool]) - -assert_type(np.strings.not_equal(AR_U, AR_U), npt.NDArray[np.bool]) -assert_type(np.strings.not_equal(AR_S, AR_S), npt.NDArray[np.bool]) -assert_type(np.strings.not_equal(AR_T, AR_T), npt.NDArray[np.bool]) - -assert_type(np.strings.greater_equal(AR_U, AR_U), npt.NDArray[np.bool]) -assert_type(np.strings.greater_equal(AR_S, AR_S), npt.NDArray[np.bool]) -assert_type(np.strings.greater_equal(AR_T, AR_T), npt.NDArray[np.bool]) - -assert_type(np.strings.less_equal(AR_U, AR_U), npt.NDArray[np.bool]) -assert_type(np.strings.less_equal(AR_S, AR_S), npt.NDArray[np.bool]) -assert_type(np.strings.less_equal(AR_T, AR_T), npt.NDArray[np.bool]) - -assert_type(np.strings.greater(AR_U, AR_U), npt.NDArray[np.bool]) -assert_type(np.strings.greater(AR_S, AR_S), npt.NDArray[np.bool]) -assert_type(np.strings.greater(AR_T, AR_T), npt.NDArray[np.bool]) - -assert_type(np.strings.less(AR_U, AR_U), npt.NDArray[np.bool]) -assert_type(np.strings.less(AR_S, AR_S), npt.NDArray[np.bool]) -assert_type(np.strings.less(AR_T, AR_T), npt.NDArray[np.bool]) - -assert_type(np.strings.add(AR_U, AR_U), npt.NDArray[np.str_]) -assert_type(np.strings.add(AR_S, AR_S), npt.NDArray[np.bytes_]) -assert_type(np.strings.add(AR_T, AR_T), AR_T_alias) - -assert_type(np.strings.multiply(AR_U, 5), npt.NDArray[np.str_]) -assert_type(np.strings.multiply(AR_S, [5, 4, 3]), npt.NDArray[np.bytes_]) -assert_type(np.strings.multiply(AR_T, 5), AR_T_alias) - -assert_type(np.strings.mod(AR_U, "test"), npt.NDArray[np.str_]) -assert_type(np.strings.mod(AR_S, "test"), npt.NDArray[np.bytes_]) -assert_type(np.strings.mod(AR_T, "test"), AR_T_alias) - -assert_type(np.strings.capitalize(AR_U), npt.NDArray[np.str_]) -assert_type(np.strings.capitalize(AR_S), npt.NDArray[np.bytes_]) -assert_type(np.strings.capitalize(AR_T), AR_T_alias) - -assert_type(np.strings.center(AR_U, 5), npt.NDArray[np.str_]) -assert_type(np.strings.center(AR_S, [2, 3, 4], b"a"), npt.NDArray[np.bytes_]) -assert_type(np.strings.center(AR_T, 5), AR_T_alias) - -assert_type(np.strings.encode(AR_U), npt.NDArray[np.bytes_]) -assert_type(np.strings.encode(AR_T), npt.NDArray[np.bytes_]) -assert_type(np.strings.decode(AR_S), npt.NDArray[np.str_]) - -assert_type(np.strings.expandtabs(AR_U), npt.NDArray[np.str_]) -assert_type(np.strings.expandtabs(AR_S, tabsize=4), npt.NDArray[np.bytes_]) -assert_type(np.strings.expandtabs(AR_T), AR_T_alias) - -assert_type(np.strings.ljust(AR_U, 5), npt.NDArray[np.str_]) -assert_type(np.strings.ljust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"]), npt.NDArray[np.bytes_]) -assert_type(np.strings.ljust(AR_T, 5), AR_T_alias) -assert_type(np.strings.ljust(AR_T, [4, 2, 1], fillchar=["a", "b", "c"]), AR_TU_alias) +_BoolArray: TypeAlias = npt.NDArray[np.bool_] +_IntArray: TypeAlias = npt.NDArray[np.int_] +_BytesArray: TypeAlias = npt.NDArray[np.bytes_] +_StrArray: TypeAlias = npt.NDArray[np.str_] +_StringArray: TypeAlias = np.ndarray[tuple[int, ...], np.dtypes.StringDType] + +AR_S: _BytesArray +AR_U: _StrArray +AR_T: _StringArray + +assert_type(np.strings.equal(AR_U, AR_U), _BoolArray) +assert_type(np.strings.equal(AR_S, AR_S), _BoolArray) +assert_type(np.strings.equal(AR_T, AR_T), _BoolArray) + +assert_type(np.strings.not_equal(AR_U, AR_U), _BoolArray) +assert_type(np.strings.not_equal(AR_S, AR_S), _BoolArray) +assert_type(np.strings.not_equal(AR_T, AR_T), _BoolArray) + +assert_type(np.strings.greater_equal(AR_U, AR_U), _BoolArray) +assert_type(np.strings.greater_equal(AR_S, AR_S), _BoolArray) +assert_type(np.strings.greater_equal(AR_T, AR_T), _BoolArray) + +assert_type(np.strings.less_equal(AR_U, AR_U), _BoolArray) +assert_type(np.strings.less_equal(AR_S, AR_S), _BoolArray) +assert_type(np.strings.less_equal(AR_T, AR_T), _BoolArray) + +assert_type(np.strings.greater(AR_U, AR_U), _BoolArray) +assert_type(np.strings.greater(AR_S, AR_S), _BoolArray) +assert_type(np.strings.greater(AR_T, AR_T), _BoolArray) + +assert_type(np.strings.less(AR_U, AR_U), _BoolArray) +assert_type(np.strings.less(AR_S, AR_S), _BoolArray) +assert_type(np.strings.less(AR_T, AR_T), _BoolArray) + +assert_type(np.strings.add(AR_U, AR_U), _StrArray) +assert_type(np.strings.add(AR_S, AR_S), _BytesArray) +assert_type(np.strings.add(AR_T, AR_T), _StringArray) + +assert_type(np.strings.multiply(AR_U, 5), _StrArray) +assert_type(np.strings.multiply(AR_S, [5, 4, 3]), _BytesArray) +assert_type(np.strings.multiply(AR_T, 5), _StringArray) + +assert_type(np.strings.mod(AR_U, "test"), _StrArray) +assert_type(np.strings.mod(AR_S, "test"), _BytesArray) +assert_type(np.strings.mod(AR_T, "test"), _StringArray) + +assert_type(np.strings.capitalize(AR_U), _StrArray) +assert_type(np.strings.capitalize(AR_S), _BytesArray) +assert_type(np.strings.capitalize(AR_T), _StringArray) + +assert_type(np.strings.center(AR_U, 5), _StrArray) +assert_type(np.strings.center(AR_S, [2, 3, 4], b"a"), _BytesArray) +assert_type(np.strings.center(AR_T, 5), _StringArray) + +assert_type(np.strings.encode(AR_U), _BytesArray) +assert_type(np.strings.encode(AR_T), _BytesArray) +assert_type(np.strings.decode(AR_S), _StrArray) + +assert_type(np.strings.expandtabs(AR_U), _StrArray) +assert_type(np.strings.expandtabs(AR_S, tabsize=4), _BytesArray) +assert_type(np.strings.expandtabs(AR_T), _StringArray) + +assert_type(np.strings.ljust(AR_U, 5), _StrArray) +assert_type(np.strings.ljust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"]), _BytesArray) +assert_type(np.strings.ljust(AR_T, 5), _StringArray) +assert_type(np.strings.ljust(AR_T, [4, 2, 1], fillchar=["a", "b", "c"]), _StringArray) + +assert_type(np.strings.rjust(AR_U, 5), _StrArray) +assert_type(np.strings.rjust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"]), _BytesArray) +assert_type(np.strings.rjust(AR_T, 5), _StringArray) +assert_type(np.strings.rjust(AR_T, [4, 2, 1], fillchar=["a", "b", "c"]), _StringArray) + +assert_type(np.strings.lstrip(AR_U), _StrArray) +assert_type(np.strings.lstrip(AR_S, b"_"), _BytesArray) +assert_type(np.strings.lstrip(AR_T), _StringArray) +assert_type(np.strings.lstrip(AR_T, "_"), _StringArray) + +assert_type(np.strings.rstrip(AR_U), _StrArray) +assert_type(np.strings.rstrip(AR_S, b"_"), _BytesArray) +assert_type(np.strings.rstrip(AR_T), _StringArray) +assert_type(np.strings.rstrip(AR_T, "_"), _StringArray) -assert_type(np.strings.rjust(AR_U, 5), npt.NDArray[np.str_]) -assert_type(np.strings.rjust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"]), npt.NDArray[np.bytes_]) -assert_type(np.strings.rjust(AR_T, 5), AR_T_alias) -assert_type(np.strings.rjust(AR_T, [4, 2, 1], fillchar=["a", "b", "c"]), AR_TU_alias) +assert_type(np.strings.strip(AR_U), _StrArray) +assert_type(np.strings.strip(AR_S, b"_"), _BytesArray) +assert_type(np.strings.strip(AR_T), _StringArray) +assert_type(np.strings.strip(AR_T, "_"), _StringArray) + +assert_type(np.strings.count(AR_U, "a", start=[1, 2, 3]), _IntArray) +assert_type(np.strings.count(AR_S, [b"a", b"b", b"c"], end=9), _IntArray) +assert_type(np.strings.count(AR_T, "a", start=[1, 2, 3]), _IntArray) +assert_type(np.strings.count(AR_T, ["a", "b", "c"], end=9), _IntArray) + +assert_type(np.strings.partition(AR_U, "\n"), _StrArray) +assert_type(np.strings.partition(AR_S, [b"a", b"b", b"c"]), _BytesArray) +assert_type(np.strings.partition(AR_T, "\n"), _StringArray) + +assert_type(np.strings.rpartition(AR_U, "\n"), _StrArray) +assert_type(np.strings.rpartition(AR_S, [b"a", b"b", b"c"]), _BytesArray) +assert_type(np.strings.rpartition(AR_T, "\n"), _StringArray) + +assert_type(np.strings.replace(AR_U, "_", "-"), _StrArray) +assert_type(np.strings.replace(AR_S, [b"_", b""], [b"a", b"b"]), _BytesArray) +assert_type(np.strings.replace(AR_T, "_", "_"), _StringArray) + +assert_type(np.strings.lower(AR_U), _StrArray) +assert_type(np.strings.lower(AR_S), _BytesArray) +assert_type(np.strings.lower(AR_T), _StringArray) + +assert_type(np.strings.upper(AR_U), _StrArray) +assert_type(np.strings.upper(AR_S), _BytesArray) +assert_type(np.strings.upper(AR_T), _StringArray) + +assert_type(np.strings.swapcase(AR_U), _StrArray) +assert_type(np.strings.swapcase(AR_S), _BytesArray) +assert_type(np.strings.swapcase(AR_T), _StringArray) + +assert_type(np.strings.title(AR_U), _StrArray) +assert_type(np.strings.title(AR_S), _BytesArray) +assert_type(np.strings.title(AR_T), _StringArray) + +assert_type(np.strings.zfill(AR_U, 5), _StrArray) +assert_type(np.strings.zfill(AR_S, [2, 3, 4]), _BytesArray) +assert_type(np.strings.zfill(AR_T, 5), _StringArray) + +assert_type(np.strings.endswith(AR_U, "a", start=[1, 2, 3]), _BoolArray) +assert_type(np.strings.endswith(AR_S, [b"a", b"b", b"c"], end=9), _BoolArray) +assert_type(np.strings.endswith(AR_T, "a", start=[1, 2, 3]), _BoolArray) + +assert_type(np.strings.startswith(AR_U, "a", start=[1, 2, 3]), _BoolArray) +assert_type(np.strings.startswith(AR_S, [b"a", b"b", b"c"], end=9), _BoolArray) +assert_type(np.strings.startswith(AR_T, "a", start=[1, 2, 3]), _BoolArray) + +assert_type(np.strings.find(AR_U, "a", start=[1, 2, 3]), _IntArray) +assert_type(np.strings.find(AR_S, [b"a", b"b", b"c"], end=9), _IntArray) +assert_type(np.strings.find(AR_T, "a", start=[1, 2, 3]), _IntArray) + +assert_type(np.strings.rfind(AR_U, "a", start=[1, 2, 3]), _IntArray) +assert_type(np.strings.rfind(AR_S, [b"a", b"b", b"c"], end=9), _IntArray) +assert_type(np.strings.rfind(AR_T, "a", start=[1, 2, 3]), _IntArray) + +assert_type(np.strings.index(AR_U, "a", start=[1, 2, 3]), _IntArray) +assert_type(np.strings.index(AR_S, [b"a", b"b", b"c"], end=9), _IntArray) +assert_type(np.strings.index(AR_T, "a", start=[1, 2, 3]), _IntArray) + +assert_type(np.strings.rindex(AR_U, "a", start=[1, 2, 3]), _IntArray) +assert_type(np.strings.rindex(AR_S, [b"a", b"b", b"c"], end=9), _IntArray) +assert_type(np.strings.rindex(AR_T, "a", start=[1, 2, 3]), _IntArray) + +assert_type(np.strings.isalpha(AR_U), _BoolArray) +assert_type(np.strings.isalpha(AR_S), _BoolArray) +assert_type(np.strings.isalpha(AR_T), _BoolArray) + +assert_type(np.strings.isalnum(AR_U), _BoolArray) +assert_type(np.strings.isalnum(AR_S), _BoolArray) +assert_type(np.strings.isalnum(AR_T), _BoolArray) + +assert_type(np.strings.isdecimal(AR_U), _BoolArray) +assert_type(np.strings.isdecimal(AR_T), _BoolArray) + +assert_type(np.strings.isdigit(AR_U), _BoolArray) +assert_type(np.strings.isdigit(AR_S), _BoolArray) +assert_type(np.strings.isdigit(AR_T), _BoolArray) + +assert_type(np.strings.islower(AR_U), _BoolArray) +assert_type(np.strings.islower(AR_S), _BoolArray) +assert_type(np.strings.islower(AR_T), _BoolArray) -assert_type(np.strings.lstrip(AR_U), npt.NDArray[np.str_]) -assert_type(np.strings.lstrip(AR_S, b"_"), npt.NDArray[np.bytes_]) -assert_type(np.strings.lstrip(AR_T), AR_T_alias) -assert_type(np.strings.lstrip(AR_T, "_"), AR_TU_alias) +assert_type(np.strings.isnumeric(AR_U), _BoolArray) +assert_type(np.strings.isnumeric(AR_T), _BoolArray) + +assert_type(np.strings.isspace(AR_U), _BoolArray) +assert_type(np.strings.isspace(AR_S), _BoolArray) +assert_type(np.strings.isspace(AR_T), _BoolArray) + +assert_type(np.strings.istitle(AR_U), _BoolArray) +assert_type(np.strings.istitle(AR_S), _BoolArray) +assert_type(np.strings.istitle(AR_T), _BoolArray) + +assert_type(np.strings.isupper(AR_U), _BoolArray) +assert_type(np.strings.isupper(AR_S), _BoolArray) +assert_type(np.strings.isupper(AR_T), _BoolArray) -assert_type(np.strings.rstrip(AR_U), npt.NDArray[np.str_]) -assert_type(np.strings.rstrip(AR_S, b"_"), npt.NDArray[np.bytes_]) -assert_type(np.strings.rstrip(AR_T), AR_T_alias) -assert_type(np.strings.rstrip(AR_T, "_"), AR_TU_alias) +assert_type(np.strings.str_len(AR_U), _IntArray) +assert_type(np.strings.str_len(AR_S), _IntArray) +assert_type(np.strings.str_len(AR_T), _IntArray) -assert_type(np.strings.strip(AR_U), npt.NDArray[np.str_]) -assert_type(np.strings.strip(AR_S, b"_"), npt.NDArray[np.bytes_]) -assert_type(np.strings.strip(AR_T), AR_T_alias) -assert_type(np.strings.strip(AR_T, "_"), AR_TU_alias) - -assert_type(np.strings.count(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_]) -assert_type(np.strings.count(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_]) -assert_type(np.strings.count(AR_T, "a", start=[1, 2, 3]), npt.NDArray[np.int_]) -assert_type(np.strings.count(AR_T, ["a", "b", "c"], end=9), npt.NDArray[np.int_]) - -assert_type(np.strings.partition(AR_U, "\n"), npt.NDArray[np.str_]) -assert_type(np.strings.partition(AR_S, [b"a", b"b", b"c"]), npt.NDArray[np.bytes_]) -assert_type(np.strings.partition(AR_T, "\n"), AR_TU_alias) - -assert_type(np.strings.rpartition(AR_U, "\n"), npt.NDArray[np.str_]) -assert_type(np.strings.rpartition(AR_S, [b"a", b"b", b"c"]), npt.NDArray[np.bytes_]) -assert_type(np.strings.rpartition(AR_T, "\n"), AR_TU_alias) - -assert_type(np.strings.replace(AR_U, "_", "-"), npt.NDArray[np.str_]) -assert_type(np.strings.replace(AR_S, [b"_", b""], [b"a", b"b"]), npt.NDArray[np.bytes_]) -assert_type(np.strings.replace(AR_T, "_", "_"), AR_TU_alias) - -assert_type(np.strings.lower(AR_U), npt.NDArray[np.str_]) -assert_type(np.strings.lower(AR_S), npt.NDArray[np.bytes_]) -assert_type(np.strings.lower(AR_T), AR_T_alias) - -assert_type(np.strings.upper(AR_U), npt.NDArray[np.str_]) -assert_type(np.strings.upper(AR_S), npt.NDArray[np.bytes_]) -assert_type(np.strings.upper(AR_T), AR_T_alias) - -assert_type(np.strings.swapcase(AR_U), npt.NDArray[np.str_]) -assert_type(np.strings.swapcase(AR_S), npt.NDArray[np.bytes_]) -assert_type(np.strings.swapcase(AR_T), AR_T_alias) - -assert_type(np.strings.title(AR_U), npt.NDArray[np.str_]) -assert_type(np.strings.title(AR_S), npt.NDArray[np.bytes_]) -assert_type(np.strings.title(AR_T), AR_T_alias) - -assert_type(np.strings.zfill(AR_U, 5), npt.NDArray[np.str_]) -assert_type(np.strings.zfill(AR_S, [2, 3, 4]), npt.NDArray[np.bytes_]) -assert_type(np.strings.zfill(AR_T, 5), AR_T_alias) - -assert_type(np.strings.endswith(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.bool]) -assert_type(np.strings.endswith(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.bool]) -assert_type(np.strings.endswith(AR_T, "a", start=[1, 2, 3]), npt.NDArray[np.bool]) - -assert_type(np.strings.startswith(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.bool]) -assert_type(np.strings.startswith(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.bool]) -assert_type(np.strings.startswith(AR_T, "a", start=[1, 2, 3]), npt.NDArray[np.bool]) - -assert_type(np.strings.find(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_]) -assert_type(np.strings.find(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_]) -assert_type(np.strings.find(AR_T, "a", start=[1, 2, 3]), npt.NDArray[np.int_]) - -assert_type(np.strings.rfind(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_]) -assert_type(np.strings.rfind(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_]) -assert_type(np.strings.rfind(AR_T, "a", start=[1, 2, 3]), npt.NDArray[np.int_]) - -assert_type(np.strings.index(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_]) -assert_type(np.strings.index(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_]) -assert_type(np.strings.index(AR_T, "a", start=[1, 2, 3]), npt.NDArray[np.int_]) - -assert_type(np.strings.rindex(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_]) -assert_type(np.strings.rindex(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_]) -assert_type(np.strings.rindex(AR_T, "a", start=[1, 2, 3]), npt.NDArray[np.int_]) - -assert_type(np.strings.isalpha(AR_U), npt.NDArray[np.bool]) -assert_type(np.strings.isalpha(AR_S), npt.NDArray[np.bool]) -assert_type(np.strings.isalpha(AR_T), npt.NDArray[np.bool]) - -assert_type(np.strings.isalnum(AR_U), npt.NDArray[np.bool]) -assert_type(np.strings.isalnum(AR_S), npt.NDArray[np.bool]) -assert_type(np.strings.isalnum(AR_T), npt.NDArray[np.bool]) - -assert_type(np.strings.isdecimal(AR_U), npt.NDArray[np.bool]) -assert_type(np.strings.isdecimal(AR_T), npt.NDArray[np.bool]) - -assert_type(np.strings.isdigit(AR_U), npt.NDArray[np.bool]) -assert_type(np.strings.isdigit(AR_S), npt.NDArray[np.bool]) -assert_type(np.strings.isdigit(AR_T), npt.NDArray[np.bool]) - -assert_type(np.strings.islower(AR_U), npt.NDArray[np.bool]) -assert_type(np.strings.islower(AR_S), npt.NDArray[np.bool]) -assert_type(np.strings.islower(AR_T), npt.NDArray[np.bool]) - -assert_type(np.strings.isnumeric(AR_U), npt.NDArray[np.bool]) -assert_type(np.strings.isnumeric(AR_T), npt.NDArray[np.bool]) - -assert_type(np.strings.isspace(AR_U), npt.NDArray[np.bool]) -assert_type(np.strings.isspace(AR_S), npt.NDArray[np.bool]) -assert_type(np.strings.isspace(AR_T), npt.NDArray[np.bool]) - -assert_type(np.strings.istitle(AR_U), npt.NDArray[np.bool]) -assert_type(np.strings.istitle(AR_S), npt.NDArray[np.bool]) -assert_type(np.strings.istitle(AR_T), npt.NDArray[np.bool]) - -assert_type(np.strings.isupper(AR_U), npt.NDArray[np.bool]) -assert_type(np.strings.isupper(AR_S), npt.NDArray[np.bool]) -assert_type(np.strings.isupper(AR_T), npt.NDArray[np.bool]) - -assert_type(np.strings.str_len(AR_U), npt.NDArray[np.int_]) -assert_type(np.strings.str_len(AR_S), npt.NDArray[np.int_]) -assert_type(np.strings.str_len(AR_T), npt.NDArray[np.int_]) - -assert_type(np.strings.translate(AR_U, ""), npt.NDArray[np.str_]) -assert_type(np.strings.translate(AR_S, ""), npt.NDArray[np.bytes_]) -assert_type(np.strings.translate(AR_T, ""), AR_T_alias) +assert_type(np.strings.translate(AR_U, ""), _StrArray) +assert_type(np.strings.translate(AR_S, ""), _BytesArray) +assert_type(np.strings.translate(AR_T, ""), _StringArray) diff --git a/test/static/reject/strings.pyi b/test/static/reject/strings.pyi index e4849bb1..1d7ee581 100644 --- a/test/static/reject/strings.pyi +++ b/test/static/reject/strings.pyi @@ -17,11 +17,6 @@ np.strings.decode(AR_U) # type: ignore[arg-type] # pyright: ignore[reportArgum np.strings.join(AR_U, b"_") # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue] -np.strings.ljust(AR_U, 5, fillchar=b"a") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] -np.strings.ljust(AR_S, 5, fillchar="a") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] -np.strings.rjust(AR_U, 5, fillchar=b"a") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] -np.strings.rjust(AR_S, 5, fillchar="a") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] - np.strings.lstrip(AR_U, b"a") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] np.strings.lstrip(AR_S, "a") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] np.strings.strip(AR_U, b"a") # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType]