commit 3

Author: jonathandung

stdlib/collections/__init__.pyi

@@ -22,16 +22,16 @@ if sys.version_info >= (3, 15):
 
 __all__ = ["ChainMap", "Counter", "OrderedDict", "UserDict", "UserList", "UserString", "defaultdict", "deque", "namedtuple"]
 
-_S = TypeVar("_S")
 _T = TypeVar("_T")
 _T1 = TypeVar("_T1")
 _T2 = TypeVar("_T2")
-_KT = TypeVar("_KT")
+_KT = TypeVar("_KT", bound=Hashable)
 _VT = TypeVar("_VT")
-_KT_co = TypeVar("_KT_co", covariant=True)
+_KT2 = TypeVar("_KT2")
+_KT_co = TypeVar("_KT_co", bound=Hashable, covariant=True)
 _VT_co = TypeVar("_VT_co", covariant=True)
 
-# namedtuple is special-cased in the type checker; the initializer is ignored.
+# namedtuple is special-cased in type checkers; the initializer is ignored.
 def namedtuple(
     typename: str,
     field_names: str | Iterable[str],
@@ -86,18 +86,18 @@ class UserDict(MutableMapping[_KT, _VT]):
     # See #3800 & https://github.com/python/typing/issues/548#issuecomment-683336963.
     @classmethod
     @overload
-    def fromkeys(cls, iterable: Iterable[_T], value: None = None) -> UserDict[_T, Any | None]: ...
+    def fromkeys(cls, iterable: Iterable[_KT], value: None = None) -> UserDict[_KT, Any | None]: ...
     @classmethod
     @overload
-    def fromkeys(cls, iterable: Iterable[_T], value: _S) -> UserDict[_T, _S]: ...
+    def fromkeys(cls, iterable: Iterable[_KT], value: _T) -> UserDict[_KT, _T]: ...
     @overload
     def __or__(self, other: UserDict[_KT, _VT] | dict[_KT, _VT]) -> Self: ...
     @overload
-    def __or__(self, other: UserDict[_T1, _T2] | dict[_T1, _T2]) -> UserDict[_KT | _T1, _VT | _T2]: ...
+    def __or__(self, other: UserDict[_KT2, _T] | dict[_KT2, _T]) -> UserDict[_KT | _KT2, _VT | _T]: ...
     @overload
     def __ror__(self, other: UserDict[_KT, _VT] | dict[_KT, _VT]) -> Self: ...
     @overload
-    def __ror__(self, other: UserDict[_T1, _T2] | dict[_T1, _T2]) -> UserDict[_KT | _T1, _VT | _T2]: ...
+    def __ror__(self, other: UserDict[_KT2, _T] | dict[_KT2, _T]) -> UserDict[_KT | _KT2, _VT | _T]: ...
     # UserDict.__ior__ should be kept roughly in line with MutableMapping.update()
     @overload  # type: ignore[misc]
     def __ior__(self, other: SupportsKeysAndGetItem[_KT, _VT]) -> Self: ...
@@ -270,63 +270,69 @@ class deque(MutableSequence[_T]):
     def __eq__(self, value: object, /) -> bool: ...
     def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
-class Counter(dict[_T, int], Generic[_T]):
+class Counter(dict[_KT, int], Generic[_KT]):
     @overload
     def __init__(self, iterable: None = None, /) -> None: ...
     @overload
     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[_KT, int], /) -> None: ...
     @overload
-    def __init__(self, iterable: Iterable[_T], /) -> None: ...
+    def __init__(self, iterable: Iterable[_KT], /) -> None: ...
     def copy(self) -> Self: ...
-    def elements(self) -> Iterator[_T]: ...
-    def most_common(self, n: int | None = None) -> list[tuple[_T, int]]: ...
+    def elements(self) -> Iterator[_KT]: ...
+    def most_common(self, n: int | None = None) -> list[tuple[_KT, int]]: ...
     @classmethod
     def fromkeys(cls, iterable: Any, v: int | None = None) -> NoReturn: ...  # type: ignore[override]
     @overload
     def subtract(self, iterable: None = None, /) -> None: ...
     @overload
-    def subtract(self, mapping: Mapping[_T, int], /) -> None: ...
+    def subtract(self, mapping: Mapping[_KT, int], /) -> None: ...
     @overload
-    def subtract(self, iterable: Iterable[_T], /) -> None: ...
+    def subtract(self, iterable: Iterable[_KT], /) -> None: ...
     # Unlike dict.update(), use Mapping instead of SupportsKeysAndGetItem for the first overload
     # (source code does an `isinstance(other, Mapping)` check)
     #
     # The second overload is also deliberately different to dict.update()
-    # (if it were `Iterable[_T] | Iterable[tuple[_T, int]]`,
+    # (if it were `Iterable[_KT] | Iterable[tuple[_KT, 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: Counter[str], m: Mapping[str, int], /, **kwargs: int) -> None: ...
     @overload
-    def update(self, iterable: Iterable[_T], /, **kwargs: int) -> None: ...
+    def update(self: Counter[str], iterable: Iterable[str], /, **kwargs: int) -> None: ...
     @overload
-    def update(self, iterable: None = None, /, **kwargs: int) -> None: ...
+    def update(self: Counter[str], iterable: None = None, /, **kwargs: int) -> None: ...
+    @overload
+    def update(self, m: Mapping[_KT, int], /) -> None: ...
+    @overload
+    def update(self, iterable: Iterable[_KT], /) -> None: ...
+    @overload
+    def update(self, iterable: None = None, /) -> None: ...
     def total(self) -> int: ...
-    def __missing__(self, key: _T) -> int: ...
-    def __delitem__(self, elem: object) -> None: ...
-    def __eq__(self, other: object) -> bool: ...
-    def __ne__(self, other: object) -> bool: ...
-    def __le__(self, other: Counter[Any]) -> bool: ...
-    def __lt__(self, other: Counter[Any]) -> bool: ...
-    def __ge__(self, other: Counter[Any]) -> bool: ...
-    def __gt__(self, other: Counter[Any]) -> bool: ...
-    def __add__(self, other: Counter[_S]) -> Counter[_T | _S]: ...
-    def __sub__(self, other: Counter[_T]) -> Counter[_T]: ...
-    def __and__(self, other: Counter[_T]) -> Counter[_T]: ...
-    def __or__(self, other: Counter[_S]) -> Counter[_T | _S]: ...  # type: ignore[override]
+    def __missing__(self, key: _KT) -> int: ...
+    def __delitem__(self, elem: Hashable) -> None: ...
+    def __eq__(self, other: Hashable) -> bool: ...
+    def __ne__(self, other: Hashable) -> bool: ...
+    def __le__(self, other: Counter[Hashable]) -> bool: ...
+    def __lt__(self, other: Counter[Hashable]) -> bool: ...
+    def __ge__(self, other: Counter[Hashable]) -> bool: ...
+    def __gt__(self, other: Counter[Hashable]) -> bool: ...
+    def __add__(self, other: Counter[_KT2]) -> Counter[_KT | _KT2]: ...
+    def __sub__(self, other: Counter[_KT]) -> Counter[_KT]: ...
+    def __and__(self, other: Counter[_KT]) -> Counter[_KT]: ...
+    def __or__(self, other: Counter[_KT2]) -> Counter[_KT | _KT2]: ...  # type: ignore[override]
     if sys.version_info >= (3, 15):
-        def __xor__(self, other: Counter[_S]) -> Counter[_T | _S]: ...  # type: ignore[override]
+        def __xor__(self, other: Counter[_KT2]) -> Counter[_KT | _KT2]: ...  # type: ignore[override]
 
-    def __pos__(self) -> Counter[_T]: ...
-    def __neg__(self) -> Counter[_T]: ...
+    def __pos__(self) -> Counter[_KT]: ...
+    def __neg__(self) -> Counter[_KT]: ...
     # several type: ignores because __iadd__ is supposedly incompatible with __add__, etc.
-    def __iadd__(self, other: SupportsItems[_T, int]) -> Self: ...  # type: ignore[misc]
-    def __isub__(self, other: SupportsItems[_T, int]) -> Self: ...
-    def __iand__(self, other: SupportsItems[_T, int]) -> Self: ...
-    def __ior__(self, other: SupportsItems[_T, int]) -> Self: ...  # type: ignore[override,misc]
+    def __iadd__(self, other: SupportsItems[_KT, int]) -> Self: ...  # type: ignore[misc]
+    def __isub__(self, other: SupportsItems[_KT, int]) -> Self: ...
+    def __iand__(self, other: SupportsItems[_KT, int]) -> Self: ...
+    def __ior__(self, other: SupportsItems[_KT, int]) -> Self: ...  # type: ignore[override,misc]
     if sys.version_info >= (3, 15):
-        def __ixor__(self, other: Counter[_T]) -> Self: ...  # type: ignore[misc]
+        def __ixor__(self, other: Counter[_KT]) -> Self: ...  # type: ignore[misc]
 
 # The pure-Python implementations of the "views" classes
 # These are exposed at runtime in `collections/__init__.py`
@@ -372,10 +378,10 @@ class OrderedDict(dict[_KT, _VT]):
     # See #3800 & https://github.com/python/typing/issues/548#issuecomment-683336963.
     @classmethod
     @overload
-    def fromkeys(cls, iterable: Iterable[_T], value: None = None) -> OrderedDict[_T, Any | None]: ...
+    def fromkeys(cls, iterable: Iterable[_KT], value: None = None) -> OrderedDict[_KT, Any | None]: ...
     @classmethod
     @overload
-    def fromkeys(cls, iterable: Iterable[_T], value: _S) -> OrderedDict[_T, _S]: ...
+    def fromkeys(cls, iterable: Iterable[_KT], value: _T) -> OrderedDict[_KT, _T]: ...
     # Keep OrderedDict.setdefault in line with MutableMapping.setdefault, modulo positional-only differences.
     @overload
     def setdefault(self: OrderedDict[_KT, _T | None], key: _KT, default: None = None) -> _T | None: ...
@@ -393,22 +399,22 @@ class OrderedDict(dict[_KT, _VT]):
         @overload
         def __or__(self, value: dict[_KT, _VT] | frozendict[_KT, _VT], /) -> Self: ...
         @overload
-        def __or__(self, value: dict[_T1, _T2] | frozendict[_T1, _T2], /) -> OrderedDict[_KT | _T1, _VT | _T2]: ...
+        def __or__(self, value: dict[_KT2, _T] | frozendict[_KT2, _T], /) -> OrderedDict[_KT | _KT2, _VT | _T]: ...
         @overload  # type: ignore[override]
         def __ror__(self, value: dict[_KT, _VT] | frozendict[_KT, _VT], /) -> Self: ...  # type: ignore[override,misc]
         @overload
         def __ror__(  # type: ignore[misc]
-            self, value: dict[_T1, _T2] | frozendict[_T1, _T2], /
-        ) -> OrderedDict[_KT | _T1, _VT | _T2]: ...
+            self, value: dict[_KT2, _T] | frozendict[_KT2, _T], /
+        ) -> OrderedDict[_KT | _KT2, _VT | _T]: ...
     else:
         @overload
         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[_KT2, _T], /) -> OrderedDict[_KT | _KT2, _VT | _T]: ...
         @overload
         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[_KT2, _T], /) -> OrderedDict[_KT | _KT2, _VT | _T]: ...  # type: ignore[misc]
 
 @disjoint_base
 class defaultdict(dict[_KT, _VT]):
@@ -454,11 +460,11 @@ class defaultdict(dict[_KT, _VT]):
     @overload  # type: ignore[override]
     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[_KT2, _T], /) -> defaultdict[_KT | _KT2, _VT | _T]: ...
     @overload  # type: ignore[override]
     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[_KT2, _T], /) -> defaultdict[_KT | _KT2, _VT | _T]: ...  # type: ignore[misc]
 
 class ChainMap(MutableMapping[_KT, _VT]):
     maps: list[MutableMapping[_KT, _VT]]
@@ -498,27 +504,27 @@ class ChainMap(MutableMapping[_KT, _VT]):
     if sys.version_info >= (3, 13):
         @classmethod
         @overload
-        def fromkeys(cls, iterable: Iterable[_T], /) -> ChainMap[_T, Any | None]: ...
+        def fromkeys(cls, iterable: Iterable[_KT], /) -> ChainMap[_KT, Any | None]: ...
     else:
         @classmethod
         @overload
-        def fromkeys(cls, iterable: Iterable[_T]) -> ChainMap[_T, Any | None]: ...
+        def fromkeys(cls, iterable: Iterable[_KT]) -> ChainMap[_KT, Any | None]: ...
 
     @classmethod
     @overload
     # Special-case None: the user probably wants to add non-None values later.
-    def fromkeys(cls, iterable: Iterable[_T], value: None, /) -> ChainMap[_T, Any | None]: ...
+    def fromkeys(cls, iterable: Iterable[_KT], value: None, /) -> ChainMap[_KT, Any | None]: ...
     @classmethod
     @overload
-    def fromkeys(cls, iterable: Iterable[_T], value: _S, /) -> ChainMap[_T, _S]: ...
+    def fromkeys(cls, iterable: Iterable[_KT], value: _T, /) -> ChainMap[_KT, _T]: ...
     @overload
     def __or__(self, other: Mapping[_KT, _VT]) -> Self: ...
     @overload
-    def __or__(self, other: Mapping[_T1, _T2]) -> ChainMap[_KT | _T1, _VT | _T2]: ...
+    def __or__(self, other: Mapping[_KT2, _T]) -> ChainMap[_KT | _KT2, _VT | _T]: ...
     @overload
     def __ror__(self, other: Mapping[_KT, _VT]) -> Self: ...
     @overload
-    def __ror__(self, other: Mapping[_T1, _T2]) -> ChainMap[_KT | _T1, _VT | _T2]: ...
+    def __ror__(self, other: Mapping[_KT2, _T]) -> ChainMap[_KT | _KT2, _VT | _T]: ...
     # ChainMap.__ior__ should be kept roughly in line with MutableMapping.update()
     @overload  # type: ignore[misc]
     def __ior__(self, other: SupportsKeysAndGetItem[_KT, _VT]) -> Self: ...