Full backport to 3.8 to support Concatenate[...]

Author: Daraan

src/test_typing_extensions.py

@@ -1727,8 +1727,6 @@ class C(Generic[T]): pass
         self.assertEqual(get_args(Callable[Concatenate[int, P], int]),
                          (Concatenate[int, P], int))
         with self.subTest("Concatenate[int, ...]"):
-            if sys.version_info < (3, 9, 2):
-                self.skipTest("arguments must be types before 3.9.2, i.e. no ...")
             self.assertEqual(get_args(Callable[Concatenate[int, ...], int]),
                         (Concatenate[int, ...], int))
 
@@ -5385,19 +5383,16 @@ def test_valid_uses(self):
         self.assertEqual(C1.__origin__, C2.__origin__)
         self.assertNotEqual(C1, C2)
 
-    @skipUnless(TYPING_3_9_0, "Needs PEP 585; no backport for 3.8 typing")
-    def test_valid_uses_py39_plus(self):
-        P = ParamSpec('P')
-        T = TypeVar('T')
-
         with self.subTest("typing.Callable with Ellipsis"):
-            if sys.version_info < (3, 9, 2):
-                self.skipTest("Must use types before 3.9.2")
             C3 = Callable[Concatenate[int, ...], int]
             C4 = Callable[Concatenate[int, T, ...], T]
             self.assertEqual(C3.__origin__, C4.__origin__)
             self.assertNotEqual(C3, C4)
 
+    @skipUnless(TYPING_3_9_0, "Needs PEP 585")
+    def test_pep585_collections_callable(self):
+        P = ParamSpec('P')
+        T = TypeVar('T')
         # Test collections.abc.Callable too.
         C5 = collections.abc.Callable[Concatenate[int, P], int]
         C6 = collections.abc.Callable[Concatenate[int, T, P], T]
@@ -5425,14 +5420,11 @@ def test_invalid_uses(self):
         ):
             Concatenate[P, T]
 
-    @skipIf(sys.version_info < (3, 9, 2), "Args must be types below 3.9.2")
-    def test_invalid_uses_py39_2_plus(self):
-        T = TypeVar('T')
         with self.assertRaisesRegex(
             TypeError,
             'is not a generic class',
         ):
-            Callable[Concatenate[int, ...], Any][T]
+            Callable[Concatenate[int, ...], Any][Any]
 
     @skipIf(TYPING_3_11_0, "Args can be non-types in 3.11+")
     def test_invalid_uses_before_3_11(self):
@@ -5450,15 +5442,15 @@ def test_invalid_uses_before_3_11(self):
             Concatenate[1, ..., P]
 
     @skipUnless(TYPING_3_11_0 or (3, 10, 0) <= sys.version_info < (3, 10, 2),
-                "Cannot be backported to <=3.9"
+                "Cannot be backported to <=3.9. See issue #48"
                 "Cannot use ... with typing._ConcatenateGenericAlias after 3.10.2")
     def test_alias_subscription_with_ellipsis(self):
         P = ParamSpec('P')
         X = Callable[Concatenate[int, P], Any]
 
         C1 = X[...]
         self.assertEqual(C1.__parameters__, ())
-        self.assertEqual(C1.__args__, (Concatenate[int, ...], Any))
+        self.assertEqual(get_args(C1), (Concatenate[int, ...], Any))
 
     def test_basic_introspection(self):
         P = ParamSpec('P')

src/typing_extensions.py

@@ -1799,53 +1799,47 @@ def __parameters__(self):
 else:
     _ConcatenateGenericAlias = typing._ConcatenateGenericAlias
 
-# 3.10.2+
-if sys.version_info >= (3, 10, 2):
-    _ellipsis_dummy = ParamSpec('_ellipsis_dummy')
-
-    @typing._tp_cache
-    def _concatenate_getitem(self, parameters):
-        if parameters == ():
-            raise TypeError("Cannot take a Concatenate of no types.")
-        if not isinstance(parameters, tuple):
-            parameters = (parameters,)
-        if not (parameters[-1] is ... or isinstance(parameters[-1], ParamSpec)):
-            raise TypeError("The last parameter to Concatenate should be a "
-                            "ParamSpec variable or ellipsis.")
-        msg = "Concatenate[arg, ...]: each arg must be a type."
-        parameters = (*(typing._type_check(p, msg) for p in parameters[:-1]),
-                      parameters[-1])
-        if parameters[-1] is Ellipsis:
-            # Hack: Need ParamSpec as last parameter when passing to typing class in 3.10
-            parameters = parameters[:-1] + (_ellipsis_dummy,)
-            concatenate = _ConcatenateGenericAlias(self, parameters,
-                                                _typevar_types=(TypeVar, ParamSpec),
-                                                _paramspec_tvars=True)
-            # Remove dummy and replace with Ellipsis again
-            concatenate.__args__ = tuple(p if p is not _ellipsis_dummy else ...
-                                         for p in concatenate.__args__)
-            concatenate.__parameters__ = tuple(p for p in concatenate.__parameters__
-                                               if p is not _ellipsis_dummy)
-            return concatenate
-        return _ConcatenateGenericAlias(self, parameters,
+# 3.8-3.9,2
+class _EllipsisDummyType: ...
+
+# 3.8-3.10
+def _create_concatenate_alias(origin, parameters):
+    if parameters[-1] is ... and sys.version_info < (3, 9, 2):
+        # Arguments must be types
+        parameters = parameters[:-1] + (_EllipsisDummyType,)
+    if sys.version_info >= (3, 10, 2):
+        concatenate = _ConcatenateGenericAlias(origin, parameters,
                                         _typevar_types=(TypeVar, ParamSpec),
                                         _paramspec_tvars=True)
-
-# 3.8-3.10.0
-else:
-    @typing._tp_cache
-    def _concatenate_getitem(self, parameters):
-        if parameters == ():
-            raise TypeError("Cannot take a Concatenate of no types.")
-        if not isinstance(parameters, tuple):
-            parameters = (parameters,)
-        if not (parameters[-1] is ... or isinstance(parameters[-1], ParamSpec)):
-            raise TypeError("The last parameter to Concatenate should be a "
-                            "ParamSpec variable or ellipsis.")
-        msg = "Concatenate[arg, ...]: each arg must be a type."
-        parameters = (*(typing._type_check(p, msg) for p in parameters[:-1]),
-                      parameters[-1])
-        return _ConcatenateGenericAlias(self, parameters)
+    else:
+        concatenate = _ConcatenateGenericAlias(origin, parameters)
+    if parameters[-1] is not _EllipsisDummyType:
+        return concatenate
+    # Remove dummy again
+    concatenate.__args__ = tuple(p if p is not _EllipsisDummyType else ...
+                                    for p in concatenate.__args__)
+    if sys.version_info < (3, 10):
+        # backport needs __args__ adjustment only
+        return concatenate
+    concatenate.__parameters__ = tuple(p for p in concatenate.__parameters__
+                                        if p is not _EllipsisDummyType)
+    return concatenate
+
+
+# 3.8-3.10
+@typing._tp_cache
+def _concatenate_getitem(self, parameters):
+    if parameters == ():
+        raise TypeError("Cannot take a Concatenate of no types.")
+    if not isinstance(parameters, tuple):
+        parameters = (parameters,)
+    if not (parameters[-1] is ... or isinstance(parameters[-1], ParamSpec)):
+        raise TypeError("The last parameter to Concatenate should be a "
+                        "ParamSpec variable or ellipsis.")
+    msg = "Concatenate[arg, ...]: each arg must be a type."
+    parameters = (*(typing._type_check(p, msg) for p in parameters[:-1]),
+                    parameters[-1])
+    return _create_concatenate_alias(self, parameters)
 
 # 3.11+; Concatenate does not accept ellipsis in 3.10
 if hasattr(typing, 'Concatenate') and sys.version_info >= (3, 11):