IGNIETFERRO-1816 Update Python 3 from 3.9.12 to 3.10.4

ref:9f96be6d02ee8044fdd6f124b799b270c20ce641

1 files changed, 1305 insertions, 320 deletions

diff --git a/contrib/tools/python3/src/Lib/pydoc_data/topics.py b/contrib/tools/python3/src/Lib/pydoc_data/topics.py
index 2546eb933b..76db0426df 100644
--- a/contrib/tools/python3/src/Lib/pydoc_data/topics.py
+++ b/contrib/tools/python3/src/Lib/pydoc_data/topics.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Autogenerated by Sphinx on Wed Mar 23 22:08:02 2022
+# Autogenerated by Sphinx on Wed Mar 23 20:11:40 2022
 topics = {'assert': 'The "assert" statement\n'
            '**********************\n'
            '\n'
@@ -433,11 +433,9 @@ topics = {'assert': 'The "assert" statement\n'
           '\n'
           'Execution of Python coroutines can be suspended and resumed at '
           'many\n'
-          'points (see *coroutine*).  Inside the body of a coroutine '
-          'function,\n'
-          '"await" and "async" identifiers become reserved keywords; "await"\n'
-          'expressions, "async for" and "async with" can only be used in\n'
-          'coroutine function bodies.\n'
+          'points (see *coroutine*). "await" expressions, "async for" and '
+          '"async\n'
+          'with" can only be used in the body of a coroutine function.\n'
           '\n'
           'Functions defined with "async def" syntax are always coroutine\n'
           'functions, even if they do not contain "await" or "async" '
@@ -453,6 +451,10 @@ topics = {'assert': 'The "assert" statement\n'
           '       do_stuff()\n'
           '       await some_coroutine()\n'
           '\n'
+          'Changed in version 3.7: "await" and "async" are now keywords;\n'
+          'previously they were only treated as such inside the body of a\n'
+          'coroutine function.\n'
+          '\n'
           '\n'
           'The "async for" statement\n'
           '=========================\n'
@@ -549,13 +551,65 @@ topics = {'assert': 'The "assert" statement\n'
           'exception.\n'
           '    That new exception causes the old one to be lost.\n'
           '\n'
-          '[2] A string literal appearing as the first statement in the '
+          '[2] In pattern matching, a sequence is defined as one of the\n'
+          '    following:\n'
+          '\n'
+          '       * a class that inherits from "collections.abc.Sequence"\n'
+          '\n'
+          '       * a Python class that has been registered as\n'
+          '         "collections.abc.Sequence"\n'
+          '\n'
+          '       * a builtin class that has its (CPython) '
+          '"Py_TPFLAGS_SEQUENCE"\n'
+          '         bit set\n'
+          '\n'
+          '       * a class that inherits from any of the above\n'
+          '\n'
+          '    The following standard library classes are sequences:\n'
+          '\n'
+          '       * "array.array"\n'
+          '\n'
+          '       * "collections.deque"\n'
+          '\n'
+          '       * "list"\n'
+          '\n'
+          '       * "memoryview"\n'
+          '\n'
+          '       * "range"\n'
+          '\n'
+          '       * "tuple"\n'
+          '\n'
+          '    Note:\n'
+          '\n'
+          '      Subject values of type "str", "bytes", and "bytearray" do '
+          'not\n'
+          '      match sequence patterns.\n'
+          '\n'
+          '[3] In pattern matching, a mapping is defined as one of the '
+          'following:\n'
+          '\n'
+          '       * a class that inherits from "collections.abc.Mapping"\n'
+          '\n'
+          '       * a Python class that has been registered as\n'
+          '         "collections.abc.Mapping"\n'
+          '\n'
+          '       * a builtin class that has its (CPython) '
+          '"Py_TPFLAGS_MAPPING"\n'
+          '         bit set\n'
+          '\n'
+          '       * a class that inherits from any of the above\n'
+          '\n'
+          '    The standard library classes "dict" and '
+          '"types.MappingProxyType"\n'
+          '    are mappings.\n'
+          '\n'
+          '[4] A string literal appearing as the first statement in the '
           'function\n'
           '    body is transformed into the function’s "__doc__" attribute '
           'and\n'
           '    therefore the function’s *docstring*.\n'
           '\n'
-          '[3] A string literal appearing as the first statement in the class\n'
+          '[5] A string literal appearing as the first statement in the class\n'
           '    body is transformed into the namespace’s "__doc__" item and\n'
           '    therefore the class’s *docstring*.\n',
  'atom-identifiers': 'Identifiers (Names)\n'
@@ -882,32 +936,6 @@ topics = {'assert': 'The "assert" statement\n'
                      '*instance* of the\n'
                      '   owner class.\n'
                      '\n'
-                     'object.__set_name__(self, owner, name)\n'
-                     '\n'
-                     '   Called at the time the owning class *owner* is '
-                     'created. The\n'
-                     '   descriptor has been assigned to *name*.\n'
-                     '\n'
-                     '   Note:\n'
-                     '\n'
-                     '     "__set_name__()" is only called implicitly as part '
-                     'of the "type"\n'
-                     '     constructor, so it will need to be called '
-                     'explicitly with the\n'
-                     '     appropriate parameters when a descriptor is added '
-                     'to a class\n'
-                     '     after initial creation:\n'
-                     '\n'
-                     '        class A:\n'
-                     '           pass\n'
-                     '        descr = custom_descriptor()\n'
-                     '        A.attr = descr\n'
-                     "        descr.__set_name__(A, 'attr')\n"
-                     '\n'
-                     '     See Creating the class object for more details.\n'
-                     '\n'
-                     '   New in version 3.6.\n'
-                     '\n'
                      'The attribute "__objclass__" is interpreted by the '
                      '"inspect" module as\n'
                      'specifying the class where this object was defined '
@@ -1736,7 +1764,7 @@ topics = {'assert': 'The "assert" statement\n'
           'original global namespace. (Usually, the suite contains mostly\n'
           'function definitions.)  When the class’s suite finishes execution, '
           'its\n'
-          'execution frame is discarded but its local namespace is saved. [3] '
+          'execution frame is discarded but its local namespace is saved. [5] '
           'A\n'
           'class object is then created using the inheritance list for the '
           'base\n'
@@ -2219,6 +2247,7 @@ topics = {'assert': 'The "assert" statement\n'
              '                     | for_stmt\n'
              '                     | try_stmt\n'
              '                     | with_stmt\n'
+             '                     | match_stmt\n'
              '                     | funcdef\n'
              '                     | classdef\n'
              '                     | async_with_stmt\n'
@@ -2356,33 +2385,6 @@ topics = {'assert': 'The "assert" statement\n'
              ':= a to b do"; e.g., "list(range(3))" returns the list "[0, 1, '
              '2]".\n'
              '\n'
-             'Note:\n'
-             '\n'
-             '  There is a subtlety when the sequence is being modified by the '
-             'loop\n'
-             '  (this can only occur for mutable sequences, e.g. lists).  An\n'
-             '  internal counter is used to keep track of which item is used '
-             'next,\n'
-             '  and this is incremented on each iteration.  When this counter '
-             'has\n'
-             '  reached the length of the sequence the loop terminates.  This '
-             'means\n'
-             '  that if the suite deletes the current (or a previous) item '
-             'from the\n'
-             '  sequence, the next item will be skipped (since it gets the '
-             'index of\n'
-             '  the current item which has already been treated).  Likewise, '
-             'if the\n'
-             '  suite inserts an item in the sequence before the current item, '
-             'the\n'
-             '  current item will be treated again the next time through the '
-             'loop.\n'
-             '  This can lead to nasty bugs that can be avoided by making a\n'
-             '  temporary copy using a slice of the whole sequence, e.g.,\n'
-             '\n'
-             '     for x in a[:]:\n'
-             '         if x < 0: a.remove(x)\n'
-             '\n'
              '\n'
              'The "try" statement\n'
              '===================\n'
@@ -2487,11 +2489,32 @@ topics = {'assert': 'The "assert" statement\n'
              '(see\n'
              'section The standard type hierarchy) identifying the point in '
              'the\n'
-             'program where the exception occurred.  "sys.exc_info()" values '
-             'are\n'
-             'restored to their previous values (before the call) when '
-             'returning\n'
-             'from a function that handled an exception.\n'
+             'program where the exception occurred.  The details about the '
+             'exception\n'
+             'accessed via "sys.exc_info()" are restored to their previous '
+             'values\n'
+             'when leaving an exception handler:\n'
+             '\n'
+             '   >>> print(sys.exc_info())\n'
+             '   (None, None, None)\n'
+             '   >>> try:\n'
+             '   ...     raise TypeError\n'
+             '   ... except:\n'
+             '   ...     print(sys.exc_info())\n'
+             '   ...     try:\n'
+             '   ...          raise ValueError\n'
+             '   ...     except:\n'
+             '   ...         print(sys.exc_info())\n'
+             '   ...     print(sys.exc_info())\n'
+             '   ...\n'
+             "   (<class 'TypeError'>, TypeError(), <traceback object at "
+             '0x10efad080>)\n'
+             "   (<class 'ValueError'>, ValueError(), <traceback object at "
+             '0x10efad040>)\n'
+             "   (<class 'TypeError'>, TypeError(), <traceback object at "
+             '0x10efad080>)\n'
+             '   >>> print(sys.exc_info())\n'
+             '   (None, None, None)\n'
              '\n'
              'The optional "else" clause is executed if the control flow '
              'leaves the\n'
@@ -2576,8 +2599,10 @@ topics = {'assert': 'The "assert" statement\n'
              'usage\n'
              'patterns to be encapsulated for convenient reuse.\n'
              '\n'
-             '   with_stmt ::= "with" with_item ("," with_item)* ":" suite\n'
-             '   with_item ::= expression ["as" target]\n'
+             '   with_stmt          ::= "with" ( "(" with_stmt_contents ","? '
+             '")" | with_stmt_contents ) ":" suite\n'
+             '   with_stmt_contents ::= with_item ("," with_item)*\n'
+             '   with_item          ::= expression ["as" target]\n'
              '\n'
              'The execution of the "with" statement with one “item” proceeds '
              'as\n'
@@ -2669,9 +2694,23 @@ topics = {'assert': 'The "assert" statement\n'
              '       with B() as b:\n'
              '           SUITE\n'
              '\n'
+             'You can also write multi-item context managers in multiple lines '
+             'if\n'
+             'the items are surrounded by parentheses. For example:\n'
+             '\n'
+             '   with (\n'
+             '       A() as a,\n'
+             '       B() as b,\n'
+             '   ):\n'
+             '       SUITE\n'
+             '\n'
              'Changed in version 3.1: Support for multiple context '
              'expressions.\n'
              '\n'
+             'Changed in version 3.10: Support for using grouping parentheses '
+             'to\n'
+             'break the statement in multiple lines.\n'
+             '\n'
              'See also:\n'
              '\n'
              '  **PEP 343** - The “with” statement\n'
@@ -2680,6 +2719,746 @@ topics = {'assert': 'The "assert" statement\n'
              '     statement.\n'
              '\n'
              '\n'
+             'The "match" statement\n'
+             '=====================\n'
+             '\n'
+             'New in version 3.10.\n'
+             '\n'
+             'The match statement is used for pattern matching.  Syntax:\n'
+             '\n'
+             '   match_stmt   ::= \'match\' subject_expr ":" NEWLINE INDENT '
+             'case_block+ DEDENT\n'
+             '   subject_expr ::= star_named_expression "," '
+             'star_named_expressions?\n'
+             '                    | named_expression\n'
+             '   case_block   ::= \'case\' patterns [guard] ":" block\n'
+             '\n'
+             'Note:\n'
+             '\n'
+             '  This section uses single quotes to denote soft keywords.\n'
+             '\n'
+             'Pattern matching takes a pattern as input (following "case") and '
+             'a\n'
+             'subject value (following "match").  The pattern (which may '
+             'contain\n'
+             'subpatterns) is matched against the subject value.  The outcomes '
+             'are:\n'
+             '\n'
+             '* A match success or failure (also termed a pattern success or\n'
+             '  failure).\n'
+             '\n'
+             '* Possible binding of matched values to a name.  The '
+             'prerequisites for\n'
+             '  this are further discussed below.\n'
+             '\n'
+             'The "match" and "case" keywords are soft keywords.\n'
+             '\n'
+             'See also:\n'
+             '\n'
+             '  * **PEP 634** – Structural Pattern Matching: Specification\n'
+             '\n'
+             '  * **PEP 636** – Structural Pattern Matching: Tutorial\n'
+             '\n'
+             '\n'
+             'Overview\n'
+             '--------\n'
+             '\n'
+             'Here’s an overview of the logical flow of a match statement:\n'
+             '\n'
+             '1. The subject expression "subject_expr" is evaluated and a '
+             'resulting\n'
+             '   subject value obtained. If the subject expression contains a '
+             'comma,\n'
+             '   a tuple is constructed using the standard rules.\n'
+             '\n'
+             '2. Each pattern in a "case_block" is attempted to match with '
+             'the\n'
+             '   subject value. The specific rules for success or failure are\n'
+             '   described below. The match attempt can also bind some or all '
+             'of the\n'
+             '   standalone names within the pattern. The precise pattern '
+             'binding\n'
+             '   rules vary per pattern type and are specified below.  **Name\n'
+             '   bindings made during a successful pattern match outlive the\n'
+             '   executed block and can be used after the match statement**.\n'
+             '\n'
+             '      Note:\n'
+             '\n'
+             '        During failed pattern matches, some subpatterns may '
+             'succeed.\n'
+             '        Do not rely on bindings being made for a failed match.\n'
+             '        Conversely, do not rely on variables remaining unchanged '
+             'after\n'
+             '        a failed match.  The exact behavior is dependent on\n'
+             '        implementation and may vary.  This is an intentional '
+             'decision\n'
+             '        made to allow different implementations to add '
+             'optimizations.\n'
+             '\n'
+             '3. If the pattern succeeds, the corresponding guard (if present) '
+             'is\n'
+             '   evaluated. In this case all name bindings are guaranteed to '
+             'have\n'
+             '   happened.\n'
+             '\n'
+             '   * If the guard evaluates as true or is missing, the "block" '
+             'inside\n'
+             '     "case_block" is executed.\n'
+             '\n'
+             '   * Otherwise, the next "case_block" is attempted as described '
+             'above.\n'
+             '\n'
+             '   * If there are no further case blocks, the match statement '
+             'is\n'
+             '     completed.\n'
+             '\n'
+             'Note:\n'
+             '\n'
+             '  Users should generally never rely on a pattern being '
+             'evaluated.\n'
+             '  Depending on implementation, the interpreter may cache values '
+             'or use\n'
+             '  other optimizations which skip repeated evaluations.\n'
+             '\n'
+             'A sample match statement:\n'
+             '\n'
+             '   >>> flag = False\n'
+             '   >>> match (100, 200):\n'
+             '   ...    case (100, 300):  # Mismatch: 200 != 300\n'
+             "   ...        print('Case 1')\n"
+             '   ...    case (100, 200) if flag:  # Successful match, but '
+             'guard fails\n'
+             "   ...        print('Case 2')\n"
+             '   ...    case (100, y):  # Matches and binds y to 200\n'
+             "   ...        print(f'Case 3, y: {y}')\n"
+             '   ...    case _:  # Pattern not attempted\n'
+             "   ...        print('Case 4, I match anything!')\n"
+             '   ...\n'
+             '   Case 3, y: 200\n'
+             '\n'
+             'In this case, "if flag" is a guard.  Read more about that in the '
+             'next\n'
+             'section.\n'
+             '\n'
+             '\n'
+             'Guards\n'
+             '------\n'
+             '\n'
+             '   guard ::= "if" named_expression\n'
+             '\n'
+             'A "guard" (which is part of the "case") must succeed for code '
+             'inside\n'
+             'the "case" block to execute.  It takes the form: "if" followed '
+             'by an\n'
+             'expression.\n'
+             '\n'
+             'The logical flow of a "case" block with a "guard" follows:\n'
+             '\n'
+             '1. Check that the pattern in the "case" block succeeded.  If '
+             'the\n'
+             '   pattern failed, the "guard" is not evaluated and the next '
+             '"case"\n'
+             '   block is checked.\n'
+             '\n'
+             '2. If the pattern succeeded, evaluate the "guard".\n'
+             '\n'
+             '   * If the "guard" condition evaluates as true, the case block '
+             'is\n'
+             '     selected.\n'
+             '\n'
+             '   * If the "guard" condition evaluates as false, the case block '
+             'is\n'
+             '     not selected.\n'
+             '\n'
+             '   * If the "guard" raises an exception during evaluation, the\n'
+             '     exception bubbles up.\n'
+             '\n'
+             'Guards are allowed to have side effects as they are '
+             'expressions.\n'
+             'Guard evaluation must proceed from the first to the last case '
+             'block,\n'
+             'one at a time, skipping case blocks whose pattern(s) don’t all\n'
+             'succeed. (I.e., guard evaluation must happen in order.) Guard\n'
+             'evaluation must stop once a case block is selected.\n'
+             '\n'
+             '\n'
+             'Irrefutable Case Blocks\n'
+             '-----------------------\n'
+             '\n'
+             'An irrefutable case block is a match-all case block.  A match\n'
+             'statement may have at most one irrefutable case block, and it '
+             'must be\n'
+             'last.\n'
+             '\n'
+             'A case block is considered irrefutable if it has no guard and '
+             'its\n'
+             'pattern is irrefutable.  A pattern is considered irrefutable if '
+             'we can\n'
+             'prove from its syntax alone that it will always succeed.  Only '
+             'the\n'
+             'following patterns are irrefutable:\n'
+             '\n'
+             '* AS Patterns whose left-hand side is irrefutable\n'
+             '\n'
+             '* OR Patterns containing at least one irrefutable pattern\n'
+             '\n'
+             '* Capture Patterns\n'
+             '\n'
+             '* Wildcard Patterns\n'
+             '\n'
+             '* parenthesized irrefutable patterns\n'
+             '\n'
+             '\n'
+             'Patterns\n'
+             '--------\n'
+             '\n'
+             'Note:\n'
+             '\n'
+             '  This section uses grammar notations beyond standard EBNF:\n'
+             '\n'
+             '  * the notation "SEP.RULE+" is shorthand for "RULE (SEP '
+             'RULE)*"\n'
+             '\n'
+             '  * the notation "!RULE" is shorthand for a negative lookahead\n'
+             '    assertion\n'
+             '\n'
+             'The top-level syntax for "patterns" is:\n'
+             '\n'
+             '   patterns       ::= open_sequence_pattern | pattern\n'
+             '   pattern        ::= as_pattern | or_pattern\n'
+             '   closed_pattern ::= | literal_pattern\n'
+             '                      | capture_pattern\n'
+             '                      | wildcard_pattern\n'
+             '                      | value_pattern\n'
+             '                      | group_pattern\n'
+             '                      | sequence_pattern\n'
+             '                      | mapping_pattern\n'
+             '                      | class_pattern\n'
+             '\n'
+             'The descriptions below will include a description “in simple '
+             'terms” of\n'
+             'what a pattern does for illustration purposes (credits to '
+             'Raymond\n'
+             'Hettinger for a document that inspired most of the '
+             'descriptions). Note\n'
+             'that these descriptions are purely for illustration purposes and '
+             '**may\n'
+             'not** reflect the underlying implementation.  Furthermore, they '
+             'do not\n'
+             'cover all valid forms.\n'
+             '\n'
+             '\n'
+             'OR Patterns\n'
+             '~~~~~~~~~~~\n'
+             '\n'
+             'An OR pattern is two or more patterns separated by vertical bars '
+             '"|".\n'
+             'Syntax:\n'
+             '\n'
+             '   or_pattern ::= "|".closed_pattern+\n'
+             '\n'
+             'Only the final subpattern may be irrefutable, and each '
+             'subpattern must\n'
+             'bind the same set of names to avoid ambiguity.\n'
+             '\n'
+             'An OR pattern matches each of its subpatterns in turn to the '
+             'subject\n'
+             'value, until one succeeds.  The OR pattern is then considered\n'
+             'successful.  Otherwise, if none of the subpatterns succeed, the '
+             'OR\n'
+             'pattern fails.\n'
+             '\n'
+             'In simple terms, "P1 | P2 | ..." will try to match "P1", if it '
+             'fails\n'
+             'it will try to match "P2", succeeding immediately if any '
+             'succeeds,\n'
+             'failing otherwise.\n'
+             '\n'
+             '\n'
+             'AS Patterns\n'
+             '~~~~~~~~~~~\n'
+             '\n'
+             'An AS pattern matches an OR pattern on the left of the "as" '
+             'keyword\n'
+             'against a subject.  Syntax:\n'
+             '\n'
+             '   as_pattern ::= or_pattern "as" capture_pattern\n'
+             '\n'
+             'If the OR pattern fails, the AS pattern fails.  Otherwise, the '
+             'AS\n'
+             'pattern binds the subject to the name on the right of the as '
+             'keyword\n'
+             'and succeeds. "capture_pattern" cannot be a a "_".\n'
+             '\n'
+             'In simple terms "P as NAME" will match with "P", and on success '
+             'it\n'
+             'will set "NAME = <subject>".\n'
+             '\n'
+             '\n'
+             'Literal Patterns\n'
+             '~~~~~~~~~~~~~~~~\n'
+             '\n'
+             'A literal pattern corresponds to most literals in Python.  '
+             'Syntax:\n'
+             '\n'
+             '   literal_pattern ::= signed_number\n'
+             '                       | signed_number "+" NUMBER\n'
+             '                       | signed_number "-" NUMBER\n'
+             '                       | strings\n'
+             '                       | "None"\n'
+             '                       | "True"\n'
+             '                       | "False"\n'
+             '                       | signed_number: NUMBER | "-" NUMBER\n'
+             '\n'
+             'The rule "strings" and the token "NUMBER" are defined in the '
+             'standard\n'
+             'Python grammar.  Triple-quoted strings are supported.  Raw '
+             'strings and\n'
+             'byte strings are supported.  Formatted string literals are not\n'
+             'supported.\n'
+             '\n'
+             'The forms "signed_number \'+\' NUMBER" and "signed_number \'-\' '
+             'NUMBER"\n'
+             'are for expressing complex numbers; they require a real number '
+             'on the\n'
+             'left and an imaginary number on the right. E.g. "3 + 4j".\n'
+             '\n'
+             'In simple terms, "LITERAL" will succeed only if "<subject> ==\n'
+             'LITERAL". For the singletons "None", "True" and "False", the '
+             '"is"\n'
+             'operator is used.\n'
+             '\n'
+             '\n'
+             'Capture Patterns\n'
+             '~~~~~~~~~~~~~~~~\n'
+             '\n'
+             'A capture pattern binds the subject value to a name. Syntax:\n'
+             '\n'
+             "   capture_pattern ::= !'_' NAME\n"
+             '\n'
+             'A single underscore "_" is not a capture pattern (this is what '
+             '"!\'_\'"\n'
+             'expresses). It is instead treated as a "wildcard_pattern".\n'
+             '\n'
+             'In a given pattern, a given name can only be bound once.  E.g. '
+             '"case\n'
+             'x, x: ..." is invalid while "case [x] | x: ..." is allowed.\n'
+             '\n'
+             'Capture patterns always succeed.  The binding follows scoping '
+             'rules\n'
+             'established by the assignment expression operator in **PEP '
+             '572**; the\n'
+             'name becomes a local variable in the closest containing function '
+             'scope\n'
+             'unless there’s an applicable "global" or "nonlocal" statement.\n'
+             '\n'
+             'In simple terms "NAME" will always succeed and it will set "NAME '
+             '=\n'
+             '<subject>".\n'
+             '\n'
+             '\n'
+             'Wildcard Patterns\n'
+             '~~~~~~~~~~~~~~~~~\n'
+             '\n'
+             'A wildcard pattern always succeeds (matches anything) and binds '
+             'no\n'
+             'name.  Syntax:\n'
+             '\n'
+             "   wildcard_pattern ::= '_'\n"
+             '\n'
+             '"_" is a soft keyword within any pattern, but only within '
+             'patterns.\n'
+             'It is an identifier, as usual, even within "match" subject\n'
+             'expressions, "guard"s, and "case" blocks.\n'
+             '\n'
+             'In simple terms, "_" will always succeed.\n'
+             '\n'
+             '\n'
+             'Value Patterns\n'
+             '~~~~~~~~~~~~~~\n'
+             '\n'
+             'A value pattern represents a named value in Python. Syntax:\n'
+             '\n'
+             '   value_pattern ::= attr\n'
+             '   attr          ::= name_or_attr "." NAME\n'
+             '   name_or_attr  ::= attr | NAME\n'
+             '\n'
+             'The dotted name in the pattern is looked up using standard '
+             'Python name\n'
+             'resolution rules.  The pattern succeeds if the value found '
+             'compares\n'
+             'equal to the subject value (using the "==" equality operator).\n'
+             '\n'
+             'In simple terms "NAME1.NAME2" will succeed only if "<subject> '
+             '==\n'
+             'NAME1.NAME2"\n'
+             '\n'
+             'Note:\n'
+             '\n'
+             '  If the same value occurs multiple times in the same match '
+             'statement,\n'
+             '  the interpreter may cache the first value found and reuse it '
+             'rather\n'
+             '  than repeat the same lookup.  This cache is strictly tied to a '
+             'given\n'
+             '  execution of a given match statement.\n'
+             '\n'
+             '\n'
+             'Group Patterns\n'
+             '~~~~~~~~~~~~~~\n'
+             '\n'
+             'A group pattern allows users to add parentheses around patterns '
+             'to\n'
+             'emphasize the intended grouping.  Otherwise, it has no '
+             'additional\n'
+             'syntax. Syntax:\n'
+             '\n'
+             '   group_pattern ::= "(" pattern ")"\n'
+             '\n'
+             'In simple terms "(P)" has the same effect as "P".\n'
+             '\n'
+             '\n'
+             'Sequence Patterns\n'
+             '~~~~~~~~~~~~~~~~~\n'
+             '\n'
+             'A sequence pattern contains several subpatterns to be matched '
+             'against\n'
+             'sequence elements. The syntax is similar to the unpacking of a '
+             'list or\n'
+             'tuple.\n'
+             '\n'
+             '   sequence_pattern       ::= "[" [maybe_sequence_pattern] "]"\n'
+             '                        | "(" [open_sequence_pattern] ")"\n'
+             '   open_sequence_pattern  ::= maybe_star_pattern "," '
+             '[maybe_sequence_pattern]\n'
+             '   maybe_sequence_pattern ::= ",".maybe_star_pattern+ ","?\n'
+             '   maybe_star_pattern     ::= star_pattern | pattern\n'
+             '   star_pattern           ::= "*" (capture_pattern | '
+             'wildcard_pattern)\n'
+             '\n'
+             'There is no difference if parentheses  or square brackets are '
+             'used for\n'
+             'sequence patterns (i.e. "(...)" vs "[...]" ).\n'
+             '\n'
+             'Note:\n'
+             '\n'
+             '  A single pattern enclosed in parentheses without a trailing '
+             'comma\n'
+             '  (e.g. "(3 | 4)") is a group pattern. While a single pattern '
+             'enclosed\n'
+             '  in square brackets (e.g. "[3 | 4]") is still a sequence '
+             'pattern.\n'
+             '\n'
+             'At most one star subpattern may be in a sequence pattern.  The '
+             'star\n'
+             'subpattern may occur in any position. If no star subpattern is\n'
+             'present, the sequence pattern is a fixed-length sequence '
+             'pattern;\n'
+             'otherwise it is a variable-length sequence pattern.\n'
+             '\n'
+             'The following is the logical flow for matching a sequence '
+             'pattern\n'
+             'against a subject value:\n'
+             '\n'
+             '1. If the subject value is not a sequence [2], the sequence '
+             'pattern\n'
+             '   fails.\n'
+             '\n'
+             '2. If the subject value is an instance of "str", "bytes" or\n'
+             '   "bytearray" the sequence pattern fails.\n'
+             '\n'
+             '3. The subsequent steps depend on whether the sequence pattern '
+             'is\n'
+             '   fixed or variable-length.\n'
+             '\n'
+             '   If the sequence pattern is fixed-length:\n'
+             '\n'
+             '   1. If the length of the subject sequence is not equal to the '
+             'number\n'
+             '      of subpatterns, the sequence pattern fails\n'
+             '\n'
+             '   2. Subpatterns in the sequence pattern are matched to their\n'
+             '      corresponding items in the subject sequence from left to '
+             'right.\n'
+             '      Matching stops as soon as a subpattern fails.  If all\n'
+             '      subpatterns succeed in matching their corresponding item, '
+             'the\n'
+             '      sequence pattern succeeds.\n'
+             '\n'
+             '   Otherwise, if the sequence pattern is variable-length:\n'
+             '\n'
+             '   1. If the length of the subject sequence is less than the '
+             'number of\n'
+             '      non-star subpatterns, the sequence pattern fails.\n'
+             '\n'
+             '   2. The leading non-star subpatterns are matched to their\n'
+             '      corresponding items as for fixed-length sequences.\n'
+             '\n'
+             '   3. If the previous step succeeds, the star subpattern matches '
+             'a\n'
+             '      list formed of the remaining subject items, excluding the\n'
+             '      remaining items corresponding to non-star subpatterns '
+             'following\n'
+             '      the star subpattern.\n'
+             '\n'
+             '   4. Remaining non-star subpatterns are matched to their\n'
+             '      corresponding subject items, as for a fixed-length '
+             'sequence.\n'
+             '\n'
+             '   Note:\n'
+             '\n'
+             '     The length of the subject sequence is obtained via "len()" '
+             '(i.e.\n'
+             '     via the "__len__()" protocol).  This length may be cached '
+             'by the\n'
+             '     interpreter in a similar manner as value patterns.\n'
+             '\n'
+             'In simple terms "[P1, P2, P3," … ", P<N>]" matches only if all '
+             'the\n'
+             'following happens:\n'
+             '\n'
+             '* check "<subject>" is a sequence\n'
+             '\n'
+             '* "len(subject) == <N>"\n'
+             '\n'
+             '* "P1" matches "<subject>[0]" (note that this match can also '
+             'bind\n'
+             '  names)\n'
+             '\n'
+             '* "P2" matches "<subject>[1]" (note that this match can also '
+             'bind\n'
+             '  names)\n'
+             '\n'
+             '* … and so on for the corresponding pattern/element.\n'
+             '\n'
+             '\n'
+             'Mapping Patterns\n'
+             '~~~~~~~~~~~~~~~~\n'
+             '\n'
+             'A mapping pattern contains one or more key-value patterns.  The '
+             'syntax\n'
+             'is similar to the construction of a dictionary. Syntax:\n'
+             '\n'
+             '   mapping_pattern     ::= "{" [items_pattern] "}"\n'
+             '   items_pattern       ::= ",".key_value_pattern+ ","?\n'
+             '   key_value_pattern   ::= (literal_pattern | value_pattern) ":" '
+             'pattern\n'
+             '                         | double_star_pattern\n'
+             '   double_star_pattern ::= "**" capture_pattern\n'
+             '\n'
+             'At most one double star pattern may be in a mapping pattern.  '
+             'The\n'
+             'double star pattern must be the last subpattern in the mapping\n'
+             'pattern.\n'
+             '\n'
+             'Duplicate keys in mapping patterns are disallowed. Duplicate '
+             'literal\n'
+             'keys will raise a "SyntaxError". Two keys that otherwise have '
+             'the same\n'
+             'value will raise a "ValueError" at runtime.\n'
+             '\n'
+             'The following is the logical flow for matching a mapping '
+             'pattern\n'
+             'against a subject value:\n'
+             '\n'
+             '1. If the subject value is not a mapping [3],the mapping '
+             'pattern\n'
+             '   fails.\n'
+             '\n'
+             '2. If every key given in the mapping pattern is present in the '
+             'subject\n'
+             '   mapping, and the pattern for each key matches the '
+             'corresponding\n'
+             '   item of the subject mapping, the mapping pattern succeeds.\n'
+             '\n'
+             '3. If duplicate keys are detected in the mapping pattern, the '
+             'pattern\n'
+             '   is considered invalid. A "SyntaxError" is raised for '
+             'duplicate\n'
+             '   literal values; or a "ValueError" for named keys of the same '
+             'value.\n'
+             '\n'
+             'Note:\n'
+             '\n'
+             '  Key-value pairs are matched using the two-argument form of '
+             'the\n'
+             '  mapping subject’s "get()" method.  Matched key-value pairs '
+             'must\n'
+             '  already be present in the mapping, and not created on-the-fly '
+             'via\n'
+             '  "__missing__()" or "__getitem__()".\n'
+             '\n'
+             'In simple terms "{KEY1: P1, KEY2: P2, ... }" matches only if all '
+             'the\n'
+             'following happens:\n'
+             '\n'
+             '* check "<subject>" is a mapping\n'
+             '\n'
+             '* "KEY1 in <subject>"\n'
+             '\n'
+             '* "P1" matches "<subject>[KEY1]"\n'
+             '\n'
+             '* … and so on for the corresponding KEY/pattern pair.\n'
+             '\n'
+             '\n'
+             'Class Patterns\n'
+             '~~~~~~~~~~~~~~\n'
+             '\n'
+             'A class pattern represents a class and its positional and '
+             'keyword\n'
+             'arguments (if any).  Syntax:\n'
+             '\n'
+             '   class_pattern       ::= name_or_attr "(" [pattern_arguments '
+             '","?] ")"\n'
+             '   pattern_arguments   ::= positional_patterns ["," '
+             'keyword_patterns]\n'
+             '                         | keyword_patterns\n'
+             '   positional_patterns ::= ",".pattern+\n'
+             '   keyword_patterns    ::= ",".keyword_pattern+\n'
+             '   keyword_pattern     ::= NAME "=" pattern\n'
+             '\n'
+             'The same keyword should not be repeated in class patterns.\n'
+             '\n'
+             'The following is the logical flow for matching a class pattern '
+             'against\n'
+             'a subject value:\n'
+             '\n'
+             '1. If "name_or_attr" is not an instance of the builtin "type" , '
+             'raise\n'
+             '   "TypeError".\n'
+             '\n'
+             '2. If the subject value is not an instance of "name_or_attr" '
+             '(tested\n'
+             '   via "isinstance()"), the class pattern fails.\n'
+             '\n'
+             '3. If no pattern arguments are present, the pattern succeeds.\n'
+             '   Otherwise, the subsequent steps depend on whether keyword or\n'
+             '   positional argument patterns are present.\n'
+             '\n'
+             '   For a number of built-in types (specified below), a single\n'
+             '   positional subpattern is accepted which will match the '
+             'entire\n'
+             '   subject; for these types keyword patterns also work as for '
+             'other\n'
+             '   types.\n'
+             '\n'
+             '   If only keyword patterns are present, they are processed as\n'
+             '   follows, one by one:\n'
+             '\n'
+             '   I. The keyword is looked up as an attribute on the subject.\n'
+             '\n'
+             '      * If this raises an exception other than "AttributeError", '
+             'the\n'
+             '        exception bubbles up.\n'
+             '\n'
+             '      * If this raises "AttributeError", the class pattern has '
+             'failed.\n'
+             '\n'
+             '      * Else, the subpattern associated with the keyword pattern '
+             'is\n'
+             '        matched against the subject’s attribute value.  If this '
+             'fails,\n'
+             '        the class pattern fails; if this succeeds, the match '
+             'proceeds\n'
+             '        to the next keyword.\n'
+             '\n'
+             '   II. If all keyword patterns succeed, the class pattern '
+             'succeeds.\n'
+             '\n'
+             '   If any positional patterns are present, they are converted '
+             'to\n'
+             '   keyword patterns using the "__match_args__" attribute on the '
+             'class\n'
+             '   "name_or_attr" before matching:\n'
+             '\n'
+             '   I. The equivalent of "getattr(cls, "__match_args__", ())" is\n'
+             '   called.\n'
+             '\n'
+             '      * If this raises an exception, the exception bubbles up.\n'
+             '\n'
+             '      * If the returned value is not a tuple, the conversion '
+             'fails and\n'
+             '        "TypeError" is raised.\n'
+             '\n'
+             '      * If there are more positional patterns than\n'
+             '        "len(cls.__match_args__)", "TypeError" is raised.\n'
+             '\n'
+             '      * Otherwise, positional pattern "i" is converted to a '
+             'keyword\n'
+             '        pattern using "__match_args__[i]" as the keyword.\n'
+             '        "__match_args__[i]" must be a string; if not "TypeError" '
+             'is\n'
+             '        raised.\n'
+             '\n'
+             '      * If there are duplicate keywords, "TypeError" is raised.\n'
+             '\n'
+             '      See also:\n'
+             '\n'
+             '        Customizing positional arguments in class pattern '
+             'matching\n'
+             '\n'
+             '   II. Once all positional patterns have been converted to '
+             'keyword\n'
+             '   patterns,\n'
+             '      the match proceeds as if there were only keyword '
+             'patterns.\n'
+             '\n'
+             '   For the following built-in types the handling of positional\n'
+             '   subpatterns is different:\n'
+             '\n'
+             '   * "bool"\n'
+             '\n'
+             '   * "bytearray"\n'
+             '\n'
+             '   * "bytes"\n'
+             '\n'
+             '   * "dict"\n'
+             '\n'
+             '   * "float"\n'
+             '\n'
+             '   * "frozenset"\n'
+             '\n'
+             '   * "int"\n'
+             '\n'
+             '   * "list"\n'
+             '\n'
+             '   * "set"\n'
+             '\n'
+             '   * "str"\n'
+             '\n'
+             '   * "tuple"\n'
+             '\n'
+             '   These classes accept a single positional argument, and the '
+             'pattern\n'
+             '   there is matched against the whole object rather than an '
+             'attribute.\n'
+             '   For example "int(0|1)" matches the value "0", but not the '
+             'values\n'
+             '   "0.0" or "False".\n'
+             '\n'
+             'In simple terms "CLS(P1, attr=P2)" matches only if the '
+             'following\n'
+             'happens:\n'
+             '\n'
+             '* "isinstance(<subject>, CLS)"\n'
+             '\n'
+             '* convert "P1" to a keyword pattern using "CLS.__match_args__"\n'
+             '\n'
+             '* For each keyword argument "attr=P2":\n'
+             '     * "hasattr(<subject>, "attr")"\n'
+             '\n'
+             '     * "P2" matches "<subject>.attr"\n'
+             '\n'
+             '* … and so on for the corresponding keyword argument/pattern '
+             'pair.\n'
+             '\n'
+             'See also:\n'
+             '\n'
+             '  * **PEP 634** – Structural Pattern Matching: Specification\n'
+             '\n'
+             '  * **PEP 636** – Structural Pattern Matching: Tutorial\n'
+             '\n'
+             '\n'
              'Function definitions\n'
              '====================\n'
              '\n'
@@ -2717,7 +3496,7 @@ topics = {'assert': 'The "assert" statement\n'
              '\n'
              'The function definition does not execute the function body; this '
              'gets\n'
-             'executed only when the function is called. [2]\n'
+             'executed only when the function is called. [4]\n'
              '\n'
              'A function definition may be wrapped by one or more *decorator*\n'
              'expressions. Decorator expressions are evaluated when the '
@@ -2770,17 +3549,17 @@ topics = {'assert': 'The "assert" statement\n'
              '“pre-\n'
              'computed” value is used for each call.  This is especially '
              'important\n'
-             'to understand when a default parameter is a mutable object, such '
-             'as a\n'
-             'list or a dictionary: if the function modifies the object (e.g. '
-             'by\n'
-             'appending an item to a list), the default value is in effect '
-             'modified.\n'
-             'This is generally not what was intended.  A way around this is '
-             'to use\n'
-             '"None" as the default, and explicitly test for it in the body of '
-             'the\n'
-             'function, e.g.:\n'
+             'to understand when a default parameter value is a mutable '
+             'object, such\n'
+             'as a list or a dictionary: if the function modifies the object '
+             '(e.g.\n'
+             'by appending an item to a list), the default parameter value is '
+             'in\n'
+             'effect modified.  This is generally not what was intended.  A '
+             'way\n'
+             'around this is to use "None" as the default, and explicitly test '
+             'for\n'
+             'it in the body of the function, e.g.:\n'
              '\n'
              '   def whats_on_the_telly(penguin=None):\n'
              '       if penguin is None:\n'
@@ -2922,7 +3701,7 @@ topics = {'assert': 'The "assert" statement\n'
              'function definitions.)  When the class’s suite finishes '
              'execution, its\n'
              'execution frame is discarded but its local namespace is saved. '
-             '[3] A\n'
+             '[5] A\n'
              'class object is then created using the inheritance list for the '
              'base\n'
              'classes and the saved local namespace for the attribute '
@@ -3007,12 +3786,9 @@ topics = {'assert': 'The "assert" statement\n'
              '\n'
              'Execution of Python coroutines can be suspended and resumed at '
              'many\n'
-             'points (see *coroutine*).  Inside the body of a coroutine '
-             'function,\n'
-             '"await" and "async" identifiers become reserved keywords; '
-             '"await"\n'
-             'expressions, "async for" and "async with" can only be used in\n'
-             'coroutine function bodies.\n'
+             'points (see *coroutine*). "await" expressions, "async for" and '
+             '"async\n'
+             'with" can only be used in the body of a coroutine function.\n'
              '\n'
              'Functions defined with "async def" syntax are always coroutine\n'
              'functions, even if they do not contain "await" or "async" '
@@ -3028,6 +3804,10 @@ topics = {'assert': 'The "assert" statement\n'
              '       do_stuff()\n'
              '       await some_coroutine()\n'
              '\n'
+             'Changed in version 3.7: "await" and "async" are now keywords;\n'
+             'previously they were only treated as such inside the body of a\n'
+             'coroutine function.\n'
+             '\n'
              '\n'
              'The "async for" statement\n'
              '-------------------------\n'
@@ -3125,13 +3905,65 @@ topics = {'assert': 'The "assert" statement\n'
              'exception.\n'
              '    That new exception causes the old one to be lost.\n'
              '\n'
-             '[2] A string literal appearing as the first statement in the '
+             '[2] In pattern matching, a sequence is defined as one of the\n'
+             '    following:\n'
+             '\n'
+             '       * a class that inherits from "collections.abc.Sequence"\n'
+             '\n'
+             '       * a Python class that has been registered as\n'
+             '         "collections.abc.Sequence"\n'
+             '\n'
+             '       * a builtin class that has its (CPython) '
+             '"Py_TPFLAGS_SEQUENCE"\n'
+             '         bit set\n'
+             '\n'
+             '       * a class that inherits from any of the above\n'
+             '\n'
+             '    The following standard library classes are sequences:\n'
+             '\n'
+             '       * "array.array"\n'
+             '\n'
+             '       * "collections.deque"\n'
+             '\n'
+             '       * "list"\n'
+             '\n'
+             '       * "memoryview"\n'
+             '\n'
+             '       * "range"\n'
+             '\n'
+             '       * "tuple"\n'
+             '\n'
+             '    Note:\n'
+             '\n'
+             '      Subject values of type "str", "bytes", and "bytearray" do '
+             'not\n'
+             '      match sequence patterns.\n'
+             '\n'
+             '[3] In pattern matching, a mapping is defined as one of the '
+             'following:\n'
+             '\n'
+             '       * a class that inherits from "collections.abc.Mapping"\n'
+             '\n'
+             '       * a Python class that has been registered as\n'
+             '         "collections.abc.Mapping"\n'
+             '\n'
+             '       * a builtin class that has its (CPython) '
+             '"Py_TPFLAGS_MAPPING"\n'
+             '         bit set\n'
+             '\n'
+             '       * a class that inherits from any of the above\n'
+             '\n'
+             '    The standard library classes "dict" and '
+             '"types.MappingProxyType"\n'
+             '    are mappings.\n'
+             '\n'
+             '[4] A string literal appearing as the first statement in the '
              'function\n'
              '    body is transformed into the function’s "__doc__" attribute '
              'and\n'
              '    therefore the function’s *docstring*.\n'
              '\n'
-             '[3] A string literal appearing as the first statement in the '
+             '[5] A string literal appearing as the first statement in the '
              'class\n'
              '    body is transformed into the namespace’s "__doc__" item and\n'
              '    therefore the class’s *docstring*.\n',
@@ -4637,20 +5469,32 @@ topics = {'assert': 'The "assert" statement\n'
               'binding\n'
               'operations.\n'
               '\n'
-              'The following constructs bind names: formal parameters to '
-              'functions,\n'
-              '"import" statements, class and function definitions (these bind '
-              'the\n'
-              'class or function name in the defining block), and targets that '
-              'are\n'
-              'identifiers if occurring in an assignment, "for" loop header, '
-              'or after\n'
-              '"as" in a "with" statement or "except" clause. The "import" '
-              'statement\n'
-              'of the form "from ... import *" binds all names defined in the\n'
-              'imported module, except those beginning with an underscore.  '
-              'This form\n'
-              'may only be used at the module level.\n'
+              'The following constructs bind names:\n'
+              '\n'
+              '* formal parameters to functions,\n'
+              '\n'
+              '* class definitions,\n'
+              '\n'
+              '* function definitions,\n'
+              '\n'
+              '* assignment expressions,\n'
+              '\n'
+              '* targets that are identifiers if occurring in an assignment:\n'
+              '\n'
+              '  * "for" loop header,\n'
+              '\n'
+              '  * after "as" in a "with" statement, "except" clause or in the '
+              'as-\n'
+              '    pattern in structural pattern matching,\n'
+              '\n'
+              '  * in a capture pattern in structural pattern matching\n'
+              '\n'
+              '* "import" statements.\n'
+              '\n'
+              'The "import" statement of the form "from ... import *" binds '
+              'all names\n'
+              'defined in the imported module, except those beginning with an\n'
+              'underscore. This form may only be used at the module level.\n'
               '\n'
               'A target occurring in a "del" statement is also considered '
               'bound for\n'
@@ -5031,30 +5875,7 @@ topics = {'assert': 'The "assert" statement\n'
         'all by the loop.  Hint: the built-in function "range()" returns an\n'
         'iterator of integers suitable to emulate the effect of Pascal’s "for '
         'i\n'
-        ':= a to b do"; e.g., "list(range(3))" returns the list "[0, 1, 2]".\n'
-        '\n'
-        'Note:\n'
-        '\n'
-        '  There is a subtlety when the sequence is being modified by the '
-        'loop\n'
-        '  (this can only occur for mutable sequences, e.g. lists).  An\n'
-        '  internal counter is used to keep track of which item is used next,\n'
-        '  and this is incremented on each iteration.  When this counter has\n'
-        '  reached the length of the sequence the loop terminates.  This '
-        'means\n'
-        '  that if the suite deletes the current (or a previous) item from '
-        'the\n'
-        '  sequence, the next item will be skipped (since it gets the index '
-        'of\n'
-        '  the current item which has already been treated).  Likewise, if '
-        'the\n'
-        '  suite inserts an item in the sequence before the current item, the\n'
-        '  current item will be treated again the next time through the loop.\n'
-        '  This can lead to nasty bugs that can be avoided by making a\n'
-        '  temporary copy using a slice of the whole sequence, e.g.,\n'
-        '\n'
-        '     for x in a[:]:\n'
-        '         if x < 0: a.remove(x)\n',
+        ':= a to b do"; e.g., "list(range(3))" returns the list "[0, 1, 2]".\n',
  'formatstrings': 'Format String Syntax\n'
                   '********************\n'
                   '\n'
@@ -5300,9 +6121,9 @@ topics = {'assert': 'The "assert" statement\n'
                   '   |           | in the form ‘+000000120’. This alignment '
                   'option is only    |\n'
                   '   |           | valid for numeric types.  It becomes the '
-                  'default when ‘0’  |\n'
-                  '   |           | immediately precedes the field '
-                  'width.                      |\n'
+                  'default for       |\n'
+                  '   |           | numbers when ‘0’ immediately precedes the '
+                  'field width.     |\n'
                   '   '
                   '+-----------+------------------------------------------------------------+\n'
                   '   | "\'^\'"     | Forces the field to be centered within '
@@ -5410,6 +6231,10 @@ topics = {'assert': 'The "assert" statement\n'
                   'with an\n'
                   '*alignment* type of "\'=\'".\n'
                   '\n'
+                  'Changed in version 3.10: Preceding the *width* field by '
+                  '"\'0\'" no\n'
+                  'longer affects the default alignment for strings.\n'
+                  '\n'
                   'The *precision* is a decimal integer indicating how many '
                   'digits should\n'
                   'be displayed after the decimal point for presentation types '
@@ -5868,7 +6693,7 @@ topics = {'assert': 'The "assert" statement\n'
              '\n'
              'The function definition does not execute the function body; this '
              'gets\n'
-             'executed only when the function is called. [2]\n'
+             'executed only when the function is called. [4]\n'
              '\n'
              'A function definition may be wrapped by one or more *decorator*\n'
              'expressions. Decorator expressions are evaluated when the '
@@ -5921,17 +6746,17 @@ topics = {'assert': 'The "assert" statement\n'
              '“pre-\n'
              'computed” value is used for each call.  This is especially '
              'important\n'
-             'to understand when a default parameter is a mutable object, such '
-             'as a\n'
-             'list or a dictionary: if the function modifies the object (e.g. '
-             'by\n'
-             'appending an item to a list), the default value is in effect '
-             'modified.\n'
-             'This is generally not what was intended.  A way around this is '
-             'to use\n'
-             '"None" as the default, and explicitly test for it in the body of '
-             'the\n'
-             'function, e.g.:\n'
+             'to understand when a default parameter value is a mutable '
+             'object, such\n'
+             'as a list or a dictionary: if the function modifies the object '
+             '(e.g.\n'
+             'by appending an item to a list), the default parameter value is '
+             'in\n'
+             'effect modified.  This is generally not what was intended.  A '
+             'way\n'
+             'around this is to use "None" as the default, and explicitly test '
+             'for\n'
+             'it in the body of the function, e.g.:\n'
              '\n'
              '   def whats_on_the_telly(penguin=None):\n'
              '       if penguin is None:\n'
@@ -6054,8 +6879,10 @@ topics = {'assert': 'The "assert" statement\n'
            '\n'
            'Names listed in a "global" statement must not be defined as '
            'formal\n'
-           'parameters or in a "for" loop control target, "class" definition,\n'
-           'function definition, "import" statement, or variable annotation.\n'
+           'parameters, or as targets in "with" statements or "except" '
+           'clauses, or\n'
+           'in a "for" target list, "class" definition, function definition,\n'
+           '"import" statement, or variable annotation.\n'
            '\n'
            '**CPython implementation detail:** The current implementation does '
            'not\n'
@@ -6087,22 +6914,31 @@ topics = {'assert': 'The "assert" statement\n'
                'trailing underscore characters:\n'
                '\n'
                '"_*"\n'
-               '   Not imported by "from module import *".  The special '
-               'identifier "_"\n'
-               '   is used in the interactive interpreter to store the result '
-               'of the\n'
-               '   last evaluation; it is stored in the "builtins" module.  '
-               'When not\n'
-               '   in interactive mode, "_" has no special meaning and is not '
-               'defined.\n'
-               '   See section The import statement.\n'
+               '   Not imported by "from module import *".\n'
+               '\n'
+               '"_"\n'
+               '   In a "case" pattern within a "match" statement, "_" is a '
+               'soft\n'
+               '   keyword that denotes a wildcard.\n'
+               '\n'
+               '   Separately, the interactive interpreter makes the result of '
+               'the\n'
+               '   last evaluation available in the variable "_". (It is '
+               'stored in the\n'
+               '   "builtins" module, alongside built-in functions like '
+               '"print".)\n'
+               '\n'
+               '   Elsewhere, "_" is a regular identifier. It is often used to '
+               'name\n'
+               '   “special” items, but it is not special to Python itself.\n'
                '\n'
                '   Note:\n'
                '\n'
                '     The name "_" is often used in conjunction with\n'
                '     internationalization; refer to the documentation for the\n'
                '     "gettext" module for more information on this '
-               'convention.\n'
+               'convention.It is\n'
+               '     also commonly used for unused variables.\n'
                '\n'
                '"__*__"\n'
                '   System-defined names, informally known as “dunder” names. '
@@ -6225,6 +7061,28 @@ topics = {'assert': 'The "assert" statement\n'
                 '   async      elif       if         or         yield\n'
                 '\n'
                 '\n'
+                'Soft Keywords\n'
+                '=============\n'
+                '\n'
+                'New in version 3.10.\n'
+                '\n'
+                'Some identifiers are only reserved under specific contexts. '
+                'These are\n'
+                'known as *soft keywords*.  The identifiers "match", "case" '
+                'and "_" can\n'
+                'syntactically act as keywords in contexts related to the '
+                'pattern\n'
+                'matching statement, but this distinction is done at the '
+                'parser level,\n'
+                'not when tokenizing.\n'
+                '\n'
+                'As soft keywords, their use with pattern matching is possible '
+                'while\n'
+                'still preserving compatibility with existing code that uses '
+                '"match",\n'
+                '"case" and "_" as identifier names.\n'
+                '\n'
+                '\n'
                 'Reserved classes of identifiers\n'
                 '===============================\n'
                 '\n'
@@ -6235,15 +7093,23 @@ topics = {'assert': 'The "assert" statement\n'
                 'trailing underscore characters:\n'
                 '\n'
                 '"_*"\n'
-                '   Not imported by "from module import *".  The special '
-                'identifier "_"\n'
-                '   is used in the interactive interpreter to store the result '
+                '   Not imported by "from module import *".\n'
+                '\n'
+                '"_"\n'
+                '   In a "case" pattern within a "match" statement, "_" is a '
+                'soft\n'
+                '   keyword that denotes a wildcard.\n'
+                '\n'
+                '   Separately, the interactive interpreter makes the result '
                 'of the\n'
-                '   last evaluation; it is stored in the "builtins" module.  '
-                'When not\n'
-                '   in interactive mode, "_" has no special meaning and is not '
-                'defined.\n'
-                '   See section The import statement.\n'
+                '   last evaluation available in the variable "_". (It is '
+                'stored in the\n'
+                '   "builtins" module, alongside built-in functions like '
+                '"print".)\n'
+                '\n'
+                '   Elsewhere, "_" is a regular identifier. It is often used '
+                'to name\n'
+                '   “special” items, but it is not special to Python itself.\n'
                 '\n'
                 '   Note:\n'
                 '\n'
@@ -6251,7 +7117,8 @@ topics = {'assert': 'The "assert" statement\n'
                 '     internationalization; refer to the documentation for '
                 'the\n'
                 '     "gettext" module for more information on this '
-                'convention.\n'
+                'convention.It is\n'
+                '     also commonly used for unused variables.\n'
                 '\n'
                 '"__*__"\n'
                 '   System-defined names, informally known as “dunder” names. '
@@ -6712,20 +7579,32 @@ topics = {'assert': 'The "assert" statement\n'
            '*Names* refer to objects.  Names are introduced by name binding\n'
            'operations.\n'
            '\n'
-           'The following constructs bind names: formal parameters to '
-           'functions,\n'
-           '"import" statements, class and function definitions (these bind '
-           'the\n'
-           'class or function name in the defining block), and targets that '
-           'are\n'
-           'identifiers if occurring in an assignment, "for" loop header, or '
-           'after\n'
-           '"as" in a "with" statement or "except" clause. The "import" '
-           'statement\n'
-           'of the form "from ... import *" binds all names defined in the\n'
-           'imported module, except those beginning with an underscore.  This '
-           'form\n'
-           'may only be used at the module level.\n'
+           'The following constructs bind names:\n'
+           '\n'
+           '* formal parameters to functions,\n'
+           '\n'
+           '* class definitions,\n'
+           '\n'
+           '* function definitions,\n'
+           '\n'
+           '* assignment expressions,\n'
+           '\n'
+           '* targets that are identifiers if occurring in an assignment:\n'
+           '\n'
+           '  * "for" loop header,\n'
+           '\n'
+           '  * after "as" in a "with" statement, "except" clause or in the '
+           'as-\n'
+           '    pattern in structural pattern matching,\n'
+           '\n'
+           '  * in a capture pattern in structural pattern matching\n'
+           '\n'
+           '* "import" statements.\n'
+           '\n'
+           'The "import" statement of the form "from ... import *" binds all '
+           'names\n'
+           'defined in the imported module, except those beginning with an\n'
+           'underscore. This form may only be used at the module level.\n'
            '\n'
            'A target occurring in a "del" statement is also considered bound '
            'for\n'
@@ -7092,16 +7971,6 @@ topics = {'assert': 'The "assert" statement\n'
                   'the data\n'
                   '   model.\n'
                   '\n'
-                  '   Note:\n'
-                  '\n'
-                  '     Due to a bug in the dispatching mechanism for "**=", a '
-                  'class that\n'
-                  '     defines "__ipow__()" but returns "NotImplemented" '
-                  'would fail to\n'
-                  '     fall back to "x.__pow__(y)" and "y.__rpow__(x)". This '
-                  'bug is\n'
-                  '     fixed in Python 3.10.\n'
-                  '\n'
                   'object.__neg__(self)\n'
                   'object.__pos__(self)\n'
                   'object.__abs__(self)\n'
@@ -7851,19 +8720,13 @@ topics = {'assert': 'The "assert" statement\n'
                    '\n'
                    'object.__iter__(self)\n'
                    '\n'
-                   '   This method is called when an iterator is required for '
-                   'a container.\n'
-                   '   This method should return a new iterator object that '
-                   'can iterate\n'
-                   '   over all the objects in the container.  For mappings, '
-                   'it should\n'
-                   '   iterate over the keys of the container.\n'
-                   '\n'
-                   '   Iterator objects also need to implement this method; '
-                   'they are\n'
-                   '   required to return themselves.  For more information on '
-                   'iterator\n'
-                   '   objects, see Iterator Types.\n'
+                   '   This method is called when an *iterator* is required '
+                   'for a\n'
+                   '   container. This method should return a new iterator '
+                   'object that can\n'
+                   '   iterate over all the objects in the container.  For '
+                   'mappings, it\n'
+                   '   should iterate over the keys of the container.\n'
                    '\n'
                    'object.__reversed__(self)\n'
                    '\n'
@@ -8820,32 +9683,6 @@ topics = {'assert': 'The "assert" statement\n'
                  'of the\n'
                  '   owner class.\n'
                  '\n'
-                 'object.__set_name__(self, owner, name)\n'
-                 '\n'
-                 '   Called at the time the owning class *owner* is created. '
-                 'The\n'
-                 '   descriptor has been assigned to *name*.\n'
-                 '\n'
-                 '   Note:\n'
-                 '\n'
-                 '     "__set_name__()" is only called implicitly as part of '
-                 'the "type"\n'
-                 '     constructor, so it will need to be called explicitly '
-                 'with the\n'
-                 '     appropriate parameters when a descriptor is added to a '
-                 'class\n'
-                 '     after initial creation:\n'
-                 '\n'
-                 '        class A:\n'
-                 '           pass\n'
-                 '        descr = custom_descriptor()\n'
-                 '        A.attr = descr\n'
-                 "        descr.__set_name__(A, 'attr')\n"
-                 '\n'
-                 '     See Creating the class object for more details.\n'
-                 '\n'
-                 '   New in version 3.6.\n'
-                 '\n'
                  'The attribute "__objclass__" is interpreted by the "inspect" '
                  'module as\n'
                  'specifying the class where this object was defined (setting '
@@ -9141,6 +9978,38 @@ topics = {'assert': 'The "assert" statement\n'
                  '\n'
                  '   New in version 3.6.\n'
                  '\n'
+                 'When a class is created, "type.__new__()" scans the class '
+                 'variables\n'
+                 'and makes callbacks to those with a "__set_name__()" hook.\n'
+                 '\n'
+                 'object.__set_name__(self, owner, name)\n'
+                 '\n'
+                 '   Automatically called at the time the owning class *owner* '
+                 'is\n'
+                 '   created. The object has been assigned to *name* in that '
+                 'class:\n'
+                 '\n'
+                 '      class A:\n'
+                 '          x = C()  # Automatically calls: x.__set_name__(A, '
+                 "'x')\n"
+                 '\n'
+                 '   If the class variable is assigned after the class is '
+                 'created,\n'
+                 '   "__set_name__()" will not be called automatically. If '
+                 'needed,\n'
+                 '   "__set_name__()" can be called directly:\n'
+                 '\n'
+                 '      class A:\n'
+                 '         pass\n'
+                 '\n'
+                 '      c = C()\n'
+                 '      A.x = c                  # The hook is not called\n'
+                 "      c.__set_name__(A, 'x')   # Manually invoke the hook\n"
+                 '\n'
+                 '   See Creating the class object for more details.\n'
+                 '\n'
+                 '   New in version 3.6.\n'
+                 '\n'
                  '\n'
                  'Metaclasses\n'
                  '-----------\n'
@@ -9336,22 +10205,21 @@ topics = {'assert': 'The "assert" statement\n'
                  'When using the default metaclass "type", or any metaclass '
                  'that\n'
                  'ultimately calls "type.__new__", the following additional\n'
-                 'customisation steps are invoked after creating the class '
+                 'customization steps are invoked after creating the class '
                  'object:\n'
                  '\n'
-                 '* first, "type.__new__" collects all of the descriptors in '
-                 'the class\n'
-                 '  namespace that define a "__set_name__()" method;\n'
+                 '1. The "type.__new__" method collects all of the attributes '
+                 'in the\n'
+                 '   class namespace that define a "__set_name__()" method;\n'
                  '\n'
-                 '* second, all of these "__set_name__" methods are called '
-                 'with the\n'
-                 '  class being defined and the assigned name of that '
-                 'particular\n'
-                 '  descriptor;\n'
+                 '2. Those "__set_name__" methods are called with the class '
+                 'being\n'
+                 '   defined and the assigned name of that particular '
+                 'attribute;\n'
                  '\n'
-                 '* finally, the "__init_subclass__()" hook is called on the '
-                 'immediate\n'
-                 '  parent of the new class in its method resolution order.\n'
+                 '3. The "__init_subclass__()" hook is called on the immediate '
+                 'parent of\n'
+                 '   the new class in its method resolution order.\n'
                  '\n'
                  'After the class object is created, it is passed to the '
                  'class\n'
@@ -9814,19 +10682,13 @@ topics = {'assert': 'The "assert" statement\n'
                  '\n'
                  'object.__iter__(self)\n'
                  '\n'
-                 '   This method is called when an iterator is required for a '
-                 'container.\n'
-                 '   This method should return a new iterator object that can '
-                 'iterate\n'
-                 '   over all the objects in the container.  For mappings, it '
-                 'should\n'
-                 '   iterate over the keys of the container.\n'
-                 '\n'
-                 '   Iterator objects also need to implement this method; they '
-                 'are\n'
-                 '   required to return themselves.  For more information on '
-                 'iterator\n'
-                 '   objects, see Iterator Types.\n'
+                 '   This method is called when an *iterator* is required for '
+                 'a\n'
+                 '   container. This method should return a new iterator '
+                 'object that can\n'
+                 '   iterate over all the objects in the container.  For '
+                 'mappings, it\n'
+                 '   should iterate over the keys of the container.\n'
                  '\n'
                  'object.__reversed__(self)\n'
                  '\n'
@@ -10019,16 +10881,6 @@ topics = {'assert': 'The "assert" statement\n'
                  'the data\n'
                  '   model.\n'
                  '\n'
-                 '   Note:\n'
-                 '\n'
-                 '     Due to a bug in the dispatching mechanism for "**=", a '
-                 'class that\n'
-                 '     defines "__ipow__()" but returns "NotImplemented" would '
-                 'fail to\n'
-                 '     fall back to "x.__pow__(y)" and "y.__rpow__(x)". This '
-                 'bug is\n'
-                 '     fixed in Python 3.10.\n'
-                 '\n'
                  'object.__neg__(self)\n'
                  'object.__pos__(self)\n'
                  'object.__abs__(self)\n'
@@ -10147,6 +10999,51 @@ topics = {'assert': 'The "assert" statement\n'
                  '     statement.\n'
                  '\n'
                  '\n'
+                 'Customizing positional arguments in class pattern matching\n'
+                 '==========================================================\n'
+                 '\n'
+                 'When using a class name in a pattern, positional arguments '
+                 'in the\n'
+                 'pattern are not allowed by default, i.e. "case MyClass(x, '
+                 'y)" is\n'
+                 'typically invalid without special support in "MyClass". To '
+                 'be able to\n'
+                 'use that kind of patterns, the class needs to define a\n'
+                 '*__match_args__* attribute.\n'
+                 '\n'
+                 'object.__match_args__\n'
+                 '\n'
+                 '   This class variable can be assigned a tuple of strings. '
+                 'When this\n'
+                 '   class is used in a class pattern with positional '
+                 'arguments, each\n'
+                 '   positional argument will be converted into a keyword '
+                 'argument,\n'
+                 '   using the corresponding value in *__match_args__* as the '
+                 'keyword.\n'
+                 '   The absence of this attribute is equivalent to setting it '
+                 'to "()".\n'
+                 '\n'
+                 'For example, if "MyClass.__match_args__" is "("left", '
+                 '"center",\n'
+                 '"right")" that means that "case MyClass(x, y)" is equivalent '
+                 'to "case\n'
+                 'MyClass(left=x, center=y)". Note that the number of '
+                 'arguments in the\n'
+                 'pattern must be smaller than or equal to the number of '
+                 'elements in\n'
+                 '*__match_args__*; if it is larger, the pattern match attempt '
+                 'will\n'
+                 'raise a "TypeError".\n'
+                 '\n'
+                 'New in version 3.10.\n'
+                 '\n'
+                 'See also:\n'
+                 '\n'
+                 '  **PEP 634** - Structural Pattern Matching\n'
+                 '     The specification for the Python "match" statement.\n'
+                 '\n'
+                 '\n'
                  'Special method lookup\n'
                  '=====================\n'
                  '\n'
@@ -10317,7 +11214,7 @@ topics = {'assert': 'The "assert" statement\n'
                    '*start* and\n'
                    '   *end* are interpreted as in slice notation.\n'
                    '\n'
-                   'str.encode(encoding="utf-8", errors="strict")\n'
+                   "str.encode(encoding='utf-8', errors='strict')\n"
                    '\n'
                    '   Return an encoded version of the string as a bytes '
                    'object. Default\n'
@@ -10823,7 +11720,7 @@ topics = {'assert': 'The "assert" statement\n'
                    'followed by\n'
                    '   the string itself.\n'
                    '\n'
-                   'str.rsplit(sep=None, maxsplit=-1)\n'
+                   'str.rsplit(sep=None, maxsplit=- 1)\n'
                    '\n'
                    '   Return a list of the words in the string, using *sep* '
                    'as the\n'
@@ -10864,7 +11761,7 @@ topics = {'assert': 'The "assert" statement\n'
                    "      >>> 'Monty Python'.removesuffix(' Python')\n"
                    "      'Monty'\n"
                    '\n'
-                   'str.split(sep=None, maxsplit=-1)\n'
+                   'str.split(sep=None, maxsplit=- 1)\n'
                    '\n'
                    '   Return a list of the words in the string, using *sep* '
                    'as the\n'
@@ -11593,9 +12490,31 @@ topics = {'assert': 'The "assert" statement\n'
         'the\n'
         'exception class, the exception instance and a traceback object (see\n'
         'section The standard type hierarchy) identifying the point in the\n'
-        'program where the exception occurred.  "sys.exc_info()" values are\n'
-        'restored to their previous values (before the call) when returning\n'
-        'from a function that handled an exception.\n'
+        'program where the exception occurred.  The details about the '
+        'exception\n'
+        'accessed via "sys.exc_info()" are restored to their previous values\n'
+        'when leaving an exception handler:\n'
+        '\n'
+        '   >>> print(sys.exc_info())\n'
+        '   (None, None, None)\n'
+        '   >>> try:\n'
+        '   ...     raise TypeError\n'
+        '   ... except:\n'
+        '   ...     print(sys.exc_info())\n'
+        '   ...     try:\n'
+        '   ...          raise ValueError\n'
+        '   ...     except:\n'
+        '   ...         print(sys.exc_info())\n'
+        '   ...     print(sys.exc_info())\n'
+        '   ...\n'
+        "   (<class 'TypeError'>, TypeError(), <traceback object at "
+        '0x10efad080>)\n'
+        "   (<class 'ValueError'>, ValueError(), <traceback object at "
+        '0x10efad040>)\n'
+        "   (<class 'TypeError'>, TypeError(), <traceback object at "
+        '0x10efad080>)\n'
+        '   >>> print(sys.exc_info())\n'
+        '   (None, None, None)\n'
         '\n'
         'The optional "else" clause is executed if the control flow leaves '
         'the\n'
@@ -11855,7 +12774,7 @@ topics = {'assert': 'The "assert" statement\n'
           '         points. All the code points in the range "U+0000 - '
           'U+10FFFF"\n'
           '         can be represented in a string.  Python doesn’t have a '
-          '"char"\n'
+          '*char*\n'
           '         type; instead, every code point in the string is '
           'represented\n'
           '         as a string object with length "1".  The built-in '
@@ -12115,7 +13034,13 @@ topics = {'assert': 'The "assert" statement\n'
           '|             |\n'
           '      |                           | and "\'return\'" for the '
           'return   |             |\n'
-          '      |                           | annotation, if provided.        '
+          '      |                           | annotation, if provided.  For   '
+          '|             |\n'
+          '      |                           | more information on working     '
+          '|             |\n'
+          '      |                           | with this attribute, see        '
+          '|             |\n'
+          '      |                           | Annotations Best Practices.     '
           '|             |\n'
           '      '
           '+---------------------------+---------------------------------+-------------+\n'
@@ -12236,20 +13161,18 @@ topics = {'assert': 'The "assert" statement\n'
           '      A function or method which uses the "yield" statement (see\n'
           '      section The yield statement) is called a *generator '
           'function*.\n'
-          '      Such a function, when called, always returns an iterator '
-          'object\n'
-          '      which can be used to execute the body of the function:  '
-          'calling\n'
-          '      the iterator’s "iterator.__next__()" method will cause the\n'
-          '      function to execute until it provides a value using the '
-          '"yield"\n'
-          '      statement.  When the function executes a "return" statement '
-          'or\n'
-          '      falls off the end, a "StopIteration" exception is raised and '
-          'the\n'
-          '      iterator will have reached the end of the set of values to '
-          'be\n'
-          '      returned.\n'
+          '      Such a function, when called, always returns an *iterator*\n'
+          '      object which can be used to execute the body of the '
+          'function:\n'
+          '      calling the iterator’s "iterator.__next__()" method will '
+          'cause\n'
+          '      the function to execute until it provides a value using the\n'
+          '      "yield" statement.  When the function executes a "return"\n'
+          '      statement or falls off the end, a "StopIteration" exception '
+          'is\n'
+          '      raised and the iterator will have reached the end of the set '
+          'of\n'
+          '      values to be returned.\n'
           '\n'
           '   Coroutine functions\n'
           '      A function or method which is defined using "async def" is\n'
@@ -12265,9 +13188,9 @@ topics = {'assert': 'The "assert" statement\n'
           '      which uses the "yield" statement is called a *asynchronous\n'
           '      generator function*.  Such a function, when called, returns '
           'an\n'
-          '      asynchronous iterator object which can be used in an "async '
-          'for"\n'
-          '      statement to execute the body of the function.\n'
+          '      *asynchronous iterator* object which can be used in an '
+          '"async\n'
+          '      for" statement to execute the body of the function.\n'
           '\n'
           '      Calling the asynchronous iterator’s "aiterator.__anext__" '
           'method\n'
@@ -12340,20 +13263,34 @@ topics = {'assert': 'The "assert" statement\n'
           '   Attribute assignment updates the module’s namespace dictionary,\n'
           '   e.g., "m.x = 1" is equivalent to "m.__dict__["x"] = 1".\n'
           '\n'
-          '   Predefined (writable) attributes: "__name__" is the module’s '
-          'name;\n'
-          '   "__doc__" is the module’s documentation string, or "None" if\n'
-          '   unavailable; "__annotations__" (optional) is a dictionary\n'
-          '   containing *variable annotations* collected during module body\n'
-          '   execution; "__file__" is the pathname of the file from which '
+          '   Predefined (writable) attributes:\n'
+          '\n'
+          '      "__name__"\n'
+          '         The module’s name.\n'
+          '\n'
+          '      "__doc__"\n'
+          '         The module’s documentation string, or "None" if '
+          'unavailable.\n'
+          '\n'
+          '      "__file__"\n'
+          '         The pathname of the file from which the module was loaded, '
+          'if\n'
+          '         it was loaded from a file. The "__file__" attribute may '
+          'be\n'
+          '         missing for certain types of modules, such as C modules '
+          'that\n'
+          '         are statically linked into the interpreter.  For '
+          'extension\n'
+          '         modules loaded dynamically from a shared library, it’s '
           'the\n'
-          '   module was loaded, if it was loaded from a file. The "__file__"\n'
-          '   attribute may be missing for certain types of modules, such as '
-          'C\n'
-          '   modules that are statically linked into the interpreter; for\n'
-          '   extension modules loaded dynamically from a shared library, it '
-          'is\n'
-          '   the pathname of the shared library file.\n'
+          '         pathname of the shared library file.\n'
+          '\n'
+          '      "__annotations__"\n'
+          '         A dictionary containing *variable annotations* collected\n'
+          '         during module body execution.  For best practices on '
+          'working\n'
+          '         with "__annotations__", please see Annotations Best\n'
+          '         Practices.\n'
           '\n'
           '   Special read-only attribute: "__dict__" is the module’s '
           'namespace\n'
@@ -12411,20 +13348,31 @@ topics = {'assert': 'The "assert" statement\n'
           'instance\n'
           '   (see below).\n'
           '\n'
-          '   Special attributes: "__name__" is the class name; "__module__" '
-          'is\n'
-          '   the module name in which the class was defined; "__dict__" is '
-          'the\n'
-          '   dictionary containing the class’s namespace; "__bases__" is a '
-          'tuple\n'
-          '   containing the base classes, in the order of their occurrence '
-          'in\n'
-          '   the base class list; "__doc__" is the class’s documentation '
-          'string,\n'
-          '   or "None" if undefined; "__annotations__" (optional) is a\n'
-          '   dictionary containing *variable annotations* collected during '
-          'class\n'
-          '   body execution.\n'
+          '   Special attributes:\n'
+          '\n'
+          '      "__name__"\n'
+          '         The class name.\n'
+          '\n'
+          '      "__module__"\n'
+          '         The name of the module in which the class was defined.\n'
+          '\n'
+          '      "__dict__"\n'
+          '         The dictionary containing the class’s namespace.\n'
+          '\n'
+          '      "__bases__"\n'
+          '         A tuple containing the base classes, in the order of '
+          'their\n'
+          '         occurrence in the base class list.\n'
+          '\n'
+          '      "__doc__"\n'
+          '         The class’s documentation string, or "None" if undefined.\n'
+          '\n'
+          '      "__annotations__"\n'
+          '         A dictionary containing *variable annotations* collected\n'
+          '         during class body execution.  For best practices on '
+          'working\n'
+          '         with "__annotations__", please see Annotations Best\n'
+          '         Practices.\n'
           '\n'
           'Class instances\n'
           '   A class instance is created by calling a class object (see '
@@ -12725,9 +13673,8 @@ topics = {'assert': 'The "assert" statement\n'
           '      object actually returned is the wrapped object, which is not\n'
           '      subject to any further transformation. Static method objects '
           'are\n'
-          '      not themselves callable, although the objects they wrap '
-          'usually\n'
-          '      are. Static method objects are created by the built-in\n'
+          '      also callable. Static method objects are created by the '
+          'built-in\n'
           '      "staticmethod()" constructor.\n'
           '\n'
           '   Class method objects\n'
@@ -13192,6 +14139,14 @@ topics = {'assert': 'The "assert" statement\n'
                  '   Changed in version 3.8: Dictionary views are now '
                  'reversible.\n'
                  '\n'
+                 'dictview.mapping\n'
+                 '\n'
+                 '   Return a "types.MappingProxyType" that wraps the '
+                 'original\n'
+                 '   dictionary to which the view refers.\n'
+                 '\n'
+                 '   New in version 3.10.\n'
+                 '\n'
                  'Keys views are set-like since their entries are unique and '
                  'hashable.\n'
                  'If all values are hashable, so that "(key, value)" pairs are '
@@ -13237,7 +14192,15 @@ topics = {'assert': 'The "assert" statement\n'
                  "   >>> keys & {'eggs', 'bacon', 'salad'}\n"
                  "   {'bacon'}\n"
                  "   >>> keys ^ {'sausage', 'juice'}\n"
-                 "   {'juice', 'sausage', 'bacon', 'spam'}\n",
+                 "   {'juice', 'sausage', 'bacon', 'spam'}\n"
+                 '\n'
+                 '   >>> # get back a read-only proxy for the original '
+                 'dictionary\n'
+                 '   >>> values.mapping\n'
+                 "   mappingproxy({'eggs': 2, 'sausage': 1, 'bacon': 1, "
+                 "'spam': 500})\n"
+                 "   >>> values.mapping['spam']\n"
+                 '   500\n',
  'typesmethods': 'Methods\n'
                  '*******\n'
                  '\n'
@@ -13432,6 +14395,14 @@ topics = {'assert': 'The "assert" statement\n'
              'Comparisons in\n'
              'the language reference.)\n'
              '\n'
+             'Forward and reversed iterators over mutable sequences access '
+             'values\n'
+             'using an index.  That index will continue to march forward (or\n'
+             'backward) even if the underlying sequence is mutated.  The '
+             'iterator\n'
+             'terminates only when an "IndexError" or a "StopIteration" is\n'
+             'encountered (or when the index drops below zero).\n'
+             '\n'
              'Notes:\n'
              '\n'
              '1. While the "in" and "not in" operations are used only for '
@@ -14244,8 +15215,10 @@ topics = {'assert': 'The "assert" statement\n'
          'usage\n'
          'patterns to be encapsulated for convenient reuse.\n'
          '\n'
-         '   with_stmt ::= "with" with_item ("," with_item)* ":" suite\n'
-         '   with_item ::= expression ["as" target]\n'
+         '   with_stmt          ::= "with" ( "(" with_stmt_contents ","? ")" | '
+         'with_stmt_contents ) ":" suite\n'
+         '   with_stmt_contents ::= with_item ("," with_item)*\n'
+         '   with_item          ::= expression ["as" target]\n'
          '\n'
          'The execution of the "with" statement with one “item” proceeds as\n'
          'follows:\n'
@@ -14331,8 +15304,20 @@ topics = {'assert': 'The "assert" statement\n'
          '       with B() as b:\n'
          '           SUITE\n'
          '\n'
+         'You can also write multi-item context managers in multiple lines if\n'
+         'the items are surrounded by parentheses. For example:\n'
+         '\n'
+         '   with (\n'
+         '       A() as a,\n'
+         '       B() as b,\n'
+         '   ):\n'
+         '       SUITE\n'
+         '\n'
          'Changed in version 3.1: Support for multiple context expressions.\n'
          '\n'
+         'Changed in version 3.10: Support for using grouping parentheses to\n'
+         'break the statement in multiple lines.\n'
+         '\n'
          'See also:\n'
          '\n'
          '  **PEP 343** - The “with” statement\n'