Python 3.14.3v3.14.3

2 files changed, 192 insertions, 24 deletions

diff --git a/Lib/pydoc_data/module_docs.py b/Lib/pydoc_data/module_docs.py
index f6d84a6..2a6ede3 100644
--- a/Lib/pydoc_data/module_docs.py
+++ b/Lib/pydoc_data/module_docs.py
@@ -1,4 +1,4 @@
-# Autogenerated by Sphinx on Sun Oct 12 12:02:22 2025
+# Autogenerated by Sphinx on Tue Feb  3 17:32:13 2026
 # as part of the release process.
 
 module_docs = {
@@ -183,7 +183,6 @@ module_docs = {
     'posix': 'posix#module-posix',
     'pprint': 'pprint#module-pprint',
     'profile': 'profile#module-profile',
-    'profiling.sampling': 'profile#module-profiling.sampling',
     'pstats': 'profile#module-pstats',
     'pty': 'pty#module-pty',
     'pwd': 'pwd#module-pwd',
diff --git a/Lib/pydoc_data/topics.py b/Lib/pydoc_data/topics.py
index 56317b8..4e31cf0 100644
--- a/Lib/pydoc_data/topics.py
+++ b/Lib/pydoc_data/topics.py
@@ -1,4 +1,4 @@
-# Autogenerated by Sphinx on Fri Dec  5 18:49:09 2025
+# Autogenerated by Sphinx on Tue Feb  3 17:32:13 2026
 # as part of the release process.
 
 topics = {
@@ -2000,7 +2000,7 @@ ensures that the type of the target "e" is consistently
    ... except* BlockingIOError as e:
    ...     print(repr(e))
    ...
-   ExceptionGroup('', (BlockingIOError()))
+   ExceptionGroup('', (BlockingIOError(),))
 
 "break", "continue" and "return" cannot appear in an "except*" clause.
 
@@ -5796,7 +5796,9 @@ The available presentation types for "float" and "Decimal" values are:
    |           | With no precision given, uses a precision of "6" digits    |
    |           | after the decimal point for "float", and shows all         |
    |           | coefficient digits for "Decimal".  If "p=0", the decimal   |
-   |           | point is omitted unless the "#" option is used.            |
+   |           | point is omitted unless the "#" option is used.  For       |
+   |           | "float", the exponent always contains at least two digits, |
+   |           | and is zero if the value is zero.                          |
    +-----------+------------------------------------------------------------+
    | "'E'"     | Scientific notation. Same as "'e'" except it uses an upper |
    |           | case ‘E’ as the separator character.                       |
@@ -9830,7 +9832,12 @@ str.casefold()
    it is intended to remove all case distinctions in a string. For
    example, the German lowercase letter "'ß'" is equivalent to ""ss"".
    Since it is already lowercase, "lower()" would do nothing to "'ß'";
-   "casefold()" converts it to ""ss"".
+   "casefold()" converts it to ""ss"". For example:
+
+      >>> 'straße'.lower()
+      'straße'
+      >>> 'straße'.casefold()
+      'strasse'
 
    The casefolding algorithm is described in section 3.13 ‘Default
    Case Folding’ of the Unicode Standard.
@@ -10019,7 +10026,18 @@ str.format_map(mapping, /)
 str.index(sub[, start[, end]])
 
    Like "find()", but raise "ValueError" when the substring is not
-   found.
+   found. For example:
+
+      >>> 'spam, spam, spam'.index('spam')
+      0
+      >>> 'spam, spam, spam'.index('eggs')
+      Traceback (most recent call last):
+        File "<python-input-0>", line 1, in <module>
+          'spam, spam, spam'.index('eggs')
+          ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^
+      ValueError: substring not found
+
+   See also "rindex()".
 
 str.isalnum()
 
@@ -10118,7 +10136,19 @@ str.isnumeric()
    that have the Unicode numeric value property, e.g. U+2155, VULGAR
    FRACTION ONE FIFTH.  Formally, numeric characters are those with
    the property value Numeric_Type=Digit, Numeric_Type=Decimal or
-   Numeric_Type=Numeric.
+   Numeric_Type=Numeric. For example:
+
+      >>> '0123456789'.isnumeric()
+      True
+      >>> '٠١٢٣٤٥٦٧٨٩'.isnumeric()  # Arabic-indic digit zero to nine
+      True
+      >>> '⅕'.isnumeric()  # Vulgar fraction one fifth
+      True
+      >>> '²'.isdecimal(), '²'.isdigit(),  '²'.isnumeric()
+      (False, True, True)
+
+   See also "isdecimal()" and "isdigit()". Numeric characters are a
+   superset of decimal numbers.
 
 str.isprintable()
 
@@ -10136,6 +10166,13 @@ str.isprintable()
    plus the ASCII space 0x20. Nonprintable characters are those in
    group Separator or Other (Z or C), except the ASCII space.
 
+   For example:
+
+      >>> ''.isprintable(), ' '.isprintable()
+      (True, True)
+      >>> '\t'.isprintable(), '\n'.isprintable()
+      (False, False)
+
 str.isspace()
 
    Return "True" if there are only whitespace characters in the string
@@ -10201,10 +10238,24 @@ str.ljust(width, fillchar=' ', /)
    space). The original string is returned if *width* is less than or
    equal to "len(s)".
 
+   For example:
+
+      >>> 'Python'.ljust(10)
+      'Python    '
+      >>> 'Python'.ljust(10, '.')
+      'Python....'
+      >>> 'Monty Python'.ljust(10, '.')
+      'Monty Python'
+
+   See also "rjust()".
+
 str.lower()
 
    Return a copy of the string with all the cased characters [4]
-   converted to lowercase.
+   converted to lowercase. For example:
+
+      >>> 'Lower Method Example'.lower()
+      'lower method example'
 
    The lowercasing algorithm used is described in section 3.13
    ‘Default Case Folding’ of the Unicode Standard.
@@ -10268,6 +10319,8 @@ str.removeprefix(prefix, /)
 
    Added in version 3.9.
 
+   See also "removesuffix()" and "startswith()".
+
 str.removesuffix(suffix, /)
 
    If the string ends with the *suffix* string and that *suffix* is
@@ -10281,12 +10334,19 @@ str.removesuffix(suffix, /)
 
    Added in version 3.9.
 
+   See also "removeprefix()" and "endswith()".
+
 str.replace(old, new, /, count=-1)
 
    Return a copy of the string with all occurrences of substring *old*
    replaced by *new*.  If *count* is given, only the first *count*
    occurrences are replaced. If *count* is not specified or "-1", then
-   all occurrences are replaced.
+   all occurrences are replaced. For example:
+
+      >>> 'spam, spam, spam'.replace('spam', 'eggs')
+      'eggs, eggs, eggs'
+      >>> 'spam, spam, spam'.replace('spam', 'eggs', 1)
+      'eggs, spam, spam'
 
    Changed in version 3.13: *count* is now supported as a keyword
    argument.
@@ -10296,12 +10356,30 @@ str.rfind(sub[, start[, end]])
    Return the highest index in the string 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.
+   notation.  Return "-1" on failure. For example:
+
+      >>> 'spam, spam, spam'.rfind('sp')
+      12
+      >>> 'spam, spam, spam'.rfind('sp', 0, 10)
+      6
+
+   See also "find()" and "rindex()".
 
 str.rindex(sub[, start[, end]])
 
    Like "rfind()" but raises "ValueError" when the substring *sub* is
-   not found.
+   not found. For example:
+
+      >>> 'spam, spam, spam'.rindex('spam')
+      12
+      >>> 'spam, spam, spam'.rindex('eggs')
+      Traceback (most recent call last):
+        File "<stdin-0>", line 1, in <module>
+          'spam, spam, spam'.rindex('eggs')
+          ~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^
+      ValueError: substring not found
+
+   See also "index()" and "find()".
 
 str.rjust(width, fillchar=' ', /)
 
@@ -10318,6 +10396,17 @@ str.rpartition(sep, /)
    found, return a 3-tuple containing two empty strings, followed by
    the string itself.
 
+   For example:
+
+      >>> 'Monty Python'.rpartition(' ')
+      ('Monty', ' ', 'Python')
+      >>> "Monty Python's Flying Circus".rpartition(' ')
+      ("Monty Python's Flying", ' ', 'Circus')
+      >>> 'Monty Python'.rpartition('-')
+      ('', '', 'Monty Python')
+
+   See also "partition()".
+
 str.rsplit(sep=None, maxsplit=-1)
 
    Return a list of the words in the string, using *sep* as the
@@ -11088,7 +11177,7 @@ Whitespace is significant in these situations:
 
 * In "fstring_replacement_field", if "f_debug_specifier" is present,
   all whitespace after the opening brace until the
-  "f_debug_specifier", as well as whitespace immediatelly following
+  "f_debug_specifier", as well as whitespace immediately following
   "f_debug_specifier", is retained as part of the expression.
 
   **CPython implementation detail:** The expression is not handled in
@@ -11211,8 +11300,11 @@ Any object can be tested for truth value, for use in an "if" or
 
 By default, an object is considered true unless its class defines
 either a "__bool__()" method that returns "False" or a "__len__()"
-method that returns zero, when called with the object. [1]  Here are
-most of the built-in objects considered false:
+method that returns zero, when called with the object. [1] If one of
+the methods raises an exception when called, the exception is
+propagated and the object does not have a truth value (for example,
+"NotImplemented"). Here are most of the built-in objects considered
+false:
 
 * constants defined to be false: "None" and "False"
 
@@ -11393,7 +11485,7 @@ ensures that the type of the target "e" is consistently
    ... except* BlockingIOError as e:
    ...     print(repr(e))
    ...
-   ExceptionGroup('', (BlockingIOError()))
+   ExceptionGroup('', (BlockingIOError(),))
 
 "break", "continue" and "return" cannot appear in an "except*" clause.
 
@@ -11777,6 +11869,10 @@ Special read-only attributes
 +----------------------------------------------------+----------------------------------------------------+
 | Attribute                                          | Meaning                                            |
 |====================================================|====================================================|
+| function.__builtins__                              | A reference to the "dictionary" that holds the     |
+|                                                    | function’s builtins namespace.  Added in version   |
+|                                                    | 3.10.                                              |
++----------------------------------------------------+----------------------------------------------------+
 | function.__globals__                               | A reference to the "dictionary" that holds the     |
 |                                                    | function’s global variables – the global namespace |
 |                                                    | of the module in which the function was defined.   |
@@ -12871,10 +12967,6 @@ class dict(iterable, /, **kwargs)
    the keyword argument replaces the value from the positional
    argument.
 
-   Providing keyword arguments as in the first example only works for
-   keys that are valid Python identifiers.  Otherwise, any valid keys
-   can be used.
-
    Dictionaries compare equal if and only if they have the same "(key,
    value)" pairs (regardless of ordering). Order comparisons (‘<’,
    ‘<=’, ‘>=’, ‘>’) raise "TypeError".  To illustrate dictionary
@@ -13387,10 +13479,17 @@ Notes:
    note that "-0" is still "0".
 
 4. The slice of *s* from *i* to *j* is defined as the sequence of
-   items with index *k* such that "i <= k < j".  If *i* or *j* is
-   greater than "len(s)", use "len(s)".  If *i* is omitted or "None",
-   use "0".  If *j* is omitted or "None", use "len(s)".  If *i* is
-   greater than or equal to *j*, the slice is empty.
+   items with index *k* such that "i <= k < j".
+
+   * If *i* is omitted or "None", use "0".
+
+   * If *j* is omitted or "None", use "len(s)".
+
+   * If *i* or *j* is less than "-len(s)", use "0".
+
+   * If *i* or *j* is greater than "len(s)", use "len(s)".
+
+   * If *i* is greater than or equal to *j*, the slice is empty.
 
 5. The slice of *s* from *i* to *j* with step *k* is defined as the
    sequence of items with index  "x = i + n*k" such that "0 <= n <
@@ -13655,6 +13754,76 @@ class list(iterable=(), /)
       empty for the duration, and raises "ValueError" if it can detect
       that the list has been mutated during a sort.
 
+Thread safety: Reading a single element from a "list" is *atomic*:
+
+   lst[i]   # list.__getitem__
+
+The following methods traverse the list and use *atomic* reads of each
+item to perform their function. That means that they may return
+results affected by concurrent modifications:
+
+   item in lst
+   lst.index(item)
+   lst.count(item)
+
+All of the above methods/operations are also lock-free. They do not
+block concurrent modifications. Other operations that hold a lock will
+not block these from observing intermediate states.All other
+operations from here on block using the per-object lock.Writing a
+single item via "lst[i] = x" is safe to call from multiple threads and
+will not corrupt the list.The following operations return new objects
+and appear *atomic* to other threads:
+
+   lst1 + lst2    # concatenates two lists into a new list
+   x * lst        # repeats lst x times into a new list
+   lst.copy()     # returns a shallow copy of the list
+
+Methods that only operate on a single elements with no shifting
+required are *atomic*:
+
+   lst.append(x)  # append to the end of the list, no shifting required
+   lst.pop()      # pop element from the end of the list, no shifting required
+
+The "clear()" method is also *atomic*. Other threads cannot observe
+elements being removed.The "sort()" method is not *atomic*. Other
+threads cannot observe intermediate states during sorting, but the
+list appears empty for the duration of the sort.The following
+operations may allow lock-free operations to observe intermediate
+states since they modify multiple elements in place:
+
+   lst.insert(idx, item)  # shifts elements
+   lst.pop(idx)           # idx not at the end of the list, shifts elements
+   lst *= x               # copies elements in place
+
+The "remove()" method may allow concurrent modifications since element
+comparison may execute arbitrary Python code (via
+"__eq__()")."extend()" is safe to call from multiple threads.
+However, its guarantees depend on the iterable passed to it. If it is
+a "list", a "tuple", a "set", a "frozenset", a "dict" or a dictionary
+view object (but not their subclasses), the "extend" operation is safe
+from concurrent modifications to the iterable. Otherwise, an iterator
+is created which can be concurrently modified by another thread.  The
+same applies to inplace concatenation of a list with other iterables
+when using "lst += iterable".Similarly, assigning to a list slice with
+"lst[i:j] = iterable" is safe to call from multiple threads, but
+"iterable" is only locked when it is also a "list" (but not its
+subclasses).Operations that involve multiple accesses, as well as
+iteration, are never atomic. For example:
+
+   # NOT atomic: read-modify-write
+   lst[i] = lst[i] + 1
+
+   # NOT atomic: check-then-act
+   if lst:
+       item = lst.pop()
+
+   # NOT thread-safe: iteration while modifying
+   for item in lst:
+       process(item)  # another thread may modify lst
+
+Consider external synchronization when sharing "list" instances across
+threads.  See Python support for free threading for more information.
+
 
 Tuples
 ======