mirror of
https://github.com/davidhalter/typeshed.git
synced 2025-12-20 10:51:15 +08:00
Use PEP 570 syntax in stdlib (#11250)
This commit is contained in:
@@ -49,21 +49,21 @@ class UserDict(MutableMapping[_KT, _VT]):
|
||||
data: dict[_KT, _VT]
|
||||
# __init__ should be kept roughly in line with `dict.__init__`, which has the same semantics
|
||||
@overload
|
||||
def __init__(self, __dict: None = None) -> None: ...
|
||||
def __init__(self, dict: None = None, /) -> None: ...
|
||||
@overload
|
||||
def __init__(self: UserDict[str, _VT], __dict: None = None, **kwargs: _VT) -> None: ...
|
||||
def __init__(self: UserDict[str, _VT], dict: None = None, /, **kwargs: _VT) -> None: ...
|
||||
@overload
|
||||
def __init__(self, __dict: SupportsKeysAndGetItem[_KT, _VT]) -> None: ...
|
||||
def __init__(self, dict: SupportsKeysAndGetItem[_KT, _VT], /) -> None: ...
|
||||
@overload
|
||||
def __init__(self: UserDict[str, _VT], __dict: SupportsKeysAndGetItem[str, _VT], **kwargs: _VT) -> None: ...
|
||||
def __init__(self: UserDict[str, _VT], dict: SupportsKeysAndGetItem[str, _VT], /, **kwargs: _VT) -> None: ...
|
||||
@overload
|
||||
def __init__(self, __iterable: Iterable[tuple[_KT, _VT]]) -> None: ...
|
||||
def __init__(self, iterable: Iterable[tuple[_KT, _VT]], /) -> None: ...
|
||||
@overload
|
||||
def __init__(self: UserDict[str, _VT], __iterable: Iterable[tuple[str, _VT]], **kwargs: _VT) -> None: ...
|
||||
def __init__(self: UserDict[str, _VT], iterable: Iterable[tuple[str, _VT]], /, **kwargs: _VT) -> None: ...
|
||||
@overload
|
||||
def __init__(self: UserDict[str, str], __iterable: Iterable[list[str]]) -> None: ...
|
||||
def __init__(self: UserDict[str, str], iterable: Iterable[list[str]], /) -> None: ...
|
||||
@overload
|
||||
def __init__(self: UserDict[bytes, bytes], __iterable: Iterable[list[bytes]]) -> None: ...
|
||||
def __init__(self: UserDict[bytes, bytes], iterable: Iterable[list[bytes]], /) -> None: ...
|
||||
def __len__(self) -> int: ...
|
||||
def __getitem__(self, key: _KT) -> _VT: ...
|
||||
def __setitem__(self, key: _KT, item: _VT) -> None: ...
|
||||
@@ -200,8 +200,8 @@ class UserString(Sequence[UserString]):
|
||||
maketrans = str.maketrans
|
||||
def partition(self, sep: str) -> tuple[str, str, str]: ...
|
||||
if sys.version_info >= (3, 9):
|
||||
def removeprefix(self, __prefix: str | UserString) -> Self: ...
|
||||
def removesuffix(self, __suffix: str | UserString) -> Self: ...
|
||||
def removeprefix(self, prefix: str | UserString, /) -> Self: ...
|
||||
def removesuffix(self, suffix: str | UserString, /) -> Self: ...
|
||||
|
||||
def replace(self, old: str | UserString, new: str | UserString, maxsplit: int = -1) -> Self: ...
|
||||
def rfind(self, sub: str | UserString, start: int = 0, end: int = sys.maxsize) -> int: ...
|
||||
@@ -227,58 +227,58 @@ class deque(MutableSequence[_T]):
|
||||
def __init__(self, *, maxlen: int | None = None) -> None: ...
|
||||
@overload
|
||||
def __init__(self, iterable: Iterable[_T], maxlen: int | None = None) -> None: ...
|
||||
def append(self, __x: _T) -> None: ...
|
||||
def appendleft(self, __x: _T) -> None: ...
|
||||
def append(self, x: _T, /) -> None: ...
|
||||
def appendleft(self, x: _T, /) -> None: ...
|
||||
def copy(self) -> Self: ...
|
||||
def count(self, __x: _T) -> int: ...
|
||||
def extend(self, __iterable: Iterable[_T]) -> None: ...
|
||||
def extendleft(self, __iterable: Iterable[_T]) -> None: ...
|
||||
def insert(self, __i: int, __x: _T) -> None: ...
|
||||
def index(self, __x: _T, __start: int = 0, __stop: int = ...) -> int: ...
|
||||
def count(self, x: _T, /) -> int: ...
|
||||
def extend(self, iterable: Iterable[_T], /) -> None: ...
|
||||
def extendleft(self, iterable: Iterable[_T], /) -> None: ...
|
||||
def insert(self, i: int, x: _T, /) -> None: ...
|
||||
def index(self, x: _T, start: int = 0, stop: int = ..., /) -> int: ...
|
||||
def pop(self) -> _T: ... # type: ignore[override]
|
||||
def popleft(self) -> _T: ...
|
||||
def remove(self, __value: _T) -> None: ...
|
||||
def rotate(self, __n: int = 1) -> None: ...
|
||||
def remove(self, value: _T, /) -> None: ...
|
||||
def rotate(self, n: int = 1, /) -> None: ...
|
||||
def __copy__(self) -> Self: ...
|
||||
def __len__(self) -> int: ...
|
||||
# These methods of deque don't take slices, unlike MutableSequence, hence the type: ignores
|
||||
def __getitem__(self, __key: SupportsIndex) -> _T: ... # type: ignore[override]
|
||||
def __setitem__(self, __key: SupportsIndex, __value: _T) -> None: ... # type: ignore[override]
|
||||
def __delitem__(self, __key: SupportsIndex) -> None: ... # type: ignore[override]
|
||||
def __contains__(self, __key: object) -> bool: ...
|
||||
def __getitem__(self, key: SupportsIndex, /) -> _T: ... # type: ignore[override]
|
||||
def __setitem__(self, key: SupportsIndex, value: _T, /) -> None: ... # type: ignore[override]
|
||||
def __delitem__(self, key: SupportsIndex, /) -> None: ... # type: ignore[override]
|
||||
def __contains__(self, key: object, /) -> bool: ...
|
||||
def __reduce__(self) -> tuple[type[Self], tuple[()], None, Iterator[_T]]: ...
|
||||
def __iadd__(self, __value: Iterable[_T]) -> Self: ...
|
||||
def __add__(self, __value: Self) -> Self: ...
|
||||
def __mul__(self, __value: int) -> Self: ...
|
||||
def __imul__(self, __value: int) -> Self: ...
|
||||
def __lt__(self, __value: deque[_T]) -> bool: ...
|
||||
def __le__(self, __value: deque[_T]) -> bool: ...
|
||||
def __gt__(self, __value: deque[_T]) -> bool: ...
|
||||
def __ge__(self, __value: deque[_T]) -> bool: ...
|
||||
def __eq__(self, __value: object) -> bool: ...
|
||||
def __iadd__(self, value: Iterable[_T], /) -> Self: ...
|
||||
def __add__(self, value: Self, /) -> Self: ...
|
||||
def __mul__(self, value: int, /) -> Self: ...
|
||||
def __imul__(self, value: int, /) -> Self: ...
|
||||
def __lt__(self, value: deque[_T], /) -> bool: ...
|
||||
def __le__(self, value: deque[_T], /) -> bool: ...
|
||||
def __gt__(self, value: deque[_T], /) -> bool: ...
|
||||
def __ge__(self, value: deque[_T], /) -> bool: ...
|
||||
def __eq__(self, value: object, /) -> bool: ...
|
||||
if sys.version_info >= (3, 9):
|
||||
def __class_getitem__(cls, __item: Any) -> GenericAlias: ...
|
||||
def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
|
||||
|
||||
class Counter(dict[_T, int], Generic[_T]):
|
||||
@overload
|
||||
def __init__(self, __iterable: None = None) -> None: ...
|
||||
def __init__(self, iterable: None = None, /) -> None: ...
|
||||
@overload
|
||||
def __init__(self: Counter[str], __iterable: None = None, **kwargs: int) -> None: ...
|
||||
def __init__(self: Counter[str], iterable: None = None, /, **kwargs: int) -> None: ...
|
||||
@overload
|
||||
def __init__(self, __mapping: SupportsKeysAndGetItem[_T, int]) -> None: ...
|
||||
def __init__(self, mapping: SupportsKeysAndGetItem[_T, int], /) -> None: ...
|
||||
@overload
|
||||
def __init__(self, __iterable: Iterable[_T]) -> None: ...
|
||||
def __init__(self, iterable: Iterable[_T], /) -> None: ...
|
||||
def copy(self) -> Self: ...
|
||||
def elements(self) -> Iterator[_T]: ...
|
||||
def most_common(self, n: int | None = None) -> list[tuple[_T, int]]: ...
|
||||
@classmethod
|
||||
def fromkeys(cls, iterable: Any, v: int | None = None) -> NoReturn: ... # type: ignore[override]
|
||||
@overload
|
||||
def subtract(self, __iterable: None = None) -> None: ...
|
||||
def subtract(self, iterable: None = None, /) -> None: ...
|
||||
@overload
|
||||
def subtract(self, __mapping: Mapping[_T, int]) -> None: ...
|
||||
def subtract(self, mapping: Mapping[_T, int], /) -> None: ...
|
||||
@overload
|
||||
def subtract(self, __iterable: Iterable[_T]) -> None: ...
|
||||
def subtract(self, iterable: Iterable[_T], /) -> None: ...
|
||||
# Unlike dict.update(), use Mapping instead of SupportsKeysAndGetItem for the first overload
|
||||
# (source code does an `isinstance(other, Mapping)` check)
|
||||
#
|
||||
@@ -286,11 +286,11 @@ class Counter(dict[_T, int], Generic[_T]):
|
||||
# (if it were `Iterable[_T] | Iterable[tuple[_T, int]]`,
|
||||
# the tuples would be added as keys, breaking type safety)
|
||||
@overload # type: ignore[override]
|
||||
def update(self, __m: Mapping[_T, int], **kwargs: int) -> None: ...
|
||||
def update(self, m: Mapping[_T, int], /, **kwargs: int) -> None: ...
|
||||
@overload
|
||||
def update(self, __iterable: Iterable[_T], **kwargs: int) -> None: ...
|
||||
def update(self, iterable: Iterable[_T], /, **kwargs: int) -> None: ...
|
||||
@overload
|
||||
def update(self, __iterable: None = None, **kwargs: int) -> None: ...
|
||||
def update(self, iterable: None = None, /, **kwargs: int) -> None: ...
|
||||
def __missing__(self, key: _T) -> int: ...
|
||||
def __delitem__(self, elem: object) -> None: ...
|
||||
if sys.version_info >= (3, 10):
|
||||
@@ -371,16 +371,16 @@ class OrderedDict(dict[_KT, _VT], Reversible[_KT], Generic[_KT, _VT]):
|
||||
def pop(self, key: _KT, default: _VT) -> _VT: ...
|
||||
@overload
|
||||
def pop(self, key: _KT, default: _T) -> _VT | _T: ...
|
||||
def __eq__(self, __value: object) -> bool: ...
|
||||
def __eq__(self, value: object, /) -> bool: ...
|
||||
if sys.version_info >= (3, 9):
|
||||
@overload
|
||||
def __or__(self, __value: dict[_KT, _VT]) -> Self: ...
|
||||
def __or__(self, value: dict[_KT, _VT], /) -> Self: ...
|
||||
@overload
|
||||
def __or__(self, __value: dict[_T1, _T2]) -> OrderedDict[_KT | _T1, _VT | _T2]: ...
|
||||
def __or__(self, value: dict[_T1, _T2], /) -> OrderedDict[_KT | _T1, _VT | _T2]: ...
|
||||
@overload
|
||||
def __ror__(self, __value: dict[_KT, _VT]) -> Self: ...
|
||||
def __ror__(self, value: dict[_KT, _VT], /) -> Self: ...
|
||||
@overload
|
||||
def __ror__(self, __value: dict[_T1, _T2]) -> OrderedDict[_KT | _T1, _VT | _T2]: ... # type: ignore[misc]
|
||||
def __ror__(self, value: dict[_T1, _T2], /) -> OrderedDict[_KT | _T1, _VT | _T2]: ... # type: ignore[misc]
|
||||
|
||||
class defaultdict(dict[_KT, _VT]):
|
||||
default_factory: Callable[[], _VT] | None
|
||||
@@ -389,39 +389,41 @@ class defaultdict(dict[_KT, _VT]):
|
||||
@overload
|
||||
def __init__(self: defaultdict[str, _VT], **kwargs: _VT) -> None: ...
|
||||
@overload
|
||||
def __init__(self, __default_factory: Callable[[], _VT] | None) -> None: ...
|
||||
def __init__(self, default_factory: Callable[[], _VT] | None, /) -> None: ...
|
||||
@overload
|
||||
def __init__(self: defaultdict[str, _VT], __default_factory: Callable[[], _VT] | None, **kwargs: _VT) -> None: ...
|
||||
def __init__(self: defaultdict[str, _VT], default_factory: Callable[[], _VT] | None, /, **kwargs: _VT) -> None: ...
|
||||
@overload
|
||||
def __init__(self, __default_factory: Callable[[], _VT] | None, __map: SupportsKeysAndGetItem[_KT, _VT]) -> None: ...
|
||||
def __init__(self, default_factory: Callable[[], _VT] | None, map: SupportsKeysAndGetItem[_KT, _VT], /) -> None: ...
|
||||
@overload
|
||||
def __init__(
|
||||
self: defaultdict[str, _VT],
|
||||
__default_factory: Callable[[], _VT] | None,
|
||||
__map: SupportsKeysAndGetItem[str, _VT],
|
||||
default_factory: Callable[[], _VT] | None,
|
||||
map: SupportsKeysAndGetItem[str, _VT],
|
||||
/,
|
||||
**kwargs: _VT,
|
||||
) -> None: ...
|
||||
@overload
|
||||
def __init__(self, __default_factory: Callable[[], _VT] | None, __iterable: Iterable[tuple[_KT, _VT]]) -> None: ...
|
||||
def __init__(self, default_factory: Callable[[], _VT] | None, iterable: Iterable[tuple[_KT, _VT]], /) -> None: ...
|
||||
@overload
|
||||
def __init__(
|
||||
self: defaultdict[str, _VT],
|
||||
__default_factory: Callable[[], _VT] | None,
|
||||
__iterable: Iterable[tuple[str, _VT]],
|
||||
default_factory: Callable[[], _VT] | None,
|
||||
iterable: Iterable[tuple[str, _VT]],
|
||||
/,
|
||||
**kwargs: _VT,
|
||||
) -> None: ...
|
||||
def __missing__(self, __key: _KT) -> _VT: ...
|
||||
def __missing__(self, key: _KT, /) -> _VT: ...
|
||||
def __copy__(self) -> Self: ...
|
||||
def copy(self) -> Self: ...
|
||||
if sys.version_info >= (3, 9):
|
||||
@overload
|
||||
def __or__(self, __value: dict[_KT, _VT]) -> Self: ...
|
||||
def __or__(self, value: dict[_KT, _VT], /) -> Self: ...
|
||||
@overload
|
||||
def __or__(self, __value: dict[_T1, _T2]) -> defaultdict[_KT | _T1, _VT | _T2]: ...
|
||||
def __or__(self, value: dict[_T1, _T2], /) -> defaultdict[_KT | _T1, _VT | _T2]: ...
|
||||
@overload
|
||||
def __ror__(self, __value: dict[_KT, _VT]) -> Self: ...
|
||||
def __ror__(self, value: dict[_KT, _VT], /) -> Self: ...
|
||||
@overload
|
||||
def __ror__(self, __value: dict[_T1, _T2]) -> defaultdict[_KT | _T1, _VT | _T2]: ... # type: ignore[misc]
|
||||
def __ror__(self, value: dict[_T1, _T2], /) -> defaultdict[_KT | _T1, _VT | _T2]: ... # type: ignore[misc]
|
||||
|
||||
class ChainMap(MutableMapping[_KT, _VT]):
|
||||
maps: list[MutableMapping[_KT, _VT]]
|
||||
@@ -460,7 +462,7 @@ class ChainMap(MutableMapping[_KT, _VT]):
|
||||
def fromkeys(cls, iterable: Iterable[_T], __value: None = None) -> ChainMap[_T, Any | None]: ...
|
||||
@classmethod
|
||||
@overload
|
||||
def fromkeys(cls, __iterable: Iterable[_T], __value: _S) -> ChainMap[_T, _S]: ...
|
||||
def fromkeys(cls, iterable: Iterable[_T], value: _S, /) -> ChainMap[_T, _S]: ...
|
||||
if sys.version_info >= (3, 9):
|
||||
@overload
|
||||
def __or__(self, other: Mapping[_KT, _VT]) -> Self: ...
|
||||
|
||||
Reference in New Issue
Block a user