basedpyright 1.18.4 → 1.19.0

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

@@ -208,8 +208,6 @@ class object:
 
 class staticmethod(Generic[_P, _R_co]):
     """
-    staticmethod(function) -> method
-
     Convert a function to be a static method.
 
     A static method does not receive an implicit first argument.
@@ -251,8 +249,6 @@ class staticmethod(Generic[_P, _R_co]):
 
 class classmethod(Generic[_T, _P, _R_co]):
     """
-    classmethod(function) -> method
-
     Convert a function to be a class method.
 
     A class method receives the class as implicit first argument,
@@ -348,10 +344,7 @@ class type:
         ...
     @classmethod
     def __prepare__(metacls, name: str, bases: tuple[type, ...], /, **kwds: Any) -> MutableMapping[str, object]:
-        """
-        __prepare__() -> dict
-        used to create the namespace for the class statement
-        """
+        """Create the namespace for the class statement"""
         ...
     if sys.version_info >= (3, 10):
         def __or__(self, value: Any, /) -> types.UnionType:
@@ -484,7 +477,7 @@ class int:
               the most significant byte is at the beginning of the byte array.  If
               byteorder is 'little', the most significant byte is at the end of the
               byte array.  To request the native byte order of the host system, use
-              `sys.byteorder' as the byte order value.  Default is to use 'big'.
+              sys.byteorder as the byte order value.  Default is to use 'big'.
             signed
               Determines whether two's complement is used to represent the integer.
               If signed is False and a negative integer is given, an OverflowError
@@ -512,7 +505,7 @@ class int:
               the most significant byte is at the beginning of the byte array.  If
               byteorder is 'little', the most significant byte is at the end of the
               byte array.  To request the native byte order of the host system, use
-              `sys.byteorder' as the byte order value.  Default is to use 'big'.
+              sys.byteorder as the byte order value.  Default is to use 'big'.
             signed
               Indicates whether two's complement is used to represent the integer.
             """
@@ -1020,7 +1013,7 @@ class str(Sequence[str]):
     that will be decoded using the given encoding and error handler.
     Otherwise, returns the result of object.__str__() (if defined)
     or repr(object).
-    encoding defaults to sys.getdefaultencoding().
+    encoding defaults to 'utf-8'.
     errors defaults to 'strict'.
     """
     @overload
@@ -1071,11 +1064,9 @@ class str(Sequence[str]):
         ...
     def count(self, sub: str, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /) -> int:
         """
-        S.count(sub[, start[, end]]) -> int
+        Return the number of non-overlapping occurrences of substring sub in string S[start:end].
 
-        Return the number of non-overlapping occurrences of substring sub in
-        string S[start:end].  Optional arguments start and end are
-        interpreted as in slice notation.
+        Optional arguments start and end are interpreted as in slice notation.
         """
         ...
     def encode(self, encoding: str = "utf-8", errors: str = "strict") -> bytes:
@@ -1096,12 +1087,14 @@ class str(Sequence[str]):
         self, suffix: str | tuple[str, ...], start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> bool:
         """
-        S.endswith(suffix[, start[, end]]) -> bool
+        Return True if the string ends with the specified suffix, False otherwise.
 
-        Return True if S ends with the specified suffix, False otherwise.
-        With optional start, test S beginning at that position.
-        With optional end, stop comparing S at that position.
-        suffix can also be a tuple of strings to try.
+        suffix
+          A string or a tuple of strings to try.
+        start
+          Optional start position. Default: start of the string.
+        end
+          Optional stop position. Default: end of the string.
         """
         ...
     @overload
@@ -1122,49 +1115,37 @@ class str(Sequence[str]):
         ...
     def find(self, sub: str, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /) -> int:
         """
-        S.find(sub[, start[, end]]) -> int
-
-        Return the lowest index in S where substring sub is found,
-        such that sub is contained within S[start:end].  Optional
-        arguments start and end are interpreted as in slice notation.
+        Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end].
 
+        Optional arguments start and end are interpreted as in slice notation.
         Return -1 on failure.
         """
         ...
     @overload
     def format(self: LiteralString, *args: LiteralString, **kwargs: LiteralString) -> LiteralString:
         """
-        S.format(*args, **kwargs) -> str
-
-        Return a formatted version of S, using substitutions from args and kwargs.
+        Return a formatted version of the string, using substitutions from args and kwargs.
         The substitutions are identified by braces ('{' and '}').
         """
         ...
     @overload
     def format(self, *args: object, **kwargs: object) -> str:
         """
-        S.format(*args, **kwargs) -> str
-
-        Return a formatted version of S, using substitutions from args and kwargs.
+        Return a formatted version of the string, using substitutions from args and kwargs.
         The substitutions are identified by braces ('{' and '}').
         """
         ...
     def format_map(self, mapping: _FormatMapMapping, /) -> str:
         """
-        S.format_map(mapping) -> str
-
-        Return a formatted version of S, using substitutions from mapping.
+        Return a formatted version of the string, using substitutions from mapping.
         The substitutions are identified by braces ('{' and '}').
         """
         ...
     def index(self, sub: str, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /) -> int:
         """
-        S.index(sub[, start[, end]]) -> int
-
-        Return the lowest index in S where substring sub is found,
-        such that sub is contained within S[start:end].  Optional
-        arguments start and end are interpreted as in slice notation.
+        Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end].
 
+        Optional arguments start and end are interpreted as in slice notation.
         Raises ValueError when the substring is not found.
         """
         ...
@@ -1356,9 +1337,31 @@ class str(Sequence[str]):
         @overload
         def replace(
             self: LiteralString, old: LiteralString, new: LiteralString, /, count: SupportsIndex = -1
-        ) -> LiteralString: ...
+        ) -> LiteralString:
+            """
+            Return a copy with all occurrences of substring old replaced by new.
+
+              count
+                Maximum number of occurrences to replace.
+                -1 (the default value) means replace all occurrences.
+
+            If the optional argument count is given, only the first count occurrences are
+            replaced.
+            """
+            ...
         @overload
-        def replace(self, old: str, new: str, /, count: SupportsIndex = -1) -> str: ...  # type: ignore[misc]
+        def replace(self, old: str, new: str, /, count: SupportsIndex = -1) -> str:
+            """
+            Return a copy with all occurrences of substring old replaced by new.
+
+              count
+                Maximum number of occurrences to replace.
+                -1 (the default value) means replace all occurrences.
+
+            If the optional argument count is given, only the first count occurrences are
+            replaced.
+            """
+            ...
     else:
         @overload
         def replace(
@@ -1430,23 +1433,17 @@ class str(Sequence[str]):
 
     def rfind(self, sub: str, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /) -> int:
         """
-        S.rfind(sub[, start[, end]]) -> int
-
-        Return the highest index in S where substring sub is found,
-        such that sub is contained within S[start:end].  Optional
-        arguments start and end are interpreted as in slice notation.
+        Return the highest index in S where substring sub is found, such that sub is contained within S[start:end].
 
+        Optional arguments start and end are interpreted as in slice notation.
         Return -1 on failure.
         """
         ...
     def rindex(self, sub: str, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /) -> int:
         """
-        S.rindex(sub[, start[, end]]) -> int
-
-        Return the highest index in S where substring sub is found,
-        such that sub is contained within S[start:end].  Optional
-        arguments start and end are interpreted as in slice notation.
+        Return the highest index in S where substring sub is found, such that sub is contained within S[start:end].
 
+        Optional arguments start and end are interpreted as in slice notation.
         Raises ValueError when the substring is not found.
         """
         ...
@@ -1610,12 +1607,14 @@ class str(Sequence[str]):
         self, prefix: str | tuple[str, ...], start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> bool:
         """
-        S.startswith(prefix[, start[, end]]) -> bool
+        Return True if the string starts with the specified prefix, False otherwise.
 
-        Return True if S starts with the specified prefix, False otherwise.
-        With optional start, test S beginning at that position.
-        With optional end, stop comparing S at that position.
-        prefix can also be a tuple of strings to try.
+        prefix
+          A string or a tuple of strings to try.
+        start
+          Optional start position. Default: start of the string.
+        end
+          Optional stop position. Default: end of the string.
         """
         ...
     @overload
@@ -1859,11 +1858,12 @@ class bytes(Sequence[int]):
         self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int:
         """
-        B.count(sub[, start[, end]]) -> int
+        Return the number of non-overlapping occurrences of subsection 'sub' in bytes B[start:end].
 
-        Return the number of non-overlapping occurrences of subsection sub in
-        bytes B[start:end].  Optional arguments start and end are interpreted
-        as in slice notation.
+        start
+          Optional start position. Default: start of the bytes.
+        end
+          Optional stop position. Default: end of the bytes.
         """
         ...
     def decode(self, encoding: str = "utf-8", errors: str = "strict") -> str:
@@ -1888,12 +1888,14 @@ class bytes(Sequence[int]):
         /,
     ) -> bool:
         """
-        B.endswith(suffix[, start[, end]]) -> bool
+        Return True if the bytes ends with the specified suffix, False otherwise.
 
-        Return True if B ends with the specified suffix, False otherwise.
-        With optional start, test B beginning at that position.
-        With optional end, stop comparing B at that position.
-        suffix can also be a tuple of bytes to try.
+        suffix
+          A bytes or a tuple of bytes to try.
+        start
+          Optional start position. Default: start of the bytes.
+        end
+          Optional stop position. Default: end of the bytes.
         """
         ...
     def expandtabs(self, tabsize: SupportsIndex = 8) -> bytes:
@@ -1907,11 +1909,12 @@ class bytes(Sequence[int]):
         self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int:
         """
-        B.find(sub[, start[, end]]) -> int
+        Return the lowest index in B where subsection 'sub' is found, such that 'sub' is contained within B[start,end].
 
-        Return the lowest index in B where subsection sub is found,
-        such that sub is contained within B[start,end].  Optional
-        arguments start and end are interpreted as in slice notation.
+          start
+            Optional start position. Default: start of the bytes.
+          end
+            Optional stop position. Default: end of the bytes.
 
         Return -1 on failure.
         """
@@ -1942,13 +1945,14 @@ class bytes(Sequence[int]):
         self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int:
         """
-        B.index(sub[, start[, end]]) -> int
+        Return the lowest index in B where subsection 'sub' is found, such that 'sub' is contained within B[start,end].
 
-        Return the lowest index in B where subsection sub is found,
-        such that sub is contained within B[start,end].  Optional
-        arguments start and end are interpreted as in slice notation.
+          start
+            Optional start position. Default: start of the bytes.
+          end
+            Optional stop position. Default: end of the bytes.
 
-        Raises ValueError when the subsection is not found.
+        Raise ValueError if the subsection is not found.
         """
         ...
     def isalnum(self) -> bool:
@@ -2096,11 +2100,12 @@ class bytes(Sequence[int]):
         self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int:
         """
-        B.rfind(sub[, start[, end]]) -> int
+        Return the highest index in B where subsection 'sub' is found, such that 'sub' is contained within B[start,end].
 
-        Return the highest index in B where subsection sub is found,
-        such that sub is contained within B[start,end].  Optional
-        arguments start and end are interpreted as in slice notation.
+          start
+            Optional start position. Default: start of the bytes.
+          end
+            Optional stop position. Default: end of the bytes.
 
         Return -1 on failure.
         """
@@ -2109,13 +2114,14 @@ class bytes(Sequence[int]):
         self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int:
         """
-        B.rindex(sub[, start[, end]]) -> int
+        Return the highest index in B where subsection 'sub' is found, such that 'sub' is contained within B[start,end].
 
-        Return the highest index in B where subsection sub is found,
-        such that sub is contained within B[start,end].  Optional
-        arguments start and end are interpreted as in slice notation.
+          start
+            Optional start position. Default: start of the bytes.
+          end
+            Optional stop position. Default: end of the bytes.
 
-        Raise ValueError when the subsection is not found.
+        Raise ValueError if the subsection is not found.
         """
         ...
     def rjust(self, width: SupportsIndex, fillchar: bytes | bytearray = b" ", /) -> bytes:
@@ -2188,12 +2194,14 @@ class bytes(Sequence[int]):
         /,
     ) -> bool:
         """
-        B.startswith(prefix[, start[, end]]) -> bool
+        Return True if the bytes starts with the specified prefix, False otherwise.
 
-        Return True if B starts with the specified prefix, False otherwise.
-        With optional start, test B beginning at that position.
-        With optional end, stop comparing B at that position.
-        prefix can also be a tuple of bytes to try.
+        prefix
+          A bytes or a tuple of bytes to try.
+        start
+          Optional start position. Default: start of the bytes.
+        end
+          Optional stop position. Default: end of the bytes.
         """
         ...
     def strip(self, bytes: ReadableBuffer | None = None, /) -> bytes:
@@ -2256,7 +2264,7 @@ class bytes(Sequence[int]):
     @staticmethod
     def maketrans(frm: ReadableBuffer, to: ReadableBuffer, /) -> bytes:
         """
-        Return a translation table useable for the bytes or bytearray translate method.
+        Return a translation table usable for the bytes or bytearray translate method.
 
         The returned table will be one where each byte in frm is mapped to the byte at
         the same position in to.
@@ -2373,11 +2381,12 @@ class bytearray(MutableSequence[int]):
         self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int:
         """
-        B.count(sub[, start[, end]]) -> int
+        Return the number of non-overlapping occurrences of subsection 'sub' in bytes B[start:end].
 
-        Return the number of non-overlapping occurrences of subsection sub in
-        bytes B[start:end].  Optional arguments start and end are interpreted
-        as in slice notation.
+        start
+          Optional start position. Default: start of the bytes.
+        end
+          Optional stop position. Default: end of the bytes.
         """
         ...
     def copy(self) -> bytearray:
@@ -2405,12 +2414,14 @@ class bytearray(MutableSequence[int]):
         /,
     ) -> bool:
         """
-        B.endswith(suffix[, start[, end]]) -> bool
+        Return True if the bytearray ends with the specified suffix, False otherwise.
 
-        Return True if B ends with the specified suffix, False otherwise.
-        With optional start, test B beginning at that position.
-        With optional end, stop comparing B at that position.
-        suffix can also be a tuple of bytes to try.
+        suffix
+          A bytes or a tuple of bytes to try.
+        start
+          Optional start position. Default: start of the bytearray.
+        end
+          Optional stop position. Default: end of the bytearray.
         """
         ...
     def expandtabs(self, tabsize: SupportsIndex = 8) -> bytearray:
@@ -2432,11 +2443,12 @@ class bytearray(MutableSequence[int]):
         self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int:
         """
-        B.find(sub[, start[, end]]) -> int
+        Return the lowest index in B where subsection 'sub' is found, such that 'sub' is contained within B[start:end].
 
-        Return the lowest index in B where subsection sub is found,
-        such that sub is contained within B[start,end].  Optional
-        arguments start and end are interpreted as in slice notation.
+          start
+            Optional start position. Default: start of the bytes.
+          end
+            Optional stop position. Default: end of the bytes.
 
         Return -1 on failure.
         """
@@ -2467,13 +2479,14 @@ class bytearray(MutableSequence[int]):
         self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int:
         """
-        B.index(sub[, start[, end]]) -> int
+        Return the lowest index in B where subsection 'sub' is found, such that 'sub' is contained within B[start:end].
 
-        Return the lowest index in B where subsection sub is found,
-        such that sub is contained within B[start,end].  Optional
-        arguments start and end are interpreted as in slice notation.
+          start
+            Optional start position. Default: start of the bytes.
+          end
+            Optional stop position. Default: end of the bytes.
 
-        Raises ValueError when the subsection is not found.
+        Raise ValueError if the subsection is not found.
         """
         ...
     def insert(self, index: SupportsIndex, item: SupportsIndex, /) -> None:
@@ -2649,11 +2662,12 @@ class bytearray(MutableSequence[int]):
         self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int:
         """
-        B.rfind(sub[, start[, end]]) -> int
+        Return the highest index in B where subsection 'sub' is found, such that 'sub' is contained within B[start:end].
 
-        Return the highest index in B where subsection sub is found,
-        such that sub is contained within B[start,end].  Optional
-        arguments start and end are interpreted as in slice notation.
+          start
+            Optional start position. Default: start of the bytes.
+          end
+            Optional stop position. Default: end of the bytes.
 
         Return -1 on failure.
         """
@@ -2662,13 +2676,14 @@ class bytearray(MutableSequence[int]):
         self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int:
         """
-        B.rindex(sub[, start[, end]]) -> int
+        Return the highest index in B where subsection 'sub' is found, such that 'sub' is contained within B[start:end].
 
-        Return the highest index in B where subsection sub is found,
-        such that sub is contained within B[start,end].  Optional
-        arguments start and end are interpreted as in slice notation.
+          start
+            Optional start position. Default: start of the bytes.
+          end
+            Optional stop position. Default: end of the bytes.
 
-        Raise ValueError when the subsection is not found.
+        Raise ValueError if the subsection is not found.
         """
         ...
     def rjust(self, width: SupportsIndex, fillchar: bytes | bytearray = b" ", /) -> bytearray:
@@ -2742,12 +2757,14 @@ class bytearray(MutableSequence[int]):
         /,
     ) -> bool:
         """
-        B.startswith(prefix[, start[, end]]) -> bool
+        Return True if the bytearray starts with the specified prefix, False otherwise.
 
-        Return True if B starts with the specified prefix, False otherwise.
-        With optional start, test B beginning at that position.
-        With optional end, stop comparing B at that position.
-        prefix can also be a tuple of bytes to try.
+        prefix
+          A bytes or a tuple of bytes to try.
+        start
+          Optional start position. Default: start of the bytearray.
+        end
+          Optional stop position. Default: end of the bytearray.
         """
         ...
     def strip(self, bytes: ReadableBuffer | None = None, /) -> bytearray:
@@ -2810,7 +2827,7 @@ class bytearray(MutableSequence[int]):
     @staticmethod
     def maketrans(frm: ReadableBuffer, to: ReadableBuffer, /) -> bytes:
         """
-        Return a translation table useable for the bytes or bytearray translate method.
+        Return a translation table usable for the bytes or bytearray translate method.
 
         The returned table will be one where each byte in frm is mapped to the byte at
         the same position in to.
@@ -2973,7 +2990,9 @@ class memoryview(Sequence[_I]):
     def __enter__(self) -> Self: ...
     def __exit__(
         self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
-    ) -> None: ...
+    ) -> None:
+        """Release the underlying buffer exposed by the memoryview object."""
+        ...
     @overload
     def cast(self, format: Literal["c", "@c"], shape: list[int] | tuple[int, ...] = ...) -> memoryview[bytes]:
         """Cast a memoryview to a new format or shape."""
@@ -3083,9 +3102,7 @@ class memoryview(Sequence[_I]):
 @final
 class bool(int):
     """
-    bool(x) -> bool
-
-    Returns True when the argument x is true, False otherwise.
+    Returns True when the argument is true, False otherwise.
     The builtins True and False are the only two instances of the class bool.
     The class bool is a subclass of the class int, and cannot be subclassed.
     """
@@ -3480,16 +3497,16 @@ class dict(MutableMapping[_KT, _VT]):
     def __init__(self: dict[bytes, bytes], iterable: Iterable[list[bytes]], /) -> None: ...
     def __new__(cls, *args: Any, **kwargs: Any) -> Self: ...
     def copy(self) -> dict[_KT, _VT]:
-        """D.copy() -> a shallow copy of D"""
+        """Return a shallow copy of the dict."""
         ...
     def keys(self) -> dict_keys[_KT, _VT]:
-        """D.keys() -> a set-like object providing a view on D's keys"""
+        """Return a set-like object providing a view on the dict's keys."""
         ...
     def values(self) -> dict_values[_KT, _VT]:
-        """D.values() -> an object providing a view on D's values"""
+        """Return an object providing a view on the dict's values."""
         ...
     def items(self) -> dict_items[_KT, _VT]:
-        """D.items() -> a set-like object providing a view on D's items"""
+        """Return a set-like object providing a view on the dict's items."""
         ...
     # Signature of `dict.fromkeys` should be kept identical to
     # `fromkeys` methods of `OrderedDict`/`ChainMap`/`UserDict` in `collections`
@@ -3598,12 +3615,7 @@ class dict(MutableMapping[_KT, _VT]):
             ...
 
 class set(MutableSet[_T]):
-    """
-    set() -> new empty set object
-    set(iterable) -> new set object
-
-    Build an unordered collection of unique elements.
-    """
+    """Build an unordered collection of unique elements."""
     @overload
     def __init__(self) -> None: ...
     @overload
@@ -3619,14 +3631,10 @@ class set(MutableSet[_T]):
         """Return a shallow copy of a set."""
         ...
     def difference(self, *s: Iterable[Any]) -> set[_T]:
-        """
-        Return the difference of two or more sets as a new set.
-
-        (i.e. all elements that are in this set but not the others.)
-        """
+        """Return a new set with elements in the set that are not in the others."""
         ...
     def difference_update(self, *s: Iterable[Any]) -> None:
-        """Remove all elements of another set from this set."""
+        """Update the set, removing elements found in others."""
         ...
     def discard(self, element: _T, /) -> None:
         """
@@ -3637,23 +3645,19 @@ class set(MutableSet[_T]):
         """
         ...
     def intersection(self, *s: Iterable[Any]) -> set[_T]:
-        """
-        Return the intersection of two sets as a new set.
-
-        (i.e. all elements that are in both sets.)
-        """
+        """Return a new set with elements common to the set and all others."""
         ...
     def intersection_update(self, *s: Iterable[Any]) -> None:
-        """Update a set with the intersection of itself and another."""
+        """Update the set, keeping only elements found in it and all others."""
         ...
     def isdisjoint(self, s: Iterable[Any], /) -> bool:
         """Return True if two sets have a null intersection."""
         ...
     def issubset(self, s: Iterable[Any], /) -> bool:
-        """Test whether every element in the set is in other."""
+        """Report whether another set contains this set."""
         ...
     def issuperset(self, s: Iterable[Any], /) -> bool:
-        """Test whether every element in other is in the set."""
+        """Report whether this set contains another set."""
         ...
     def remove(self, element: _T, /) -> None:
         """
@@ -3663,24 +3667,16 @@ class set(MutableSet[_T]):
         """
         ...
     def symmetric_difference(self, s: Iterable[_T], /) -> set[_T]:
-        """
-        Return the symmetric difference of two sets as a new set.
-
-        (i.e. all elements that are in exactly one of the sets.)
-        """
+        """Return a new set with elements in either the set or other but not both."""
         ...
     def symmetric_difference_update(self, s: Iterable[_T], /) -> None:
-        """Update a set with the symmetric difference of itself and another."""
+        """Update the set, keeping only elements found in either set, but not in both."""
         ...
     def union(self, *s: Iterable[_S]) -> set[_T | _S]:
-        """
-        Return the union of sets as a new set.
-
-        (i.e. all elements that are in either set.)
-        """
+        """Return a new set with elements from the set and all others."""
         ...
     def update(self, *s: Iterable[_T]) -> None:
-        """Update a set with the union of itself and others."""
+        """Update the set, adding elements from all others."""
         ...
     def __len__(self) -> int:
         """Return len(self)."""
@@ -3737,12 +3733,7 @@ class set(MutableSet[_T]):
             ...
 
 class frozenset(AbstractSet[_T_co]):
-    """
-    frozenset() -> empty frozenset object
-    frozenset(iterable) -> frozenset object
-
-    Build an immutable unordered collection of unique elements.
-    """
+    """Build an immutable unordered collection of unique elements."""
     @overload
     def __new__(cls) -> Self: ...
     @overload
@@ -3751,41 +3742,25 @@ class frozenset(AbstractSet[_T_co]):
         """Return a shallow copy of a set."""
         ...
     def difference(self, *s: Iterable[object]) -> frozenset[_T_co]:
-        """
-        Return the difference of two or more sets as a new set.
-
-        (i.e. all elements that are in this set but not the others.)
-        """
+        """Return a new set with elements in the set that are not in the others."""
         ...
     def intersection(self, *s: Iterable[object]) -> frozenset[_T_co]:
-        """
-        Return the intersection of two sets as a new set.
-
-        (i.e. all elements that are in both sets.)
-        """
+        """Return a new set with elements common to the set and all others."""
         ...
     def isdisjoint(self, s: Iterable[_T_co], /) -> bool:
         """Return True if two sets have a null intersection."""
         ...
     def issubset(self, s: Iterable[object], /) -> bool:
-        """Test whether every element in the set is in other."""
+        """Report whether another set contains this set."""
         ...
     def issuperset(self, s: Iterable[object], /) -> bool:
-        """Test whether every element in other is in the set."""
+        """Report whether this set contains another set."""
         ...
     def symmetric_difference(self, s: Iterable[_T_co], /) -> frozenset[_T_co]:
-        """
-        Return the symmetric difference of two sets as a new set.
-
-        (i.e. all elements that are in exactly one of the sets.)
-        """
+        """Return a new set with elements in either the set or other but not both."""
         ...
     def union(self, *s: Iterable[_S]) -> frozenset[_T_co | _S]:
-        """
-        Return the union of sets as a new set.
-
-        (i.e. all elements that are in either set.)
-        """
+        """Return a new set with elements from the set and all others."""
         ...
     def __len__(self) -> int:
         """Return len(self)."""
@@ -4027,8 +4002,6 @@ def bin(number: int | SupportsIndex, /) -> str:
     ...
 def breakpoint(*args: Any, **kws: Any) -> None:
     """
-    breakpoint(*args, **kws)
-
     Call sys.breakpointhook(*args, **kws).  sys.breakpointhook() must accept
     whatever arguments are passed.
 
@@ -4066,19 +4039,19 @@ if sys.version_info >= (3, 10):
     # See discussion in #7491 and pure-Python implementation of `anext` at https://github.com/python/cpython/blob/ea786a882b9ed4261eafabad6011bc7ef3b5bf94/Lib/test/test_asyncgen.py#L52-L80
     def anext(i: _SupportsSynchronousAnext[_AwaitableT], /) -> _AwaitableT:
         """
-        async anext(aiterator[, default])
+        Return the next item from the async iterator.
 
-        Return the next item from the async iterator.  If default is given and the async
-        iterator is exhausted, it is returned instead of raising StopAsyncIteration.
+        If default is given and the async iterator is exhausted,
+        it is returned instead of raising StopAsyncIteration.
         """
         ...
     @overload
     async def anext(i: SupportsAnext[_T], default: _VT, /) -> _T | _VT:
         """
-        async anext(aiterator[, default])
+        Return the next item from the async iterator.
 
-        Return the next item from the async iterator.  If default is given and the async
-        iterator is exhausted, it is returned instead of raising StopAsyncIteration.
+        If default is given and the async iterator is exhausted,
+        it is returned instead of raising StopAsyncIteration.
         """
         ...
 
@@ -4199,7 +4172,7 @@ def delattr(obj: object, name: str, /) -> None:
     ...
 def dir(o: object = ..., /) -> list[str]:
     """
-    Show attributes of an object.
+    dir([object]) -> list of strings
 
     If called without an argument, return the names in the current scope.
     Else, return an alphabetized list of names comprising (some of) the attributes
@@ -4230,7 +4203,17 @@ if sys.version_info >= (3, 13):
         /,
         globals: dict[str, Any] | None = None,
         locals: Mapping[str, object] | None = None,
-    ) -> Any: ...
+    ) -> Any:
+        """
+        Evaluate the given source in the context of globals and locals.
+
+        The source may be a string representing a Python expression
+        or a code object as returned by compile().
+        The globals must be a dictionary and locals can be any mapping,
+        defaulting to the current globals and locals.
+        If only globals is given, locals defaults to it.
+        """
+        ...
 
 else:
     def eval(
@@ -4259,7 +4242,19 @@ if sys.version_info >= (3, 13):
         locals: Mapping[str, object] | None = None,
         *,
         closure: tuple[CellType, ...] | None = None,
-    ) -> None: ...
+    ) -> None:
+        """
+        Execute the given source in the context of globals and locals.
+
+        The source may be a string representing one or more Python statements
+        or a code object as returned by compile().
+        The globals must be a dictionary and locals can be any mapping,
+        defaulting to the current globals and locals.
+        If only globals is given, locals defaults to it.
+        The closure must be a tuple of cellvars, and can only be used
+        when source is a code object requiring exactly that many cellvars.
+        """
+        ...
 
 elif sys.version_info >= (3, 11):
     def exec(
@@ -4305,8 +4300,6 @@ def exit(code: sys._ExitCode = None) -> NoReturn: ...
 
 class filter(Iterator[_T]):
     """
-    filter(function or None, iterable) --> filter object
-
     Return an iterator yielding those items of iterable for which function(item)
     is true. If function is None, return the items that are true.
     """
@@ -4340,9 +4333,9 @@ def format(value: object, format_spec: str = "", /) -> str:
 @overload
 def getattr(o: object, name: str, /) -> Any:
     """
-    Get a named attribute from an object.
+    getattr(object, name[, default]) -> value
 
-    getattr(x, 'y') is equivalent to x.y
+    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
     When a default argument is given, it is returned when the attribute doesn't
     exist; without it, an exception is raised in that case.
     """
@@ -4354,9 +4347,9 @@ def getattr(o: object, name: str, /) -> Any:
 @overload
 def getattr(o: object, name: str, default: None, /) -> Any | None:
     """
-    Get a named attribute from an object.
+    getattr(object, name[, default]) -> value
 
-    getattr(x, 'y') is equivalent to x.y
+    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
     When a default argument is given, it is returned when the attribute doesn't
     exist; without it, an exception is raised in that case.
     """
@@ -4364,9 +4357,9 @@ def getattr(o: object, name: str, default: None, /) -> Any | None:
 @overload
 def getattr(o: object, name: str, default: bool, /) -> Any | bool:
     """
-    Get a named attribute from an object.
+    getattr(object, name[, default]) -> value
 
-    getattr(x, 'y') is equivalent to x.y
+    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
     When a default argument is given, it is returned when the attribute doesn't
     exist; without it, an exception is raised in that case.
     """
@@ -4374,9 +4367,9 @@ def getattr(o: object, name: str, default: bool, /) -> Any | bool:
 @overload
 def getattr(o: object, name: str, default: list[Any], /) -> Any | list[Any]:
     """
-    Get a named attribute from an object.
+    getattr(object, name[, default]) -> value
 
-    getattr(x, 'y') is equivalent to x.y
+    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
     When a default argument is given, it is returned when the attribute doesn't
     exist; without it, an exception is raised in that case.
     """
@@ -4384,9 +4377,9 @@ def getattr(o: object, name: str, default: list[Any], /) -> Any | list[Any]:
 @overload
 def getattr(o: object, name: str, default: dict[Any, Any], /) -> Any | dict[Any, Any]:
     """
-    Get a named attribute from an object.
+    getattr(object, name[, default]) -> value
 
-    getattr(x, 'y') is equivalent to x.y
+    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
     When a default argument is given, it is returned when the attribute doesn't
     exist; without it, an exception is raised in that case.
     """
@@ -4394,9 +4387,9 @@ def getattr(o: object, name: str, default: dict[Any, Any], /) -> Any | dict[Any,
 @overload
 def getattr(o: object, name: str, default: _T, /) -> Any | _T:
     """
-    Get a named attribute from an object.
+    getattr(object, name[, default]) -> value
 
-    getattr(x, 'y') is equivalent to x.y
+    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
     When a default argument is given, it is returned when the attribute doesn't
     exist; without it, an exception is raised in that case.
     """
@@ -4459,36 +4452,44 @@ class _GetItemIterable(Protocol[_T_co]):
 @overload
 def iter(object: SupportsIter[_SupportsNextT], /) -> _SupportsNextT:
     """
-    Get an iterator from an object.
+    iter(iterable) -> iterator
+    iter(callable, sentinel) -> iterator
 
-    In the first form, the argument must supply its own iterator, or be a sequence.
+    Get an iterator from an object.  In the first form, the argument must
+    supply its own iterator, or be a sequence.
     In the second form, the callable is called until it returns the sentinel.
     """
     ...
 @overload
 def iter(object: _GetItemIterable[_T], /) -> Iterator[_T]:
     """
-    Get an iterator from an object.
+    iter(iterable) -> iterator
+    iter(callable, sentinel) -> iterator
 
-    In the first form, the argument must supply its own iterator, or be a sequence.
+    Get an iterator from an object.  In the first form, the argument must
+    supply its own iterator, or be a sequence.
     In the second form, the callable is called until it returns the sentinel.
     """
     ...
 @overload
 def iter(object: Callable[[], _T | None], sentinel: None, /) -> Iterator[_T]:
     """
-    Get an iterator from an object.
+    iter(iterable) -> iterator
+    iter(callable, sentinel) -> iterator
 
-    In the first form, the argument must supply its own iterator, or be a sequence.
+    Get an iterator from an object.  In the first form, the argument must
+    supply its own iterator, or be a sequence.
     In the second form, the callable is called until it returns the sentinel.
     """
     ...
 @overload
 def iter(object: Callable[[], _T], sentinel: object, /) -> Iterator[_T]:
     """
-    Get an iterator from an object.
+    iter(iterable) -> iterator
+    iter(callable, sentinel) -> iterator
 
-    In the first form, the argument must supply its own iterator, or be a sequence.
+    Get an iterator from an object.  In the first form, the argument must
+    supply its own iterator, or be a sequence.
     In the second form, the callable is called until it returns the sentinel.
     """
     ...
@@ -4533,8 +4534,6 @@ def locals() -> dict[str, Any]:
 
 class map(Iterator[_S]):
     """
-    map(func, *iterables) --> map object
-
     Make an iterator that computes the function using arguments from
     each of the iterables.  Stops when the shortest iterable is exhausted.
     """
@@ -4598,7 +4597,7 @@ def max(
     With a single iterable argument, return its biggest item. The
     default keyword-only argument specifies an object to return if
     the provided iterable is empty.
-    With two or more arguments, return the largest argument.
+    With two or more positional arguments, return the largest argument.
     """
     ...
 @overload
@@ -4610,7 +4609,7 @@ def max(arg1: _T, arg2: _T, /, *_args: _T, key: Callable[[_T], SupportsRichCompa
     With a single iterable argument, return its biggest item. The
     default keyword-only argument specifies an object to return if
     the provided iterable is empty.
-    With two or more arguments, return the largest argument.
+    With two or more positional arguments, return the largest argument.
     """
     ...
 @overload
@@ -4622,7 +4621,7 @@ def max(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None) ->
     With a single iterable argument, return its biggest item. The
     default keyword-only argument specifies an object to return if
     the provided iterable is empty.
-    With two or more arguments, return the largest argument.
+    With two or more positional arguments, return the largest argument.
     """
     ...
 @overload
@@ -4634,7 +4633,7 @@ def max(iterable: Iterable[_T], /, *, key: Callable[[_T], SupportsRichComparison
     With a single iterable argument, return its biggest item. The
     default keyword-only argument specifies an object to return if
     the provided iterable is empty.
-    With two or more arguments, return the largest argument.
+    With two or more positional arguments, return the largest argument.
     """
     ...
 @overload
@@ -4646,7 +4645,7 @@ def max(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None, def
     With a single iterable argument, return its biggest item. The
     default keyword-only argument specifies an object to return if
     the provided iterable is empty.
-    With two or more arguments, return the largest argument.
+    With two or more positional arguments, return the largest argument.
     """
     ...
 @overload
@@ -4658,7 +4657,7 @@ def max(iterable: Iterable[_T1], /, *, key: Callable[[_T1], SupportsRichComparis
     With a single iterable argument, return its biggest item. The
     default keyword-only argument specifies an object to return if
     the provided iterable is empty.
-    With two or more arguments, return the largest argument.
+    With two or more positional arguments, return the largest argument.
     """
     ...
 @overload
@@ -4672,7 +4671,7 @@ def min(
     With a single iterable argument, return its smallest item. The
     default keyword-only argument specifies an object to return if
     the provided iterable is empty.
-    With two or more arguments, return the smallest argument.
+    With two or more positional arguments, return the smallest argument.
     """
     ...
 @overload
@@ -4684,7 +4683,7 @@ def min(arg1: _T, arg2: _T, /, *_args: _T, key: Callable[[_T], SupportsRichCompa
     With a single iterable argument, return its smallest item. The
     default keyword-only argument specifies an object to return if
     the provided iterable is empty.
-    With two or more arguments, return the smallest argument.
+    With two or more positional arguments, return the smallest argument.
     """
     ...
 @overload
@@ -4696,7 +4695,7 @@ def min(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None) ->
     With a single iterable argument, return its smallest item. The
     default keyword-only argument specifies an object to return if
     the provided iterable is empty.
-    With two or more arguments, return the smallest argument.
+    With two or more positional arguments, return the smallest argument.
     """
     ...
 @overload
@@ -4708,7 +4707,7 @@ def min(iterable: Iterable[_T], /, *, key: Callable[[_T], SupportsRichComparison
     With a single iterable argument, return its smallest item. The
     default keyword-only argument specifies an object to return if
     the provided iterable is empty.
-    With two or more arguments, return the smallest argument.
+    With two or more positional arguments, return the smallest argument.
     """
     ...
 @overload
@@ -4720,7 +4719,7 @@ def min(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None, def
     With a single iterable argument, return its smallest item. The
     default keyword-only argument specifies an object to return if
     the provided iterable is empty.
-    With two or more arguments, return the smallest argument.
+    With two or more positional arguments, return the smallest argument.
     """
     ...
 @overload
@@ -4732,25 +4731,25 @@ def min(iterable: Iterable[_T1], /, *, key: Callable[[_T1], SupportsRichComparis
     With a single iterable argument, return its smallest item. The
     default keyword-only argument specifies an object to return if
     the provided iterable is empty.
-    With two or more arguments, return the smallest argument.
+    With two or more positional arguments, return the smallest argument.
     """
     ...
 @overload
 def next(i: SupportsNext[_T], /) -> _T:
     """
-    Return the next item from the iterator.
+    next(iterator[, default])
 
-    If default is given and the iterator is exhausted,
-    it is returned instead of raising StopIteration.
+    Return the next item from the iterator. If default is given and the iterator
+    is exhausted, it is returned instead of raising StopIteration.
     """
     ...
 @overload
 def next(i: SupportsNext[_T], default: _VT, /) -> _T | _VT:
     """
-    Return the next item from the iterator.
+    next(iterator[, default])
 
-    If default is given and the iterator is exhausted,
-    it is returned instead of raising StopIteration.
+    Return the next item from the iterator. If default is given and the iterator
+    is exhausted, it is returned instead of raising StopIteration.
     """
     ...
 def oct(number: int | SupportsIndex, /) -> str:
@@ -5999,7 +5998,7 @@ def sum(iterable: Iterable[_AddableT1], /, start: _AddableT2) -> _AddableT1 | _A
 @overload
 def vars(object: type, /) -> types.MappingProxyType[str, Any]:
     """
-    Show vars.
+    vars([object]) -> dictionary
 
     Without arguments, equivalent to locals().
     With an argument, equivalent to object.__dict__.
@@ -6008,7 +6007,7 @@ def vars(object: type, /) -> types.MappingProxyType[str, Any]:
 @overload
 def vars(object: Any = ..., /) -> dict[str, Any]:
     """
-    Show vars.
+    vars([object]) -> dictionary
 
     Without arguments, equivalent to locals().
     With an argument, equivalent to object.__dict__.
@@ -6017,11 +6016,6 @@ def vars(object: Any = ..., /) -> dict[str, Any]:
 
 class zip(Iterator[_T_co]):
     """
-    zip(*iterables, strict=False) --> Yield tuples until an input is exhausted.
-
-       >>> list(zip('abcdefg', range(3), range(4)))
-       [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
-
     The zip object yields n-length tuples, where n is the number of iterables
     passed as positional arguments to zip().  The i-th element in every tuple
     comes from the i-th iterable argument to zip().  This continues until the
@@ -6029,6 +6023,9 @@ class zip(Iterator[_T_co]):
 
     If strict is true and one of the arguments is exhausted before the others,
     raise a ValueError.
+
+       >>> list(zip('abcdefg', range(3), range(4)))
+       [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
     """
     if sys.version_info >= (3, 10):
         @overload
@@ -6537,4 +6534,6 @@ if sys.version_info >= (3, 11):
         ) -> tuple[ExceptionGroup[_ExceptionT_co] | None, ExceptionGroup[_ExceptionT_co] | None]: ...
 
 if sys.version_info >= (3, 13):
-    class PythonFinalizationError(RuntimeError): ...
+    class PythonFinalizationError(RuntimeError):
+        """Operation blocked during Python finalization."""
+        ...