Fix tests on Python 3.12

CHANGELOG.md

@@ -73,6 +73,8 @@
 - Backport the implementation of `NewType` from 3.10 (where it is implemented
   as a class rather than a function). This allows user-defined `NewType`s to be
   pickled. Patch by Alex Waygood.
+- Fix tests and import on Python 3.12, where `typing.TypeVar` can no longer be
+  subclassed. Patch by Jelle Zijlstra.
 - Add `typing_extensions.TypeAliasType`, a backport of `typing.TypeAliasType`
   from PEP 695. Patch by Jelle Zijlstra.
 - Backport changes to the repr of `typing.Unpack` that were made in order to

src/test_typing_extensions.py

@@ -14,6 +14,7 @@
 import re
 import subprocess
 import tempfile
+import textwrap
 import types
 from pathlib import Path
 from unittest import TestCase, main, skipUnless, skipIf
@@ -47,6 +48,9 @@
 # 3.11 makes runtime type checks (_type_check) more lenient.
 TYPING_3_11_0 = sys.version_info[:3] >= (3, 11, 0)
 
+# 3.12 changes the representation of Unpack[] (PEP 692)
+TYPING_3_12_0 = sys.version_info[:3] >= (3, 12, 0)
+
 # https://github.com/python/cpython/pull/27017 was backported into some 3.9 and 3.10
 # versions, but not all
 HAS_FORWARD_MODULE = "module" in inspect.signature(typing._type_check).parameters
@@ -2396,7 +2400,7 @@ def bar(self, x: str) -> str:
             with self.assertRaises(TypeError):
                 PR[int, ClassVar]
 
-    if sys.version_info >= (3, 12):
+    if hasattr(typing, "TypeAliasType"):
         exec(textwrap.dedent(
             """
             def test_pep695_generic_protocol_callable_members(self):
@@ -4342,8 +4346,8 @@ def test_signature_on_37(self):
     @skipUnless(TYPING_3_9_0, "NamedTuple was a class on 3.8 and lower")
     def test_same_as_typing_NamedTuple_39_plus(self):
         self.assertEqual(
-            set(dir(NamedTuple)),
-            set(dir(typing.NamedTuple)) | {"__text_signature__"}
+            set(dir(NamedTuple)) - {"__text_signature__"},
+            set(dir(typing.NamedTuple))
         )
         self.assertIs(type(NamedTuple), type(typing.NamedTuple))
 
@@ -4374,7 +4378,12 @@ class GenericNamedTuple(NamedTuple, Generic[T]):
 class TypeVarLikeDefaultsTests(BaseTestCase):
     def test_typevar(self):
         T = typing_extensions.TypeVar('T', default=int)
+        typing_T = TypeVar('T')
         self.assertEqual(T.__default__, int)
+        self.assertIsInstance(T, typing_extensions.TypeVar)
+        self.assertIsInstance(T, typing.TypeVar)
+        self.assertIsInstance(typing_T, typing.TypeVar)
+        self.assertIsInstance(typing_T, typing_extensions.TypeVar)
 
         class A(Generic[T]): ...
         Alias = Optional[T]
@@ -4388,13 +4397,25 @@ def test_typevar_none(self):
     def test_paramspec(self):
         P = ParamSpec('P', default=(str, int))
         self.assertEqual(P.__default__, (str, int))
+        self.assertIsInstance(P, ParamSpec)
+        if hasattr(typing, "ParamSpec"):
+            self.assertIsInstance(P, typing.ParamSpec)
+            typing_P = typing.ParamSpec('P')
+            self.assertIsInstance(typing_P, typing.ParamSpec)
+            self.assertIsInstance(typing_P, ParamSpec)
 
         class A(Generic[P]): ...
         Alias = typing.Callable[P, None]
 
     def test_typevartuple(self):
         Ts = TypeVarTuple('Ts', default=Unpack[Tuple[str, int]])
         self.assertEqual(Ts.__default__, Unpack[Tuple[str, int]])
+        self.assertIsInstance(Ts, TypeVarTuple)
+        if hasattr(typing, "TypeVarTuple"):
+            self.assertIsInstance(Ts, typing.TypeVarTuple)
+            typing_Ts = typing.TypeVarTuple('Ts')
+            self.assertIsInstance(typing_Ts, typing.TypeVarTuple)
+            self.assertIsInstance(typing_Ts, TypeVarTuple)
 
         class A(Generic[Unpack[Ts]]): ...
         Alias = Optional[Unpack[Ts]]
@@ -4454,8 +4475,13 @@ class MyRegisteredBuffer:
             def __buffer__(self, flags: int) -> memoryview:
                 return memoryview(b'')
 
-        self.assertNotIsInstance(MyRegisteredBuffer(), Buffer)
-        self.assertNotIsSubclass(MyRegisteredBuffer, Buffer)
+        # On 3.12, collections.abc.Buffer does a structural compatibility check
+        if TYPING_3_12_0:
+            self.assertIsInstance(MyRegisteredBuffer(), Buffer)
+            self.assertIsSubclass(MyRegisteredBuffer, Buffer)
+        else:
+            self.assertNotIsInstance(MyRegisteredBuffer(), Buffer)
+            self.assertNotIsSubclass(MyRegisteredBuffer, Buffer)
         Buffer.register(MyRegisteredBuffer)
         self.assertIsInstance(MyRegisteredBuffer(), Buffer)
         self.assertIsSubclass(MyRegisteredBuffer, Buffer)

src/typing_extensions.py

@@ -759,6 +759,7 @@ def runtime_checkable(cls):
     SupportsInt = typing.SupportsInt
     SupportsFloat = typing.SupportsFloat
     SupportsComplex = typing.SupportsComplex
+    SupportsBytes = typing.SupportsBytes
     SupportsIndex = typing.SupportsIndex
     SupportsAbs = typing.SupportsAbs
     SupportsRound = typing.SupportsRound
@@ -1343,39 +1344,53 @@ def __repr__(self):
                                above.""")
 
 
+def _set_default(type_param, default):
+    if isinstance(default, (tuple, list)):
+        type_param.__default__ = tuple((typing._type_check(d, "Default must be a type")
+                                        for d in default))
+    elif default != _marker:
+        type_param.__default__ = typing._type_check(default, "Default must be a type")
+    else:
+        type_param.__default__ = None
+
+
 class _DefaultMixin:
     """Mixin for TypeVarLike defaults."""
 
     __slots__ = ()
-
-    def __init__(self, default):
-        if isinstance(default, (tuple, list)):
-            self.__default__ = tuple((typing._type_check(d, "Default must be a type")
-                                      for d in default))
-        elif default != _marker:
-            self.__default__ = typing._type_check(default, "Default must be a type")
-        else:
-            self.__default__ = None
+    __init__ = _set_default
 
 
 # Add default and infer_variance parameters from PEP 696 and 695
-class TypeVar(typing.TypeVar, _DefaultMixin, _root=True):
-    """Type variable."""
-
-    __module__ = 'typing'
-
-    def __init__(self, name, *constraints, bound=None,
+class _TypeVarMeta(type):
+    def __call__(self, name, *constraints, bound=None,
                  covariant=False, contravariant=False,
                  default=_marker, infer_variance=False):
-        super().__init__(name, *constraints, bound=bound, covariant=covariant,
-                         contravariant=contravariant)
-        _DefaultMixin.__init__(self, default)
-        self.__infer_variance__ = infer_variance
+        if hasattr(typing, "TypeAliasType"):
+            # PEP 695 implemented, can pass infer_variance to typing.TypeVar
+            typevar = typing.TypeVar(name, *constraints, bound=bound,
+                                     covariant=covariant, contravariant=contravariant,
+                                     infer_variance=infer_variance)
+        else:
+            typevar = typing.TypeVar(name, *constraints, bound=bound,
+                                     covariant=covariant, contravariant=contravariant)
+            typevar.__infer_variance__ = infer_variance
+        _set_default(typevar, default)
 
         # for pickling:
         def_mod = _caller()
         if def_mod != 'typing_extensions':
-            self.__module__ = def_mod
+            typevar.__module__ = def_mod
+        return typevar
+
+    def __instancecheck__(self, __instance: Any) -> bool:
+        return isinstance(__instance, typing.TypeVar)
+
+
+class TypeVar(metaclass=_TypeVarMeta):
+    """Type variable."""
+
+    __module__ = 'typing'
 
 
 # Python 3.10+ has PEP 612
@@ -1443,22 +1458,28 @@ def __eq__(self, other):
 # 3.10+
 if hasattr(typing, 'ParamSpec'):
 
-    # Add default Parameter - PEP 696
-    class ParamSpec(typing.ParamSpec, _DefaultMixin, _root=True):
-        """Parameter specification variable."""
-
-        __module__ = 'typing'
-
-        def __init__(self, name, *, bound=None, covariant=False, contravariant=False,
+    # Add default parameter - PEP 696
+    class _ParamSpecMeta(type):
+        def __call__(self, name, *, bound=None,
+                     covariant=False, contravariant=False,
                      default=_marker):
-            super().__init__(name, bound=bound, covariant=covariant,
-                             contravariant=contravariant)
-            _DefaultMixin.__init__(self, default)
+            paramspec = typing.ParamSpec(name, bound=bound,
+                                         covariant=covariant, contravariant=contravariant)
+            _set_default(paramspec, default)
 
             # for pickling:
             def_mod = _caller()
             if def_mod != 'typing_extensions':
-                self.__module__ = def_mod
+                paramspec.__module__ = def_mod
+            return paramspec
+
+        def __instancecheck__(self, __instance: Any) -> bool:
+            return isinstance(__instance, typing.ParamSpec)
+
+    class ParamSpec(metaclass=_ParamSpecMeta):
+        """Parameter specification."""
+
+        __module__ = 'typing'
 
 # 3.7-3.9
 else:
@@ -2061,18 +2082,28 @@ def _is_unpack(obj):
 
 if hasattr(typing, "TypeVarTuple"):  # 3.11+
 
-    # Add default Parameter - PEP 696
-    class TypeVarTuple(typing.TypeVarTuple, _DefaultMixin, _root=True):
-        """Type variable tuple."""
-
-        def __init__(self, name, *, default=_marker):
-            super().__init__(name)
-            _DefaultMixin.__init__(self, default)
+    # Add default parameter - PEP 696
+    class _TypeVarTupleMeta(type):
+        def __call__(self, name, *, default=_marker):
+            tvt = typing.TypeVarTuple(name)
+            _set_default(tvt, default)
 
             # for pickling:
             def_mod = _caller()
             if def_mod != 'typing_extensions':
-                self.__module__ = def_mod
+                tvt.__module__ = def_mod
+            return tvt
+
+        def __instancecheck__(self, __instance: Any) -> bool:
+            return isinstance(__instance, typing.TypeVarTuple)
+
+    class TypeVarTuple(metaclass=_TypeVarTupleMeta):
+        """Type variable tuple."""
+
+        __module__ = 'typing'
+
+        def __init_subclass__(self, *args, **kwds):
+            raise TypeError("Cannot subclass special typing classes")
 
 else:
     class TypeVarTuple(_DefaultMixin):