basedpyright 1.13.2 → 1.13.3

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

@@ -236,42 +236,105 @@ class UserString(Sequence[UserString]):
 
 class deque(MutableSequence[_T]):
     @property
-    def maxlen(self) -> int | None: ...
+    def maxlen(self) -> int | None:
+        """maximum size of a deque or None if unbounded"""
+        ...
     @overload
     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 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 pop(self) -> _T: ...  # type: ignore[override]
-    def popleft(self) -> _T: ...
-    def remove(self, value: _T, /) -> None: ...
-    def rotate(self, n: int = 1, /) -> None: ...
-    def __copy__(self) -> Self: ...
-    def __len__(self) -> int: ...
+    def append(self, x: _T, /) -> None:
+        """Add an element to the right side of the deque."""
+        ...
+    def appendleft(self, x: _T, /) -> None:
+        """Add an element to the left side of the deque."""
+        ...
+    def copy(self) -> Self:
+        """Return a shallow copy of a deque."""
+        ...
+    def count(self, x: _T, /) -> int:
+        """D.count(value) -> integer -- return number of occurrences of value"""
+        ...
+    def extend(self, iterable: Iterable[_T], /) -> None:
+        """Extend the right side of the deque with elements from the iterable"""
+        ...
+    def extendleft(self, iterable: Iterable[_T], /) -> None:
+        """Extend the left side of the deque with elements from the iterable"""
+        ...
+    def insert(self, i: int, x: _T, /) -> None:
+        """D.insert(index, object) -- insert object before index"""
+        ...
+    def index(self, x: _T, start: int = 0, stop: int = ..., /) -> int:
+        """
+        D.index(value, [start, [stop]]) -> integer -- return first index of value.
+        Raises ValueError if the value is not present.
+        """
+        ...
+    def pop(self) -> _T:
+        """Remove and return the rightmost element."""
+        ...
+    def popleft(self) -> _T:
+        """Remove and return the leftmost element."""
+        ...
+    def remove(self, value: _T, /) -> None:
+        """D.remove(value) -- remove first occurrence of value."""
+        ...
+    def rotate(self, n: int = 1, /) -> None:
+        """Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left."""
+        ...
+    def __copy__(self) -> Self:
+        """Return a shallow copy of a deque."""
+        ...
+    def __len__(self) -> int:
+        """Return len(self)."""
+        ...
     # 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 __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 __getitem__(self, key: SupportsIndex, /) -> _T:
+        """Return self[key]."""
+        ...
+    def __setitem__(self, key: SupportsIndex, value: _T, /) -> None:
+        """Set self[key] to value."""
+        ...
+    def __delitem__(self, key: SupportsIndex, /) -> None:
+        """Delete self[key]."""
+        ...
+    def __contains__(self, key: object, /) -> bool:
+        """Return key in self."""
+        ...
+    def __reduce__(self) -> tuple[type[Self], tuple[()], None, Iterator[_T]]:
+        """Return state information for pickling."""
+        ...
+    def __iadd__(self, value: Iterable[_T], /) -> Self:
+        """Implement self+=value."""
+        ...
+    def __add__(self, value: Self, /) -> Self:
+        """Return self+value."""
+        ...
+    def __mul__(self, value: int, /) -> Self:
+        """Return self*value."""
+        ...
+    def __imul__(self, value: int, /) -> Self:
+        """Implement self*=value."""
+        ...
+    def __lt__(self, value: deque[_T], /) -> bool:
+        """Return self<value."""
+        ...
+    def __le__(self, value: deque[_T], /) -> bool:
+        """Return self<=value."""
+        ...
+    def __gt__(self, value: deque[_T], /) -> bool:
+        """Return self>value."""
+        ...
+    def __ge__(self, value: deque[_T], /) -> bool:
+        """Return self>=value."""
+        ...
+    def __eq__(self, value: object, /) -> bool:
+        """Return self==value."""
+        ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """See PEP 585"""
+            ...
 
 class Counter(dict[_T, int], Generic[_T]):
     @overload
@@ -357,10 +420,26 @@ class _odict_values(dict_values[_KT_co, _VT_co], Reversible[_VT_co], Generic[_KT
     def __reversed__(self) -> Iterator[_VT_co]: ...
 
 class OrderedDict(dict[_KT, _VT], Reversible[_KT], Generic[_KT, _VT]):
-    def popitem(self, last: bool = True) -> tuple[_KT, _VT]: ...
-    def move_to_end(self, key: _KT, last: bool = True) -> None: ...
-    def copy(self) -> Self: ...
-    def __reversed__(self) -> Iterator[_KT]: ...
+    def popitem(self, last: bool = True) -> tuple[_KT, _VT]:
+        """
+        Remove and return a (key, value) pair from the dictionary.
+
+        Pairs are returned in LIFO order if last is true or FIFO order if false.
+        """
+        ...
+    def move_to_end(self, key: _KT, last: bool = True) -> None:
+        """
+        Move an existing element to the end (or beginning if last is false).
+
+        Raise KeyError if the element does not exist.
+        """
+        ...
+    def copy(self) -> Self:
+        """od.copy() -> a shallow copy of od"""
+        ...
+    def __reversed__(self) -> Iterator[_KT]:
+        """od.__reversed__() <==> reversed(od)"""
+        ...
     def keys(self) -> _odict_keys[_KT, _VT]: ...
     def items(self) -> _odict_items[_KT, _VT]: ...
     def values(self) -> _odict_values[_KT, _VT]: ...
@@ -369,32 +448,76 @@ class OrderedDict(dict[_KT, _VT], Reversible[_KT], Generic[_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[_T], value: None = None) -> OrderedDict[_T, Any | None]:
+        """Create a new ordered dictionary with keys from iterable and values set to value."""
+        ...
     @classmethod
     @overload
-    def fromkeys(cls, iterable: Iterable[_T], value: _S) -> OrderedDict[_T, _S]: ...
+    def fromkeys(cls, iterable: Iterable[_T], value: _S) -> OrderedDict[_T, _S]:
+        """Create a new ordered dictionary with keys from iterable and values set to value."""
+        ...
     # 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: ...
+    def setdefault(self: OrderedDict[_KT, _T | None], key: _KT, default: None = None) -> _T | None:
+        """
+        Insert key with a value of default if key is not in the dictionary.
+
+        Return the value for key if key is in the dictionary, else default.
+        """
+        ...
     @overload
-    def setdefault(self, key: _KT, default: _VT) -> _VT: ...
+    def setdefault(self, key: _KT, default: _VT) -> _VT:
+        """
+        Insert key with a value of default if key is not in the dictionary.
+
+        Return the value for key if key is in the dictionary, else default.
+        """
+        ...
     # Same as dict.pop, but accepts keyword arguments
     @overload
-    def pop(self, key: _KT) -> _VT: ...
-    @overload
-    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 pop(self, key: _KT) -> _VT:
+        """
+        od.pop(k[,d]) -> v, remove specified key and return the corresponding
+        value.  If key is not found, d is returned if given, otherwise KeyError
+        is raised.
+        """
+        ...
+    @overload
+    def pop(self, key: _KT, default: _VT) -> _VT:
+        """
+        od.pop(k[,d]) -> v, remove specified key and return the corresponding
+        value.  If key is not found, d is returned if given, otherwise KeyError
+        is raised.
+        """
+        ...
+    @overload
+    def pop(self, key: _KT, default: _T) -> _VT | _T:
+        """
+        od.pop(k[,d]) -> v, remove specified key and return the corresponding
+        value.  If key is not found, d is returned if given, otherwise KeyError
+        is raised.
+        """
+        ...
+    def __eq__(self, value: object, /) -> bool:
+        """Return self==value."""
+        ...
     if sys.version_info >= (3, 9):
         @overload
-        def __or__(self, value: dict[_KT, _VT], /) -> Self: ...
+        def __or__(self, value: dict[_KT, _VT], /) -> Self:
+            """Return self|value."""
+            ...
         @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]:
+            """Return self|value."""
+            ...
         @overload
-        def __ror__(self, value: dict[_KT, _VT], /) -> Self: ...
+        def __ror__(self, value: dict[_KT, _VT], /) -> Self:
+            """Return value|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]:
+            """Return value|self."""
+            ...
 
 class defaultdict(dict[_KT, _VT]):
     default_factory: Callable[[], _VT] | None
@@ -431,25 +554,46 @@ class defaultdict(dict[_KT, _VT]):
         /,
         **kwargs: _VT,
     ) -> None: ...
-    def __missing__(self, key: _KT, /) -> _VT: ...
-    def __copy__(self) -> Self: ...
-    def copy(self) -> Self: ...
+    def __missing__(self, key: _KT, /) -> _VT:
+        """
+        __missing__(key) # Called by __getitem__ for missing key; pseudo-code:
+        if self.default_factory is None: raise KeyError((key,))
+        self[key] = value = self.default_factory()
+        return value
+        """
+        ...
+    def __copy__(self) -> Self:
+        """D.copy() -> a shallow copy of D."""
+        ...
+    def copy(self) -> Self:
+        """D.copy() -> a shallow copy of D."""
+        ...
     if sys.version_info >= (3, 9):
         @overload
-        def __or__(self, value: dict[_KT, _VT], /) -> Self: ...
+        def __or__(self, value: dict[_KT, _VT], /) -> Self:
+            """Return self|value."""
+            ...
         @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]:
+            """Return self|value."""
+            ...
         @overload
-        def __ror__(self, value: dict[_KT, _VT], /) -> Self: ...
+        def __ror__(self, value: dict[_KT, _VT], /) -> Self:
+            """Return value|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]:
+            """Return value|self."""
+            ...
 
 class ChainMap(MutableMapping[_KT, _VT]):
     maps: list[MutableMapping[_KT, _VT]]
     def __init__(self, *maps: MutableMapping[_KT, _VT]) -> None: ...
     def new_child(self, m: MutableMapping[_KT, _VT] | None = None) -> Self: ...
     @property
-    def parents(self) -> Self: ...
+    def parents(self) -> Self:
+        """New ChainMap from maps[1:]."""
+        ...
     def __setitem__(self, key: _KT, value: _VT) -> None: ...
     def __delitem__(self, key: _KT) -> None: ...
     def __getitem__(self, key: _KT) -> _VT: ...

package/dist/typeshed-fallback/stdlib/concurrent/futures/__init__.pyi

@@ -1,3 +1,5 @@
+import sys
+
 from ._base import (
     ALL_COMPLETED as ALL_COMPLETED,
     FIRST_COMPLETED as FIRST_COMPLETED,
@@ -14,19 +16,36 @@ from ._base import (
 from .process import ProcessPoolExecutor as ProcessPoolExecutor
 from .thread import ThreadPoolExecutor as ThreadPoolExecutor
 
-__all__ = (
-    "FIRST_COMPLETED",
-    "FIRST_EXCEPTION",
-    "ALL_COMPLETED",
-    "CancelledError",
-    "TimeoutError",
-    "BrokenExecutor",
-    "Future",
-    "Executor",
-    "wait",
-    "as_completed",
-    "ProcessPoolExecutor",
-    "ThreadPoolExecutor",
-)
+if sys.version_info >= (3, 13):
+    __all__ = (
+        "FIRST_COMPLETED",
+        "FIRST_EXCEPTION",
+        "ALL_COMPLETED",
+        "CancelledError",
+        "TimeoutError",
+        "InvalidStateError",
+        "BrokenExecutor",
+        "Future",
+        "Executor",
+        "wait",
+        "as_completed",
+        "ProcessPoolExecutor",
+        "ThreadPoolExecutor",
+    )
+else:
+    __all__ = (
+        "FIRST_COMPLETED",
+        "FIRST_EXCEPTION",
+        "ALL_COMPLETED",
+        "CancelledError",
+        "TimeoutError",
+        "BrokenExecutor",
+        "Future",
+        "Executor",
+        "wait",
+        "as_completed",
+        "ProcessPoolExecutor",
+        "ThreadPoolExecutor",
+    )
 
 def __dir__() -> tuple[str, ...]: ...

package/dist/typeshed-fallback/stdlib/concurrent/futures/_base.pyi

@@ -54,7 +54,13 @@ class Future(Generic[_T]):
     def exception(self, timeout: float | None = None) -> BaseException | None: ...
     def set_exception(self, exception: BaseException | None) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """
+            Represent a PEP 585 generic type
+
+            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
+            """
+            ...
 
 class Executor:
     if sys.version_info >= (3, 9):

package/dist/typeshed-fallback/stdlib/concurrent/futures/thread.pyi

@@ -29,7 +29,13 @@ class _WorkItem(Generic[_S]):
     def __init__(self, future: Future[_S], fn: Callable[..., _S], args: Iterable[Any], kwargs: Mapping[str, Any]) -> None: ...
     def run(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """
+            Represent a PEP 585 generic type
+
+            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
+            """
+            ...
 
 def _worker(
     executor_reference: ref[Any],

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

@@ -18,19 +18,69 @@ class ContextVar(Generic[_T]):
     def __init__(self, name: str) -> None: ...
     @overload
     def __init__(self, name: str, *, default: _T) -> None: ...
-    def __hash__(self) -> int: ...
+    def __hash__(self) -> int:
+        """Return hash(self)."""
+        ...
     @property
     def name(self) -> str: ...
     @overload
-    def get(self) -> _T: ...
+    def get(self) -> _T:
+        """
+        Return a value for the context variable for the current context.
+
+        If there is no value for the variable in the current context, the method will:
+         * return the value of the default argument of the method, if provided; or
+         * return the default value for the context variable, if it was created
+           with one; or
+         * raise a LookupError.
+        """
+        ...
     @overload
-    def get(self, default: _T, /) -> _T: ...
+    def get(self, default: _T, /) -> _T:
+        """
+        Return a value for the context variable for the current context.
+
+        If there is no value for the variable in the current context, the method will:
+         * return the value of the default argument of the method, if provided; or
+         * return the default value for the context variable, if it was created
+           with one; or
+         * raise a LookupError.
+        """
+        ...
     @overload
-    def get(self, default: _D, /) -> _D | _T: ...
-    def set(self, value: _T, /) -> Token[_T]: ...
-    def reset(self, token: Token[_T], /) -> None: ...
+    def get(self, default: _D, /) -> _D | _T:
+        """
+        Return a value for the context variable for the current context.
+
+        If there is no value for the variable in the current context, the method will:
+         * return the value of the default argument of the method, if provided; or
+         * return the default value for the context variable, if it was created
+           with one; or
+         * raise a LookupError.
+        """
+        ...
+    def set(self, value: _T, /) -> Token[_T]:
+        """
+        Call to set a new value for the context variable in the current context.
+
+        The required value argument is the new value for the context variable.
+
+        Returns a Token object that can be used to restore the variable to its previous
+        value via the `ContextVar.reset()` method.
+        """
+        ...
+    def reset(self, token: Token[_T], /) -> None:
+        """
+        Reset the context variable.
+
+        The variable is reset to the value it had before the `ContextVar.set()` that
+        created the token was used.
+        """
+        ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """See PEP 585"""
+            ...
 
 @final
 class Token(Generic[_T]):
@@ -40,7 +90,9 @@ class Token(Generic[_T]):
     def old_value(self) -> Any: ...  # returns either _T or MISSING, but that's hard to express
     MISSING: ClassVar[object]
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """See PEP 585"""
+            ...
 
 def copy_context() -> Context: ...
 
@@ -50,14 +102,45 @@ def copy_context() -> Context: ...
 class Context(Mapping[ContextVar[Any], Any]):
     def __init__(self) -> None: ...
     @overload
-    def get(self, key: ContextVar[_T], default: None = None, /) -> _T | None: ...
+    def get(self, key: ContextVar[_T], default: None = None, /) -> _T | None:
+        """
+        Return the value for `key` if `key` has the value in the context object.
+
+        If `key` does not exist, return `default`. If `default` is not given,
+        return None.
+        """
+        ...
     @overload
-    def get(self, key: ContextVar[_T], default: _T, /) -> _T: ...
+    def get(self, key: ContextVar[_T], default: _T, /) -> _T:
+        """
+        Return the value for `key` if `key` has the value in the context object.
+
+        If `key` does not exist, return `default`. If `default` is not given,
+        return None.
+        """
+        ...
     @overload
-    def get(self, key: ContextVar[_T], default: _D, /) -> _T | _D: ...
+    def get(self, key: ContextVar[_T], default: _D, /) -> _T | _D:
+        """
+        Return the value for `key` if `key` has the value in the context object.
+
+        If `key` does not exist, return `default`. If `default` is not given,
+        return None.
+        """
+        ...
     def run(self, callable: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs) -> _T: ...
-    def copy(self) -> Context: ...
-    def __getitem__(self, key: ContextVar[_T], /) -> _T: ...
-    def __iter__(self) -> Iterator[ContextVar[Any]]: ...
-    def __len__(self) -> int: ...
-    def __eq__(self, value: object, /) -> bool: ...
+    def copy(self) -> Context:
+        """Return a shallow copy of the context object."""
+        ...
+    def __getitem__(self, key: ContextVar[_T], /) -> _T:
+        """Return self[key]."""
+        ...
+    def __iter__(self) -> Iterator[ContextVar[Any]]:
+        """Implement iter(self)."""
+        ...
+    def __len__(self) -> int:
+        """Return len(self)."""
+        ...
+    def __eq__(self, value: object, /) -> bool:
+        """Return self==value."""
+        ...

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

@@ -111,7 +111,13 @@ class DictReader(Iterator[dict[_T | Any, str | Any]], Generic[_T]):
     def __iter__(self) -> Self: ...
     def __next__(self) -> dict[_T | Any, str | Any]: ...
     if sys.version_info >= (3, 12):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """
+            Represent a PEP 585 generic type
+
+            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
+            """
+            ...
 
 class DictWriter(Generic[_T]):
     fieldnames: Collection[_T]
@@ -139,7 +145,13 @@ class DictWriter(Generic[_T]):
     def writerow(self, rowdict: Mapping[_T, Any]) -> Any: ...
     def writerows(self, rowdicts: Iterable[Mapping[_T, Any]]) -> None: ...
     if sys.version_info >= (3, 12):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """
+            Represent a PEP 585 generic type
+
+            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
+            """
+            ...
 
 class Sniffer:
     preferred: list[str]

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

@@ -76,7 +76,13 @@ class LibraryLoader(Generic[_DLLT]):
     def __getitem__(self, name: str) -> _DLLT: ...
     def LoadLibrary(self, name: str) -> _DLLT: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """
+            Represent a PEP 585 generic type
+
+            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
+            """
+            ...
 
 cdll: LibraryLoader[CDLL]
 if sys.platform == "win32":

package/dist/typeshed-fallback/stdlib/ctypes/_endian.pyi

@@ -11,9 +11,13 @@ if sys.platform == "win32":
 # At runtime, the native endianness is an alias for Structure,
 # while the other is a subclass with a metaclass added in.
 class BigEndianStructure(Structure): ...
-class LittleEndianStructure(Structure): ...
+class LittleEndianStructure(Structure):
+    """Structure base class"""
+    ...
 
 # Same thing for these: one is an alias of Union at runtime
 if sys.version_info >= (3, 11):
     class BigEndianUnion(Union): ...
-    class LittleEndianUnion(Union): ...
+    class LittleEndianUnion(Union):
+        """Union base class"""
+        ...

package/dist/typeshed-fallback/stdlib/curses/panel.pyi

@@ -16,7 +16,19 @@ class _Curses_Panel:  # type is <class '_curses_panel.curses panel'> (note the s
     def userptr(self) -> object: ...
     def window(self) -> _CursesWindow: ...
 
-def bottom_panel() -> _Curses_Panel: ...
-def new_panel(win: _CursesWindow, /) -> _Curses_Panel: ...
-def top_panel() -> _Curses_Panel: ...
-def update_panels() -> _Curses_Panel: ...
+def bottom_panel() -> _Curses_Panel:
+    """Return the bottom panel in the panel stack."""
+    ...
+def new_panel(win: _CursesWindow, /) -> _Curses_Panel:
+    """Return a panel object, associating it with the given window win."""
+    ...
+def top_panel() -> _Curses_Panel:
+    """Return the top panel in the panel stack."""
+    ...
+def update_panels() -> _Curses_Panel:
+    """
+    Updates the virtual screen after changes in the panel stack.
+
+    This does not call curses.doupdate(), so you'll have to do this yourself.
+    """
+    ...

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

@@ -143,7 +143,13 @@ class Field(Generic[_T]):
 
     def __set_name__(self, owner: Type[Any], name: str) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """
+            Represent a PEP 585 generic type
+
+            E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).
+            """
+            ...
 
 # NOTE: Actual return type is 'Field[_T]', but we want to help type checkers
 # to understand the magic that happens at runtime.