Lines Matching refs:Tuple
20 from typing import Tuple, List, Dict, MutableMapping
298 alias_1 = Tuple[Self, Self]
353 alias_1 = Tuple[LiteralString, LiteralString]
631 tuple_types = ['tuple', 'Tuple']
681 tuple_types = ['tuple', 'Tuple']
746 tuple_types = ['tuple', 'Tuple']
777 generics = ['C', 'tuple', 'Tuple']
778 tuple_types = ['tuple', 'Tuple']
878 Unpack[Tuple[int]]
881 dir_items = set(dir(Unpack[Tuple[int]]))
890 Unpack[Tuple[int], Tuple[str]]
892 # *(Tuple[int], Tuple[str]) is just plain tuple unpacking,
899 Unpack[Tuple[int]][Tuple[int]]
942 self.assertEqual(Tuple[Unpack[Ts]], Tuple[Unpack[Ts]])
952 Tuple[Unpack[Ts1], Unpack[Ts2]],
953 Tuple[Unpack[Ts2], Unpack[Ts1]],
961 t2 = Tuple[Unpack[Ts]]
972 for A in G1, G2, Tuple, tuple:
1016 if A != Tuple:
1024 I = Tuple[List[T], A[Unpack[Ts]], List[T2]]
1029 if A != Tuple:
1031 Tuple[List[float], A[()], List[str]])
1033 Tuple[List[float], A[str], List[int]])
1035 Tuple[List[float], A[str, int], List[bytes]])
1044 for A in G1, G2, Tuple, tuple:
1079 self.assertEqual(repr(Tuple[Unpack[Ts]]), 'typing.Tuple[*Ts]')
1082 self.assertEqual(repr(Unpack[Tuple[Unpack[Ts]]]), '*typing.Tuple[*Ts]')
1098 self.assertEndsWith(repr(B[Unpack[Tuple[int, ...]]]),
1099 'B[*typing.Tuple[int, ...]]')
1103 self.assertEndsWith(repr(A[float, Unpack[Tuple[int, ...]]]),
1104 'A[float, *typing.Tuple[int, ...]]')
1108 self.assertEndsWith(repr(B[Unpack[Tuple[int, ...]], str]),
1109 'B[*typing.Tuple[int, ...], str]')
1113 self.assertEndsWith(repr(B[float, Unpack[Tuple[int, ...]], str]),
1114 'B[float, *typing.Tuple[int, ...], str]')
1174 K = A[Unpack[Ts], Unpack[Tuple[str, ...]]]
1175 self.assertEndsWith(repr(K), 'A[*Ts, *typing.Tuple[str, ...]]')
1176 self.assertEndsWith(repr(K[()]), 'A[*typing.Tuple[str, ...]]')
1177 self.assertEndsWith(repr(K[float]), 'A[float, *typing.Tuple[str, ...]]')
1178 self.assertEndsWith(repr(K[float, str]), 'A[float, str, *typing.Tuple[str, ...]]')
1290 self.assertEqual(Tuple[Unpack[Ts]].__args__, (Unpack[Ts],))
1293 self.assertEqual(Tuple[Unpack[Ts], int].__args__, (Unpack[Ts], int))
1296 self.assertEqual(Tuple[int, Unpack[Ts]].__args__, (int, Unpack[Ts]))
1300 self.assertEqual(Tuple[int, Unpack[Ts], str].__args__,
1304 self.assertEqual(Tuple[Unpack[Ts]].__args__, (Unpack[Ts],))
1341 l = Callable[[None], Tuple[int, Unpack[Ts]]]
1343 self.assertEqual(l.__args__, (type(None), Tuple[int, Unpack[Ts]]))
1346 n = Callable[[None], Tuple[Unpack[Ts], int]]
1348 self.assertEqual(n.__args__, (type(None), Tuple[Unpack[Ts], int]))
1351 p = Callable[[None], Tuple[str, Unpack[Ts], int]]
1353 self.assertEqual(p.__args__, (type(None), Tuple[str, Unpack[Ts], int]))
1405 Tuple[int, Unpack[Ts]]
1406 Tuple[Unpack[Ts], int]
1407 Tuple[int, Unpack[Ts], str]
1408 Tuple[int, bool, Unpack[Ts], float, str]
1470 def b(*args: Unpack[Tuple[int, ...]]): pass
1472 {'args': Unpack[Tuple[int, ...]]})
1503 # Unpacking using `Unpack`, `Tuple` type from typing.py
1505 def e(*args: Unpack[Tuple[int, Unpack[Ts]]]): pass
1508 {'args': Unpack[Tuple[int, Unpack[Ts]]]},
1511 def f(*args: Unpack[Tuple[Unpack[Ts], int]]): pass
1514 {'args': Unpack[Tuple[Unpack[Ts], int]]},
1517 def g(*args: Unpack[Tuple[str, Unpack[Ts], int]]): pass
1520 {'args': Unpack[Tuple[str, Unpack[Ts], int]]},
1523 def h(*args: Unpack[Tuple[int, bool, Unpack[Ts], float, str]]): pass
1526 {'args': Unpack[Tuple[int, bool, Unpack[Ts], float, str]]},
1641 Tuple[Unpack[global_Ts]],
1644 Tuple[T, Unpack[global_Ts]],
1647 Tuple[int, Unpack[global_Ts]],
1847 issubclass(Tuple, Tuple[int, str])
1849 issubclass(tuple, Tuple[int, str])
1852 self.assertIsSubclass(tuple, Tuple)
1853 self.assertIsSubclass(TP, Tuple)
1856 self.assertEqual(Tuple[int], Tuple[int])
1857 self.assertEqual(Tuple[int, ...], Tuple[int, ...])
1858 self.assertNotEqual(Tuple[int], Tuple[int, int])
1859 self.assertNotEqual(Tuple[int], Tuple[int, ...])
1864 self.assertIsSubclass(MyTuple, Tuple)
1865 self.assertIsSubclass(Tuple, Tuple)
1866 self.assertIsSubclass(tuple, Tuple)
1870 isinstance((0, 0), Tuple[int, int])
1871 self.assertIsInstance((0, 0), Tuple)
1874 self.assertEqual(repr(Tuple), 'typing.Tuple')
1875 self.assertEqual(repr(Tuple[()]), 'typing.Tuple[()]')
1876 self.assertEqual(repr(Tuple[int, float]), 'typing.Tuple[int, float]')
1877 self.assertEqual(repr(Tuple[int, ...]), 'typing.Tuple[int, ...]')
1878 self.assertEqual(repr(Tuple[list[int]]), 'typing.Tuple[list[int]]')
1882 issubclass(42, Tuple)
1884 issubclass(42, Tuple[int])
1981 self.assertEqual(Callable | Tuple, Union[Callable, Tuple])
1982 self.assertEqual(Tuple | Callable, Union[Tuple, Callable])
3135 self.assertEqual(P[T, T][Tuple[T, S]][int, str],
3136 P[Tuple[int, str], Tuple[int, str]])
3440 X = C[Tuple[S, T]]
3441 self.assertEqual(X, C[Tuple[S, T]])
3442 self.assertNotEqual(X, C[Tuple[T, S]])
3455 '.C[typing.Tuple[str, int]]'))
3473 self.assertEqual(repr(List[Tuple[T, TS]][int, T]),
3474 'typing.List[typing.Tuple[int, ~T]]')
3476 repr(List[Tuple[T, T]][List[int]]),
3477 'typing.List[typing.Tuple[typing.List[int], typing.List[int]]]'
3516 self.assertEqual(C[Tuple[int]].z, 'new')
3519 self.assertEqual(C[Tuple[str]]().z, 'new')
3665 self.assertNotEqual(Tuple[A[str]], Tuple[B.A[str]])
3666 self.assertNotEqual(Tuple[A[List[Any]]], Tuple[B.A[List[Any]]])
3673 self.assertTrue(repr(Tuple[A[str]]).endswith('<locals>.A[str]]'))
3674 self.assertTrue(repr(Tuple[B.A[str]]).endswith('<locals>.B.A[str]]'))
3675 self.assertTrue(repr(Tuple[mod_generics_cache.A[str]])
3677 self.assertTrue(repr(Tuple[mod_generics_cache.B.A[str]])
3683 self.assertEqual(Tuple[T, T][int], Tuple[int, int])
3684 self.assertEqual(typing.Iterable[Tuple[T, T]][T], typing.Iterable[Tuple[T, T]])
3686 Tuple[T, int][()]
3698 self.assertEqual(repr(Union[Tuple, Callable]).replace('typing.', ''),
3699 'Union[Tuple, Callable]')
3700 self.assertEqual(repr(Union[Tuple, Tuple[int]]).replace('typing.', ''),
3701 'Union[Tuple, Tuple[int]]')
3726 AT = Tuple[T, ...]
3773 class T1(Tuple[T, KT]): ...
3774 class T2(Tuple[T, ...]): ...
3797 issubclass(Tuple[int, ...], typing.Sequence)
3799 issubclass(Tuple[int, ...], typing.Iterable)
3805 Tuple[Optional]
3816 Tuple[Generic[T]]
3824 class MyTup(Tuple[T, T]): ...
3871 samples = [Any, Union, Tuple, Callable, ClassVar,
3872 Union[int, str], ClassVar[List], Tuple[int, ...], Tuple[()],
3881 typing.Type[typing.Mapping], typing.AbstractSet[Tuple[int, str]]]
3891 things = [Union[T, int], Tuple[T, int], Tuple[()],
3893 Tuple[Any, Any], Node[T], Node[int], Node[Any], typing.Iterable[T],
3895 typing.Dict[T, Any], ClassVar[int], ClassVar[List[T]], Tuple['T', 'T'],
3911 Union, Any, Tuple, Callable]:
3955 things = [Any, Union[T, int], Callable[..., T], Tuple[Any, Any],
4274 for t in Tuple, tuple:
4639 def foo(a: Tuple['T']):
4643 {'a': Tuple[T]})
5232 ann_module_type_hints = {1: 2, 'f': Tuple[int, int], 'x': int, 'y': str, 'u': int | float}
5352 BA = Tuple[Annotated[T, (1, 0)], ...]
5354 self.assertEqual(get_type_hints(barfoo, globals(), locals())['x'], Tuple[T, ...])
5549 self.assertIs(get_origin(List[Tuple[T, T]][int]), list)
5552 self.assertIs(get_origin(Tuple), tuple)
5564 self.assertIs(get_origin(Unpack[Tuple[Unpack[Ts]]]), Unpack)
5576 self.assertEqual(get_args(Union[int, Tuple[T, int]][str]),
5577 (int, Tuple[str, int]))
5578 self.assertEqual(get_args(typing.Dict[int, Tuple[T, T]][Optional[int]]),
5579 (int, Tuple[Optional[int], Optional[int]]))
5582 self.assertEqual(get_args(Union[int, Callable[[Tuple[T, ...]], str]]),
5583 (int, Callable[[Tuple[T, ...]], str]))
5584 self.assertEqual(get_args(Tuple[int, ...]), (int, ...))
5585 self.assertEqual(get_args(Tuple[()]), ())
5588 self.assertEqual(get_args(Tuple), ())
5903 Tuple()
5905 Tuple[T]()
5907 Tuple[int]()
6584 self.assertNotEqual(typing.List[EmpD], typing.Tuple[EmpD])
7245 typing.Optional[str], Tuple[int, ...],
7315 B = Annotated[Tuple[Unpack[Ts]], dec]
7316 self.assertEqual(B[int], Annotated[Tuple[int], dec])
7317 self.assertEqual(B[str, int], Annotated[Tuple[str, int], dec])
7331 D = Annotated[Tuple[T, Unpack[Ts]], dec]
7332 self.assertEqual(D[int], Annotated[Tuple[int], dec])
7333 self.assertEqual(D[int, str], Annotated[Tuple[int, str], dec])
7336 Annotated[Tuple[int, str, float], dec]
7351 F = Annotated[Tuple[Unpack[Ts], T], dec]
7352 self.assertEqual(F[int], Annotated[Tuple[int], dec])
7353 self.assertEqual(F[int, str], Annotated[Tuple[int, str], dec])
7356 Annotated[Tuple[int, str, float], dec]
7374 H = Annotated[Tuple[T1, Unpack[Ts], T2], dec]
7375 self.assertEqual(H[int, str], Annotated[Tuple[int, str], dec])
7378 Annotated[Tuple[int, str, float], dec]
7382 Annotated[Tuple[int, str, bool, float], dec]
7600 g: Tuple[*Ts]
7615 g: Tuple[*Ts]
7635 A = C[P, Tuple[*Ts]]
7637 self.assertEqual(B.__args__, (int, str, Tuple[bytes, float]))
7642 A = X[Tuple[*Ts], P]
7644 self.assertEqual(B.__args__, (Tuple[bytes, float], (int, str,)))
7649 A = Y[P, Tuple[*Ts]]
7651 self.assertEqual(B.__args__, ((int, str,), Tuple[bytes, float]))
7731 A9 = Base[[Tuple[*Ts], *Ts]]
7733 self.assertEqual(A9.__args__, ((Tuple[*Ts], *Ts),))
7734 self.assertEqual(A9[int, str], Base[Tuple[int, str], int, str])
7977 typing.Tuple: 'Tuple',
8014 typing.Tuple[Any]: 'Tuple',
8015 typing.Tuple[Any, ...]: 'Tuple',
8279 Tuple,