bpo-43224: Initial implementation of PEP 646 in typing.py

Lib/test/test_genericalias.py

@@ -40,10 +40,11 @@
 from weakref import WeakSet, ReferenceType, ref
 import typing
 
-from typing import TypeVar
+from typing import TypeVar, TypeVarTuple
 T = TypeVar('T')
 K = TypeVar('K')
 V = TypeVar('V')
+Ts = TypeVarTuple('Ts)')
 
 class BaseTest(unittest.TestCase):
  """Test basics."""
@@ -170,7 +171,7 @@ def test_exposed_type(self):
  self.assertEqual(a.__args__, (int,))
  self.assertEqual(a.__parameters__, ())
 
- def test_parameters(self):
+ def test_parameters_typevar(self):
  from typing import List, Dict, Callable
  D0 = dict[str, int]
  self.assertEqual(D0.__args__, (str, int))
@@ -209,6 +210,34 @@ def test_parameters(self):
  self.assertEqual(L5.__args__, (Callable[[K, V], K],))
  self.assertEqual(L5.__parameters__, (K, V))
 
+ def test_parameters_typevartuple(self):
+ from typing import List, Dict, Callable
+ T0 = tuple[*Ts]
+ self.assertEqual(T0.__args__, (Ts._unpacked,))
+ self.assertEqual(T0.__parameters__, (T,))
+
+ L0 = list[str]
+ self.assertEqual(L0.__args__, (str,))
+ self.assertEqual(L0.__parameters__, ())
+ L1 = list[T]
+ self.assertEqual(L1.__args__, (T,))
+ self.assertEqual(L1.__parameters__, (T,))
+ L2 = list[list[T]]
+ self.assertEqual(L2.__args__, (list[T],))
+ self.assertEqual(L2.__parameters__, (T,))
+ L3 = list[List[T]]
+ self.assertEqual(L3.__args__, (List[T],))
+ self.assertEqual(L3.__parameters__, (T,))
+ L4a = list[Dict[K, V]]
+ self.assertEqual(L4a.__args__, (Dict[K, V],))
+ self.assertEqual(L4a.__parameters__, (K, V))
+ L4b = list[Dict[T, int]]
+ self.assertEqual(L4b.__args__, (Dict[T, int],))
+ self.assertEqual(L4b.__parameters__, (T,))
+ L5 = list[Callable[[K, V], K]]
+ self.assertEqual(L5.__args__, (Callable[[K, V], K],))
+ self.assertEqual(L5.__parameters__, (K, V))
+
  def test_parameter_chaining(self):
  from typing import List, Dict, Union, Callable
  self.assertEqual(list[T][int], list[int])
@@ -391,5 +420,9 @@ def __call__(self):
  self.assertEqual(repr(C1), "collections.abc.Callable"
  "[typing.Concatenate[int, ~P], int]")
 
+ with self.subTest("Testing TypeVarTuple uses"):
+ Ts = typing.TypeVarTuple('Ts')
+ tuple[*Ts]
+
 if __name__ == "__main__":
  unittest.main()

Lib/test/test_typing.py

@@ -7,7 +7,7 @@
 from copy import copy, deepcopy
 
 from typing import Any, NoReturn
-from typing import TypeVar, AnyStr
+from typing import TypeVar, TypeVarTuple, Unpack, _UnpackedTypeVarTuple, AnyStr
 from typing import T, KT, VT # Not in __all__.
 from typing import Union, Optional, Literal
 from typing import Tuple, List, Dict, MutableMapping
@@ -236,6 +236,153 @@ def test_no_bivariant(self):
  TypeVar('T', covariant=True, contravariant=True)
 
 
+class TypeVarTupleTests(BaseTestCase):
+
+ def test_basic_plain(self):
+ Ts = TypeVarTuple('Ts')
+ self.assertEqual(Ts, Ts)
+ self.assertEqual(Unpack[Ts], Unpack[Ts])
+ self.assertIsInstance(Ts, TypeVarTuple)
+ self.assertIsInstance(Unpack[Ts], _UnpackedTypeVarTuple)
+
+ def test_repr(self):
+ Ts = TypeVarTuple('Ts')
+ self.assertEqual(repr(Ts), 'Ts')
+ self.assertEqual(repr(Unpack[Ts]), '*Ts')
+
+ def test_no_redefinition(self):
+ self.assertNotEqual(TypeVar('Ts'), TypeVar('Ts'))
+
+ def test_cannot_subclass_vars(self):
+ with self.assertRaises(TypeError):
+ class V(TypeVarTuple('Ts')):
+ pass
+ with self.assertRaises(TypeError):
+ class V(Unpack[TypeVarTuple('Ts')]):
+ pass
+
+ def test_cannot_subclass_var_itself(self):
+ with self.assertRaises(TypeError):
+ class V(TypeVarTuple):
+ pass
+
+ def test_cannot_instantiate_vars(self):
+ Ts = TypeVarTuple('Ts')
+ with self.assertRaises(TypeError):
+ Ts()
+
+ def test_unpack(self):
+ Ts = TypeVarTuple('Ts')
+ self.assertEqual(Unpack[Ts], Unpack[Ts])
+ self.assertIsInstance(Unpack[Ts], _UnpackedTypeVarTuple)
+ with self.assertRaises(TypeError):
+ Unpack()
+ with self.assertRaises(TypeError):
+ Unpack[Tuple[int, str]]
+ with self.assertRaises(TypeError):
+ Unpack[List[int]]
+
+ def test_tuple(self):
+ Ts = TypeVarTuple('Ts')
+ Tuple[Unpack[Ts]]
+ with self.assertRaises(TypeError):
+ Tuple[Ts]
+
+ def test_list(self):
+ Ts = TypeVarTuple('Ts')
+ with self.assertRaises(TypeError):
+ List[Ts]
+ with self.assertRaises(TypeError):
+ List[Unpack[Ts]]
+
+ def test_union(self):
+ Xs = TypeVarTuple('Xs')
+ Ys = TypeVarTuple('Ys')
+ self.assertNotEqual(Xs, Ys)
+ with self.assertRaises(TypeError):
+ Union[Xs]
+ Union[Xs, int]
+ self.assertEqual(
+ Union[Unpack[Xs]],
+ Unpack[Xs]
+ )
+ self.assertNotEqual(
+ Union[Unpack[Xs]],
+ Union[Unpack[Xs], Unpack[Ys]]
+ )
+ self.assertEqual(
+ Union[Unpack[Xs], Unpack[Xs]],
+ Unpack[Xs]
+ )
+ self.assertNotEqual(
+ Union[Unpack[Xs], int],
+ Union[Unpack[Xs]]
+ )
+ self.assertNotEqual(
+ Union[Unpack[Xs], int],
+ Union[int]
+ )
+ self.assertEqual(
+ Union[Unpack[Xs], int].__args__,
+ (Unpack[Xs], int)
+ )
+ self.assertEqual(
+ Union[Unpack[Xs], int].__parameters__,
+ (Unpack[Xs],)
+ )
+ self.assertIs(
+ Union[Unpack[Xs], int].__origin__,
+ Union
+ )
+
+ def test_concatenation(self):
+ Xs = TypeVarTuple('Xs')
+ Tuple[int, Unpack[Xs]]
+ Tuple[Unpack[Xs], int]
+ Tuple[int, Unpack[Xs], str]
+ class C(Generic[Unpack[Xs]]): pass
+ C[int, Unpack[Xs]]
+ C[Unpack[Xs], int]
+ C[int, Unpack[Xs], str]
+
+ with self.assertRaises(TypeError):
+ Tuple[Unpack[Xs], Unpack[Xs]]
+ with self.assertRaises(TypeError):
+ C[Unpack[Xs], Unpack[Xs]]
+ Ys = TypeVarTuple('Ys')
+ with self.assertRaises(TypeError):
+ Tuple[Unpack[Xs], Unpack[Ys]]
+ with self.assertRaises(TypeError):
+ C[Unpack[Xs], Unpack[Ys]]
+
+ def test_class(self):
+ Ts = TypeVarTuple('Ts')
+
+ class C(Generic[Unpack[Ts]]): pass
+ C[int]
+ C[int, str]
+
+ with self.assertRaises(TypeError):
+ class C(Generic[Ts]): pass
+ with self.assertRaises(TypeError):
+ class C(Generic[Unpack[Ts], int]): pass
+
+ T1 = TypeVar('T')
+ T2 = TypeVar('T')
+ class C(Generic[T1, T2, Unpack[Ts]]): pass
+ C[int, str]
+ C[int, str, float]
+ with self.assertRaises(TypeError):
+ C[int]
+
+ def test_args_and_parameters(self):
+ Ts = TypeVarTuple('Ts')
+
+ t = Tuple[*Ts]
+ self.assertEqual(t.__args__, (Ts._unpacked,))
+ self.assertEqual(t.__parameters__, (Ts,))
+
+
 class UnionTests(BaseTestCase):
 
  def test_basics(self):
@@ -1433,12 +1580,20 @@ def test_basics(self):
  def test_generic_errors(self):
  T = TypeVar('T')
  S = TypeVar('S')
+ Ts1 = TypeVarTuple('Ts1')
+ Ts2 = TypeVarTuple('Ts2')
  with self.assertRaises(TypeError):
  Generic[T][T]
+ with self.assertRaises(TypeError):
+ Generic[Unpack[Ts1]][Unpack[Ts1]]
  with self.assertRaises(TypeError):
  Generic[T][S]
+ with self.assertRaises(TypeError):
+ Generic[Unpack[Ts1]][Unpack[Ts2]]
  with self.assertRaises(TypeError):
  class C(Generic[T], Generic[T]): ...
+ with self.assertRaises(TypeError):
+ class C(Generic[Ts1], Generic[Ts1]): ...
  with self.assertRaises(TypeError):
  isinstance([], List[int])
  with self.assertRaises(TypeError):
@@ -1447,14 +1602,22 @@ class C(Generic[T], Generic[T]): ...
  class NewGeneric(Generic): ...
  with self.assertRaises(TypeError):
  class MyGeneric(Generic[T], Generic[S]): ...
+ with self.assertRaises(TypeError):
+ class MyGeneric(Generic[Ts1], Generic[Ts2]): ...
  with self.assertRaises(TypeError):
  class MyGeneric(List[T], Generic[S]): ...
 
  def test_init(self):
  T = TypeVar('T')
  S = TypeVar('S')
+ Ts1 = TypeVar('Ts1')
+ Ts2 = TypeVar('Ts2')
  with self.assertRaises(TypeError):
  Generic[T, T]
+ with self.assertRaises(TypeError):
+ Generic[Unpack[Ts1], Unpack[Ts1]]
+ with self.assertRaises(TypeError):
+ Generic[Unpack[Ts1], Unpack[Ts2]]
  with self.assertRaises(TypeError):
  Generic[T, S, T]
 
@@ -1508,14 +1671,40 @@ class C(Generic[T]):
  self.assertTrue(str(Z).endswith(
  '.C[typing.Tuple[str, int]]'))
 
+ def test_chain_repr_typevartuple(self):
+ T = TypeVar('T')
+ Ts = TypeVarTuple('Ts')
+
+ class C(Generic[Unpack[Ts]]):
+ pass
+
+ X = C[Tuple[Unpack[Ts], T]]
+ self.assertEqual(X, C[Tuple[Unpack[Ts], T]])
+ self.assertNotEqual(X, C[Tuple[T, Unpack[Ts]]])
+
+ Y = X[T, int]
+ self.assertEqual(Y, X[T, int])
+ self.assertNotEqual(Y, X[Unpack[Ts], int])
+ self.assertNotEqual(Y, X[T, str])
+
+ Z = Y[str]
+ self.assertEqual(Z, Y[str])
+ self.assertNotEqual(Z, Y[int])
+ self.assertNotEqual(Z, Y[T])
+
+ self.assertTrue(str(Z).endswith(
+ '.C[typing.Tuple[str, int]]'))
+
  def test_new_repr(self):
  T = TypeVar('T')
  U = TypeVar('U', covariant=True)
  S = TypeVar('S')
+ Ts = TypeVarTuple('Ts')
 
  self.assertEqual(repr(List), 'typing.List')
  self.assertEqual(repr(List[T]), 'typing.List[~T]')
  self.assertEqual(repr(List[U]), 'typing.List[+U]')
+ self.assertEqual(repr(Tuple[Unpack[Ts]]), 'typing.Tuple[*Ts]')
  self.assertEqual(repr(List[S][T][int]), 'typing.List[int]')
  self.assertEqual(repr(List[int]), 'typing.List[int]')
 
@@ -1535,6 +1724,8 @@ def test_new_repr_bare(self):
  T = TypeVar('T')
  self.assertEqual(repr(Generic[T]), 'typing.Generic[~T]')
  self.assertEqual(repr(typing.Protocol[T]), 'typing.Protocol[~T]')
+ Ts = TypeVarTuple('Ts')
+ self.assertEqual(repr(Generic[Unpack[Ts]]), 'typing.Generic[*Ts]')
  class C(typing.Dict[Any, Any]): ...
  # this line should just work
  repr(C.__mro__)