Update Python from 3.11.8 to 3.12.2

1 files changed, 832 insertions, 168 deletions

diff --git a/contrib/tools/python3/src/Lib/pydoc_data/topics.py b/contrib/tools/python3/src/Lib/pydoc_data/topics.py
index d43b5c6b19..e97e543a87 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 Tue Feb  6 21:21:08 2024
+# Autogenerated by Sphinx on Tue Feb  6 21:16:37 2024
 # as part of the release process.
 topics = {'assert': 'The "assert" statement\n'
            '**********************\n'
@@ -539,77 +539,7 @@ topics = {'assert': 'The "assert" statement\n'
           '  **PEP 492** - Coroutines with async and await syntax\n'
           '     The proposal that made coroutines a proper standalone concept '
           'in\n'
-          '     Python, and added supporting syntax.\n'
-          '\n'
-          '-[ Footnotes ]-\n'
-          '\n'
-          '[1] The exception is propagated to the invocation stack unless '
-          'there\n'
-          '    is a "finally" clause which happens to raise another '
-          'exception.\n'
-          '    That new exception causes the old one to be lost.\n'
-          '\n'
-          '[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" '
-          'bit\n'
-          '      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" '
-          'bit\n'
-          '      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'
-          '[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',
+          '     Python, and added supporting syntax.\n',
  'atom-identifiers': 'Identifiers (Names)\n'
                      '*******************\n'
                      '\n'
@@ -1760,8 +1690,8 @@ topics = {'assert': 'The "assert" statement\n'
           'standard\n'
           'type hierarchy):\n'
           '\n'
-          '   classdef    ::= [decorators] "class" classname [inheritance] ":" '
-          'suite\n'
+          '   classdef    ::= [decorators] "class" classname [type_params] '
+          '[inheritance] ":" suite\n'
           '   inheritance ::= "(" [argument_list] ")"\n'
           '   classname   ::= identifier\n'
           '\n'
@@ -1825,6 +1755,19 @@ topics = {'assert': 'The "assert" statement\n'
           '"assignment_expression". Previously, the grammar was much more\n'
           'restrictive; see **PEP 614** for details.\n'
           '\n'
+          'A list of type parameters may be given in square brackets '
+          'immediately\n'
+          'after the class’s name. This indicates to static type checkers '
+          'that\n'
+          'the class is generic. At runtime, the type parameters can be '
+          'retrieved\n'
+          'from the class’s "__type_params__" attribute. See Generic classes '
+          'for\n'
+          'more.\n'
+          '\n'
+          'Changed in version 3.12: Type parameter lists are new in Python '
+          '3.12.\n'
+          '\n'
           '**Programmer’s note:** Variables defined in the class definition '
           'are\n'
           'class attributes; they are shared by instances.  Instance '
@@ -2585,15 +2528,12 @@ topics = {'assert': 'The "assert" statement\n'
              '\n'
              'Any remaining exceptions that were not handled by any "except*" '
              'clause\n'
-             'are re-raised at the end, combined into an exception group along '
-             'with\n'
-             'all exceptions that were raised from within "except*" clauses.\n'
-             '\n'
-             'From version 3.11.4, when the entire "ExceptionGroup" is handled '
-             'and\n'
-             'only one exception is raised from an "except*" clause, this '
-             'exception\n'
-             'is no longer wrapped to form a new "ExceptionGroup".\n'
+             'are re-raised at the end, along with all exceptions that were '
+             'raised\n'
+             'from within the "except*" clauses. If this list contains more '
+             'than one\n'
+             'exception to reraise, they are combined into an exception '
+             'group.\n'
              '\n'
              'If the raised exception is not an exception group and its type '
              'matches\n'
@@ -3570,8 +3510,8 @@ topics = {'assert': 'The "assert" statement\n'
              '(see\n'
              'section The standard type hierarchy):\n'
              '\n'
-             '   funcdef                   ::= [decorators] "def" funcname "(" '
-             '[parameter_list] ")"\n'
+             '   funcdef                   ::= [decorators] "def" funcname '
+             '[type_params] "(" [parameter_list] ")"\n'
              '               ["->" expression] ":" suite\n'
              '   decorators                ::= decorator+\n'
              '   decorator                 ::= "@" assignment_expression '
@@ -3633,6 +3573,19 @@ topics = {'assert': 'The "assert" statement\n'
              '"assignment_expression". Previously, the grammar was much more\n'
              'restrictive; see **PEP 614** for details.\n'
              '\n'
+             'A list of type parameters may be given in square brackets '
+             'between the\n'
+             'function’s name and the opening parenthesis for its parameter '
+             'list.\n'
+             'This indicates to static type checkers that the function is '
+             'generic.\n'
+             'At runtime, the type parameters can be retrieved from the '
+             'function’s\n'
+             '"__type_params__" attribute. See Generic functions for more.\n'
+             '\n'
+             'Changed in version 3.12: Type parameter lists are new in Python '
+             '3.12.\n'
+             '\n'
              'When one or more *parameters* have the form *parameter* "="\n'
              '*expression*, the function is said to have “default parameter '
              'values.”\n'
@@ -3780,8 +3733,8 @@ topics = {'assert': 'The "assert" statement\n'
              'standard\n'
              'type hierarchy):\n'
              '\n'
-             '   classdef    ::= [decorators] "class" classname [inheritance] '
-             '":" suite\n'
+             '   classdef    ::= [decorators] "class" classname [type_params] '
+             '[inheritance] ":" suite\n'
              '   inheritance ::= "(" [argument_list] ")"\n'
              '   classname   ::= identifier\n'
              '\n'
@@ -3849,6 +3802,19 @@ topics = {'assert': 'The "assert" statement\n'
              '"assignment_expression". Previously, the grammar was much more\n'
              'restrictive; see **PEP 614** for details.\n'
              '\n'
+             'A list of type parameters may be given in square brackets '
+             'immediately\n'
+             'after the class’s name. This indicates to static type checkers '
+             'that\n'
+             'the class is generic. At runtime, the type parameters can be '
+             'retrieved\n'
+             'from the class’s "__type_params__" attribute. See Generic '
+             'classes for\n'
+             'more.\n'
+             '\n'
+             'Changed in version 3.12: Type parameter lists are new in Python '
+             '3.12.\n'
+             '\n'
              '**Programmer’s note:** Variables defined in the class definition '
              'are\n'
              'class attributes; they are shared by instances.  Instance '
@@ -4006,6 +3972,272 @@ topics = {'assert': 'The "assert" statement\n'
              'concept in\n'
              '     Python, and added supporting syntax.\n'
              '\n'
+             '\n'
+             'Type parameter lists\n'
+             '====================\n'
+             '\n'
+             'New in version 3.12.\n'
+             '\n'
+             '   type_params  ::= "[" type_param ("," type_param)* "]"\n'
+             '   type_param   ::= typevar | typevartuple | paramspec\n'
+             '   typevar      ::= identifier (":" expression)?\n'
+             '   typevartuple ::= "*" identifier\n'
+             '   paramspec    ::= "**" identifier\n'
+             '\n'
+             'Functions (including coroutines), classes and type aliases may '
+             'contain\n'
+             'a type parameter list:\n'
+             '\n'
+             '   def max[T](args: list[T]) -> T:\n'
+             '       ...\n'
+             '\n'
+             '   async def amax[T](args: list[T]) -> T:\n'
+             '       ...\n'
+             '\n'
+             '   class Bag[T]:\n'
+             '       def __iter__(self) -> Iterator[T]:\n'
+             '           ...\n'
+             '\n'
+             '       def add(self, arg: T) -> None:\n'
+             '           ...\n'
+             '\n'
+             '   type ListOrSet[T] = list[T] | set[T]\n'
+             '\n'
+             'Semantically, this indicates that the function, class, or type '
+             'alias\n'
+             'is generic over a type variable. This information is primarily '
+             'used by\n'
+             'static type checkers, and at runtime, generic objects behave '
+             'much like\n'
+             'their non-generic counterparts.\n'
+             '\n'
+             'Type parameters are declared in square brackets ("[]") '
+             'immediately\n'
+             'after the name of the function, class, or type alias. The type\n'
+             'parameters are accessible within the scope of the generic '
+             'object, but\n'
+             'not elsewhere. Thus, after a declaration "def func[T](): pass", '
+             'the\n'
+             'name "T" is not available in the module scope. Below, the '
+             'semantics of\n'
+             'generic objects are described with more precision. The scope of '
+             'type\n'
+             'parameters is modeled with a special function (technically, an\n'
+             'annotation scope) that wraps the creation of the generic '
+             'object.\n'
+             '\n'
+             'Generic functions, classes, and type aliases have a '
+             '"__type_params__"\n'
+             'attribute listing their type parameters.\n'
+             '\n'
+             'Type parameters come in three kinds:\n'
+             '\n'
+             '* "typing.TypeVar", introduced by a plain name (e.g., "T").\n'
+             '  Semantically, this represents a single type to a type '
+             'checker.\n'
+             '\n'
+             '* "typing.TypeVarTuple", introduced by a name prefixed with a '
+             'single\n'
+             '  asterisk (e.g., "*Ts"). Semantically, this stands for a tuple '
+             'of any\n'
+             '  number of types.\n'
+             '\n'
+             '* "typing.ParamSpec", introduced by a name prefixed with two '
+             'asterisks\n'
+             '  (e.g., "**P"). Semantically, this stands for the parameters of '
+             'a\n'
+             '  callable.\n'
+             '\n'
+             '"typing.TypeVar" declarations can define *bounds* and '
+             '*constraints*\n'
+             'with a colon (":") followed by an expression. A single '
+             'expression\n'
+             'after the colon indicates a bound (e.g. "T: int"). Semantically, '
+             'this\n'
+             'means that the "typing.TypeVar" can only represent types that '
+             'are a\n'
+             'subtype of this bound. A parenthesized tuple of expressions '
+             'after the\n'
+             'colon indicates a set of constraints (e.g. "T: (str, bytes)"). '
+             'Each\n'
+             'member of the tuple should be a type (again, this is not '
+             'enforced at\n'
+             'runtime). Constrained type variables can only take on one of the '
+             'types\n'
+             'in the list of constraints.\n'
+             '\n'
+             'For "typing.TypeVar"s declared using the type parameter list '
+             'syntax,\n'
+             'the bound and constraints are not evaluated when the generic '
+             'object is\n'
+             'created, but only when the value is explicitly accessed through '
+             'the\n'
+             'attributes "__bound__" and "__constraints__". To accomplish '
+             'this, the\n'
+             'bounds or constraints are evaluated in a separate annotation '
+             'scope.\n'
+             '\n'
+             '"typing.TypeVarTuple"s and "typing.ParamSpec"s cannot have '
+             'bounds or\n'
+             'constraints.\n'
+             '\n'
+             'The following example indicates the full set of allowed type '
+             'parameter\n'
+             'declarations:\n'
+             '\n'
+             '   def overly_generic[\n'
+             '      SimpleTypeVar,\n'
+             '      TypeVarWithBound: int,\n'
+             '      TypeVarWithConstraints: (str, bytes),\n'
+             '      *SimpleTypeVarTuple,\n'
+             '      **SimpleParamSpec,\n'
+             '   ](\n'
+             '      a: SimpleTypeVar,\n'
+             '      b: TypeVarWithBound,\n'
+             '      c: Callable[SimpleParamSpec, TypeVarWithConstraints],\n'
+             '      *d: SimpleTypeVarTuple,\n'
+             '   ): ...\n'
+             '\n'
+             '\n'
+             'Generic functions\n'
+             '-----------------\n'
+             '\n'
+             'Generic functions are declared as follows:\n'
+             '\n'
+             '   def func[T](arg: T): ...\n'
+             '\n'
+             'This syntax is equivalent to:\n'
+             '\n'
+             '   annotation-def TYPE_PARAMS_OF_func():\n'
+             '       T = typing.TypeVar("T")\n'
+             '       def func(arg: T): ...\n'
+             '       func.__type_params__ = (T,)\n'
+             '       return func\n'
+             '   func = TYPE_PARAMS_OF_func()\n'
+             '\n'
+             'Here "annotation-def" indicates an annotation scope, which is '
+             'not\n'
+             'actually bound to any name at runtime. (One other liberty is '
+             'taken in\n'
+             'the translation: the syntax does not go through attribute access '
+             'on\n'
+             'the "typing" module, but creates an instance of '
+             '"typing.TypeVar"\n'
+             'directly.)\n'
+             '\n'
+             'The annotations of generic functions are evaluated within the\n'
+             'annotation scope used for declaring the type parameters, but '
+             'the\n'
+             'function’s defaults and decorators are not.\n'
+             '\n'
+             'The following example illustrates the scoping rules for these '
+             'cases,\n'
+             'as well as for additional flavors of type parameters:\n'
+             '\n'
+             '   @decorator\n'
+             '   def func[T: int, *Ts, **P](*args: *Ts, arg: Callable[P, T] = '
+             'some_default):\n'
+             '       ...\n'
+             '\n'
+             'Except for the lazy evaluation of the "TypeVar" bound, this is\n'
+             'equivalent to:\n'
+             '\n'
+             '   DEFAULT_OF_arg = some_default\n'
+             '\n'
+             '   annotation-def TYPE_PARAMS_OF_func():\n'
+             '\n'
+             '       annotation-def BOUND_OF_T():\n'
+             '           return int\n'
+             '       # In reality, BOUND_OF_T() is evaluated only on demand.\n'
+             '       T = typing.TypeVar("T", bound=BOUND_OF_T())\n'
+             '\n'
+             '       Ts = typing.TypeVarTuple("Ts")\n'
+             '       P = typing.ParamSpec("P")\n'
+             '\n'
+             '       def func(*args: *Ts, arg: Callable[P, T] = '
+             'DEFAULT_OF_arg):\n'
+             '           ...\n'
+             '\n'
+             '       func.__type_params__ = (T, Ts, P)\n'
+             '       return func\n'
+             '   func = decorator(TYPE_PARAMS_OF_func())\n'
+             '\n'
+             'The capitalized names like "DEFAULT_OF_arg" are not actually '
+             'bound at\n'
+             'runtime.\n'
+             '\n'
+             '\n'
+             'Generic classes\n'
+             '---------------\n'
+             '\n'
+             'Generic classes are declared as follows:\n'
+             '\n'
+             '   class Bag[T]: ...\n'
+             '\n'
+             'This syntax is equivalent to:\n'
+             '\n'
+             '   annotation-def TYPE_PARAMS_OF_Bag():\n'
+             '       T = typing.TypeVar("T")\n'
+             '       class Bag(typing.Generic[T]):\n'
+             '           __type_params__ = (T,)\n'
+             '           ...\n'
+             '       return Bag\n'
+             '   Bag = TYPE_PARAMS_OF_Bag()\n'
+             '\n'
+             'Here again "annotation-def" (not a real keyword) indicates an\n'
+             'annotation scope, and the name "TYPE_PARAMS_OF_Bag" is not '
+             'actually\n'
+             'bound at runtime.\n'
+             '\n'
+             'Generic classes implicitly inherit from "typing.Generic". The '
+             'base\n'
+             'classes and keyword arguments of generic classes are evaluated '
+             'within\n'
+             'the type scope for the type parameters, and decorators are '
+             'evaluated\n'
+             'outside that scope. This is illustrated by this example:\n'
+             '\n'
+             '   @decorator\n'
+             '   class Bag(Base[T], arg=T): ...\n'
+             '\n'
+             'This is equivalent to:\n'
+             '\n'
+             '   annotation-def TYPE_PARAMS_OF_Bag():\n'
+             '       T = typing.TypeVar("T")\n'
+             '       class Bag(Base[T], typing.Generic[T], arg=T):\n'
+             '           __type_params__ = (T,)\n'
+             '           ...\n'
+             '       return Bag\n'
+             '   Bag = decorator(TYPE_PARAMS_OF_Bag())\n'
+             '\n'
+             '\n'
+             'Generic type aliases\n'
+             '--------------------\n'
+             '\n'
+             'The "type" statement can also be used to create a generic type '
+             'alias:\n'
+             '\n'
+             '   type ListOrSet[T] = list[T] | set[T]\n'
+             '\n'
+             'Except for the lazy evaluation of the value, this is equivalent '
+             'to:\n'
+             '\n'
+             '   annotation-def TYPE_PARAMS_OF_ListOrSet():\n'
+             '       T = typing.TypeVar("T")\n'
+             '\n'
+             '       annotation-def VALUE_OF_ListOrSet():\n'
+             '           return list[T] | set[T]\n'
+             '       # In reality, the value is lazily evaluated\n'
+             '       return typing.TypeAliasType("ListOrSet", '
+             'VALUE_OF_ListOrSet(), type_params=(T,))\n'
+             '   ListOrSet = TYPE_PARAMS_OF_ListOrSet()\n'
+             '\n'
+             'Here, "annotation-def" (not a real keyword) indicates an '
+             'annotation\n'
+             'scope. The capitalized names like "TYPE_PARAMS_OF_ListOrSet" are '
+             'not\n'
+             'actually bound at runtime.\n'
+             '\n'
              '-[ Footnotes ]-\n'
              '\n'
              '[1] The exception is propagated to the invocation stack unless '
@@ -4953,6 +5185,29 @@ topics = {'assert': 'The "assert" statement\n'
              'implicit\n'
              'string concatenation "\';\'\';\'" or "";"";"".\n'
              '\n'
+             'To set a temporary global variable, use a *convenience '
+             'variable*. A\n'
+             '*convenience variable* is a variable whose name starts with '
+             '"$".  For\n'
+             'example, "$foo = 1" sets a global variable "$foo" which you can '
+             'use in\n'
+             'the debugger session.  The *convenience variables* are cleared '
+             'when\n'
+             'the program resumes execution so it’s less likely to interfere '
+             'with\n'
+             'your program compared to using normal variables like "foo = 1".\n'
+             '\n'
+             'There are three preset *convenience variables*:\n'
+             '\n'
+             '* "$_frame": the current frame you are debugging\n'
+             '\n'
+             '* "$_retval": the return value if the frame is returning\n'
+             '\n'
+             '* "$_exception": the exception if the frame is raising an '
+             'exception\n'
+             '\n'
+             'New in version 3.12.\n'
+             '\n'
              'If a file ".pdbrc" exists in the user’s home directory or in '
              'the\n'
              'current directory, it is read with "\'utf-8\'" encoding and '
@@ -5046,7 +5301,7 @@ topics = {'assert': 'The "assert" statement\n'
              'first\n'
              '   ask confirmation).\n'
              '\n'
-             'disable [bpnumber ...]\n'
+             'disable bpnumber [bpnumber ...]\n'
              '\n'
              '   Disable the breakpoints given as a space separated list of\n'
              '   breakpoint numbers.  Disabling a breakpoint means it cannot '
@@ -5055,7 +5310,7 @@ topics = {'assert': 'The "assert" statement\n'
              'breakpoint, it\n'
              '   remains in the list of breakpoints and can be (re-)enabled.\n'
              '\n'
-             'enable [bpnumber ...]\n'
+             'enable bpnumber [bpnumber ...]\n'
              '\n'
              '   Enable the breakpoints specified.\n'
              '\n'
@@ -5372,11 +5627,14 @@ topics = {'assert': 'The "assert" statement\n'
              'current\n'
              '   stack frame. The exclamation point can be omitted unless the '
              'first\n'
-             '   word of the statement resembles a debugger command.  To set '
-             'a\n'
-             '   global variable, you can prefix the assignment command with '
-             'a\n'
-             '   "global" statement on the same line, e.g.:\n'
+             '   word of the statement resembles a debugger command, e.g.:\n'
+             '\n'
+             '      (Pdb) ! n=42\n'
+             '      (Pdb)\n'
+             '\n'
+             '   To set a global variable, you can prefix the assignment '
+             'command\n'
+             '   with a "global" statement on the same line, e.g.:\n'
              '\n'
              "      (Pdb) global list_options; list_options = ['-l']\n"
              '      (Pdb)\n'
@@ -5688,6 +5946,10 @@ topics = {'assert': 'The "assert" statement\n'
               '\n'
               '* "import" statements.\n'
               '\n'
+              '* "type" statements.\n'
+              '\n'
+              '* type parameter lists.\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'
@@ -5794,7 +6056,9 @@ topics = {'assert': 'The "assert" statement\n'
               'scope.\n'
               '"SyntaxError" is raised at compile time if the given name does '
               'not\n'
-              'exist in any enclosing function scope.\n'
+              'exist in any enclosing function scope. Type parameters cannot '
+              'be\n'
+              'rebound with the "nonlocal" statement.\n'
               '\n'
               'The namespace for a module is automatically created the first '
               'time a\n'
@@ -5817,17 +6081,162 @@ topics = {'assert': 'The "assert" statement\n'
               'the class. The scope of names defined in a class block is '
               'limited to\n'
               'the class block; it does not extend to the code blocks of '
-              'methods –\n'
-              'this includes comprehensions and generator expressions since '
-              'they are\n'
-              'implemented using a function scope.  This means that the '
-              'following\n'
-              'will fail:\n'
+              'methods.\n'
+              'This includes comprehensions and generator expressions, but it '
+              'does\n'
+              'not include annotation scopes, which have access to their '
+              'enclosing\n'
+              'class scopes. This means that the following will fail:\n'
               '\n'
               '   class A:\n'
               '       a = 42\n'
               '       b = list(a + i for i in range(10))\n'
               '\n'
+              'However, the following will succeed:\n'
+              '\n'
+              '   class A:\n'
+              '       type Alias = Nested\n'
+              '       class Nested: pass\n'
+              '\n'
+              "   print(A.Alias.__value__)  # <type 'A.Nested'>\n"
+              '\n'
+              '\n'
+              'Annotation scopes\n'
+              '-----------------\n'
+              '\n'
+              'Type parameter lists and "type" statements introduce '
+              '*annotation\n'
+              'scopes*, which behave mostly like function scopes, but with '
+              'some\n'
+              'exceptions discussed below. *Annotations* currently do not use\n'
+              'annotation scopes, but they are expected to use annotation '
+              'scopes in\n'
+              'Python 3.13 when **PEP 649** is implemented.\n'
+              '\n'
+              'Annotation scopes are used in the following contexts:\n'
+              '\n'
+              '* Type parameter lists for generic type aliases.\n'
+              '\n'
+              '* Type parameter lists for generic functions. A generic '
+              'function’s\n'
+              '  annotations are executed within the annotation scope, but '
+              'its\n'
+              '  defaults and decorators are not.\n'
+              '\n'
+              '* Type parameter lists for generic classes. A generic class’s '
+              'base\n'
+              '  classes and keyword arguments are executed within the '
+              'annotation\n'
+              '  scope, but its decorators are not.\n'
+              '\n'
+              '* The bounds and constraints for type variables (lazily '
+              'evaluated).\n'
+              '\n'
+              '* The value of type aliases (lazily evaluated).\n'
+              '\n'
+              'Annotation scopes differ from function scopes in the following '
+              'ways:\n'
+              '\n'
+              '* Annotation scopes have access to their enclosing class '
+              'namespace. If\n'
+              '  an annotation scope is immediately within a class scope, or '
+              'within\n'
+              '  another annotation scope that is immediately within a class '
+              'scope,\n'
+              '  the code in the annotation scope can use names defined in the '
+              'class\n'
+              '  scope as if it were executed directly within the class body. '
+              'This\n'
+              '  contrasts with regular functions defined within classes, '
+              'which\n'
+              '  cannot access names defined in the class scope.\n'
+              '\n'
+              '* Expressions in annotation scopes cannot contain "yield", '
+              '"yield\n'
+              '  from", "await", or ":=" expressions. (These expressions are '
+              'allowed\n'
+              '  in other scopes contained within the annotation scope.)\n'
+              '\n'
+              '* Names defined in annotation scopes cannot be rebound with '
+              '"nonlocal"\n'
+              '  statements in inner scopes. This includes only type '
+              'parameters, as\n'
+              '  no other syntactic elements that can appear within annotation '
+              'scopes\n'
+              '  can introduce new names.\n'
+              '\n'
+              '* While annotation scopes have an internal name, that name is '
+              'not\n'
+              '  reflected in the *__qualname__* of objects defined within the '
+              'scope.\n'
+              '  Instead, the "__qualname__" of such objects is as if the '
+              'object were\n'
+              '  defined in the enclosing scope.\n'
+              '\n'
+              'New in version 3.12: Annotation scopes were introduced in '
+              'Python 3.12\n'
+              'as part of **PEP 695**.\n'
+              '\n'
+              '\n'
+              'Lazy evaluation\n'
+              '---------------\n'
+              '\n'
+              'The values of type aliases created through the "type" statement '
+              'are\n'
+              '*lazily evaluated*. The same applies to the bounds and '
+              'constraints of\n'
+              'type variables created through the type parameter syntax. This '
+              'means\n'
+              'that they are not evaluated when the type alias or type '
+              'variable is\n'
+              'created. Instead, they are only evaluated when doing so is '
+              'necessary\n'
+              'to resolve an attribute access.\n'
+              '\n'
+              'Example:\n'
+              '\n'
+              '   >>> type Alias = 1/0\n'
+              '   >>> Alias.__value__\n'
+              '   Traceback (most recent call last):\n'
+              '     ...\n'
+              '   ZeroDivisionError: division by zero\n'
+              '   >>> def func[T: 1/0](): pass\n'
+              '   >>> T = func.__type_params__[0]\n'
+              '   >>> T.__bound__\n'
+              '   Traceback (most recent call last):\n'
+              '     ...\n'
+              '   ZeroDivisionError: division by zero\n'
+              '\n'
+              'Here the exception is raised only when the "__value__" '
+              'attribute of\n'
+              'the type alias or the "__bound__" attribute of the type '
+              'variable is\n'
+              'accessed.\n'
+              '\n'
+              'This behavior is primarily useful for references to types that '
+              'have\n'
+              'not yet been defined when the type alias or type variable is '
+              'created.\n'
+              'For example, lazy evaluation enables creation of mutually '
+              'recursive\n'
+              'type aliases:\n'
+              '\n'
+              '   from typing import Literal\n'
+              '\n'
+              '   type SimpleExpr = int | Parenthesized\n'
+              '   type Parenthesized = tuple[Literal["("], Expr, '
+              'Literal[")"]]\n'
+              '   type Expr = SimpleExpr | tuple[SimpleExpr, Literal["+", '
+              '"-"], Expr]\n'
+              '\n'
+              'Lazily evaluated values are evaluated in annotation scope, '
+              'which means\n'
+              'that names that appear inside the lazily evaluated value are '
+              'looked up\n'
+              'as if they were used in the immediately enclosing scope.\n'
+              '\n'
+              'New in version 3.12.\n'
+              '\n'
               '\n'
               'Builtins and restricted execution\n'
               '---------------------------------\n'
@@ -6859,8 +7268,8 @@ topics = {'assert': 'The "assert" statement\n'
              '(see\n'
              'section The standard type hierarchy):\n'
              '\n'
-             '   funcdef                   ::= [decorators] "def" funcname "(" '
-             '[parameter_list] ")"\n'
+             '   funcdef                   ::= [decorators] "def" funcname '
+             '[type_params] "(" [parameter_list] ")"\n'
              '               ["->" expression] ":" suite\n'
              '   decorators                ::= decorator+\n'
              '   decorator                 ::= "@" assignment_expression '
@@ -6922,6 +7331,19 @@ topics = {'assert': 'The "assert" statement\n'
              '"assignment_expression". Previously, the grammar was much more\n'
              'restrictive; see **PEP 614** for details.\n'
              '\n'
+             'A list of type parameters may be given in square brackets '
+             'between the\n'
+             'function’s name and the opening parenthesis for its parameter '
+             'list.\n'
+             'This indicates to static type checkers that the function is '
+             'generic.\n'
+             'At runtime, the type parameters can be retrieved from the '
+             'function’s\n'
+             '"__type_params__" attribute. See Generic functions for more.\n'
+             '\n'
+             'Changed in version 3.12: Type parameter lists are new in Python '
+             '3.12.\n'
+             '\n'
              'When one or more *parameters* have the form *parameter* "="\n'
              '*expression*, the function is said to have “default parameter '
              'values.”\n'
@@ -7240,8 +7662,8 @@ topics = {'assert': 'The "assert" statement\n'
                 '\n'
                 'A non-normative HTML file listing all valid identifier '
                 'characters for\n'
-                'Unicode 14.0.0 can be found at\n'
-                'https://www.unicode.org/Public/14.0.0/ucd/DerivedCoreProperties.txt\n'
+                'Unicode 15.0.0 can be found at\n'
+                'https://www.unicode.org/Public/15.0.0/ucd/DerivedCoreProperties.txt\n'
                 '\n'
                 '\n'
                 'Keywords\n'
@@ -7269,19 +7691,24 @@ topics = {'assert': 'The "assert" statement\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'
+                'known as *soft keywords*.  The identifiers "match", "case", '
+                '"type" and\n'
+                '"_" can syntactically act as keywords in certain contexts, '
+                'but this\n'
+                'distinction is done at the parser level, not when '
+                'tokenizing.\n'
+                '\n'
+                'As soft keywords, their use in the grammar is possible while '
+                'still\n'
+                'preserving compatibility with existing code that uses these '
+                'names as\n'
+                'identifier names.\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'
+                '"match", "case", and "_" are used in the "match" statement. '
+                '"type" is\n'
+                'used in the "type" statement.\n'
+                '\n'
+                'Changed in version 3.12: "type" is now a soft keyword.\n'
                 '\n'
                 '\n'
                 'Reserved classes of identifiers\n'
@@ -7801,6 +8228,10 @@ topics = {'assert': 'The "assert" statement\n'
            '\n'
            '* "import" statements.\n'
            '\n'
+           '* "type" statements.\n'
+           '\n'
+           '* type parameter lists.\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'
@@ -7900,7 +8331,8 @@ topics = {'assert': 'The "assert" statement\n'
            'scope.\n'
            '"SyntaxError" is raised at compile time if the given name does '
            'not\n'
-           'exist in any enclosing function scope.\n'
+           'exist in any enclosing function scope. Type parameters cannot be\n'
+           'rebound with the "nonlocal" statement.\n'
            '\n'
            'The namespace for a module is automatically created the first time '
            'a\n'
@@ -7922,18 +8354,156 @@ topics = {'assert': 'The "assert" statement\n'
            'of\n'
            'the class. The scope of names defined in a class block is limited '
            'to\n'
-           'the class block; it does not extend to the code blocks of methods '
-           '–\n'
-           'this includes comprehensions and generator expressions since they '
-           'are\n'
-           'implemented using a function scope.  This means that the '
-           'following\n'
-           'will fail:\n'
+           'the class block; it does not extend to the code blocks of '
+           'methods.\n'
+           'This includes comprehensions and generator expressions, but it '
+           'does\n'
+           'not include annotation scopes, which have access to their '
+           'enclosing\n'
+           'class scopes. This means that the following will fail:\n'
            '\n'
            '   class A:\n'
            '       a = 42\n'
            '       b = list(a + i for i in range(10))\n'
            '\n'
+           'However, the following will succeed:\n'
+           '\n'
+           '   class A:\n'
+           '       type Alias = Nested\n'
+           '       class Nested: pass\n'
+           '\n'
+           "   print(A.Alias.__value__)  # <type 'A.Nested'>\n"
+           '\n'
+           '\n'
+           'Annotation scopes\n'
+           '=================\n'
+           '\n'
+           'Type parameter lists and "type" statements introduce *annotation\n'
+           'scopes*, which behave mostly like function scopes, but with some\n'
+           'exceptions discussed below. *Annotations* currently do not use\n'
+           'annotation scopes, but they are expected to use annotation scopes '
+           'in\n'
+           'Python 3.13 when **PEP 649** is implemented.\n'
+           '\n'
+           'Annotation scopes are used in the following contexts:\n'
+           '\n'
+           '* Type parameter lists for generic type aliases.\n'
+           '\n'
+           '* Type parameter lists for generic functions. A generic '
+           'function’s\n'
+           '  annotations are executed within the annotation scope, but its\n'
+           '  defaults and decorators are not.\n'
+           '\n'
+           '* Type parameter lists for generic classes. A generic class’s '
+           'base\n'
+           '  classes and keyword arguments are executed within the '
+           'annotation\n'
+           '  scope, but its decorators are not.\n'
+           '\n'
+           '* The bounds and constraints for type variables (lazily '
+           'evaluated).\n'
+           '\n'
+           '* The value of type aliases (lazily evaluated).\n'
+           '\n'
+           'Annotation scopes differ from function scopes in the following '
+           'ways:\n'
+           '\n'
+           '* Annotation scopes have access to their enclosing class '
+           'namespace. If\n'
+           '  an annotation scope is immediately within a class scope, or '
+           'within\n'
+           '  another annotation scope that is immediately within a class '
+           'scope,\n'
+           '  the code in the annotation scope can use names defined in the '
+           'class\n'
+           '  scope as if it were executed directly within the class body. '
+           'This\n'
+           '  contrasts with regular functions defined within classes, which\n'
+           '  cannot access names defined in the class scope.\n'
+           '\n'
+           '* Expressions in annotation scopes cannot contain "yield", "yield\n'
+           '  from", "await", or ":=" expressions. (These expressions are '
+           'allowed\n'
+           '  in other scopes contained within the annotation scope.)\n'
+           '\n'
+           '* Names defined in annotation scopes cannot be rebound with '
+           '"nonlocal"\n'
+           '  statements in inner scopes. This includes only type parameters, '
+           'as\n'
+           '  no other syntactic elements that can appear within annotation '
+           'scopes\n'
+           '  can introduce new names.\n'
+           '\n'
+           '* While annotation scopes have an internal name, that name is not\n'
+           '  reflected in the *__qualname__* of objects defined within the '
+           'scope.\n'
+           '  Instead, the "__qualname__" of such objects is as if the object '
+           'were\n'
+           '  defined in the enclosing scope.\n'
+           '\n'
+           'New in version 3.12: Annotation scopes were introduced in Python '
+           '3.12\n'
+           'as part of **PEP 695**.\n'
+           '\n'
+           '\n'
+           'Lazy evaluation\n'
+           '===============\n'
+           '\n'
+           'The values of type aliases created through the "type" statement '
+           'are\n'
+           '*lazily evaluated*. The same applies to the bounds and constraints '
+           'of\n'
+           'type variables created through the type parameter syntax. This '
+           'means\n'
+           'that they are not evaluated when the type alias or type variable '
+           'is\n'
+           'created. Instead, they are only evaluated when doing so is '
+           'necessary\n'
+           'to resolve an attribute access.\n'
+           '\n'
+           'Example:\n'
+           '\n'
+           '   >>> type Alias = 1/0\n'
+           '   >>> Alias.__value__\n'
+           '   Traceback (most recent call last):\n'
+           '     ...\n'
+           '   ZeroDivisionError: division by zero\n'
+           '   >>> def func[T: 1/0](): pass\n'
+           '   >>> T = func.__type_params__[0]\n'
+           '   >>> T.__bound__\n'
+           '   Traceback (most recent call last):\n'
+           '     ...\n'
+           '   ZeroDivisionError: division by zero\n'
+           '\n'
+           'Here the exception is raised only when the "__value__" attribute '
+           'of\n'
+           'the type alias or the "__bound__" attribute of the type variable '
+           'is\n'
+           'accessed.\n'
+           '\n'
+           'This behavior is primarily useful for references to types that '
+           'have\n'
+           'not yet been defined when the type alias or type variable is '
+           'created.\n'
+           'For example, lazy evaluation enables creation of mutually '
+           'recursive\n'
+           'type aliases:\n'
+           '\n'
+           '   from typing import Literal\n'
+           '\n'
+           '   type SimpleExpr = int | Parenthesized\n'
+           '   type Parenthesized = tuple[Literal["("], Expr, Literal[")"]]\n'
+           '   type Expr = SimpleExpr | tuple[SimpleExpr, Literal["+", "-"], '
+           'Expr]\n'
+           '\n'
+           'Lazily evaluated values are evaluated in annotation scope, which '
+           'means\n'
+           'that names that appear inside the lazily evaluated value are '
+           'looked up\n'
+           'as if they were used in the immediately enclosing scope.\n'
+           '\n'
+           'New in version 3.12.\n'
+           '\n'
            '\n'
            'Builtins and restricted execution\n'
            '=================================\n'
@@ -9098,6 +9668,14 @@ topics = {'assert': 'The "assert" statement\n'
                  '\n'
                  '   New in version 3.3.\n'
                  '\n'
+                 'definition.__type_params__\n'
+                 '\n'
+                 '   The type parameters of generic classes, functions, and '
+                 'type\n'
+                 '   aliases.\n'
+                 '\n'
+                 '   New in version 3.12.\n'
+                 '\n'
                  'class.__mro__\n'
                  '\n'
                  '   This attribute is a tuple of classes that are considered '
@@ -10277,6 +10855,11 @@ topics = {'assert': 'The "assert" statement\n'
                  '     Dynamically resolve bases that are not instances of '
                  '"type".\n'
                  '\n'
+                 '  "types.get_original_bases()"\n'
+                 '     Retrieve a class’s “original bases” prior to '
+                 'modifications by\n'
+                 '     "__mro_entries__()".\n'
+                 '\n'
                  '  **PEP 560**\n'
                  '     Core support for typing module and generic types.\n'
                  '\n'
@@ -11252,6 +11835,61 @@ topics = {'assert': 'The "assert" statement\n'
                  '     The specification for the Python "match" statement.\n'
                  '\n'
                  '\n'
+                 'Emulating buffer types\n'
+                 '======================\n'
+                 '\n'
+                 'The buffer protocol provides a way for Python objects to '
+                 'expose\n'
+                 'efficient access to a low-level memory array. This protocol '
+                 'is\n'
+                 'implemented by builtin types such as "bytes" and '
+                 '"memoryview", and\n'
+                 'third-party libraries may define additional buffer types.\n'
+                 '\n'
+                 'While buffer types are usually implemented in C, it is also '
+                 'possible\n'
+                 'to implement the protocol in Python.\n'
+                 '\n'
+                 'object.__buffer__(self, flags)\n'
+                 '\n'
+                 '   Called when a buffer is requested from *self* (for '
+                 'example, by the\n'
+                 '   "memoryview" constructor). The *flags* argument is an '
+                 'integer\n'
+                 '   representing the kind of buffer requested, affecting for '
+                 'example\n'
+                 '   whether the returned buffer is read-only or writable.\n'
+                 '   "inspect.BufferFlags" provides a convenient way to '
+                 'interpret the\n'
+                 '   flags. The method must return a "memoryview" object.\n'
+                 '\n'
+                 'object.__release_buffer__(self, buffer)\n'
+                 '\n'
+                 '   Called when a buffer is no longer needed. The *buffer* '
+                 'argument is\n'
+                 '   a "memoryview" object that was previously returned by\n'
+                 '   "__buffer__()". The method must release any resources '
+                 'associated\n'
+                 '   with the buffer. This method should return "None". Buffer '
+                 'objects\n'
+                 '   that do not need to perform any cleanup are not required '
+                 'to\n'
+                 '   implement this method.\n'
+                 '\n'
+                 'New in version 3.12.\n'
+                 '\n'
+                 'See also:\n'
+                 '\n'
+                 '  **PEP 688** - Making the buffer protocol accessible in '
+                 'Python\n'
+                 '     Introduces the Python "__buffer__" and '
+                 '"__release_buffer__"\n'
+                 '     methods.\n'
+                 '\n'
+                 '  "collections.abc.Buffer"\n'
+                 '     ABC for buffer types.\n'
+                 '\n'
+                 '\n'
                  'Special method lookup\n'
                  '=====================\n'
                  '\n'
@@ -11399,8 +12037,8 @@ topics = {'assert': 'The "assert" statement\n'
                    '   "casefold()" converts it to ""ss"".\n'
                    '\n'
                    '   The casefolding algorithm is described in section 3.13 '
-                   'of the\n'
-                   '   Unicode Standard.\n'
+                   '‘Default\n'
+                   '   Case Folding’ of the Unicode Standard.\n'
                    '\n'
                    '   New in version 3.3.\n'
                    '\n'
@@ -11617,9 +12255,10 @@ topics = {'assert': 'The "assert" statement\n'
                    'property\n'
                    '   being one of “Lm”, “Lt”, “Lu”, “Ll”, or “Lo”.  Note '
                    'that this is\n'
-                   '   different from the “Alphabetic” property defined in the '
-                   'Unicode\n'
-                   '   Standard.\n'
+                   '   different from the Alphabetic property defined in the '
+                   'section 4.10\n'
+                   '   ‘Letters, Alphabetic, and Ideographic’ of the Unicode '
+                   'Standard.\n'
                    '\n'
                    'str.isascii()\n'
                    '\n'
@@ -11666,9 +12305,9 @@ topics = {'assert': 'The "assert" statement\n'
                    'according to the\n'
                    '   language definition, section Identifiers and keywords.\n'
                    '\n'
-                   '   Call "keyword.iskeyword()" to test whether string "s" '
-                   'is a reserved\n'
-                   '   identifier, such as "def" and "class".\n'
+                   '   "keyword.iskeyword()" can be used to test whether '
+                   'string "s" is a\n'
+                   '   reserved identifier, such as "def" and "class".\n'
                    '\n'
                    '   Example:\n'
                    '\n'
@@ -11791,8 +12430,8 @@ topics = {'assert': 'The "assert" statement\n'
                    '   converted to lowercase.\n'
                    '\n'
                    '   The lowercasing algorithm used is described in section '
-                   '3.13 of the\n'
-                   '   Unicode Standard.\n'
+                   '3.13\n'
+                   '   ‘Default Case Folding’ of the Unicode Standard.\n'
                    '\n'
                    'str.lstrip([chars])\n'
                    '\n'
@@ -12258,8 +12897,8 @@ topics = {'assert': 'The "assert" statement\n'
                    '   uppercase), but e.g. “Lt” (Letter, titlecase).\n'
                    '\n'
                    '   The uppercasing algorithm used is described in section '
-                   '3.13 of the\n'
-                   '   Unicode Standard.\n'
+                   '3.13\n'
+                   '   ‘Default Case Folding’ of the Unicode Standard.\n'
                    '\n'
                    'str.zfill(width)\n'
                    '\n'
@@ -12328,12 +12967,15 @@ topics = {'assert': 'The "assert" statement\n'
             'single quotes ("\'") or double quotes (""").  They can also be '
             'enclosed\n'
             'in matching groups of three single or double quotes (these are\n'
-            'generally referred to as *triple-quoted strings*).  The '
-            'backslash\n'
-            '("\\") character is used to escape characters that otherwise have '
-            'a\n'
-            'special meaning, such as newline, backslash itself, or the quote\n'
+            'generally referred to as *triple-quoted strings*). The backslash '
+            '("\\")\n'
+            'character is used to give special meaning to otherwise ordinary\n'
+            'characters like "n", which means ‘newline’ when escaped ("\\n"). '
+            'It can\n'
+            'also be used to escape characters that otherwise have a special\n'
+            'meaning, such as newline, backslash itself, or the quote '
             'character.\n'
+            'See escape sequences below for examples.\n'
             '\n'
             'Bytes literals are always prefixed with "\'b\'" or "\'B\'"; they '
             'produce\n'
@@ -12472,10 +13114,12 @@ topics = {'assert': 'The "assert" statement\n'
             '2. As in Standard C, up to three octal digits are accepted.\n'
             '\n'
             '   Changed in version 3.11: Octal escapes with value larger than\n'
-            '   "0o377" produce a "DeprecationWarning". In a future Python '
-            'version\n'
-            '   they will be a "SyntaxWarning" and eventually a '
-            '"SyntaxError".\n'
+            '   "0o377" produce a "DeprecationWarning".\n'
+            '\n'
+            '   Changed in version 3.12: Octal escapes with value larger than\n'
+            '   "0o377" produce a "SyntaxWarning". In a future Python version '
+            'they\n'
+            '   will be eventually a "SyntaxError".\n'
             '\n'
             '3. Unlike in Standard C, exactly two hex digits are required.\n'
             '\n'
@@ -12509,8 +13153,12 @@ topics = {'assert': 'The "assert" statement\n'
             'literals.\n'
             '\n'
             'Changed in version 3.6: Unrecognized escape sequences produce a\n'
-            '"DeprecationWarning".  In a future Python version they will be a\n'
-            '"SyntaxWarning" and eventually a "SyntaxError".\n'
+            '"DeprecationWarning".\n'
+            '\n'
+            'Changed in version 3.12: Unrecognized escape sequences produce a\n'
+            '"SyntaxWarning". In a future Python version they will be '
+            'eventually a\n'
+            '"SyntaxError".\n'
             '\n'
             'Even in a raw literal, quotes can be escaped with a backslash, '
             'but the\n'
@@ -12795,14 +13443,10 @@ topics = {'assert': 'The "assert" statement\n'
         '\n'
         'Any remaining exceptions that were not handled by any "except*" '
         'clause\n'
-        'are re-raised at the end, combined into an exception group along '
-        'with\n'
-        'all exceptions that were raised from within "except*" clauses.\n'
-        '\n'
-        'From version 3.11.4, when the entire "ExceptionGroup" is handled and\n'
-        'only one exception is raised from an "except*" clause, this '
-        'exception\n'
-        'is no longer wrapped to form a new "ExceptionGroup".\n'
+        'are re-raised at the end, along with all exceptions that were raised\n'
+        'from within the "except*" clauses. If this list contains more than '
+        'one\n'
+        'exception to reraise, they are combined into an exception group.\n'
         '\n'
         'If the raised exception is not an exception group and its type '
         'matches\n'
@@ -13362,6 +14006,11 @@ topics = {'assert': 'The "assert" statement\n'
           '|                                                    | only '
           '*parameters*.                                 |\n'
           '+----------------------------------------------------+----------------------------------------------------+\n'
+          '| function.__type_params__                           | A "tuple" '
+          'containing the type parameters of a      |\n'
+          '|                                                    | generic '
+          'function.  New in version 3.12.            |\n'
+          '+----------------------------------------------------+----------------------------------------------------+\n'
           '\n'
           'Function objects also support getting and setting arbitrary\n'
           'attributes, which can be used, for example, to attach metadata to\n'
@@ -13713,6 +14362,9 @@ topics = {'assert': 'The "assert" statement\n'
           '      class body execution.  For best practices on working with\n'
           '      "__annotations__", please see Annotations Best Practices.\n'
           '\n'
+          '   "__type_params__"\n'
+          '      A tuple containing the type parameters of a generic class.\n'
+          '\n'
           '\n'
           'Class instances\n'
           '===============\n'
@@ -13886,7 +14538,11 @@ topics = {'assert': 'The "assert" statement\n'
           '|                                                    | offsets to '
           'line numbers. For details, see the      |\n'
           '|                                                    | source code '
-          'of the interpreter.                    |\n'
+          'of the interpreter.  Deprecated since  |\n'
+          '|                                                    | version '
+          '3.12: This attribute of code objects is    |\n'
+          '|                                                    | deprecated, '
+          'and may be removed in Python 3.14.     |\n'
           '+----------------------------------------------------+----------------------------------------------------+\n'
           '| codeobject.co_stacksize                            | The required '
           'stack size of the code object         |\n'
@@ -14415,6 +15071,7 @@ topics = {'assert': 'The "assert" statement\n'
                  '         >>> class Counter(dict):\n'
                  '         ...     def __missing__(self, key):\n'
                  '         ...         return 0\n'
+                 '         ...\n'
                  '         >>> c = Counter()\n'
                  "         >>> c['red']\n"
                  '         0\n'
@@ -14714,17 +15371,23 @@ topics = {'assert': 'The "assert" statement\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 '
-                 'unique\n'
-                 'and hashable, then the items view is also set-like.  (Values '
-                 'views are\n'
-                 'not treated as set-like since the entries are generally not '
-                 'unique.)\n'
-                 'For set-like views, all of the operations defined for the '
-                 'abstract\n'
-                 'base class "collections.abc.Set" are available (for example, '
-                 '"==",\n'
-                 '"<", or "^").\n'
+                 'Items views also have set-like operations since the (key, '
+                 'value) pairs\n'
+                 'are unique and the keys are hashable. If all values in an '
+                 'items view\n'
+                 'are hashable as well, then the items view can interoperate '
+                 'with other\n'
+                 'sets. (Values views are not treated as set-like since the '
+                 'entries are\n'
+                 'generally not unique.)  For set-like views, all of the '
+                 'operations\n'
+                 'defined for the abstract base class "collections.abc.Set" '
+                 'are\n'
+                 'available (for example, "==", "<", or "^").  While using '
+                 'set\n'
+                 'operators, set-like views accept any iterable as the other '
+                 'operand,\n'
+                 'unlike sets which only accept sets as the input.\n'
                  '\n'
                  'An example of dictionary view usage:\n'
                  '\n'
@@ -14737,6 +15400,7 @@ topics = {'assert': 'The "assert" statement\n'
                  '   >>> n = 0\n'
                  '   >>> for val in values:\n'
                  '   ...     n += val\n'
+                 '   ...\n'
                  '   >>> print(n)\n'
                  '   504\n'
                  '\n'