Update the magic number, rearrange typing.py accordingly

Author: JelleZijlstra

Lib/importlib/_bootstrap_external.py

@@ -439,6 +439,7 @@ def _write_atomic(path, data, mode=0o666):
 #     Python 3.12a7 3523 (Convert COMPARE_AND_BRANCH back to COMPARE_OP)
 #     Python 3.12a7 3524 (Shrink the BINARY_SUBSCR caches)
 #     Python 3.12b1 3525 (Shrink the CALL caches)
+#     Python 3.12b1 3526 (Add new instructions for PEP 695)
 
 #     Python 3.13 will start with 3550
 
@@ -455,7 +456,7 @@ def _write_atomic(path, data, mode=0o666):
 # Whenever MAGIC_NUMBER is changed, the ranges in the magic_values array
 # in PC/launcher.c must also be updated.
 
-MAGIC_NUMBER = (3525).to_bytes(2, 'little') + b'\r\n'
+MAGIC_NUMBER = (3526).to_bytes(2, 'little') + b'\r\n'
 
 _RAW_MAGIC_NUMBER = int.from_bytes(MAGIC_NUMBER, 'little')  # For import.c
 

Lib/typing.py

@@ -918,7 +918,8 @@ def _is_unpacked_typevartuple(x: Any) -> bool:
 
 
 def _is_typevar_like(x: Any) -> bool:
-    return isinstance(x, (TypeVar, ParamSpec)) or _is_unpacked_typevartuple(x)
+    # TODO(PEP 695): remove TypeVarTuple here
+    return isinstance(x, (TypeVar, ParamSpec, TypeVarTuple)) or _is_unpacked_typevartuple(x)
 
 
 class _PickleUsingNameMixin:
@@ -1301,29 +1302,93 @@ def __typing_prepare_subst__(self, alias, args):
 
 
 import builtins
-if hasattr(builtins, "TypeVar"):
-    class _Dummy[T, *Ts, **P]:
-        type_params = (T, Ts, P)
 
-    TypeVar = type(_Dummy.type_params[0])
-    TypeVarTuple = type(_Dummy.type_params[1])
-    ParamSpec = type(_Dummy.type_params[2])
-    ParamSpecArgs = type(ParamSpec("P").args)
-    ParamSpecKwargs = type(ParamSpec("P").kwargs)
 
-    del _Dummy
+@_tp_cache
+def _generic_class_getitem(cls, params):
+    """Parameterizes a generic class.
 
-    import copyreg
+    At least, parameterizing a generic class is the *main* thing this method
+    does. For example, for some generic class `Foo`, this is called when we
+    do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 
-    def _pickle_psargs(psargs):
-        return ParamSpecArgs, (psargs.__origin__,)
+    However, note that this method is also called when defining generic
+    classes in the first place with `class Foo(Generic[T]): ...`.
+    """
+    if not isinstance(params, tuple):
+        params = (params,)
 
-    copyreg.pickle(ParamSpecArgs, _pickle_psargs)
+    params = tuple(_type_convert(p) for p in params)
+    if cls in (builtins.Generic, Protocol):
+        # Generic and Protocol can only be subscripted with unique type variables.
+        if not params:
+            raise TypeError(
+                f"Parameter list to {cls.__qualname__}[...] cannot be empty"
+            )
+        if not all(_is_typevar_like(p) for p in params):
+            raise TypeError(
+                f"Parameters to {cls.__name__}[...] must all be type variables "
+                f"or parameter specification variables.")
+        if len(set(params)) != len(params):
+            raise TypeError(
+                f"Parameters to {cls.__name__}[...] must all be unique")
+    else:
+        # Subscripting a regular Generic subclass.
+        for param in cls.__parameters__:
+            prepare = getattr(param, '__typing_prepare_subst__', None)
+            if prepare is not None:
+                params = prepare(cls, params)
+        _check_generic(cls, params, len(cls.__parameters__))
 
-    def _pickle_pskwargs(pskwargs):
-        return ParamSpecKwargs, (pskwargs.__origin__,)
+        new_args = []
+        for param, new_arg in zip(cls.__parameters__, params):
+            if isinstance(param, TypeVarTuple):
+                new_args.extend(new_arg)
+            else:
+                new_args.append(new_arg)
+        params = tuple(new_args)
+
+    return _GenericAlias(cls, params,
+                            _paramspec_tvars=True)
+
+
+def _generic_init_subclass(cls, *args, **kwargs):
+    super(builtins.Generic, cls).__init_subclass__(*args, **kwargs)
+    tvars = []
+    if '__orig_bases__' in cls.__dict__:
+        error = builtins.Generic in cls.__orig_bases__
+    else:
+        error = (builtins.Generic in cls.__bases__ and
+                    cls.__name__ != 'Protocol' and
+                    type(cls) != _TypedDictMeta)
+    if error:
+        raise TypeError("Cannot inherit from plain Generic")
+    if '__orig_bases__' in cls.__dict__:
+        tvars = _collect_parameters(cls.__orig_bases__)
+        # Look for Generic[T1, ..., Tn].
+        # If found, tvars must be a subset of it.
+        # If not found, tvars is it.
+        # Also check for and reject plain Generic,
+        # and reject multiple Generic[...].
+        gvars = None
+        for base in cls.__orig_bases__:
+            if (isinstance(base, _GenericAlias) and
+                    base.__origin__ is builtins.Generic):
+                if gvars is not None:
+                    raise TypeError(
+                        "Cannot inherit from Generic[...] multiple types.")
+                gvars = base.__parameters__
+        if gvars is not None:
+            tvarset = set(tvars)
+            gvarset = set(gvars)
+            if not tvarset <= gvarset:
+                s_vars = ', '.join(str(t) for t in tvars if t not in gvarset)
+                s_args = ', '.join(str(g) for g in gvars)
+                raise TypeError(f"Some type variables ({s_vars}) are"
+                                f" not listed in Generic[{s_args}]")
+            tvars = gvars
+    cls.__parameters__ = tuple(tvars)
 
-    copyreg.pickle(ParamSpecKwargs, _pickle_pskwargs)
 
 def _is_dunder(attr):
     return attr.startswith('__') and attr.endswith('__')
@@ -1969,92 +2034,6 @@ def __init_subclass__(cls, *args, **kwargs):
         cls.__parameters__ = tuple(tvars)
 
 
-@_tp_cache
-def _generic_class_getitem(cls, params):
-    """Parameterizes a generic class.
-
-    At least, parameterizing a generic class is the *main* thing this method
-    does. For example, for some generic class `Foo`, this is called when we
-    do `Foo[int]` - there, with `cls=Foo` and `params=int`.
-
-    However, note that this method is also called when defining generic
-    classes in the first place with `class Foo(Generic[T]): ...`.
-    """
-    if not isinstance(params, tuple):
-        params = (params,)
-
-    params = tuple(_type_convert(p) for p in params)
-    if cls in (builtins.Generic, Protocol):
-        # Generic and Protocol can only be subscripted with unique type variables.
-        if not params:
-            raise TypeError(
-                f"Parameter list to {cls.__qualname__}[...] cannot be empty"
-            )
-        if not all(_is_typevar_like(p) for p in params):
-            raise TypeError(
-                f"Parameters to {cls.__name__}[...] must all be type variables "
-                f"or parameter specification variables.")
-        if len(set(params)) != len(params):
-            raise TypeError(
-                f"Parameters to {cls.__name__}[...] must all be unique")
-    else:
-        # Subscripting a regular Generic subclass.
-        for param in cls.__parameters__:
-            prepare = getattr(param, '__typing_prepare_subst__', None)
-            if prepare is not None:
-                params = prepare(cls, params)
-        _check_generic(cls, params, len(cls.__parameters__))
-
-        new_args = []
-        for param, new_arg in zip(cls.__parameters__, params):
-            if isinstance(param, TypeVarTuple):
-                new_args.extend(new_arg)
-            else:
-                new_args.append(new_arg)
-        params = tuple(new_args)
-
-    return _GenericAlias(cls, params,
-                            _paramspec_tvars=True)
-
-import builtins
-
-def _generic_init_subclass(cls, *args, **kwargs):
-    super(builtins.Generic, cls).__init_subclass__(*args, **kwargs)
-    tvars = []
-    if '__orig_bases__' in cls.__dict__:
-        error = builtins.Generic in cls.__orig_bases__
-    else:
-        error = (builtins.Generic in cls.__bases__ and
-                    cls.__name__ != 'Protocol' and
-                    type(cls) != _TypedDictMeta)
-    if error:
-        raise TypeError("Cannot inherit from plain Generic")
-    if '__orig_bases__' in cls.__dict__:
-        tvars = _collect_parameters(cls.__orig_bases__)
-        # Look for Generic[T1, ..., Tn].
-        # If found, tvars must be a subset of it.
-        # If not found, tvars is it.
-        # Also check for and reject plain Generic,
-        # and reject multiple Generic[...].
-        gvars = None
-        for base in cls.__orig_bases__:
-            if (isinstance(base, _GenericAlias) and
-                    base.__origin__ is builtins.Generic):
-                if gvars is not None:
-                    raise TypeError(
-                        "Cannot inherit from Generic[...] multiple types.")
-                gvars = base.__parameters__
-        if gvars is not None:
-            tvarset = set(tvars)
-            gvarset = set(gvars)
-            if not tvarset <= gvarset:
-                s_vars = ', '.join(str(t) for t in tvars if t not in gvarset)
-                s_args = ', '.join(str(g) for g in gvars)
-                raise TypeError(f"Some type variables ({s_vars}) are"
-                                f" not listed in Generic[{s_args}]")
-            tvars = gvars
-    cls.__parameters__ = tuple(tvars)
-
 
 class _TypingEllipsis:
     """Internal placeholder for ... (ellipsis)."""
@@ -2303,6 +2282,30 @@ def _proto_hook(other):
         if cls.__init__ is Protocol.__init__:
             cls.__init__ = _no_init_or_replace_init
 
+if hasattr(builtins, "TypeVar"):
+    def _dummy[T, *Ts, **P]():
+        pass
+
+    TypeVar = type(_dummy.__type_variables__[0])
+    TypeVarTuple = type(_dummy.__type_variables__[1])
+    ParamSpec = type(_dummy.__type_variables__[2])
+    ParamSpecArgs = type(ParamSpec("P").args)
+    ParamSpecKwargs = type(ParamSpec("P").kwargs)
+
+    del _dummy
+
+    import copyreg
+
+    def _pickle_psargs(psargs):
+        return ParamSpecArgs, (psargs.__origin__,)
+
+    copyreg.pickle(ParamSpecArgs, _pickle_psargs)
+
+    def _pickle_pskwargs(pskwargs):
+        return ParamSpecKwargs, (pskwargs.__origin__,)
+
+    copyreg.pickle(ParamSpecKwargs, _pickle_pskwargs)
+
 
 class _AnnotatedAlias(_NotIterable, _GenericAlias, _root=True):
     """Runtime representation of an annotated type.

Objects/typevarobject.c

@@ -11,9 +11,9 @@ class paramspec "paramspecobject *" "&_PyParamSpec_Type"
 class paramspecargs "paramspecargsobject *" "&_PyParamSpecArgs_Type"
 class paramspeckwargs "paramspeckwargsobject *" "&_PyParamSpecKwargs_Type"
 class typevartuple "typevartupleobject *" "&_PyTypeVarTuple_Type"
-class Generic "PyObject *" "&PyGeneric_Type
+class Generic "PyObject *" "&PyGeneric_Type"
 [clinic start generated code]*/
-/*[clinic end generated code: output=da39a3ee5e6b4b0d input=74cb9c15a049111b]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=9b0f1a94d4a27c0c]*/
 
 typedef struct {
     PyObject_HEAD