Support ParamSpec for TypeAliasType

src/test_typing_extensions.py

@@ -3572,13 +3572,13 @@ class P(Protocol):
         self.assertEqual(Alias, Alias2)
 
     def test_protocols_pickleable(self):
-        global P, CP  # pickle wants to reference the class by name
+        global GlobalProto, CP  # pickle wants to reference the class by name
         T = TypeVar('T')
 
         @runtime_checkable
-        class P(Protocol[T]):
+        class GlobalProto(Protocol[T]):
             x = 1
-        class CP(P[int]):
+        class CP(GlobalProto[int]):
             pass
 
         c = CP()
@@ -3591,7 +3591,7 @@ class CP(P[int]):
             self.assertEqual(x.bar, 'abc')
             self.assertEqual(x.x, 1)
             self.assertEqual(x.__dict__, {'foo': 42, 'bar': 'abc'})
-            s = pickle.dumps(P)
+            s = pickle.dumps(GlobalProto)
             D = pickle.loads(s)
             class E:
                 x = 1
@@ -7165,13 +7165,52 @@ def test_attributes(self):
         self.assertEqual(ListOrSetT.__type_params__, (T,))
         self.assertEqual(ListOrSetT.__parameters__, (T,))
 
+        subscripted = ListOrSetT[int]
+        self.assertEqual(subscripted.__name__, "ListOrSetT")
+        self.assertEqual(subscripted.__value__, Union[List[T], Set[T]],)
+        self.assertEqual(subscripted.__type_params__, (T, ))
+        self.assertEqual(subscripted.__parameters__, ())
+
+        T2 = TypeVar("T2")
+        subscriptedT = ListOrSetT[T2]
+        self.assertEqual(subscriptedT.__name__, "ListOrSetT")
+        self.assertEqual(subscriptedT.__value__, Union[List[T], Set[T]],)
+        self.assertEqual(subscriptedT.__type_params__, (T, ))
+        self.assertEqual(subscriptedT.__parameters__, (T2, ))
+
         Ts = TypeVarTuple("Ts")
         Variadic = TypeAliasType("Variadic", Tuple[int, Unpack[Ts]], type_params=(Ts,))
         self.assertEqual(Variadic.__name__, "Variadic")
         self.assertEqual(Variadic.__value__, Tuple[int, Unpack[Ts]])
         self.assertEqual(Variadic.__type_params__, (Ts,))
         self.assertEqual(Variadic.__parameters__, tuple(iter(Ts)))
 
+        subscripted_tuple = Variadic[Unpack[Tuple[int, float]]]
+        self.assertEqual(subscripted_tuple.__name__, "Variadic")
+        self.assertEqual(subscripted_tuple.__value__, Tuple[int, Unpack[Ts]])
+        self.assertEqual(subscripted_tuple.__type_params__, (Ts,))
+        self.assertEqual(subscripted_tuple.__parameters__, ())
+
+        subscripted_tupleT = Variadic[Unpack[Tuple[int, T]]]
+        self.assertEqual(subscripted_tupleT.__name__, "Variadic")
+        self.assertEqual(subscripted_tupleT.__parameters__, (T, ))
+
+        # Use with Callable
+        # Use with Callable+Concatenate
+        subscripted_callable_concat = Variadic[Callable[Concatenate[Literal["s"],  P], T]]
+        self.assertEqual(subscripted_callable_concat.__parameters__, (P, T))
+
+        subcriped_callable_tvt = Variadic[Callable[[Unpack[Ts]], T]]
+        self.assertEqual(subcriped_callable_tvt.__parameters__, (Ts, T))
+
+        # Use with Callable+Unpack
+        CallableTs = TypeAliasType("CallableTs", Callable[[Unpack[Ts]], Any], type_params=(Ts, ))
+        self.assertEqual(CallableTs.__type_params__, (Ts,))
+        self.assertEqual(CallableTs.__parameters__, (*Ts,))
+
+        unpack_callable = CallableTs[Unpack[Tuple[int, T]]]
+        self.assertEqual(unpack_callable.__parameters__, (T,))
+
     def test_cannot_set_attributes(self):
         Simple = TypeAliasType("Simple", int)
         with self.assertRaisesRegex(AttributeError, "readonly attribute"):
@@ -7232,12 +7271,13 @@ def test_or(self):
             Alias | "Ref"
 
     def test_getitem(self):
+        T = TypeVar("T")
         ListOrSetT = TypeAliasType("ListOrSetT", Union[List[T], Set[T]], type_params=(T,))
         subscripted = ListOrSetT[int]
         self.assertEqual(get_args(subscripted), (int,))
         self.assertIs(get_origin(subscripted), ListOrSetT)
-        with self.assertRaises(TypeError):
-            subscripted[str]
+        with self.assertRaises(TypeError, msg="not a generic class"):
+            subscripted[int]
 
         still_generic = ListOrSetT[Iterable[T]]
         self.assertEqual(get_args(still_generic), (Iterable[T],))
@@ -7246,6 +7286,196 @@ def test_getitem(self):
         self.assertEqual(get_args(fully_subscripted), (Iterable[float],))
         self.assertIs(get_origin(fully_subscripted), ListOrSetT)
 
+        # Test ParamSpec and Ellipsis
+        P = ParamSpec('P')
+        CallableP = TypeAliasType("CallableP", Callable[P, Any], type_params=(P,))
+        # () -> Any
+        callable_no_arg = CallableP[[]]
+        self.assertEqual(get_args(callable_no_arg), ([],))
+        # (int) -> Any
+        callable_arg = CallableP[int]
+        self.assertEqual(get_args(callable_arg), (int,))
+
+        callable_arg_list = CallableP[[int]]
+        self.assertEqual(get_args(callable_arg_list), ([int],))
+
+        # (int, int) -> Any
+        callable_arg2 = CallableP[int, int]
+        self.assertEqual(get_args(callable_arg2), (int, int,))
+
+        callable_arg2_list = CallableP[[int, int]]
+        self.assertEqual(get_args(callable_arg2_list), ([int, int],))
+        # (...) -> Any
+        callable_ellipsis = CallableP[...]
+        self.assertEqual(get_args(callable_ellipsis), (...,))
+
+        callable_ellipsis2 = CallableP[(...,)]
+        self.assertEqual(callable_ellipsis, callable_ellipsis2)
+        # (int, ...) -> Any
+        callable_arg_more = CallableP[[int, ...]]
+        self.assertEqual(get_args(callable_arg_more), ([int, ...],))
+        # (T) -> Any
+        callable_generic_raw = CallableP[T]
+        self.assertEqual(get_args(callable_generic_raw), (T,))
+        self.assertEqual(callable_generic_raw.__parameters__, (T,))
+
+        # Usage with Concatenate
+        callable_concat = CallableP[Concatenate[int, P]]
+        self.assertEqual(callable_concat.__parameters__, (P,))
+        if TYPING_3_11_0:
+            self.assertEqual(get_args(callable_concat), (Concatenate[int, P],))
+            concat_usage = callable_concat[str]
+            self.assertEqual(get_args(concat_usage), ((int, str),))
+            self.assertEqual(concat_usage, callable_concat[[str]])
+        elif TYPING_3_10_0:
+            self.assertEqual(get_args(callable_concat), (int, P,))
+            with self.assertRaises(TypeError, msg="Parameters to generic types must be types"):
+                callable_concat[str]
+            concat_usage = callable_concat[[str]]
+            self.assertEqual(get_args(concat_usage), (int, [str]))
+        else:
+            self.assertEqual(get_args(callable_concat), (int, P,))
+            with self.assertRaises(TypeError, msg="Parameters to generic types must be types"):
+                callable_concat[[str]]
+            concat_usage = callable_concat[str]
+            self.assertEqual(get_args(concat_usage), (int, str))
+
+        # More complex cases
+        Ts = TypeVarTuple("Ts")
+        Variadic = TypeAliasType("Variadic", Tuple[int, Unpack[Ts]], type_params=(Ts,))
+        mixed_subscripedPT = Variadic[Callable[Concatenate[int,  P], T]]
+        self.assertEqual(get_args(mixed_subscripedPT), (Callable[Concatenate[int,  P], T],))
+
+
+    @skipUnless(TYPING_3_11_0, "__args__ behaves differently")
+    def test_311_substitution(self):
+        # To pass these tests alias.__args__ in TypeAliasType.__getitem__ needs adjustment
+        # Unpack and Concatenate are unpacked in versions before
+        T = TypeVar("T")
+        Ts = TypeVarTuple("Ts")
+
+        CallableTs = TypeAliasType("CallableTs", Callable[[Unpack[Ts]], Any], type_params=(Ts, ))
+        unpack_callable = CallableTs[Unpack[Tuple[int, T]]]
+        self.assertEqual(get_args(unpack_callable), (Unpack[Tuple[int, T]],))
+
+        P = ParamSpec('P')
+        CallableP = TypeAliasType("CallableP", Callable[P, T], type_params=(P, T))
+        callable_concat = CallableP[Concatenate[int, P], Any]
+        self.assertEqual(get_args(callable_concat), (Concatenate[int, P], Any))
+
+    @skipUnless(TYPING_3_12_0, "__args__ behaves differently")
+    def test_312_substitution(self):
+        # To pass these tests alias.__args__ in TypeAliasType.__getitem__ needs to be adjustment
+        # Would raise: TypeError: Substitution of bare TypeVarTuple is not supported
+        T = TypeVar("T")
+        Ts = TypeVarTuple("Ts")
+        Variadic = TypeAliasType("Variadic", Tuple[int, Unpack[Ts]], type_params=(Ts,))
+
+        subcriped_callable_tvt = Variadic[Callable[[Unpack[Ts]], T]]
+        variadic_tvt_callableA = subcriped_callable_tvt[str, object]
+        variadic_tvt_callableA2 = subcriped_callable_tvt[Unpack[Tuple[str]], object]
+        self.assertEqual(variadic_tvt_callableA, variadic_tvt_callableA2)
+
+        variadic_tvt_callableB = subcriped_callable_tvt[[str, int], object]
+        variadic_tvt_callableB2 = subcriped_callable_tvt[Unpack[Tuple[str, int]], object]
+        variadic_tvt_callableB3 = subcriped_callable_tvt[str, int, object]
+        self.assertNotEqual(variadic_tvt_callableB, variadic_tvt_callableB2)
+        self.assertEqual(variadic_tvt_callableB2, variadic_tvt_callableB3)
+
+    def test_invalid_cases(self):
+        # NOTE: If these cases fail the specificiation might have changed
+        # some of the cases could be seen as valid but are currently not
+
+        # More parameters
+        T = TypeVar("T")
+        T2 = TypeVar("T2")
+        ListOrSetT = TypeAliasType("ListOrSetT", Union[List[T], Set[T]], type_params=(T,))
+        too_many = ListOrSetT[int, bool]
+
+        self.assertEqual(get_args(too_many), (int, bool))
+        self.assertEqual(too_many.__parameters__, ())
+
+        # Not enough parameters
+        ListOrSet2T = TypeAliasType("ListOrSet2T", Union[List[T], Set[T2]], type_params=(T, T2))
+        not_enough = ListOrSet2T[int]
+        self.assertEqual(get_args(not_enough), (int,))
+        self.assertEqual(not_enough.__parameters__, ())
+
+        not_enough2 = ListOrSet2T[T]
+        self.assertEqual(get_args(not_enough2), (T,))
+        self.assertEqual(not_enough2.__parameters__, (T,))
+        # ParamSpec
+        P = ParamSpec('P')
+        CallableP = TypeAliasType("CallableP", Callable[P, T], type_params=(P,))
+
+        callable_not_enough = CallableP[int]
+        self.assertEqual(callable_not_enough.__parameters__, ())
+        self.assertEqual(get_args(callable_not_enough), (int, ))
+
+        callable_too_many = CallableP[str, float, T2, int]
+        self.assertEqual(callable_too_many.__parameters__, (T2, ))
+        self.assertEqual(get_args(callable_too_many), (str, float, T2, int, ))
+
+        # Test with Concatenate
+        callable_concat = CallableP[Concatenate[Any, T2, P], Any]
+        self.assertEqual(callable_concat.__parameters__, (T2, P))
+
+        # TypeVarTuple
+        Ts = TypeVarTuple("Ts")
+        Variadic = TypeAliasType("Variadic", Tuple[int, Unpack[Ts]], type_params=(Ts,))
+        # No Unpack
+        invalid_tuple_A = Variadic[Tuple[int, T]]
+        self.assertEqual(invalid_tuple_A.__parameters__, (T, ))
+        self.assertEqual(get_args(invalid_tuple_A), (Tuple[int, T], ))
+
+        # To type tuple
+        invalid_tuple_B = Variadic[int, T]
+        self.assertEqual(invalid_tuple_B.__parameters__, (T, ))
+
+        # No Tuple, but list
+        invalud_tuple_C = Variadic[[int, T]]
+        self.assertEqual(invalud_tuple_C.__parameters__, ())
+        self.assertEqual(get_args(invalud_tuple_C), ([int, T],))
+
+        # Callable
+        # NOTE: This these cases seem to be more like a limitation in the typing variant
+        # The final variable is parameterless if using a list here.
+        callable_T = CallableP[[T]]
+        self.assertEqual(get_args(callable_T), ([T],))
+        self.assertEqual(callable_T.__parameters__, ())
+        with self.assertRaises(TypeError, msg="is not a generic class"):
+            callable_T[str]
+
+        InvalidConcatP = CallableP[[int, P]]
+        self.assertEqual(get_args(InvalidConcatP), ([int, P],))
+        self.assertEqual(InvalidConcatP.__parameters__, ())
+        with self.assertRaises(TypeError, msg="is not a generic class"):
+            InvalidConcatP[str]
+
+        # Callable
+        # NOTE: This these cases seem to be more like a limitation in the typing variant
+        callable_T = CallableP[[T]]
+        self.assertEqual(get_args(callable_T), ([T],))
+        self.assertEqual(callable_T.__parameters__, ())
+        with self.assertRaises(TypeError, msg="is not a generic class"):
+            callable_T[str]
+
+        InvalidConcatP = CallableP[[int, P]]
+        self.assertEqual(get_args(InvalidConcatP), ([int, P],))
+        self.assertEqual(InvalidConcatP.__parameters__, ())
+        with self.assertRaises(TypeError, msg="is not a generic class"):
+            InvalidConcatP[str]
+
+    @skipIf(TYPING_3_11_0, "Most cases are allowed in 3.11+")
+    def test_invalid_cases_before_3_11(self):
+        T = TypeVar("T")
+        ListOrSetT = TypeAliasType("ListOrSetT", Union[List[T], Set[T]], type_params=(T,))
+        with self.assertRaises(TypeError):
+            ListOrSetT[Generic[T]]
+        with self.assertRaises(TypeError):
+            ListOrSetT[(Generic[T], )]
+
+
     def test_pickle(self):
         global Alias
         Alias = TypeAliasType("Alias", int)

src/typing_extensions.py

@@ -3487,6 +3487,8 @@ def __init__(self, name: str, value, *, type_params=()):
             self.__type_params__ = type_params
 
             parameters = []
+            if not isinstance(type_params, tuple):
+                raise TypeError("type_params must be a tuple")
             for type_param in type_params:
                 if isinstance(type_param, TypeVarTuple):
                     parameters.extend(type_param)
@@ -3524,16 +3526,57 @@ def _raise_attribute_error(self, name: str) -> Never:
         def __repr__(self) -> str:
             return self.__name__
 
-        def __getitem__(self, parameters):
-            if not isinstance(parameters, tuple):
-                parameters = (parameters,)
-            parameters = [
-                typing._type_check(
-                    item, f'Subscripting {self.__name__} requires a type.'
-                )
-                for item in parameters
-            ]
-            return typing._GenericAlias(self, tuple(parameters))
+        if sys.version_info >= (3, 11):
+            def __getitem__(self, parameters):
+                if not isinstance(parameters, tuple):
+                    parameters = (parameters,)
+                parameters = [
+                        typing._type_check(
+                            item, f'Subscripting {self.__name__} requires a type.'
+                        )
+                        for item in parameters
+                    ]
+                alias = typing._GenericAlias(self, tuple(parameters))
+                alias.__value__ = self.__value__
+                alias.__type_params__ = self.__type_params__
+                return alias
+        else:
+            def _check_parameter(self, item, recursion=0):
+                # Allow [], [int], [int, str], [int, ...], [int, T]
+                if isinstance(item, (_UnpackAlias, _ConcatenateGenericAlias)):
+                    # Unpack
+                    yield from [checked
+                                for arg in item.__args__
+                                for checked in self._check_parameter(arg, recursion+1)]
+                elif item is ...:
+                    yield ...
+                elif isinstance(item, list) and recursion == 0:
+                    yield [checked
+                           for arg in item
+                           for checked in self._check_parameter(arg, recursion+1)]
+                else:
+                    yield typing._type_check(
+                        item, f'Subscripting {self.__name__} requires a type.'
+                    )
+
+            def __getitem__(self, parameters):
+                if not isinstance(parameters, tuple):
+                    parameters = (parameters,)
+                parameters = [
+                        checked
+                        for item in parameters
+                        for checked in self._check_parameter(item)
+                ]
+                if sys.version_info[:2] == (3, 10):
+                    alias = typing._GenericAlias(self, tuple(parameters),
+                                                 _typevar_types=(TypeVar, ParamSpec)
+                                                 )
+                else:
+                    alias = typing._GenericAlias(self, tuple(parameters))
+                alias.__name__ = self.__name__
+                alias.__value__ = self.__value__
+                alias.__type_params__ = self.__type_params__
+                return alias
 
         def __reduce__(self):
             return self.__name__