basedpyright 1.13.2 → 1.13.3

package/dist/typeshed-fallback/stdlib/typing.pyi

@@ -178,8 +178,12 @@ class TypeVar:
             self, name: str, *constraints: Any, bound: Any | None = None, covariant: bool = False, contravariant: bool = False
         ) -> None: ...
     if sys.version_info >= (3, 10):
-        def __or__(self, right: Any) -> _SpecialForm: ...
-        def __ror__(self, left: Any) -> _SpecialForm: ...
+        def __or__(self, right: Any) -> _SpecialForm:
+            """Return self|value."""
+            ...
+        def __ror__(self, left: Any) -> _SpecialForm:
+            """Return value|self."""
+            ...
     if sys.version_info >= (3, 11):
         def __typing_subst__(self, arg: Any) -> Any: ...
     if sys.version_info >= (3, 13):
@@ -235,7 +239,9 @@ if sys.version_info >= (3, 11):
         else:
             def __init__(self, name: str) -> None: ...
 
-        def __iter__(self) -> Any: ...
+        def __iter__(self) -> Any:
+            """Implement iter(self)."""
+            ...
         def __typing_subst__(self, arg: Never) -> Never: ...
         def __typing_prepare_subst__(self, alias: Any, args: Any) -> tuple[Any, ...]: ...
 
@@ -245,14 +251,18 @@ if sys.version_info >= (3, 10):
         @property
         def __origin__(self) -> ParamSpec: ...
         def __init__(self, origin: ParamSpec) -> None: ...
-        def __eq__(self, other: object) -> bool: ...
+        def __eq__(self, other: object) -> bool:
+            """Return self==value."""
+            ...
 
     @final
     class ParamSpecKwargs:
         @property
         def __origin__(self) -> ParamSpec: ...
         def __init__(self, origin: ParamSpec) -> None: ...
-        def __eq__(self, other: object) -> bool: ...
+        def __eq__(self, other: object) -> bool:
+            """Return self==value."""
+            ...
 
     @final
     class ParamSpec:
@@ -297,15 +307,23 @@ if sys.version_info >= (3, 10):
             ) -> None: ...
 
         @property
-        def args(self) -> ParamSpecArgs: ...
+        def args(self) -> ParamSpecArgs:
+            """Represents positional arguments."""
+            ...
         @property
-        def kwargs(self) -> ParamSpecKwargs: ...
+        def kwargs(self) -> ParamSpecKwargs:
+            """Represents keyword arguments."""
+            ...
         if sys.version_info >= (3, 11):
             def __typing_subst__(self, arg: Any) -> Any: ...
             def __typing_prepare_subst__(self, alias: Any, args: Any) -> tuple[Any, ...]: ...
 
-        def __or__(self, right: Any) -> _SpecialForm: ...
-        def __ror__(self, left: Any) -> _SpecialForm: ...
+        def __or__(self, right: Any) -> _SpecialForm:
+            """Return self|value."""
+            ...
+        def __ror__(self, left: Any) -> _SpecialForm:
+            """Return value|self."""
+            ...
         if sys.version_info >= (3, 13):
             def has_default(self) -> bool: ...
 
@@ -419,30 +437,77 @@ class SupportsRound(Protocol[_T_co]):
 
 @runtime_checkable
 class Sized(Protocol, metaclass=ABCMeta):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     @abstractmethod
     def __len__(self) -> int: ...
 
 @runtime_checkable
 class Hashable(Protocol, metaclass=ABCMeta):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     # TODO: This is special, in that a subclass of a hashable class may not be hashable
     #   (for example, list vs. object). It's not obvious how to represent this. This class
     #   is currently mostly useless for static checking.
     @abstractmethod
-    def __hash__(self) -> int: ...
+    def __hash__(self) -> int:
+        """Return hash(self)."""
+        ...
 
 @runtime_checkable
 class Iterable(Protocol[_T_co]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     @abstractmethod
     def __iter__(self) -> Iterator[_T_co]: ...
 
 @runtime_checkable
 class Iterator(Iterable[_T_co], Protocol[_T_co]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     @abstractmethod
     def __next__(self) -> _T_co: ...
     def __iter__(self) -> Iterator[_T_co]: ...
 
 @runtime_checkable
 class Reversible(Iterable[_T_co], Protocol[_T_co]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     @abstractmethod
     def __reversed__(self) -> Iterator[_T_co]: ...
 
@@ -451,6 +516,15 @@ _SendT_contra = TypeVar("_SendT_contra", contravariant=True, default=None)
 _ReturnT_co = TypeVar("_ReturnT_co", covariant=True, default=None)
 
 class Generator(Iterator[_YieldT_co], Generic[_YieldT_co, _SendT_contra, _ReturnT_co]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     def __next__(self) -> _YieldT_co: ...
     @abstractmethod
     def send(self, value: _SendT_contra, /) -> _YieldT_co: ...
@@ -480,13 +554,42 @@ else:
     from contextlib import AbstractAsyncContextManager, AbstractContextManager
 
     @runtime_checkable
-    class ContextManager(AbstractContextManager[_T_co, bool | None], Protocol[_T_co]): ...
+    class ContextManager(AbstractContextManager[_T_co, bool | None], Protocol[_T_co]):
+        """
+        The central part of internal API.
+
+        This represents a generic version of type 'origin' with type arguments 'params'.
+        There are two kind of these aliases: user defined and special. The special ones
+        are wrappers around builtin collections and ABCs in collections.abc. These must
+        have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+        this is used by e.g. typing.List and typing.Dict.
+        """
+        ...
 
     @runtime_checkable
-    class AsyncContextManager(AbstractAsyncContextManager[_T_co, bool | None], Protocol[_T_co]): ...
+    class AsyncContextManager(AbstractAsyncContextManager[_T_co, bool | None], Protocol[_T_co]):
+        """
+        The central part of internal API.
+
+        This represents a generic version of type 'origin' with type arguments 'params'.
+        There are two kind of these aliases: user defined and special. The special ones
+        are wrappers around builtin collections and ABCs in collections.abc. These must
+        have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+        this is used by e.g. typing.List and typing.Dict.
+        """
+        ...
 
 @runtime_checkable
 class Awaitable(Protocol[_T_co]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     @abstractmethod
     def __await__(self) -> Generator[Any, Any, _T_co]: ...
 
@@ -495,6 +598,15 @@ _SendT_contra_nd = TypeVar("_SendT_contra_nd", contravariant=True)
 _ReturnT_co_nd = TypeVar("_ReturnT_co_nd", covariant=True)
 
 class Coroutine(Awaitable[_ReturnT_co_nd], Generic[_YieldT_co, _SendT_contra_nd, _ReturnT_co_nd]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     __name__: str
     __qualname__: str
     @property
@@ -530,28 +642,57 @@ class AwaitableGenerator(
 
 @runtime_checkable
 class AsyncIterable(Protocol[_T_co]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     @abstractmethod
     def __aiter__(self) -> AsyncIterator[_T_co]: ...
 
 @runtime_checkable
 class AsyncIterator(AsyncIterable[_T_co], Protocol[_T_co]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     @abstractmethod
     def __anext__(self) -> Awaitable[_T_co]: ...
     def __aiter__(self) -> AsyncIterator[_T_co]: ...
 
 class AsyncGenerator(AsyncIterator[_YieldT_co], Generic[_YieldT_co, _SendT_contra]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     def __anext__(self) -> Awaitable[_YieldT_co]: ...
     @abstractmethod
-    def asend(self, value: _SendT_contra, /) -> Awaitable[_YieldT_co]: ...
+    def asend(self, value: _SendT_contra, /) -> Coroutine[Any, Any, _YieldT_co]: ...
     @overload
     @abstractmethod
     def athrow(
         self, typ: type[BaseException], val: BaseException | object = None, tb: TracebackType | None = None, /
-    ) -> Awaitable[_YieldT_co]: ...
+    ) -> Coroutine[Any, Any, _YieldT_co]: ...
     @overload
     @abstractmethod
-    def athrow(self, typ: BaseException, val: None = None, tb: TracebackType | None = None, /) -> Awaitable[_YieldT_co]: ...
-    def aclose(self) -> Awaitable[None]: ...
+    def athrow(
+        self, typ: BaseException, val: None = None, tb: TracebackType | None = None, /
+    ) -> Coroutine[Any, Any, _YieldT_co]: ...
+    def aclose(self) -> Coroutine[Any, Any, None]: ...
     @property
     def ag_await(self) -> Any: ...
     @property
@@ -563,17 +704,44 @@ class AsyncGenerator(AsyncIterator[_YieldT_co], Generic[_YieldT_co, _SendT_contr
 
 @runtime_checkable
 class Container(Protocol[_T_co]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     # This is generic more on vibes than anything else
     @abstractmethod
     def __contains__(self, x: object, /) -> bool: ...
 
 @runtime_checkable
 class Collection(Iterable[_T_co], Container[_T_co], Protocol[_T_co]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     # Implement Sized (but don't have it as a base class).
     @abstractmethod
     def __len__(self) -> int: ...
 
 class Sequence(Collection[_T_co], Reversible[_T_co]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     @overload
     @abstractmethod
     def __getitem__(self, index: int) -> _T_co: ...
@@ -588,6 +756,15 @@ class Sequence(Collection[_T_co], Reversible[_T_co]):
     def __reversed__(self) -> Iterator[_T_co]: ...
 
 class MutableSequence(Sequence[_T]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     @abstractmethod
     def insert(self, index: int, value: _T) -> None: ...
     @overload
@@ -618,22 +795,50 @@ class MutableSequence(Sequence[_T]):
     def __iadd__(self, values: Iterable[_T]) -> typing_extensions.Self: ...
 
 class AbstractSet(Collection[_T_co]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     @abstractmethod
     def __contains__(self, x: object) -> bool: ...
     def _hash(self) -> int: ...
     # Mixin methods
-    def __le__(self, other: AbstractSet[Any]) -> bool: ...
-    def __lt__(self, other: AbstractSet[Any]) -> bool: ...
-    def __gt__(self, other: AbstractSet[Any]) -> bool: ...
-    def __ge__(self, other: AbstractSet[Any]) -> bool: ...
+    def __le__(self, other: AbstractSet[Any]) -> bool:
+        """Return self<=value."""
+        ...
+    def __lt__(self, other: AbstractSet[Any]) -> bool:
+        """Return self<value."""
+        ...
+    def __gt__(self, other: AbstractSet[Any]) -> bool:
+        """Return self>value."""
+        ...
+    def __ge__(self, other: AbstractSet[Any]) -> bool:
+        """Return self>=value."""
+        ...
     def __and__(self, other: AbstractSet[Any]) -> AbstractSet[_T_co]: ...
     def __or__(self, other: AbstractSet[_T]) -> AbstractSet[_T_co | _T]: ...
     def __sub__(self, other: AbstractSet[Any]) -> AbstractSet[_T_co]: ...
     def __xor__(self, other: AbstractSet[_T]) -> AbstractSet[_T_co | _T]: ...
-    def __eq__(self, other: object) -> bool: ...
+    def __eq__(self, other: object) -> bool:
+        """Return self==value."""
+        ...
     def isdisjoint(self, other: Iterable[Any]) -> bool: ...
 
 class MutableSet(AbstractSet[_T]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     @abstractmethod
     def add(self, value: _T) -> None: ...
     @abstractmethod
@@ -648,10 +853,28 @@ class MutableSet(AbstractSet[_T]):
     def __isub__(self, it: AbstractSet[Any]) -> typing_extensions.Self: ...
 
 class MappingView(Sized):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     def __init__(self, mapping: Mapping[Any, Any]) -> None: ...  # undocumented
     def __len__(self) -> int: ...
 
 class ItemsView(MappingView, AbstractSet[tuple[_KT_co, _VT_co]], Generic[_KT_co, _VT_co]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     def __init__(self, mapping: Mapping[_KT_co, _VT_co]) -> None: ...  # undocumented
     def __and__(self, other: Iterable[Any]) -> set[tuple[_KT_co, _VT_co]]: ...
     def __rand__(self, other: Iterable[_T]) -> set[_T]: ...
@@ -666,6 +889,15 @@ class ItemsView(MappingView, AbstractSet[tuple[_KT_co, _VT_co]], Generic[_KT_co,
     def __rxor__(self, other: Iterable[_T]) -> set[tuple[_KT_co, _VT_co] | _T]: ...
 
 class KeysView(MappingView, AbstractSet[_KT_co]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     def __init__(self, mapping: Mapping[_KT_co, Any]) -> None: ...  # undocumented
     def __and__(self, other: Iterable[Any]) -> set[_KT_co]: ...
     def __rand__(self, other: Iterable[_T]) -> set[_T]: ...
@@ -680,12 +912,30 @@ class KeysView(MappingView, AbstractSet[_KT_co]):
     def __rxor__(self, other: Iterable[_T]) -> set[_KT_co | _T]: ...
 
 class ValuesView(MappingView, Collection[_VT_co]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     def __init__(self, mapping: Mapping[Any, _VT_co]) -> None: ...  # undocumented
     def __contains__(self, value: object) -> bool: ...
     def __iter__(self) -> Iterator[_VT_co]: ...
     def __reversed__(self) -> Iterator[_VT_co]: ...
 
 class Mapping(Collection[_KT], Generic[_KT, _VT_co]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     # TODO: We wish the key type could also be covariant, but that doesn't work,
     # see discussion in https://github.com/python/typing/pull/273.
     @abstractmethod
@@ -699,9 +949,20 @@ class Mapping(Collection[_KT], Generic[_KT, _VT_co]):
     def keys(self) -> KeysView[_KT]: ...
     def values(self) -> ValuesView[_VT_co]: ...
     def __contains__(self, key: object, /) -> bool: ...
-    def __eq__(self, other: object, /) -> bool: ...
+    def __eq__(self, other: object, /) -> bool:
+        """Return self==value."""
+        ...
 
 class MutableMapping(Mapping[_KT, _VT]):
+    """
+    The central part of internal API.
+
+    This represents a generic version of type 'origin' with type arguments 'params'.
+    There are two kind of these aliases: user defined and special. The special ones
+    are wrappers around builtin collections and ABCs in collections.abc. These must
+    have 'name' always set. If 'inst' is False, then the alias can't be instantiated,
+    this is used by e.g. typing.List and typing.Dict.
+    """
     @abstractmethod
     def __setitem__(self, key: _KT, value: _VT, /) -> None: ...
     @abstractmethod
@@ -926,12 +1187,16 @@ class NamedTuple(tuple[Any, ...]):
         __orig_bases__: ClassVar[tuple[Any, ...]]
 
     @overload
-    def __init__(self, typename: str, fields: Iterable[tuple[str, Any]], /) -> None: ...
+    def __init__(self, typename: str, fields: Iterable[tuple[str, Any]], /) -> None:
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
     @overload
     @typing_extensions.deprecated(
         "Creating a typing.NamedTuple using keyword arguments is deprecated and support will be removed in Python 3.15"
     )
-    def __init__(self, typename: str, fields: None = None, /, **kwargs: Any) -> None: ...
+    def __init__(self, typename: str, fields: None = None, /, **kwargs: Any) -> None:
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
     @classmethod
     def _make(cls, iterable: Iterable[Any]) -> typing_extensions.Self: ...
     def _asdict(self) -> dict[str, Any]: ...
@@ -965,13 +1230,21 @@ class _TypedDict(Mapping[str, object], metaclass=ABCMeta):
     def values(self) -> dict_values[str, object]: ...
     if sys.version_info >= (3, 9):
         @overload
-        def __or__(self, value: typing_extensions.Self, /) -> typing_extensions.Self: ...
+        def __or__(self, value: typing_extensions.Self, /) -> typing_extensions.Self:
+            """Return self|value."""
+            ...
         @overload
-        def __or__(self, value: dict[str, Any], /) -> dict[str, object]: ...
+        def __or__(self, value: dict[str, Any], /) -> dict[str, object]:
+            """Return self|value."""
+            ...
         @overload
-        def __ror__(self, value: typing_extensions.Self, /) -> typing_extensions.Self: ...
+        def __ror__(self, value: typing_extensions.Self, /) -> typing_extensions.Self:
+            """Return value|self."""
+            ...
         @overload
-        def __ror__(self, value: dict[str, Any], /) -> dict[str, object]: ...
+        def __ror__(self, value: dict[str, Any], /) -> dict[str, object]:
+            """Return value|self."""
+            ...
         # supposedly incompatible definitions of __or__ and __ior__
         def __ior__(self, value: typing_extensions.Self, /) -> typing_extensions.Self: ...  # type: ignore[misc]
 
@@ -1054,9 +1327,15 @@ if sys.version_info >= (3, 12):
         # It's writable on types, but not on instances of TypeAliasType.
         @property
         def __module__(self) -> str | None: ...  # type: ignore[override]
-        def __getitem__(self, parameters: Any) -> Any: ...
-        def __or__(self, right: Any) -> _SpecialForm: ...
-        def __ror__(self, left: Any) -> _SpecialForm: ...
+        def __getitem__(self, parameters: Any) -> Any:
+            """Return self[key]."""
+            ...
+        def __or__(self, right: Any) -> _SpecialForm:
+            """Return self|value."""
+            ...
+        def __ror__(self, left: Any) -> _SpecialForm:
+            """Return value|self."""
+            ...
 
 if sys.version_info >= (3, 13):
     def is_protocol(tp: type, /) -> bool: ...

package/dist/typeshed-fallback/stdlib/typing_extensions.pyi

@@ -243,13 +243,21 @@ class _TypedDict(Mapping[str, object], metaclass=abc.ABCMeta):
     def __delitem__(self, k: Never) -> None: ...
     if sys.version_info >= (3, 9):
         @overload
-        def __or__(self, value: Self, /) -> Self: ...
+        def __or__(self, value: Self, /) -> Self:
+            """Return self|value."""
+            ...
         @overload
-        def __or__(self, value: dict[str, Any], /) -> dict[str, object]: ...
+        def __or__(self, value: dict[str, Any], /) -> dict[str, object]:
+            """Return self|value."""
+            ...
         @overload
-        def __ror__(self, value: Self, /) -> Self: ...
+        def __ror__(self, value: Self, /) -> Self:
+            """Return value|self."""
+            ...
         @overload
-        def __ror__(self, value: dict[str, Any], /) -> dict[str, object]: ...
+        def __ror__(self, value: dict[str, Any], /) -> dict[str, object]:
+            """Return value|self."""
+            ...
         # supposedly incompatible definitions of `__ior__` and `__or__`:
         def __ior__(self, value: Self, /) -> Self: ...  # type: ignore[misc]
 
@@ -364,9 +372,13 @@ else:
         _fields: ClassVar[tuple[str, ...]]
         __orig_bases__: ClassVar[tuple[Any, ...]]
         @overload
-        def __init__(self, typename: str, fields: Iterable[tuple[str, Any]] = ...) -> None: ...
+        def __init__(self, typename: str, fields: Iterable[tuple[str, Any]] = ...) -> None:
+            """Initialize self.  See help(type(self)) for accurate signature."""
+            ...
         @overload
-        def __init__(self, typename: str, fields: None = None, **kwargs: Any) -> None: ...
+        def __init__(self, typename: str, fields: None = None, **kwargs: Any) -> None:
+            """Initialize self.  See help(type(self)) for accurate signature."""
+            ...
         @classmethod
         def _make(cls, iterable: Iterable[Any]) -> Self: ...
         def _asdict(self) -> dict[str, Any]: ...
@@ -435,7 +447,18 @@ else:
 
     NoDefault: _NoDefaultType
     @final
-    class CapsuleType: ...
+    class CapsuleType:
+        """
+        Capsule objects let you wrap a C "void *" pointer in a Python
+        object.  They're a way of passing data through the Python interpreter
+        without creating your own custom type.
+
+        Capsules are used for communication between extension modules.
+        They provide a way for an extension module to export a C interface
+        to other extension modules, so that extension modules can use the
+        Python import mechanism to link to one another.
+        """
+        ...
 
     class deprecated:
         message: LiteralString
@@ -473,8 +496,12 @@ else:
         def has_default(self) -> bool: ...
         def __typing_prepare_subst__(self, alias: Any, args: Any) -> tuple[Any, ...]: ...
         if sys.version_info >= (3, 10):
-            def __or__(self, right: Any) -> _SpecialForm: ...
-            def __ror__(self, left: Any) -> _SpecialForm: ...
+            def __or__(self, right: Any) -> _SpecialForm:
+                """Return self|value."""
+                ...
+            def __ror__(self, left: Any) -> _SpecialForm:
+                """Return value|self."""
+                ...
         if sys.version_info >= (3, 11):
             def __typing_subst__(self, arg: Any) -> Any: ...
 
@@ -508,8 +535,12 @@ else:
         def has_default(self) -> bool: ...
         def __typing_prepare_subst__(self, alias: Any, args: Any) -> tuple[Any, ...]: ...
         if sys.version_info >= (3, 10):
-            def __or__(self, right: Any) -> _SpecialForm: ...
-            def __ror__(self, left: Any) -> _SpecialForm: ...
+            def __or__(self, right: Any) -> _SpecialForm:
+                """Return self|value."""
+                ...
+            def __ror__(self, left: Any) -> _SpecialForm:
+                """Return value|self."""
+                ...
 
     @final
     class TypeVarTuple:

package/dist/typeshed-fallback/stdlib/unittest/__init__.pyi

@@ -64,4 +64,9 @@ if sys.version_info >= (3, 11):
 if sys.version_info < (3, 12):
     def load_tests(loader: TestLoader, tests: TestSuite, pattern: str | None) -> TestSuite: ...
 
-def __dir__() -> set[str]: ...
+def __dir__() -> set[str]:
+    """
+    __dir__() -> list
+    specialized dir() implementation
+    """
+    ...