basedpyright 1.15.2 → 1.16.0

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

@@ -1,7 +1,14 @@
 """
-Built-in functions, exceptions, and other objects.
+Built-in functions, types, exceptions, and other objects.
 
-Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices.
+This module provides direct access to all 'built-in'
+identifiers of Python; for example, builtins.len is
+the full name for the built-in function len().
+
+This module is not normally accessed explicitly by most
+applications, but can be useful in modules that provide
+objects with the same name as a built-in value, but in
+which the built-in of that name is also needed.
 """
 
 import _ast
@@ -148,7 +155,11 @@ class object:
         """Return hash(self)."""
         ...
     def __format__(self, format_spec: str, /) -> str:
-        """Default object formatter."""
+        """
+        Default object formatter.
+
+        Return str(self) if format_spec is empty. Raise TypeError otherwise.
+        """
         ...
     def __getattribute__(self, name: str, /) -> Any:
         """Return getattr(self, name)."""
@@ -203,7 +214,7 @@ class staticmethod(Generic[_P, _R_co]):
 
          class C:
              @staticmethod
-             def f(arg1, arg2, ...):
+             def f(arg1, arg2, argN):
                  ...
 
     It can be called either on the class (e.g. C.f()) or on an instance
@@ -247,7 +258,7 @@ class classmethod(Generic[_T, _P, _R_co]):
 
       class C:
           @classmethod
-          def f(cls, arg1, arg2, ...):
+          def f(cls, arg1, arg2, argN):
               ...
 
     It can be called either on the class (e.g. C.f()) or on an instance
@@ -279,9 +290,8 @@ class classmethod(Generic[_T, _P, _R_co]):
 
 class type:
     """
-    type(object_or_name, bases, dict)
     type(object) -> the object's type
-    type(name, bases, dict) -> a new type
+    type(name, bases, dict, **kwds) -> a new type
     """
     # object.__base__ is None. Otherwise, it would be a type.
     @property
@@ -400,10 +410,9 @@ class int:
     def __new__(cls, x: str | bytes | bytearray, /, base: SupportsIndex) -> Self: ...
     def as_integer_ratio(self) -> tuple[int, Literal[1]]:
         """
-        Return integer ratio.
+        Return a pair of integers, whose ratio is equal to the original int.
 
-        Return a pair of integers, whose ratio is exactly equal to the original int
-        and with a positive denominator.
+        The ratio is in lowest terms and has a positive denominator.
 
         >>> (10).as_integer_ratio()
         (10, 1)
@@ -679,6 +688,7 @@ class int:
     def __round__(self, ndigits: SupportsIndex = ..., /) -> int:
         """
         Rounding an Integral returns itself.
+
         Rounding with an ndigits argument also returns an integer.
         """
         ...
@@ -714,7 +724,7 @@ class int:
         """Return hash(self)."""
         ...
     def __bool__(self) -> bool:
-        """self != 0"""
+        """True if self else False"""
         ...
     def __index__(self) -> int:
         """Return self converted to an integer, if self is suitable for use as an index into a list."""
@@ -725,12 +735,10 @@ class float:
     def __new__(cls, x: ConvertibleToFloat = ..., /) -> Self: ...
     def as_integer_ratio(self) -> tuple[int, int]:
         """
-        Return integer ratio.
+        Return a pair of integers, whose ratio is exactly equal to the original float.
 
-        Return a pair of integers, whose ratio is exactly equal to the original float
-        and with a positive denominator.
-
-        Raise OverflowError on infinities and a ValueError on NaNs.
+        The ratio is in lowest terms and has a positive denominator.  Raise
+        OverflowError on infinities and a ValueError on NaNs.
 
         >>> (10.0).as_integer_ratio()
         (10, 1)
@@ -905,14 +913,17 @@ class float:
         """Return hash(self)."""
         ...
     def __bool__(self) -> bool:
-        """self != 0"""
+        """True if self else False"""
         ...
 
 class complex:
     """
-    Create a complex number from a real part and an optional imaginary part.
+    Create a complex number from a string or numbers.
 
-    This is equivalent to (real + imag*1j) where imag defaults to 0.
+    If a string is given, parse it as a complex number.
+    If a single number is given, convert it to a complex number.
+    If the 'real' or 'imag' arguments are given, create a complex number
+    with the specified real and imaginary components.
     """
     # Python doesn't currently accept SupportsComplex for the second argument
     @overload
@@ -932,11 +943,7 @@ class complex:
         """the imaginary part of a complex number"""
         ...
     def conjugate(self) -> complex:
-        """
-        complex.conjugate() -> complex
-
-        Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.
-        """
+        """Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j."""
         ...
     def __add__(self, value: complex, /) -> complex:
         """Return self+value."""
@@ -987,7 +994,7 @@ class complex:
         """Return hash(self)."""
         ...
     def __bool__(self) -> bool:
-        """self != 0"""
+        """True if self else False"""
         ...
     if sys.version_info >= (3, 11):
         def __complex__(self) -> complex:
@@ -1484,34 +1491,38 @@ class str(Sequence[str]):
         ...
     @overload
     def rsplit(self: LiteralString, sep: LiteralString | None = None, maxsplit: SupportsIndex = -1) -> list[LiteralString]:
-        """
-        Return a list of the words in the string, using sep as the delimiter string.
+        r"""
+        Return a list of the substrings in the string, using sep as the separator string.
 
           sep
-            The delimiter according which to split the string.
-            None (the default value) means split according to any whitespace,
-            and discard empty strings from the result.
+            The separator used to split the string.
+
+            When set to None (the default value), will split on any whitespace
+            character (including \n \r \t \f and spaces) and will discard
+            empty strings from the result.
           maxsplit
-            Maximum number of splits to do.
+            Maximum number of splits.
             -1 (the default value) means no limit.
 
-        Splits are done starting at the end of the string and working to the front.
+        Splitting starts at the end of the string and works to the front.
         """
         ...
     @overload
     def rsplit(self, sep: str | None = None, maxsplit: SupportsIndex = -1) -> list[str]:
-        """
-        Return a list of the words in the string, using sep as the delimiter string.
+        r"""
+        Return a list of the substrings in the string, using sep as the separator string.
 
           sep
-            The delimiter according which to split the string.
-            None (the default value) means split according to any whitespace,
-            and discard empty strings from the result.
+            The separator used to split the string.
+
+            When set to None (the default value), will split on any whitespace
+            character (including \n \r \t \f and spaces) and will discard
+            empty strings from the result.
           maxsplit
-            Maximum number of splits to do.
+            Maximum number of splits.
             -1 (the default value) means no limit.
 
-        Splits are done starting at the end of the string and working to the front.
+        Splitting starts at the end of the string and works to the front.
         """
         ...
     @overload
@@ -1532,30 +1543,46 @@ class str(Sequence[str]):
         ...
     @overload
     def split(self: LiteralString, sep: LiteralString | None = None, maxsplit: SupportsIndex = -1) -> list[LiteralString]:
-        """
-        Return a list of the words in the string, using sep as the delimiter string.
+        r"""
+        Return a list of the substrings in the string, using sep as the separator string.
 
-        sep
-          The delimiter according which to split the string.
-          None (the default value) means split according to any whitespace,
-          and discard empty strings from the result.
-        maxsplit
-          Maximum number of splits to do.
-          -1 (the default value) means no limit.
+          sep
+            The separator used to split the string.
+
+            When set to None (the default value), will split on any whitespace
+            character (including \n \r \t \f and spaces) and will discard
+            empty strings from the result.
+          maxsplit
+            Maximum number of splits.
+            -1 (the default value) means no limit.
+
+        Splitting starts at the front of the string and works to the end.
+
+        Note, str.split() is mainly useful for data that has been intentionally
+        delimited.  With natural text that includes punctuation, consider using
+        the regular expression module.
         """
         ...
     @overload
     def split(self, sep: str | None = None, maxsplit: SupportsIndex = -1) -> list[str]:
-        """
-        Return a list of the words in the string, using sep as the delimiter string.
+        r"""
+        Return a list of the substrings in the string, using sep as the separator string.
 
-        sep
-          The delimiter according which to split the string.
-          None (the default value) means split according to any whitespace,
-          and discard empty strings from the result.
-        maxsplit
-          Maximum number of splits to do.
-          -1 (the default value) means no limit.
+          sep
+            The separator used to split the string.
+
+            When set to None (the default value), will split on any whitespace
+            character (including \n \r \t \f and spaces) and will discard
+            empty strings from the result.
+          maxsplit
+            Maximum number of splits.
+            -1 (the default value) means no limit.
+
+        Splitting starts at the front of the string and works to the end.
+
+        Note, str.split() is mainly useful for data that has been intentionally
+        delimited.  With natural text that includes punctuation, consider using
+        the regular expression module.
         """
         ...
     @overload
@@ -1722,7 +1749,7 @@ class str(Sequence[str]):
         ...
     # Incompatible with Sequence.__contains__
     def __contains__(self, key: str, /) -> bool:
-        """Return key in self."""
+        """Return bool(key in self)."""
         ...
     def __eq__(self, value: object, /) -> bool:
         """Return self==value."""
@@ -1883,7 +1910,7 @@ class bytes(Sequence[int]):
         ...
     def hex(self, sep: str | bytes = ..., bytes_per_sep: SupportsIndex = ...) -> str:
         r"""
-        Create a str of hexadecimal numbers from a bytes object.
+        Create a string of hexadecimal numbers from a bytes object.
 
           sep
             An optional single character or byte to separate hex bytes.
@@ -2260,7 +2287,7 @@ class bytes(Sequence[int]):
         ...
     # Incompatible with Sequence.__contains__
     def __contains__(self, key: SupportsIndex | ReadableBuffer, /) -> bool:
-        """Return key in self."""
+        """Return bool(key in self)."""
         ...
     def __eq__(self, value: object, /) -> bool:
         """Return self==value."""
@@ -2408,7 +2435,7 @@ class bytearray(MutableSequence[int]):
         ...
     def hex(self, sep: str | bytes = ..., bytes_per_sep: SupportsIndex = ...) -> str:
         """
-        Create a str of hexadecimal numbers from a bytearray object.
+        Create a string of hexadecimal numbers from a bytearray object.
 
           sep
             An optional single character or byte to separate hex bytes.
@@ -2830,7 +2857,7 @@ class bytearray(MutableSequence[int]):
         ...
     # Incompatible with Sequence.__contains__
     def __contains__(self, key: SupportsIndex | ReadableBuffer, /) -> bool:
-        """Return key in self."""
+        """Return bool(key in self)."""
         ...
     def __eq__(self, value: object, /) -> bool:
         """Return self==value."""
@@ -3158,7 +3185,7 @@ class tuple(Sequence[_T_co]):
         """Return len(self)."""
         ...
     def __contains__(self, key: object, /) -> bool:
-        """Return key in self."""
+        """Return bool(key in self)."""
         ...
     @overload
     def __getitem__(self, key: SupportsIndex, /) -> _T_co:
@@ -3335,11 +3362,11 @@ class list(MutableSequence[_T]):
     __hash__: ClassVar[None]  # type: ignore[assignment]
     @overload
     def __getitem__(self, i: SupportsIndex, /) -> _T:
-        """x.__getitem__(y) <==> x[y]"""
+        """Return self[index]."""
         ...
     @overload
     def __getitem__(self, s: slice, /) -> list[_T]:
-        """x.__getitem__(y) <==> x[y]"""
+        """Return self[index]."""
         ...
     @overload
     def __setitem__(self, key: SupportsIndex, value: _T, /) -> None:
@@ -3374,7 +3401,7 @@ class list(MutableSequence[_T]):
         """Implement self*=value."""
         ...
     def __contains__(self, key: object, /) -> bool:
-        """Return key in self."""
+        """Return bool(key in self)."""
         ...
     def __reversed__(self) -> Iterator[_T]:
         """Return a reverse iterator over the list."""
@@ -3484,28 +3511,34 @@ class dict(MutableMapping[_KT, _VT]):
     def pop(self, key: _KT, /) -> _VT:
         """
         D.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
+
+        If the key is not found, return the default if given; otherwise,
+        raise a KeyError.
         """
         ...
     @overload
     def pop(self, key: _KT, default: _VT, /) -> _VT:
         """
         D.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
+
+        If the key is not found, return the default if given; otherwise,
+        raise a KeyError.
         """
         ...
     @overload
     def pop(self, key: _KT, default: _T, /) -> _VT | _T:
         """
         D.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
+
+        If the key is not found, return the default if given; otherwise,
+        raise a KeyError.
         """
         ...
     def __len__(self) -> int:
         """Return len(self)."""
         ...
     def __getitem__(self, key: _KT, /) -> _VT:
-        """x.__getitem__(y) <==> x[y]"""
+        """Return self[key]."""
         ...
     def __setitem__(self, key: _KT, value: _VT, /) -> None:
         """Set self[key] to value."""
@@ -3588,7 +3621,8 @@ class set(MutableSet[_T]):
         """
         Remove an element from a set if it is a member.
 
-        If the element is not a member, do nothing.
+        Unlike set.remove(), the discard() method does not raise
+        an exception when an element is missing from the set.
         """
         ...
     def intersection(self, *s: Iterable[Any]) -> set[_T]:
@@ -3605,10 +3639,10 @@ class set(MutableSet[_T]):
         """Return True if two sets have a null intersection."""
         ...
     def issubset(self, s: Iterable[Any], /) -> bool:
-        """Report whether another set contains this set."""
+        """Test whether every element in the set is in other."""
         ...
     def issuperset(self, s: Iterable[Any], /) -> bool:
-        """Report whether this set contains another set."""
+        """Test whether every element in other is in the set."""
         ...
     def remove(self, element: _T, /) -> None:
         """
@@ -3723,10 +3757,10 @@ class frozenset(AbstractSet[_T_co]):
         """Return True if two sets have a null intersection."""
         ...
     def issubset(self, s: Iterable[object], /) -> bool:
-        """Report whether another set contains this set."""
+        """Test whether every element in the set is in other."""
         ...
     def issuperset(self, s: Iterable[object], /) -> bool:
-        """Report whether this set contains another set."""
+        """Test whether every element in other is in the set."""
         ...
     def symmetric_difference(self, s: Iterable[_T_co], /) -> frozenset[_T_co]:
         """
@@ -3852,7 +3886,7 @@ class range(Sequence[int]):
         """Return hash(self)."""
         ...
     def __contains__(self, key: object, /) -> bool:
-        """Return key in self."""
+        """Return bool(key in self)."""
         ...
     def __iter__(self) -> Iterator[int]:
         """Implement iter(self)."""
@@ -3919,13 +3953,13 @@ class property:
         doc: str | None = ...,
     ) -> None: ...
     def getter(self, fget: Callable[[Any], Any], /) -> property:
-        """Descriptor to change the getter on a property."""
+        """Descriptor to obtain a copy of the property with a different getter."""
         ...
     def setter(self, fset: Callable[[Any, Any], None], /) -> property:
-        """Descriptor to change the setter on a property."""
+        """Descriptor to obtain a copy of the property with a different setter."""
         ...
     def deleter(self, fdel: Callable[[Any], None], /) -> property:
-        """Descriptor to change the deleter on a property."""
+        """Descriptor to obtain a copy of the property with a different deleter."""
         ...
     def __get__(self, instance: Any, owner: type | None = None, /) -> Any:
         """Return an attribute of instance, which is of type owner."""
@@ -4020,11 +4054,21 @@ if sys.version_info >= (3, 10):
     # `anext` is just a passthrough for `obj.__anext__`
     # 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:
-        """Return the next item from the async iterator."""
+        """
+        async anext(aiterator[, default])
+
+        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.
+        """
         ...
     @overload
     async def anext(i: SupportsAnext[_T], default: _VT, /) -> _T | _VT:
-        """Return the next item from the async iterator."""
+        """
+        async anext(aiterator[, default])
+
+        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.
+        """
         ...
 
 # compile() returns a CodeType, unless the flags argument includes PyCF_ONLY_AST (=1024),
@@ -4139,12 +4183,12 @@ def delattr(obj: object, name: str, /) -> None:
     """
     Deletes the named attribute from the given object.
 
-    delattr(x, 'y') is equivalent to ``del x.y''
+    delattr(x, 'y') is equivalent to ``del x.y``
     """
     ...
 def dir(o: object = ..., /) -> list[str]:
     """
-    dir([object]) -> list of strings
+    Show attributes of an object.
 
     If called without an argument, return the names in the current scope.
     Else, return an alphabetized list of names comprising (some of) the attributes
@@ -4272,19 +4316,22 @@ class filter(Iterator[_T]):
 
 def format(value: object, format_spec: str = "", /) -> str:
     """
-    Return value.__format__(format_spec)
+    Return type(value).__format__(value, format_spec)
+
+    Many built-in types implement format_spec according to the
+    Format Specification Mini-language. See help('FORMATTING').
 
-    format_spec defaults to the empty string.
-    See the Format Specification Mini-Language section of help('FORMATTING') for
-    details.
+    If type(value) does not supply a method named __format__
+    and format_spec is empty, then str(value) is returned.
+    See also help('SPECIALMETHODS').
     """
     ...
 @overload
 def getattr(o: object, name: str, /) -> Any:
     """
-    getattr(object, name[, default]) -> value
+    Get a named attribute from an object.
 
-    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
+    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.
     """
@@ -4296,9 +4343,9 @@ def getattr(o: object, name: str, /) -> Any:
 @overload
 def getattr(o: object, name: str, default: None, /) -> Any | None:
     """
-    getattr(object, name[, default]) -> value
+    Get a named attribute from an object.
 
-    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
+    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.
     """
@@ -4306,9 +4353,9 @@ def getattr(o: object, name: str, default: None, /) -> Any | None:
 @overload
 def getattr(o: object, name: str, default: bool, /) -> Any | bool:
     """
-    getattr(object, name[, default]) -> value
+    Get a named attribute from an object.
 
-    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
+    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.
     """
@@ -4316,9 +4363,9 @@ def getattr(o: object, name: str, default: bool, /) -> Any | bool:
 @overload
 def getattr(o: object, name: str, default: list[Any], /) -> Any | list[Any]:
     """
-    getattr(object, name[, default]) -> value
+    Get a named attribute from an object.
 
-    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
+    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.
     """
@@ -4326,9 +4373,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]:
     """
-    getattr(object, name[, default]) -> value
+    Get a named attribute from an object.
 
-    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
+    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.
     """
@@ -4336,9 +4383,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:
     """
-    getattr(object, name[, default]) -> value
+    Get a named attribute from an object.
 
-    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
+    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.
     """
@@ -4401,44 +4448,36 @@ class _GetItemIterable(Protocol[_T_co]):
 @overload
 def iter(object: SupportsIter[_SupportsNextT], /) -> _SupportsNextT:
     """
-    iter(iterable) -> iterator
-    iter(callable, sentinel) -> iterator
+    Get an iterator from an object.
 
-    Get an iterator from an object.  In the first form, the argument must
-    supply its own iterator, or be a sequence.
+    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]:
     """
-    iter(iterable) -> iterator
-    iter(callable, sentinel) -> iterator
+    Get an iterator from an object.
 
-    Get an iterator from an object.  In the first form, the argument must
-    supply its own iterator, or be a sequence.
+    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]:
     """
-    iter(iterable) -> iterator
-    iter(callable, sentinel) -> iterator
+    Get an iterator from an object.
 
-    Get an iterator from an object.  In the first form, the argument must
-    supply its own iterator, or be a sequence.
+    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]:
     """
-    iter(iterable) -> iterator
-    iter(callable, sentinel) -> iterator
+    Get an iterator from an object.
 
-    Get an iterator from an object.  In the first form, the argument must
-    supply its own iterator, or be a sequence.
+    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.
     """
     ...
@@ -4460,11 +4499,11 @@ def isinstance(obj: object, class_or_tuple: _ClassInfo, /) -> bool:
     ...
 def issubclass(cls: type, class_or_tuple: _ClassInfo, /) -> bool:
     """
-    Return whether 'cls' is a derived from another class or is the same class.
+    Return whether 'cls' is derived from another class or is the same class.
 
     A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to
     check against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)
-    or ...`` etc.
+    or ...``.
     """
     ...
 def len(obj: Sized, /) -> int:
@@ -4688,19 +4727,19 @@ def min(iterable: Iterable[_T1], /, *, key: Callable[[_T1], SupportsRichComparis
 @overload
 def next(i: SupportsNext[_T], /) -> _T:
     """
-    next(iterator[, default])
+    Return the next item from the iterator.
 
-    Return the next item from the iterator. If default is given and the iterator
-    is exhausted, it is returned instead of raising StopIteration.
+    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:
     """
-    next(iterator[, default])
+    Return the next item from the iterator.
 
-    Return the next item from the iterator. If default is given and the iterator
-    is exhausted, it is returned instead of raising StopIteration.
+    If default is given and the iterator is exhausted,
+    it is returned instead of raising StopIteration.
     """
     ...
 def oct(number: int | SupportsIndex, /) -> str:
@@ -4742,9 +4781,9 @@ def open(
     'a' for appending (which on some Unix systems, means that all writes
     append to the end of the file regardless of the current seek position).
     In text mode, if encoding is not specified the encoding used is platform
-    dependent: locale.getpreferredencoding(False) is called to get the
-    current locale encoding. (For reading and writing raw bytes use binary
-    mode and leave encoding unspecified.) The available modes are:
+    dependent: locale.getencoding() is called to get the current locale encoding.
+    (For reading and writing raw bytes use binary mode and leave encoding
+    unspecified.) The available modes are:
 
     ========= ===============================================================
     Character Meaning
@@ -4756,7 +4795,6 @@ def open(
     'b'       binary mode
     't'       text mode (default)
     '+'       open a disk file for updating (reading and writing)
-    'U'       universal newline mode (deprecated)
     ========= ===============================================================
 
     The default mode is 'rt' (open for reading text). For binary random
@@ -4772,10 +4810,6 @@ def open(
     returned as strings, the bytes having been first decoded using a
     platform-dependent encoding or using the specified encoding if given.
 
-    'U' mode is deprecated and will raise an exception in future versions
-    of Python.  It has no effect in Python 3.  Use newline to control
-    universal newlines mode.
-
     buffering is an optional integer used to set the buffering policy.
     Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
     line buffering (only usable in text mode), and an integer > 1 to indicate
@@ -4876,9 +4910,9 @@ def open(
     'a' for appending (which on some Unix systems, means that all writes
     append to the end of the file regardless of the current seek position).
     In text mode, if encoding is not specified the encoding used is platform
-    dependent: locale.getpreferredencoding(False) is called to get the
-    current locale encoding. (For reading and writing raw bytes use binary
-    mode and leave encoding unspecified.) The available modes are:
+    dependent: locale.getencoding() is called to get the current locale encoding.
+    (For reading and writing raw bytes use binary mode and leave encoding
+    unspecified.) The available modes are:
 
     ========= ===============================================================
     Character Meaning
@@ -4890,7 +4924,6 @@ def open(
     'b'       binary mode
     't'       text mode (default)
     '+'       open a disk file for updating (reading and writing)
-    'U'       universal newline mode (deprecated)
     ========= ===============================================================
 
     The default mode is 'rt' (open for reading text). For binary random
@@ -4906,10 +4939,6 @@ def open(
     returned as strings, the bytes having been first decoded using a
     platform-dependent encoding or using the specified encoding if given.
 
-    'U' mode is deprecated and will raise an exception in future versions
-    of Python.  It has no effect in Python 3.  Use newline to control
-    universal newlines mode.
-
     buffering is an optional integer used to set the buffering policy.
     Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
     line buffering (only usable in text mode), and an integer > 1 to indicate
@@ -5010,9 +5039,9 @@ def open(
     'a' for appending (which on some Unix systems, means that all writes
     append to the end of the file regardless of the current seek position).
     In text mode, if encoding is not specified the encoding used is platform
-    dependent: locale.getpreferredencoding(False) is called to get the
-    current locale encoding. (For reading and writing raw bytes use binary
-    mode and leave encoding unspecified.) The available modes are:
+    dependent: locale.getencoding() is called to get the current locale encoding.
+    (For reading and writing raw bytes use binary mode and leave encoding
+    unspecified.) The available modes are:
 
     ========= ===============================================================
     Character Meaning
@@ -5024,7 +5053,6 @@ def open(
     'b'       binary mode
     't'       text mode (default)
     '+'       open a disk file for updating (reading and writing)
-    'U'       universal newline mode (deprecated)
     ========= ===============================================================
 
     The default mode is 'rt' (open for reading text). For binary random
@@ -5040,10 +5068,6 @@ def open(
     returned as strings, the bytes having been first decoded using a
     platform-dependent encoding or using the specified encoding if given.
 
-    'U' mode is deprecated and will raise an exception in future versions
-    of Python.  It has no effect in Python 3.  Use newline to control
-    universal newlines mode.
-
     buffering is an optional integer used to set the buffering policy.
     Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
     line buffering (only usable in text mode), and an integer > 1 to indicate
@@ -5142,9 +5166,9 @@ def open(
     'a' for appending (which on some Unix systems, means that all writes
     append to the end of the file regardless of the current seek position).
     In text mode, if encoding is not specified the encoding used is platform
-    dependent: locale.getpreferredencoding(False) is called to get the
-    current locale encoding. (For reading and writing raw bytes use binary
-    mode and leave encoding unspecified.) The available modes are:
+    dependent: locale.getencoding() is called to get the current locale encoding.
+    (For reading and writing raw bytes use binary mode and leave encoding
+    unspecified.) The available modes are:
 
     ========= ===============================================================
     Character Meaning
@@ -5156,7 +5180,6 @@ def open(
     'b'       binary mode
     't'       text mode (default)
     '+'       open a disk file for updating (reading and writing)
-    'U'       universal newline mode (deprecated)
     ========= ===============================================================
 
     The default mode is 'rt' (open for reading text). For binary random
@@ -5172,10 +5195,6 @@ def open(
     returned as strings, the bytes having been first decoded using a
     platform-dependent encoding or using the specified encoding if given.
 
-    'U' mode is deprecated and will raise an exception in future versions
-    of Python.  It has no effect in Python 3.  Use newline to control
-    universal newlines mode.
-
     buffering is an optional integer used to set the buffering policy.
     Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
     line buffering (only usable in text mode), and an integer > 1 to indicate
@@ -5274,9 +5293,9 @@ def open(
     'a' for appending (which on some Unix systems, means that all writes
     append to the end of the file regardless of the current seek position).
     In text mode, if encoding is not specified the encoding used is platform
-    dependent: locale.getpreferredencoding(False) is called to get the
-    current locale encoding. (For reading and writing raw bytes use binary
-    mode and leave encoding unspecified.) The available modes are:
+    dependent: locale.getencoding() is called to get the current locale encoding.
+    (For reading and writing raw bytes use binary mode and leave encoding
+    unspecified.) The available modes are:
 
     ========= ===============================================================
     Character Meaning
@@ -5288,7 +5307,6 @@ def open(
     'b'       binary mode
     't'       text mode (default)
     '+'       open a disk file for updating (reading and writing)
-    'U'       universal newline mode (deprecated)
     ========= ===============================================================
 
     The default mode is 'rt' (open for reading text). For binary random
@@ -5304,10 +5322,6 @@ def open(
     returned as strings, the bytes having been first decoded using a
     platform-dependent encoding or using the specified encoding if given.
 
-    'U' mode is deprecated and will raise an exception in future versions
-    of Python.  It has no effect in Python 3.  Use newline to control
-    universal newlines mode.
-
     buffering is an optional integer used to set the buffering policy.
     Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
     line buffering (only usable in text mode), and an integer > 1 to indicate
@@ -5408,9 +5422,9 @@ def open(
     'a' for appending (which on some Unix systems, means that all writes
     append to the end of the file regardless of the current seek position).
     In text mode, if encoding is not specified the encoding used is platform
-    dependent: locale.getpreferredencoding(False) is called to get the
-    current locale encoding. (For reading and writing raw bytes use binary
-    mode and leave encoding unspecified.) The available modes are:
+    dependent: locale.getencoding() is called to get the current locale encoding.
+    (For reading and writing raw bytes use binary mode and leave encoding
+    unspecified.) The available modes are:
 
     ========= ===============================================================
     Character Meaning
@@ -5422,7 +5436,6 @@ def open(
     'b'       binary mode
     't'       text mode (default)
     '+'       open a disk file for updating (reading and writing)
-    'U'       universal newline mode (deprecated)
     ========= ===============================================================
 
     The default mode is 'rt' (open for reading text). For binary random
@@ -5438,10 +5451,6 @@ def open(
     returned as strings, the bytes having been first decoded using a
     platform-dependent encoding or using the specified encoding if given.
 
-    'U' mode is deprecated and will raise an exception in future versions
-    of Python.  It has no effect in Python 3.  Use newline to control
-    universal newlines mode.
-
     buffering is an optional integer used to set the buffering policy.
     Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
     line buffering (only usable in text mode), and an integer > 1 to indicate
@@ -5542,9 +5551,9 @@ def open(
     'a' for appending (which on some Unix systems, means that all writes
     append to the end of the file regardless of the current seek position).
     In text mode, if encoding is not specified the encoding used is platform
-    dependent: locale.getpreferredencoding(False) is called to get the
-    current locale encoding. (For reading and writing raw bytes use binary
-    mode and leave encoding unspecified.) The available modes are:
+    dependent: locale.getencoding() is called to get the current locale encoding.
+    (For reading and writing raw bytes use binary mode and leave encoding
+    unspecified.) The available modes are:
 
     ========= ===============================================================
     Character Meaning
@@ -5556,7 +5565,6 @@ def open(
     'b'       binary mode
     't'       text mode (default)
     '+'       open a disk file for updating (reading and writing)
-    'U'       universal newline mode (deprecated)
     ========= ===============================================================
 
     The default mode is 'rt' (open for reading text). For binary random
@@ -5572,10 +5580,6 @@ def open(
     returned as strings, the bytes having been first decoded using a
     platform-dependent encoding or using the specified encoding if given.
 
-    'U' mode is deprecated and will raise an exception in future versions
-    of Python.  It has no effect in Python 3.  Use newline to control
-    universal newlines mode.
-
     buffering is an optional integer used to set the buffering policy.
     Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
     line buffering (only usable in text mode), and an integer > 1 to indicate
@@ -5661,30 +5665,34 @@ def print(
     file: SupportsWrite[str] | None = None,
     flush: Literal[False] = False,
 ) -> None:
-    r"""
-    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
-
+    """
     Prints the values to a stream, or to sys.stdout by default.
-    Optional keyword arguments:
-    file:  a file-like object (stream); defaults to the current sys.stdout.
-    sep:   string inserted between values, default a space.
-    end:   string appended after the last value, default a newline.
-    flush: whether to forcibly flush the stream.
+
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
     """
     ...
 @overload
 def print(
     *values: object, sep: str | None = " ", end: str | None = "\n", file: _SupportsWriteAndFlush[str] | None = None, flush: bool
 ) -> None:
-    r"""
-    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
-
+    """
     Prints the values to a stream, or to sys.stdout by default.
-    Optional keyword arguments:
-    file:  a file-like object (stream); defaults to the current sys.stdout.
-    sep:   string inserted between values, default a space.
-    end:   string appended after the last value, default a newline.
-    flush: whether to forcibly flush the stream.
+
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
     """
     ...
 
@@ -5909,7 +5917,7 @@ def setattr(obj: object, name: str, value: Any, /) -> None:
     """
     Sets the named attribute on the given object to the specified value.
 
-    setattr(x, 'y', v) is equivalent to ``x.y = v''
+    setattr(x, 'y', v) is equivalent to ``x.y = v``
     """
     ...
 @overload
@@ -5980,7 +5988,7 @@ def sum(iterable: Iterable[_AddableT1], /, start: _AddableT2) -> _AddableT1 | _A
 @overload
 def vars(object: type, /) -> types.MappingProxyType[str, Any]:
     """
-    vars([object]) -> dictionary
+    Show vars.
 
     Without arguments, equivalent to locals().
     With an argument, equivalent to object.__dict__.
@@ -5989,7 +5997,7 @@ def vars(object: type, /) -> types.MappingProxyType[str, Any]:
 @overload
 def vars(object: Any = ..., /) -> dict[str, Any]:
     """
-    vars([object]) -> dictionary
+    Show vars.
 
     Without arguments, equivalent to locals().
     With an argument, equivalent to object.__dict__.
@@ -5998,7 +6006,7 @@ def vars(object: Any = ..., /) -> dict[str, Any]:
 
 class zip(Iterator[_T_co]):
     """
-    zip(*iterables) --> A zip object yielding tuples until an input is exhausted.
+    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)]
@@ -6007,6 +6015,9 @@ class zip(Iterator[_T_co]):
     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
     shortest argument is exhausted.
+
+    If strict is true and one of the arguments is exhausted before the others,
+    raise a ValueError.
     """
     if sys.version_info >= (3, 10):
         @overload
@@ -6095,16 +6106,16 @@ def __import__(
     level: int = 0,
 ) -> types.ModuleType:
     """
-    __import__(name, globals=None, locals=None, fromlist=(), level=0) -> module
+    Import a module.
 
-    Import a module. Because this function is meant for use by the Python
+    Because this function is meant for use by the Python
     interpreter and not for general use, it is better to use
     importlib.import_module() to programmatically import a module.
 
     The globals argument is only used to determine the context;
     they are not modified.  The locals argument is unused.  The fromlist
-    should be a list of names to emulate ``from name import ...'', or an
-    empty list to emulate ``import name''.
+    should be a list of names to emulate ``from name import ...``, or an
+    empty list to emulate ``import name``.
     When importing a module from a package, note that __import__('A.B', ...)
     returns package A when fromlist is empty, but its submodule B when
     fromlist is not empty.  The level argument is used to determine whether to