Lines Matching refs:int
124 Any[int] # Any is not a generic type.
178 self.bottom_type[int]
274 Self[int]
294 issubclass(int, Self)
330 LiteralString[int]
350 issubclass(int, LiteralString)
374 T_bound = TypeVar('T_bound', bound=int)
377 self.assertIs(T_bound.__bound__, int)
379 T_constraints = TypeVar('T_constraints', int, str)
381 self.assertEqual(T_constraints.__constraints__, (int, str))
402 issubclass(int, T)
404 issubclass(T, int)
408 X = TypeVar('X', int)
418 self.assertNotEqual(Union[X, int], Union[X])
419 self.assertNotEqual(Union[X, int], Union[int])
420 self.assertEqual(Union[X, int].__args__, (X, int))
421 self.assertEqual(Union[X, int].__parameters__, (X,))
422 self.assertIs(Union[X, int].__origin__, Union)
450 self.assertNotEqual(TypeVar('T', int, str), TypeVar('T', int, str))
486 self.assertIs(subst(int), int)
487 self.assertEqual(subst(list[int]), list[int])
488 self.assertEqual(subst(List[int]), List[int])
493 self.assertEqual(subst(int|str), int|str)
494 self.assertEqual(subst(Union[int, str]), Union[int, str])
499 (), (int, str), Union,
501 Final, Final[int], ClassVar, ClassVar[int],
636 ('generic[T]', '[int]', 'generic[int]'),
637 ('generic[T]', '[int, str]', 'TypeError'),
638 ('generic[T]', '[tuple_type[int, ...]]', 'generic[tuple_type[int, ...]]'),
639 ('generic[T]', '[*tuple_type[int]]', 'generic[int]'),
641 ('generic[T]', '[*tuple_type[int, str]]', 'TypeError'),
642 ('generic[T]', '[*tuple_type[int, ...]]', 'TypeError'),
648 ('C[T, *tuple_type[int, ...]]', '[int]', 'TypeError'),
650 ('list[T, *tuple_type[int, ...]]', '[int]', 'list[int, *tuple_type[int, ...]]'),
651 ('List[T, *tuple_type[int, ...]]', '[int]', 'TypeError'),
653 ('generic[*Ts, *Ts2]', '[int]', 'TypeError'),
686 ('generic[T1, T2]', '[int]', 'TypeError'),
687 ('generic[T1, T2]', '[int, str]', 'generic[int, str]'),
688 ('generic[T1, T2]', '[int, str, bool]', 'TypeError'),
689 ('generic[T1, T2]', '[*tuple_type[int]]', 'TypeError'),
690 ('generic[T1, T2]', '[*tuple_type[int, str]]', 'generic[int, str]'),
691 ('generic[T1, T2]', '[*tuple_type[int, str, bool]]', 'TypeError'),
693 ('generic[T1, T2]', '[int, *tuple_type[str]]', 'generic[int, str]'),
694 ('generic[T1, T2]', '[*tuple_type[int], str]', 'generic[int, str]'),
695 ('generic[T1, T2]', '[*tuple_type[int], *tuple_type[str]]', 'generic[int, str]'),
696 ('generic[T1, T2]', '[*tuple_type[int, str], *tuple_type[()]]', 'generic[int, str]'),
697 ('generic[T1, T2]', '[*tuple_type[()], *tuple_type[int, str]]', 'generic[int, str]'),
698 ('generic[T1, T2]', '[*tuple_type[int], *tuple_type[()]]', 'TypeError'),
699 ('generic[T1, T2]', '[*tuple_type[()], *tuple_type[int]]', 'TypeError'),
700 ('generic[T1, T2]', '[*tuple_type[int, str], *tuple_type[float]]', 'TypeError'),
701 ('generic[T1, T2]', '[*tuple_type[int], *tuple_type[str, float]]', 'TypeError'),
702 ('generic[T1, T2]', '[*tuple_type[int, str], *tuple_type[float, bool]]', 'TypeError'),
704 ('generic[T1, T2]', '[tuple_type[int, ...]]', 'TypeError'),
705 ('generic[T1, T2]', '[tuple_type[int, ...], tuple_type[str, ...]]', 'generic[tuple_type[int, ...], tuple_type[str, ...]]'),
706 ('generic[T1, T2]', '[*tuple_type[int, ...]]', 'TypeError'),
707 ('generic[T1, T2]', '[int, *tuple_type[str, ...]]', 'TypeError'),
708 ('generic[T1, T2]', '[*tuple_type[int, ...], str]', 'TypeError'),
709 ('generic[T1, T2]', '[*tuple_type[int, ...], *tuple_type[str, ...]]', 'TypeError'),
715 # shouldn't really be able to do `generic[T1, *tuple_type[int, ...]]`.
719 ('generic[T1, *tuple_type[int, ...]]', '[str]', 'generic[str, *tuple_type[int, ...]]'),
750 ('generic[T1, bool, T2]', '[int, str]', 'generic[int, bool, str]'),
751 ('generic[T1, bool, T2]', '[*tuple_type[int, str]]', 'generic[int, bool, str]'),
783 ('generic[*Ts]', '[int]', 'generic[int]'),
784 ('generic[*Ts]', '[int, str]', 'generic[int, str]'),
785 ('generic[*Ts]', '[*tuple_type[int]]', 'generic[int]'),
787 ('generic[*Ts]', '[*tuple_type[int, str]]', 'generic[int, str]'),
788 ('generic[*Ts]', '[str, *tuple_type[int, ...], bool]', 'generic[str, *tuple_type[int, ...], bool]'),
789 ('generic[*Ts]', '[tuple_type[int, ...]]', 'generic[tuple_type[int, ...]]'),
790 ('generic[*Ts]', '[tuple_type[int, ...], tuple_type[str, ...]]', 'generic[tuple_type[int, ...], tuple_type[str, ...]]'),
791 ('generic[*Ts]', '[*tuple_type[int, ...]]', 'generic[*tuple_type[int, ...]]'),
792 ('generic[*Ts]', '[*tuple_type[int, ...], *tuple_type[str, ...]]', 'TypeError'),
798 ('generic[T, *Ts]', '[int]', 'generic[int]'),
799 ('generic[T, *Ts]', '[int, str]', 'generic[int, str]'),
800 ('generic[T, *Ts]', '[int, str, bool]', 'generic[int, str, bool]'),
802 ('generic[list[T], *Ts]', '[int]', 'generic[list[int]]'),
803 ('generic[list[T], *Ts]', '[int, str]', 'generic[list[int], str]'),
804 ('generic[list[T], *Ts]', '[int, str, bool]', 'generic[list[int], str, bool]'),
807 ('generic[*Ts, T]', '[int]', 'generic[int]'),
808 ('generic[*Ts, T]', '[int, str]', 'generic[int, str]'),
809 ('generic[*Ts, T]', '[int, str, bool]', 'generic[int, str, bool]'),
811 ('generic[*Ts, list[T]]', '[int]', 'generic[list[int]]'),
812 ('generic[*Ts, list[T]]', '[int, str]', 'generic[int, list[str]]'),
813 ('generic[*Ts, list[T]]', '[int, str, bool]', 'generic[int, str, list[bool]]'),
816 ('generic[T1, T2, *Ts]', '[int]', 'TypeError'),
817 ('generic[T1, T2, *Ts]', '[int, str]', 'generic[int, str]'),
818 ('generic[T1, T2, *Ts]', '[int, str, bool]', 'generic[int, str, bool]'),
819 ('generic[T1, T2, *Ts]', '[int, str, bool, bytes]', 'generic[int, str, bool, bytes]'),
822 ('generic[*Ts, T1, T2]', '[int]', 'TypeError'),
823 ('generic[*Ts, T1, T2]', '[int, str]', 'generic[int, str]'),
824 ('generic[*Ts, T1, T2]', '[int, str, bool]', 'generic[int, str, bool]'),
825 ('generic[*Ts, T1, T2]', '[int, str, bool, bytes]', 'generic[int, str, bool, bytes]'),
828 ('generic[T1, *Ts, T2]', '[int]', 'TypeError'),
829 ('generic[T1, *Ts, T2]', '[int, str]', 'generic[int, str]'),
830 ('generic[T1, *Ts, T2]', '[int, str, bool]', 'generic[int, str, bool]'),
831 ('generic[T1, *Ts, T2]', '[int, str, bool, bytes]', 'generic[int, str, bool, bytes]'),
833 ('generic[T, *Ts]', '[*tuple_type[int, ...]]', 'generic[int, *tuple_type[int, ...]]'),
834 ('generic[T, *Ts]', '[str, *tuple_type[int, ...]]', 'generic[str, *tuple_type[int, ...]]'),
835 ('generic[T, *Ts]', '[*tuple_type[int, ...], str]', 'generic[int, *tuple_type[int, ...], str]'),
836 ('generic[*Ts, T]', '[*tuple_type[int, ...]]', 'generic[*tuple_type[int, ...], int]'),
837 ('generic[*Ts, T]', '[str, *tuple_type[int, ...]]', 'generic[str, *tuple_type[int, ...], int]'),
838 ('generic[*Ts, T]', '[*tuple_type[int, ...], str]', 'generic[*tuple_type[int, ...], str]'),
839 ('generic[T1, *Ts, T2]', '[*tuple_type[int, ...]]', 'generic[int, *tuple_type[int, ...], int]'),
840 ('generic[T, str, *Ts]', '[*tuple_type[int, ...]]', 'generic[int, str, *tuple_type[int, ...]]'),
841 ('generic[*Ts, str, T]', '[*tuple_type[int, ...]]', 'generic[*tuple_type[int, ...], str, int]'),
842 ('generic[list[T], *Ts]', '[*tuple_type[int, ...]]', 'generic[list[int], *tuple_type[int, ...]]'),
843 ('generic[*Ts, list[T]]', '[*tuple_type[int, ...]]', 'generic[*tuple_type[int, ...], list[int]]'),
845 ('generic[T, *tuple_type[int, ...]]', '[str]', 'generic[str, *tuple_type[int, ...]]'),
846 ('generic[T1, T2, *tuple_type[int, ...]]', '[str, bool]', 'generic[str, bool, *tuple_type[int, ...]]'),
847 ('generic[T1, *tuple_type[int, ...], T2]', '[str, bool]', 'generic[str, *tuple_type[int, ...], bool]'),
848 ('generic[T1, *tuple_type[int, ...], T2]', '[str, bool, float]', 'TypeError'),
850 ('generic[T1, *tuple_type[T2, ...]]', '[int, str]', 'generic[int, *tuple_type[str, ...]]'),
851 ('generic[*tuple_type[T1, ...], T2]', '[int, str]', 'generic[*tuple_type[int, ...], str]'),
852 ('generic[T1, *tuple_type[generic[*Ts], ...]]', '[int, str, bool]', 'generic[int, *tuple_type[generic[str, bool], ...]]'),
853 ('generic[*tuple_type[generic[*Ts], ...], T1]', '[int, str, bool]', 'generic[*tuple_type[generic[int, str], ...], bool]'),
877 (*tuple[int],)
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,
897 (*tuple[int],)[0][tuple[int]]
899 Unpack[Tuple[int]][Tuple[int]]
999 self.assertEqual(F[float, str, int], A[float, str, int])
1000 self.assertEqual(F[float, str, int, bytes], A[float, str, int, bytes])
1008 self.assertEqual(G[float, str, int], A[float, str, int])
1009 self.assertEqual(G[float, str, int, bytes], A[float, str, int, bytes])
1019 self.assertEqual(H[float, str, int],
1020 tuple[list[float], A[str], list[int]])
1021 self.assertEqual(H[float, str, int, bytes],
1022 tuple[list[float], A[str, int], list[bytes]])
1032 self.assertEqual(I[float, str, int],
1033 Tuple[List[float], A[str], List[int]])
1034 self.assertEqual(I[float, str, int, bytes],
1035 Tuple[List[float], A[str, int], List[bytes]])
1047 B[int, str]
1057 B[int, *Ts]
1059 B[int, *Ts, *Ts]
1063 C[int, Unpack[Ts]]
1065 C[int, Unpack[Ts], Unpack[Ts]]
1096 self.assertEndsWith(repr(A[*tuple[int, ...]]),
1097 'A[*tuple[int, ...]]')
1098 self.assertEndsWith(repr(B[Unpack[Tuple[int, ...]]]),
1099 'B[*typing.Tuple[int, ...]]')
1101 self.assertEndsWith(repr(A[float, *tuple[int, ...]]),
1102 'A[float, *tuple[int, ...]]')
1103 self.assertEndsWith(repr(A[float, Unpack[Tuple[int, ...]]]),
1104 'A[float, *typing.Tuple[int, ...]]')
1106 self.assertEndsWith(repr(A[*tuple[int, ...], str]),
1107 'A[*tuple[int, ...], str]')
1108 self.assertEndsWith(repr(B[Unpack[Tuple[int, ...]], str]),
1109 'B[*typing.Tuple[int, ...], str]')
1111 self.assertEndsWith(repr(A[float, *tuple[int, ...], str]),
1112 'A[float, *tuple[int, ...], str]')
1113 self.assertEndsWith(repr(B[float, Unpack[Tuple[int, ...]], str]),
1114 'B[float, *typing.Tuple[int, ...], str]')
1132 D = A[*Ts, int]
1133 self.assertEndsWith(repr(D), 'A[*Ts, int]')
1134 self.assertEndsWith(repr(D[()]), 'A[int]')
1135 self.assertEndsWith(repr(D[float]), 'A[float, int]')
1136 self.assertEndsWith(repr(D[float, str]), 'A[float, str, int]')
1138 E = A[Unpack[Ts], int]
1139 self.assertEndsWith(repr(E), 'A[*Ts, int]')
1140 self.assertEndsWith(repr(E[()]), 'A[int]')
1141 self.assertEndsWith(repr(E[float]), 'A[float, int]')
1142 self.assertEndsWith(repr(E[float, str]), 'A[float, str, int]')
1144 F = A[int, *Ts]
1145 self.assertEndsWith(repr(F), 'A[int, *Ts]')
1146 self.assertEndsWith(repr(F[()]), 'A[int]')
1147 self.assertEndsWith(repr(F[float]), 'A[int, float]')
1148 self.assertEndsWith(repr(F[float, str]), 'A[int, float, str]')
1150 G = A[int, Unpack[Ts]]
1151 self.assertEndsWith(repr(G), 'A[int, *Ts]')
1152 self.assertEndsWith(repr(G[()]), 'A[int]')
1153 self.assertEndsWith(repr(G[float]), 'A[int, float]')
1154 self.assertEndsWith(repr(G[float, str]), 'A[int, float, str]')
1156 H = A[int, *Ts, str]
1157 self.assertEndsWith(repr(H), 'A[int, *Ts, str]')
1158 self.assertEndsWith(repr(H[()]), 'A[int, str]')
1159 self.assertEndsWith(repr(H[float]), 'A[int, float, str]')
1160 self.assertEndsWith(repr(H[float, str]), 'A[int, float, str, str]')
1162 I = A[int, Unpack[Ts], str]
1163 self.assertEndsWith(repr(I), 'A[int, *Ts, str]')
1164 self.assertEndsWith(repr(I[()]), 'A[int, str]')
1165 self.assertEndsWith(repr(I[float]), 'A[int, float, str]')
1166 self.assertEndsWith(repr(I[float, str]), 'A[int, float, str, str]')
1213 E = A[int]
1214 F = B[int]
1215 self.assertEqual(E.__args__, (int,))
1216 self.assertEqual(F.__args__, (int,))
1218 G = A[int, str]
1219 H = B[int, str]
1220 self.assertEqual(G.__args__, (int, str))
1221 self.assertEqual(H.__args__, (int, str))
1247 self.assertIs(C[int].__origin__, C)
1252 self.assertIs(D[int].__origin__, D)
1262 def func2(*args: *tuple[int, str]): pass
1263 self.assertEqual(gth(func2), {'args': Unpack[tuple[int, str]]})
1267 def func3(*args: *CustomVariadic[int, str]): pass
1268 self.assertEqual(gth(func3), {'args': Unpack[CustomVariadic[int, str]]})
1277 def func2(*args: '*tuple[int, str]'): pass
1278 self.assertEqual(gth(func2), {'args': Unpack[tuple[int, str]]})
1282 def func3(*args: '*CustomVariadic[int, str]'): pass
1284 {'args': Unpack[CustomVariadic[int, str]]})
1292 self.assertEqual(tuple[*Ts, int].__args__, (*Ts, int))
1293 self.assertEqual(Tuple[Unpack[Ts], int].__args__, (Unpack[Ts], int))
1295 self.assertEqual(tuple[int, *Ts].__args__, (int, *Ts))
1296 self.assertEqual(Tuple[int, Unpack[Ts]].__args__, (int, Unpack[Ts]))
1298 self.assertEqual(tuple[int, *Ts, str].__args__,
1299 (int, *Ts, str))
1300 self.assertEqual(Tuple[int, Unpack[Ts], str].__args__,
1301 (int, Unpack[Ts], str))
1303 self.assertEqual(tuple[*Ts, int].__args__, (*Ts, int))
1318 c = Callable[[int, *Ts], None]
1319 d = Callable[[int, Unpack[Ts]], None]
1320 self.assertEqual(c.__args__, (int, *Ts, type(None)))
1321 self.assertEqual(d.__args__, (int, Unpack[Ts], type(None)))
1323 e = Callable[[*Ts, int], None]
1324 f = Callable[[Unpack[Ts], int], None]
1325 self.assertEqual(e.__args__, (*Ts, int, type(None)))
1326 self.assertEqual(f.__args__, (Unpack[Ts], int, type(None)))
1328 g = Callable[[str, *Ts, int], None]
1329 h = Callable[[str, Unpack[Ts], int], None]
1330 self.assertEqual(g.__args__, (str, *Ts, int, type(None)))
1331 self.assertEqual(h.__args__, (str, Unpack[Ts], int, type(None)))
1340 k = Callable[[None], tuple[int, *Ts]]
1341 l = Callable[[None], Tuple[int, Unpack[Ts]]]
1342 self.assertEqual(k.__args__, (type(None), tuple[int, *Ts]))
1343 self.assertEqual(l.__args__, (type(None), Tuple[int, Unpack[Ts]]))
1345 m = Callable[[None], tuple[*Ts, int]]
1346 n = Callable[[None], Tuple[Unpack[Ts], int]]
1347 self.assertEqual(m.__args__, (type(None), tuple[*Ts, int]))
1348 self.assertEqual(n.__args__, (type(None), Tuple[Unpack[Ts], int]))
1350 o = Callable[[None], tuple[str, *Ts, int]]
1351 p = Callable[[None], Tuple[str, Unpack[Ts], int]]
1352 self.assertEqual(o.__args__, (type(None), tuple[str, *Ts, int]))
1353 self.assertEqual(p.__args__, (type(None), Tuple[str, Unpack[Ts], int]))
1385 C[int, *Ts]
1386 C[int, Unpack[Ts]]
1388 C[*Ts, int]
1389 C[Unpack[Ts], int]
1391 C[int, *Ts, str]
1392 C[int, Unpack[Ts], str]
1394 C[int, bool, *Ts, float, str]
1395 C[int, bool, Unpack[Ts], float, str]
1400 tuple[int, *Ts]
1401 tuple[*Ts, int]
1402 tuple[int, *Ts, str]
1403 tuple[int, bool, *Ts, float, str]
1405 Tuple[int, Unpack[Ts]]
1406 Tuple[Unpack[Ts], int]
1407 Tuple[int, Unpack[Ts], str]
1408 Tuple[int, bool, Unpack[Ts], float, str]
1418 class F(Generic[*Ts, int]): pass
1420 class E(Generic[Unpack[Ts], int]): pass
1428 A[int, str]
1429 A[int, str, float]
1430 A[int, str, float, bool]
1433 B[int, str]
1434 B[int, str, float]
1435 B[int, str, float, bool]
1438 C[int, str]
1439 C[int, str, float]
1440 C[int, str, float, bool]
1443 D[int, str]
1444 D[int, str, float]
1445 D[int, str, float, bool]
1448 E[int, str]
1449 E[int, str, float]
1450 E[int, str, float, bool]
1453 F[int, str]
1454 F[int, str, float]
1455 F[int, str, float, bool]
1466 def a(*args: *tuple[int, ...]): pass
1468 {'args': (*tuple[int, ...],)[0]})
1470 def b(*args: Unpack[Tuple[int, ...]]): pass
1472 {'args': Unpack[Tuple[int, ...]]})
1479 def a(*args: *tuple[int, *Ts]): pass
1482 {'args': (*tuple[int, *Ts],)[0]},
1485 def b(*args: *tuple[*Ts, int]): pass
1488 {'args': (*tuple[*Ts, int],)[0]},
1491 def c(*args: *tuple[str, *Ts, int]): pass
1494 {'args': (*tuple[str, *Ts, int],)[0]},
1497 def d(*args: *tuple[int, bool, *Ts, float, str]): pass
1500 {'args': (*tuple[int, bool, *Ts, float, str],)[0]},
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]]},
1534 self.assertEqual(C[int], C[int])
1535 self.assertEqual(D[int], D[int])
1559 C[int, *Ts1, *Ts2],
1560 C[int, *Ts1, *Ts2],
1563 D[int, Unpack[Ts1], Unpack[Ts2]],
1564 D[int, Unpack[Ts1], Unpack[Ts2]],
1573 C[int, str],
1574 C[str, int],
1577 D[int, str],
1578 D[str, int],
1646 tuple[int, *global_Ts],
1647 Tuple[int, Unpack[global_Ts]],
1657 u = Union[int, float]
1662 issubclass(int, Union)
1664 issubclass(Union, int)
1666 issubclass(Union[int, str], int)
1671 u1 = Union[int, Any]
1672 u2 = Union[Any, int]
1682 u1 = Union[int, object]
1683 u2 = Union[object, int]
1689 u1 = Union[int, float]
1690 u2 = Union[float, int]
1704 u = Union[int, float]
1706 self.assertEqual(v, Union[int, float, Employee])
1710 u = Union[Employee, int]
1711 self.assertEqual(repr(u), 'typing.Union[%s.Employee, int]' % __name__)
1712 u = Union[int, Employee]
1713 self.assertEqual(repr(u), 'typing.Union[int, %s.Employee]' % __name__)
1715 u = Union[T, int][int]
1716 self.assertEqual(repr(u), repr(int))
1717 u = Union[List[int], int]
1718 self.assertEqual(repr(u), 'typing.Union[typing.List[int], int]')
1719 u = Union[list[int], dict[str, float]]
1720 self.assertEqual(repr(u), 'typing.Union[list[int], dict[str, float]]')
1721 u = Union[int | float]
1722 self.assertEqual(repr(u), 'typing.Union[int, float]')
1728 u = Union[None, str, int]
1729 self.assertEqual(repr(u), 'typing.Union[NoneType, str, int]')
1734 dir_items = set(dir(Union[str, int]))
1749 class C(Union[int, str]):
1757 u = Union[int, float]
1764 self.assertFalse(Union[str, typing.Iterable[int]] == str)
1765 self.assertFalse(Union[str, typing.Iterable[int]] == typing.Iterable[int])
1766 self.assertIn(str, Union[str, typing.Iterable[int]].__args__)
1767 self.assertIn(typing.Iterable[int], Union[str, typing.Iterable[int]].__args__)
1779 o = Optional[int]
1780 u = Union[int, None]
1788 u = Union[int, str]
1793 def fun() -> int: ...
1794 self.assertEqual(repr(Union[fun, int]), 'typing.Union[fun, int]')
1847 issubclass(Tuple, Tuple[int, str])
1849 issubclass(tuple, Tuple[int, str])
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, ...])
1870 isinstance((0, 0), Tuple[int, int])
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]]')
1884 issubclass(42, Tuple[int])
1892 issubclass(types.FunctionType, Callable[[int], int])
1898 C = Callable[[int], int]
1899 self.assertEqual(C, Callable[[int], int])
1900 self.assertEqual(len({C, Callable[[int], int]}), 1)
1901 self.assertNotEqual(C, Callable[[int], str])
1902 self.assertNotEqual(C, Callable[[str], int])
1903 self.assertNotEqual(C, Callable[[int, int], int])
1904 self.assertNotEqual(C, Callable[[], int])
1905 self.assertNotEqual(C, Callable[..., int])
1910 dir_items = set(dir(Callable[..., int]))
1923 c = Callable[[int], str]
1932 Callable[int]
1959 ct2 = Callable[[str, float], int]
1960 self.assertEqual(repr(ct2), f'{fullname}[[str, float], int]')
1963 ct3 = Callable[[str, float], list[int]]
1964 self.assertEqual(repr(ct3), f'{fullname}[[str, float], list[int]]')
1986 alias = Callable[[int, str], float]
1990 self.assertEqual(alias.__args__, (int, str, float))
1995 alias = Callable[[int, str], float]
2006 Callable[[int, str], float],
2007 Callable[P_pickle, int],
2009 Callable[Concatenate[int, P_pickle], int],
2010 Callable[Concatenate[*TS_pickle, P_pickle], int],
2026 C1 = Callable[[int, T], T]
2029 self.assertEqual(C1[str], Callable[[int, str], str])
2030 self.assertEqual(C1[None], Callable[[int, type(None)], type(None)])
2031 self.assertEqual(C2[int, float, str], Callable[[int, float], str])
2032 self.assertEqual(C3[int], Callable[..., int])
2036 C4 = C2[int, VT, str]
2037 self.assertEqual(repr(C4), f"{fullname}[[int, ~VT], str]")
2038 self.assertEqual(repr(C4[dict]), f"{fullname}[[int, dict], str]")
2039 self.assertEqual(C4[dict], Callable[[int, dict], str])
2043 C5 = Callable[[typing.List[T], tuple[KT, T], VT], int]
2044 self.assertEqual(C5[int, str, float],
2045 Callable[[typing.List[int], tuple[str, int], float], int])
2055 Callable[P, T][0, int]
2062 a = C1[[int], T]
2064 self.assertEqual(a().__orig_class__, C1[[int], T])
2073 self.assertEqual(C1[[int], str], Callable[[int], str])
2074 self.assertEqual(C1[[int, str], str], Callable[[int, str], str])
2078 self.assertEqual(C1[Concatenate[int, P2], str],
2079 Callable[Concatenate[int, P2], str])
2081 self.assertEqual(repr(C1[[int, str], str]), f"{fullname}[[int, str], str]")
2083 C1[int, str]
2085 C2 = Callable[P, int]
2086 self.assertEqual(C2[[int]], Callable[[int], int])
2087 self.assertEqual(C2[[int, str]], Callable[[int, str], int])
2088 self.assertEqual(C2[[]], Callable[[], int])
2089 self.assertEqual(C2[...], Callable[..., int])
2090 self.assertEqual(C2[P2], Callable[P2, int])
2091 self.assertEqual(C2[Concatenate[int, P2]],
2092 Callable[Concatenate[int, P2], int])
2094 # X[int, str, float] == X[[int, str, float]]
2095 self.assertEqual(C2[int], Callable[[int], int])
2096 self.assertEqual(C2[int, str], Callable[[int, str], int])
2097 self.assertEqual(repr(C2), f"{fullname}[~P, int]")
2098 self.assertEqual(repr(C2[int, str]), f"{fullname}[[int, str], int]")
2106 C = Callable[Concatenate[int, P], T]
2108 f"{fullname}[typing.Concatenate[int, ~P], ~T]")
2109 self.assertEqual(C[P2, int], Callable[Concatenate[int, P2], int])
2110 self.assertEqual(C[[str, float], int], Callable[[int, str, float], int])
2111 self.assertEqual(C[[], int], Callable[[int], int])
2112 self.assertEqual(C[Concatenate[str, P2], int],
2113 Callable[Concatenate[int, str, P2], int])
2114 self.assertEqual(C[..., int], Callable[Concatenate[int, ...], int])
2116 C = Callable[Concatenate[int, P], int]
2118 f"{fullname}[typing.Concatenate[int, ~P], int]")
2119 self.assertEqual(C[P2], Callable[Concatenate[int, P2], int])
2120 self.assertEqual(C[[str, float]], Callable[[int, str, float], int])
2121 self.assertEqual(C[str, float], Callable[[int, str, float], int])
2122 self.assertEqual(C[[]], Callable[[int], int])
2124 Callable[Concatenate[int, str, P2], int])
2125 self.assertEqual(C[...], Callable[Concatenate[int, ...], int])
2141 C1 = My[[int, T2], Callable[P2, T2]]
2142 self.assertEqual(C1.__args__, ((int, T2), Callable[P2, T2]))
2144 self.assertEqual(C1[str, [list[int], bytes]],
2145 My[[int, str], Callable[[list[int], bytes], str]])
2147 C2 = My[[Callable[[T2], int], list[T2]], str]
2148 self.assertEqual(C2.__args__, ((Callable[[T2], int], list[T2]), str))
2151 My[[Callable[[list[str]], int], list[list[str]]], str])
2156 self.assertEqual(C3[[], int],
2157 My[[Callable[[], int], int], int])
2158 self.assertEqual(C3[[str, bool], int],
2159 My[[Callable[[str, bool], int], int], int])
2160 self.assertEqual(C3[[str, bool], T][int],
2161 My[[Callable[[str, bool], int], int], int])
2163 C4 = My[[Callable[[int, *Ts, str], T2], T2], T2]
2164 self.assertEqual(C4.__args__, ((Callable[[int, *Ts, str], T2], T2), T2))
2167 My[[Callable[[int, bool, bytes, str], float], float], float])
2171 alias = Callable[[int, str], float]
2173 alias[int]
2177 C1[int, str, str]
2179 C1[int]
2187 c1 = typing.Callable[[int, str], dict]
2188 c2 = collections.abc.Callable[[int, str], dict]
2219 Literal[int]
2231 self.assertEqual(repr(Literal[int]), "typing.Literal[int]")
2258 isinstance(int, Literal[1])
2262 issubclass(int, Literal[1])
2355 x: int
2356 y: int
2363 x: int
2364 y: int
2368 x: int
2371 y: int
2379 attr: int
2380 def meth(self, arg: str) -> int:
2387 attr: int = 1
2388 def meth(self, arg: str) -> int:
2394 x: int
2395 y: int
2488 PG[int]()
2494 self.assertIsInstance(CG[int](), CG)
2496 CG[int](42)
2503 x: int
2504 def __init__(self, x: int) -> None:
2514 x: int
2515 def __init__(self, x: int) -> None:
2528 def ameth(self) -> int:
2535 def ameth(self) -> int:
2644 issubclass(PG, PG[int])
2756 attr: int
2783 attr: int
2801 x: int
2873 x: int
2896 CI = C[int]
3017 class P(PR[int, T], Protocol[T]):
3021 PR[int]
3023 P[int, str]
3025 class C(PR[int, T]): pass
3037 class P(PR[int, str], Protocol):
3041 issubclass(PR[int, str], PR)
3044 PR[int]
3073 self.assertEqual(C[int]().test, 'OK')
3082 self.assertEqual(D1[int]().test, 'OK')
3087 self.assertEqual(D2[int]().test, 'OK')
3100 self.assertEqual(C[int]().test, 'OK')
3102 C[int](42)
3104 C[int](a=42)
3112 class P(Protocol[int]): pass
3125 self.assertTrue(repr(P[int, str]).endswith('P[int, str]'))
3134 self.assertEqual(P[int, T], P[int, T])
3135 self.assertEqual(P[T, T][Tuple[T, S]][int, str],
3136 P[Tuple[int, str], Tuple[int, str]])
3144 self.assertEqual(P[int].__parameters__, ())
3145 self.assertEqual(P[int].__args__, (int,))
3146 self.assertIs(P[int].__origin__, P)
3170 self.assertTrue(PG[int]._is_protocol)
3192 x = None # type: int
3220 x = None # type: int
3234 class CP(P[int]):
3256 self.assertIsSubclass(int, typing.SupportsInt)
3285 self.assertIsSubclass(int, typing.SupportsAbs)
3291 self.assertIsSubclass(int, typing.SupportsRound)
3296 self.assertNotIsSubclass(int, typing.Reversible)
3299 self.assertIsSubclass(int, typing.SupportsIndex)
3305 def __int__(self) -> int:
3337 x: int
3344 x: int
3367 SM1 = SimpleMapping[str, int]
3384 isinstance([], List[int])
3386 issubclass(list, List[int])
3421 class W(X[int]):
3444 Y = X[T, int]
3445 self.assertEqual(Y, X[T, int])
3446 self.assertNotEqual(Y, X[S, int])
3451 self.assertNotEqual(Z, Y[int])
3455 '.C[typing.Tuple[str, int]]'))
3465 self.assertEqual(repr(List[S][T][int]), 'typing.List[int]')
3466 self.assertEqual(repr(List[int]), 'typing.List[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]]]'
3498 class C(B[int]):
3509 self.assertEqual(C[int].x, 'def')
3510 self.assertEqual(C[C[int]].x, 'def')
3511 C[C[int]].x = 'changed'
3516 self.assertEqual(C[Tuple[int]].z, 'new')
3523 self.assertEqual(D[int].x, 'changed')
3526 D[int].x = 'from derived x'
3528 self.assertEqual(C[int].z, 'new')
3535 C.register(int)
3537 C[int]
3589 self.assertTrue(naive_dict_check({'x': 1}, typing.Dict[str, int]))
3590 self.assertFalse(naive_dict_check({1: 'x'}, typing.Dict[str, int]))
3600 self.assertTrue(naive_generic_check(Node[int](), Node[int]))
3601 self.assertFalse(naive_generic_check(Node[str](), Node[int]))
3604 naive_generic_check([1, 2, 3], Node[int])
3610 class C(List[int]): ...
3622 self.assertEqual(C[int].__parameters__, ())
3623 self.assertEqual(D[int].__parameters__, ())
3624 self.assertEqual(C[int].__args__, (int,))
3625 self.assertEqual(D[int].__args__, (int,))
3635 self.assertEqual(Union[T, int][Meta], Union[Meta, int])
3662 self.assertNotEqual(B.A[int], mod_generics_cache.A[int])
3683 self.assertEqual(Tuple[T, T][int], Tuple[int, int])
3686 Tuple[T, int][()]
3688 self.assertEqual(Union[T, int][int], int)
3689 self.assertEqual(Union[T, U][int, Union[int, str]], Union[int, str])
3694 self.assertEqual(Callable[..., List[T]][int], Callable[..., List[int]])
3700 self.assertEqual(repr(Union[Tuple, Tuple[int]]).replace('typing.', ''),
3701 'Union[Tuple, Tuple[int]]')
3702 self.assertEqual(repr(Callable[..., Optional[T]][int]).replace('typing.', ''),
3703 'Callable[..., Optional[int]]')
3704 self.assertEqual(repr(Callable[[], List[T]][int]).replace('typing.', ''),
3705 'Callable[[], List[int]]')
3710 def foobar3(x: list[ForwardRef('CC | int')] | int): ...
3722 {'x': list[CC | int] | int}
3780 self.assertEqual(T1[int, str].__args__, (int, str))
3781 self.assertEqual(T1[int, T].__origin__, T1)
3786 ## T1[int]
3788 ## T2[int, str]
3790 self.assertEqual(repr(C1[int]).split('.')[-1], 'C1[int]')
3797 issubclass(Tuple[int, ...], typing.Sequence)
3799 issubclass(Tuple[int, ...], typing.Iterable)
3807 ClassVar[ClassVar[int]]
3809 List[ClassVar[int]]
3825 self.assertIs(MyTup[int]().__class__, MyTup)
3826 self.assertEqual(MyTup[int]().__orig_class__, MyTup[int])
3828 self.assertIs(MyDict[int]().__class__, MyDict)
3829 self.assertEqual(MyDict[int]().__orig_class__, MyDict[int])
3831 self.assertIs(MyDef[int]().__class__, MyDef)
3832 self.assertEqual(MyDef[int]().__orig_class__, MyDef[int])
3834 self.assertIs(MyChain[int]().__class__, MyChain)
3835 self.assertEqual(MyChain[int]().__orig_class__, MyChain[int])
3859 class C(B[int]):
3872 Union[int, str], ClassVar[List], Tuple[int, ...], Tuple[()],
3874 typing.DefaultDict, typing.FrozenSet[int]]
3880 more_samples = [List, typing.Iterable, typing.Type, List[int],
3881 typing.Type[typing.Mapping], typing.AbstractSet[Tuple[int, str]]]
3891 things = [Union[T, int], Tuple[T, int], Tuple[()],
3892 Callable[..., T], Callable[[int], int],
3893 Tuple[Any, Any], Node[T], Node[int], Node[Any], typing.Iterable[T],
3894 typing.Iterable[Any], typing.Iterable[int], typing.Dict[int, str],
3895 typing.Dict[T, Any], ClassVar[int], ClassVar[List[T]], Tuple['T', 'T'],
3896 Union['T', int], List['T'], typing.Mapping['T', int]]
3906 TPB = TypeVar('TPB', bound=int)
3921 TLB = TypeVar('TLB', bound=int)
3943 ci = C[int](42)
3951 self.assertEqual(ci.__orig_class__, C[int])
3955 things = [Any, Union[T, int], Callable[..., T], Tuple[Any, Any],
3956 Optional[List[int]], typing.Mapping[int, str],
3967 c_int = C[int]()
3978 self.assertEqual(copy(C[int]), deepcopy(C[int]))
3986 d_int = D[int]()
4009 X = C[int]
4011 self.assertEqual(repr(X).split('.')[-1], 'C[int]')
4013 class Y(C[int]):
4054 class C(List[int], B): ...
4073 class Subclass(Test[int]):
4093 V = Visitor[typing.List[int]]
4097 def append(self, x: int):
4142 D[int]
4219 ClassVar[int],
4220 Final[int],
4221 Union[int, float],
4222 Optional[int],
4224 Concatenate[int, ParamSpec("P")],
4225 TypeGuard[int],
4253 for b in (A, int, TypeVar, TypeVarTuple, ParamSpec, types.GenericAlias, types.UnionType):
4270 for s in (int, G, A, List, list,
4276 self.assertEqual(t[s, T][int], t[s, int])
4277 self.assertEqual(t[T, s][int], t[int, s])
4280 a[int]
4284 self.assertEqual(c[[s], T][int], c[[s], int])
4285 self.assertEqual(c[[T], s][int], c[[int], s])
4288 a[int]
4295 ClassVar[int, str]
4297 ClassVar[int][str]
4301 cv = ClassVar[int]
4302 self.assertEqual(repr(cv), 'typing.ClassVar[int]')
4311 class C(type(ClassVar[int])):
4320 type(ClassVar[Optional[int]])()
4324 isinstance(1, ClassVar[int])
4326 issubclass(int, ClassVar)
4331 Final[int] # OK
4333 Final[int, str]
4335 Final[int][str]
4337 Optional[Final[int]]
4341 cv = Final[int]
4342 self.assertEqual(repr(cv), 'typing.Final[int]')
4345 cv = Final[tuple[int]]
4346 self.assertEqual(repr(cv), 'typing.Final[tuple[int]]')
4353 class C(type(Final[int])):
4362 type(Final[Optional[int]])()
4366 isinstance(1, Final[int])
4368 issubclass(int, Final)
4408 final(int)
4409 self.assertIs(False, hasattr(int, "__final__"))
4448 self.assertEqual(cast(int, 42), 42)
4450 self.assertIs(type(cast(float, 42)), int)
4467 self.assertIs(assert_type(arg, int), arg)
4504 stuff: int = None,
4515 t = Node[int]
4519 self.assertEqual(both_hints['stuff'], int)
4529 fr = typing.ForwardRef('int')
4534 fr = typing.ForwardRef('int')
4536 issubclass(int, fr)
4543 fr = typing.ForwardRef('int')
4544 self.assertEqual(fr, typing.ForwardRef('int'))
4545 self.assertNotEqual(List['int'], List[int])
4546 self.assertNotEqual(fr, typing.ForwardRef('int', module=__name__))
4547 frm = typing.ForwardRef('int', module=__name__)
4548 self.assertEqual(frm, typing.ForwardRef('int', module=__name__))
4549 self.assertNotEqual(frm, typing.ForwardRef('int', module='__other_name__'))
4570 self.assertEqual(Union[c1, c1_gth, int], Union[c1, int])
4573 c1 = typing.ForwardRef('int')
4574 c1_gth = typing.ForwardRef('int')
4575 c2 = typing.ForwardRef('int')
4576 c2_gth = typing.ForwardRef('int')
4586 c3 = typing.ForwardRef('int', module=__name__)
4587 c4 = typing.ForwardRef('int', module='__other_name__')
4592 self.assertEqual(hash(c3), hash(typing.ForwardRef('int', module=__name__)))
4619 self.assertEqual(repr(List['int']), "typing.List[ForwardRef('int')]")
4620 self.assertEqual(repr(List[ForwardRef('int', module='mod')]),
4621 "typing.List[ForwardRef('int', module='mod')]")
4631 def foo(a: tuple[ForwardRef('T')] | int):
4635 {'a': tuple[T] | int})
4652 def foo(a: 'List[\'int\']'):
4655 {'a': List[int]})
4733 a: Annotated['ClassVar[int]', (3, 5)] = 4
4734 b: Annotated['Final[int]', "const"] = 4
4739 b: List['Final[int]'] = 4
4741 self.assertEqual(get_type_hints(C, globals())['a'], ClassVar[int])
4742 self.assertEqual(get_type_hints(C, globals())['b'], Final[int])
4792 def meth(self, x: int): ...
4798 self.assertEqual(get_type_hints(C.meth), {'x': int})
4802 def foo(self, x: int): ...
4804 self.assertEqual(get_type_hints(Child.foo), {'x': int})
4809 o: int
4811 o: int
4814 a: int
4816 b: int
4818 c: int
4820 d: int
4839 def st(x: int) -> int: ...
4841 def cl(cls, y: int) -> int: ...
4861 def some(*args: int) -> int:
4872 self.assertEqual(get_type_hints(some), {'args': int, 'return': int})
4878 bar: Callable[[int], int] = lambda arg: arg
4890 foo: typing.ClassVar[int] = 7
4892 foo: ClassVar[int] = 7
4894 foo: 'typing.ClassVar[int]' = 7
4896 foo: 'ClassVar[int]' = 7
4898 expected_result = {'foo': typing.ClassVar[int]}
4904 foo: 'typing.ClassVar[typing.ClassVar[int]]' = 7
4906 foo: ClassVar['ClassVar[int]'] = 7
4950 self.assertNotEqual(gth(Loop, globals())['attr'], Final[int])
5096 async def __aenter__(self) -> int:
5105 y: int
5106 b: int
5121 cool: int
5125 cool: int = 0
5128 x: int
5133 x: int
5134 y: int = 1
5143 x: int
5144 y: int
5151 b: int
5154 b: int
5159 log_level: int
5164 year: NotRequired[int]
5168 year: int
5174 year: NotRequired[int]
5180 year: NotRequired[Annotated[int, 2000]]
5184 year: NotRequired[Annotated[int, 2000]]
5188 year: NotRequired[Annotated[int, 2000]]
5192 year: NotRequired['Annotated[int, 2000]']
5198 async def g_with(am: typing.AsyncContextManager[int]):
5199 x: int
5232 ann_module_type_hints = {1: 2, 'f': Tuple[int, int], 'x': int, 'y': str, 'u': int | float}
5253 self.assertEqual(gth(ann_module.Y), {'z': int})
5257 self.assertEqual(gth(ann_module.foo), {'x': int})
5264 {'x': int, 'y': int})
5272 field: int = None # most type-checkers won't be happy with it
5274 self.assertEqual(gth(WithNoneDefault), {'field': int})
5285 def meth(x: int): ...
5288 self.assertEqual(gth(ABase.meth), {'x': int})
5292 self.assertEqual(gth(int), {})
5302 testf.__annotations__['x'] = 'int'
5303 self.assertEqual(gth(testf), {'x': int})
5318 {'y': int, 'x': ClassVar[Optional[B]], 'b': int})
5320 {'z': ClassVar[CSub], 'y': int, 'b': int,
5331 X = Annotated[int, (1, 10)]
5334 {'x': List[int]}
5338 {'x': List[Annotated[int, (1, 10)]]}
5342 X = Annotated[int, (1, 10)]
5345 {'x': list[int]}
5349 {'x': list[Annotated[int, (1, 10)]]}
5369 y: typing.Union[int, Annotated[T, "mutable"]]): ...
5372 {'x': typing.Callable[..., List[T]], 'y': typing.Union[int, T]}
5381 BA3 = typing.Annotated[int | float, "const"]
5385 {"x": int | float}
5389 {"x": typing.Annotated[int | float, "const"]}
5393 def with_union(x: int | list[Annotated[str, 'meta']]): ...
5395 self.assertEqual(get_type_hints(with_union), {'x': int | list[str]})
5398 {'x': int | list[Annotated[str, 'meta']]},
5430 def annotated_with_none_default(x: Annotated[int, 'data'] = None): ...
5433 {'x': int},
5437 {'x': Annotated[int, 'data']},
5477 r'typing.ClassVar\[int\] is not valid as type argument',
5482 self.assertEqual(get_type_hints(TotalMovie), {'title': str, 'year': int})
5485 'year': NotRequired[int],
5488 self.assertEqual(get_type_hints(AnnotatedMovie), {'title': str, 'year': int})
5491 'year': NotRequired[Annotated[int, 2000]],
5494 self.assertEqual(get_type_hints(DeeplyAnnotatedMovie), {'title': str, 'year': int})
5497 'year': NotRequired[Annotated[int, 2000]],
5500 self.assertEqual(get_type_hints(WeirdlyQuotedMovie), {'title': str, 'year': int})
5503 'year': NotRequired[Annotated[int, 2000]],
5506 self.assertEqual(get_type_hints(_typed_dict_helper.VeryAnnotated), {'a': int})
5508 'a': Annotated[Required[int], "a", "b", "c"]
5511 self.assertEqual(get_type_hints(ChildTotalMovie), {"title": str, "year": int})
5513 "title": Required[str], "year": NotRequired[int]
5516 self.assertEqual(get_type_hints(ChildDeeplyAnnotatedMovie), {"title": str, "year": int})
5519 "year": NotRequired[Annotated[int, 2000]]
5525 def f(x: collections.abc.Callable[[int], int]): ...
5526 def g(x: collections.abc.Callable[..., int]): ...
5527 def h(x: collections.abc.Callable[P, int]): ...
5529 self.assertEqual(get_type_hints(f), {'x': collections.abc.Callable[[int], int]})
5530 self.assertEqual(get_type_hints(g), {'x': collections.abc.Callable[..., int]})
5531 self.assertEqual(get_type_hints(h), {'x': collections.abc.Callable[P, int]})
5540 self.assertIs(get_origin(C[int]), C)
5542 self.assertIs(get_origin(int), None)
5543 self.assertIs(get_origin(ClassVar[int]), ClassVar)
5544 self.assertIs(get_origin(Union[int, str]), Union)
5546 self.assertIs(get_origin(Final[List[int]]), Final)
5549 self.assertIs(get_origin(List[Tuple[T, T]][int]), list)
5554 self.assertIs(get_origin(list[int]), list)
5559 self.assertIs(get_origin(Required[int]), Required)
5560 self.assertIs(get_origin(NotRequired[int]), NotRequired)
5569 self.assertEqual(get_args(C[int]), (int,))
5571 self.assertEqual(get_args(int), ())
5572 self.assertEqual(get_args(ClassVar[int]), (int,))
5573 self.assertEqual(get_args(Union[int, str]), (int, str))
5575 self.assertEqual(get_args(Final[List[int]]), (List[int],))
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]]))
5580 self.assertEqual(get_args(Callable[[], T][int]), ([], int))
5581 self.assertEqual(get_args(Callable[..., int]), (..., 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, ...))
5590 self.assertEqual(get_args(list[int]), (int,))
5592 self.assertEqual(get_args(collections.abc.Callable[[int], str]), ([int], str))
5595 self.assertEqual(get_args(collections.abc.Callable[[int], str]),
5596 get_args(Callable[[int], str]))
5598 self.assertEqual(get_args(Callable[P, int]), (P, int))
5599 self.assertEqual(get_args(Callable[Concatenate[int, P], int]),
5600 (Concatenate[int, P], int))
5602 self.assertEqual(get_args(Required[int]), (int,))
5603 self.assertEqual(get_args(NotRequired[int]), (int,))
5605 self.assertEqual(get_args(TypeGuard[int]), (int,))
5641 "async def foo() -> typing.Awaitable[int]:\n"
5660 isinstance(g, typing.Coroutine[int])
5668 base_it = range(10) # type: Iterator[int]
5675 base_it = range(10) # type: Iterator[int]
5727 class MyDeque(typing.Deque[int]): ...
5747 self.assertEqual(Dict[K, V][str, int], Dict[str, int])
5748 self.assertEqual(Dict[K, int][str], Dict[str, int])
5749 self.assertEqual(Dict[str, V][int], Dict[str, int])
5750 self.assertEqual(Dict[K, List[V]][str, int], Dict[str, List[int]])
5751 self.assertEqual(Dict[K, List[int]][str], Dict[str, List[int]])
5752 self.assertEqual(Dict[K, list[V]][str, int], Dict[str, list[int]])
5753 self.assertEqual(Dict[K, list[int]][str], Dict[str, list[int]])
5761 typing.List[int]()
5765 class MyList(typing.List[int]):
5781 typing.Dict[str, int]()
5785 class MyDict(typing.Dict[str, int]):
5798 self.assertIs(type(typing.DefaultDict[str, int]()), collections.defaultdict)
5802 class MyDefDict(typing.DefaultDict[str, int]):
5814 self.assertIs(type(typing.OrderedDict[str, int]()), collections.OrderedDict)
5818 class MyOrdDict(typing.OrderedDict[str, int]):
5830 self.assertIs(type(typing.ChainMap[str, int]()), collections.ChainMap)
5832 self.assertIs(type(CM[int, str]()), CM)
5836 class MyChainMap(typing.ChainMap[str, int]):
5848 self.assertIs(type(typing.Deque[int]()), collections.deque)
5850 self.assertIs(type(D[int]()), D)
5855 self.assertIs(type(typing.Counter[int]()), collections.Counter)
5857 self.assertIs(type(C[int]()), C)
5861 class MyCounter(typing.Counter[int]):
5875 typing.Set[int]()
5879 class MySet(typing.Set[int]):
5891 typing.FrozenSet[int]()
5895 class MyFrozenSet(typing.FrozenSet[int]):
5907 Tuple[int]()
5921 typing.Generator[int, int, int]()
5936 typing.AsyncGenerator[int, int]()
5999 class G(typing.Generator[int, int, int]): ...
6008 class G(typing.AsyncGenerator[int, int]):
6112 self.assertEqual(typing.AsyncContextManager[int].__args__, (int,))
6114 isinstance(42, typing.AsyncContextManager[int])
6116 typing.AsyncContextManager[int, str]
6180 UserId = cls.module.NewType('UserId', int)
6194 self.assertIsInstance(UserId(5), int)
6200 issubclass(UserId, int)
6206 for cls in (int, self.UserName):
6218 self.assertEqual(UserId.__supertype__, int)
6249 "NT = typing.NewType('NT', int)\n"
6277 cool: int
6280 Emp = NamedTuple('Emp', [('name', str), ('id', int)])
6293 collections.OrderedDict([('name', str), ('id', int)]))
6304 collections.OrderedDict(name=str, cool=int))
6318 dict(name=str, cool=int))
6323 x: int = 3
6324 y: int
6334 x: int
6340 x: int
6349 x: int
6352 x: int
6355 x: int
6357 x: int
6378 A = G[int]
6380 self.assertEqual(A.__args__, (int,))
6388 G[int, str]
6396 A = Group[int]
6399 self.assertEqual(A.__args__, (int,))
6405 LocalEmployee = NamedTuple("LocalEmployee", name=str, age=int)
6411 self.assertEqual(LocalEmployee.__annotations__, dict(name=str, age=int))
6413 NamedTuple('Name', [('x', int)], y=str)
6448 NamedTuple(typename='Emp', name=str, id=int)
6452 Emp = NamedTuple('Emp', [('name', str), ('cool', int)])
6473 Emp = TypedDict('Emp', {'name': str, 'id': int})
6484 self.assertEqual(Emp.__annotations__, {'name': str, 'id': int})
6493 Emp = TypedDict('Emp', name=str, id=int)
6504 self.assertEqual(Emp.__annotations__, {'name': str, 'id': int})
6509 TD = TypedDict("TD", cls=type, self=object, typename=str, _typename=int, fields=list, _fields=dict)
6511 self.assertEqual(TD.__annotations__, {'cls': type, 'self': object, 'typename': str, '_typename': int, 'fields': list, '_fields': dict})
6528 TypedDict(_typename='Emp', name=str, id=int)
6531 Emp = TypedDict('Emp', {'name': str, 'id': int})
6541 TypedDict('Hi', [('x', int)], y=int)
6546 self.assertEqual(LabelPoint2D.__annotations__, {'x': int, 'y': int, 'label': str})
6558 EmpD = TypedDict('EmpD', {'name': str, 'id': int})
6581 EmpD = TypedDict('EmpD', {'name': str, 'id': int})
6587 D = TypedDict('D', {'x': int}, total=False)
6604 z: int
6681 one: int
6702 {'one': int, 'two': str, 'child': bool},
6717 {'one': int, 'untotal': str, 'child': bool},
6732 {'one': int, 'untotal': str, 'child': bool},
6768 self.assertIs(is_typeddict(Union[str, int]), False)
6771 call_based = TypedDict('call_based', {'a': int})
6779 self.assertIs(is_typeddict(BarGeneric[int]), False)
6788 {'a': typing.Optional[int], 'b': int}
6794 {'a': typing.Optional[T], 'b': int}
6797 class FooBarGeneric(BarGeneric[int]):
6802 {'a': typing.Optional[T], 'b': int, 'c': str}
6841 class C(B[int]):
6842 c: int
6845 self.assertEqual(C.__orig_bases__, (B[int],))
6854 'c': int,
6875 self.assertEqual(Point3D[int, str].__origin__, Point3D)
6878 Point3D[int]
6892 c: int
6904 'c': int,
6914 A = TD[int]
6917 self.assertEqual(A.__args__, (int,))
6929 Required[int, str]
6931 Required[int][str]
6935 cv = Required[int]
6936 self.assertEqual(repr(cv), 'typing.Required[int]')
6945 class C(type(Required[int])):
6951 class C(Required[int]):
6960 type(Required[Optional[int]])()
6964 isinstance(1, Required[int])
6966 issubclass(int, Required)
6975 NotRequired[int, str]
6977 NotRequired[int][str]
6981 cv = NotRequired[int]
6982 self.assertEqual(repr(cv), 'typing.NotRequired[int]')
6991 class C(type(NotRequired[int])):
6997 class C(NotRequired[int]):
7006 type(NotRequired[Optional[int]])()
7010 isinstance(1, NotRequired[int])
7012 issubclass(int, NotRequired)
7127 repr(Annotated[int, 4, 5]),
7128 "typing.Annotated[int, 4, 5]"
7131 repr(Annotated[List[int], 4, 5]),
7132 "typing.Annotated[typing.List[int], 4, 5]"
7136 dir_items = set(dir(Annotated[int, 4]))
7145 A = Annotated[Annotated[int, 4], 5]
7146 self.assertEqual(A, Annotated[int, 4, 5])
7148 self.assertEqual(A.__origin__, int)
7152 LI = Annotated[List[int], "my decoration"]
7153 self.assertEqual(L[int], Annotated[List[int], "my decoration"])
7154 self.assertEqual(L[int].__metadata__, ("my decoration",))
7155 self.assertEqual(L[int].__origin__, List[int])
7157 LI[int]
7159 L[int, float]
7162 self.assertEqual(len({Annotated[int, 4, 5], Annotated[int, 4, 5]}), 1)
7163 self.assertNotEqual(Annotated[int, 4, 5], Annotated[int, 5, 4])
7164 self.assertNotEqual(Annotated[int, 4, 5], Annotated[str, 4, 5])
7165 self.assertNotEqual(Annotated[int, 4], Annotated[int, 4, 4])
7167 {Annotated[int, 4, 5], Annotated[int, 4, 5], Annotated[T, 4, 5]},
7168 {Annotated[int, 4, 5], Annotated[T, 4, 5]}
7193 self.assertEqual(MyCount[int]([4, 4, 5]), {4: 2, 5: 1})
7196 A = Annotated["int", (5, 6)]
7220 classvar: Annotated[ClassVar[int], "a decoration"] = 4
7221 const: Annotated[Final[int], "Const"] = 4
7223 self.assertEqual(get_type_hints(C, globals())['classvar'], ClassVar[int])
7224 self.assertEqual(get_type_hints(C, globals())['const'], Final[int])
7233 isinstance(5, Annotated[int, "positive"])
7237 issubclass(int, Annotated[int, "positive"])
7241 Annotated[int]
7244 samples = [typing.Any, typing.Union[int, str],
7245 typing.Optional[str], Tuple[int, ...],
7262 G = Annotated[_Annotated_test_G[int], "A decoration"]
7278 self.assertEqual(S[int], Annotated[int, dec2])
7280 self.assertEqual(S[Annotated[int, dec]], Annotated[int, dec, dec2])
7283 self.assertEqual(L[int], Annotated[List[int], dec])
7285 L[int, int]
7287 self.assertEqual(S[L[int]], Annotated[List[int], dec, dec2])
7290 self.assertEqual(D[str, int], Annotated[typing.Dict[str, int], dec])
7292 D[int]
7294 It = Annotated[int, dec]
7298 LI = L[int]
7310 self.assertEqual(A[int], Annotated[tuple[int], dec])
7311 self.assertEqual(A[str, int], Annotated[tuple[str, int], dec])
7316 self.assertEqual(B[int], Annotated[Tuple[int], dec])
7317 self.assertEqual(B[str, int], Annotated[Tuple[str, int], dec])
7322 self.assertEqual(C[int], Annotated[tuple[int], dec])
7323 self.assertEqual(C[int, str], Annotated[tuple[int, str], dec])
7325 C[int, str, float],
7326 Annotated[tuple[int, str, float], dec]
7332 self.assertEqual(D[int], Annotated[Tuple[int], dec])
7333 self.assertEqual(D[int, str], Annotated[Tuple[int, str], dec])
7335 D[int, str, float],
7336 Annotated[Tuple[int, str, float], dec]
7342 self.assertEqual(E[int], Annotated[tuple[int], dec])
7343 self.assertEqual(E[int, str], Annotated[tuple[int, str], dec])
7345 E[int, str, float],
7346 Annotated[tuple[int, str, float], dec]
7352 self.assertEqual(F[int], Annotated[Tuple[int], dec])
7353 self.assertEqual(F[int, str], Annotated[Tuple[int, str], dec])
7355 F[int, str, float],
7356 Annotated[Tuple[int, str, float], dec]
7362 self.assertEqual(G[int, str], Annotated[tuple[int, str], dec])
7364 G[int, str, float],
7365 Annotated[tuple[int, str, float], dec]
7368 G[int, str, bool, float],
7369 Annotated[tuple[int, str, bool, float], dec]
7372 G[int]
7375 self.assertEqual(H[int, str], Annotated[Tuple[int, str], dec])
7377 H[int, str, float],
7378 Annotated[Tuple[int, str, float], dec]
7381 H[int, str, bool, float],
7382 Annotated[Tuple[int, str, bool, float], dec]
7385 H[int]
7400 (I[int, str], Annotated[tuple[int, str], dec]),
7401 (J[int, str], Annotated[tuple[int, str], dec]),
7402 (I[int, str, float], Annotated[tuple[int, str, float], dec]),
7403 (J[int, str, float], Annotated[tuple[int, str, float], dec]),
7404 (I[int, str, bool, float],
7405 Annotated[tuple[int, str, bool, float], dec]),
7406 (J[int, str, bool, float],
7407 Annotated[tuple[int, str, bool, float], dec]),
7412 I[int]
7414 J[int]
7418 self.assertEqual(X[int], List[Annotated[int, 5]])
7421 class X(Annotated[int, (1, 10)]): ...
7422 self.assertEqual(X.__mro__, (X, int, object),
7467 TypeAlias[int]
7481 C1 = Callable[P, int]
7482 self.assertEqual(C1.__args__, (P, int))
7488 C3 = collections.abc.Callable[P, int]
7489 self.assertEqual(C3.__args__, (P, int))
7517 func: Callable["P", int]
7521 self.assertEqual(gth(C, globals(), locals()), {"func": Callable[P, int]})
7532 f: Callable[P, int]
7534 G1 = X[int, P_2]
7535 self.assertEqual(G1.__args__, (int, P_2))
7538 X[int]
7540 X[int, P_2, str]
7542 G2 = X[int, Concatenate[int, P_2]]
7543 self.assertEqual(G2.__args__, (int, Concatenate[int, P_2]))
7546 G3 = X[int, [int, bool]]
7547 self.assertEqual(G3.__args__, (int, (int, bool)))
7550 G4 = X[int, ...]
7551 self.assertEqual(G4.__args__, (int, Ellipsis))
7555 f: Callable[P, int]
7557 G5 = Z[[int, str, bool]]
7558 self.assertEqual(G5.__args__, ((int, str, bool),))
7561 G6 = Z[int, str, bool]
7562 self.assertEqual(G6.__args__, ((int, str, bool),))
7571 G7 = Z[int]
7572 self.assertEqual(G7.__args__, ((int,),))
7576 Z[[int, str], bool]
7585 f: Callable[P, int]
7588 G1 = X[[int, str], [bytes]]
7589 G2 = X[[int], [str, bytes]]
7591 self.assertEqual(G1.__args__, ((int, str), (bytes,)))
7592 self.assertEqual(G2.__args__, ((int,), (str, bytes)))
7599 f: Callable[P, int]
7602 G1 = X[int, [bytes]]
7603 self.assertEqual(G1.__args__, (int, (bytes,)))
7604 G2 = X[int, str, [bytes]]
7605 self.assertEqual(G2.__args__, (int, str, (bytes,)))
7614 f: Callable[P, int]
7617 G1 = Y[[bytes], int]
7618 self.assertEqual(G1.__args__, ((bytes,), int))
7619 G2 = Y[[bytes], int, str]
7620 self.assertEqual(G2.__args__, ((bytes,), int, str))
7636 B = A[[int, str], bytes, float]
7637 self.assertEqual(B.__args__, (int, str, Tuple[bytes, float]))
7643 B = A[bytes, float, [int, str]]
7644 self.assertEqual(B.__args__, (Tuple[bytes, float], (int, str,)))
7650 B = A[[int, str], bytes, float]
7651 self.assertEqual(B.__args__, ((int, str,), Tuple[bytes, float]))
7656 self.assertEqual(subst((int, str)), (int, str))
7657 self.assertEqual(subst([int, str]), (int, str))
7661 self.assertEqual(subst(Concatenate[int, P]), Concatenate[int, P])
7666 bad_args = (42, int, None, T, int|str, Union[int, str])
7689 self.assertEqual(A1[int], Base[int])
7694 self.assertEqual(A2[int], Base[int])
7696 A3 = Base[[int, T]]
7698 self.assertEqual(A3.__args__, ((int, T),))
7699 self.assertEqual(A3[str], Base[[int, str]])
7701 A4 = Base[[T, int, T2]]
7703 self.assertEqual(A4.__args__, ((T, int, T2),))
7704 self.assertEqual(A4[str, bool], Base[[str, int, bool]])
7706 A5 = Base[[*Ts, int]]
7708 self.assertEqual(A5.__args__, ((*Ts, int),))
7709 self.assertEqual(A5[str, bool], Base[[str, bool, int]])
7711 A5_2 = Base[[int, *Ts]]
7713 self.assertEqual(A5_2.__args__, ((int, *Ts),))
7714 self.assertEqual(A5_2[str, bool], Base[[int, str, bool]])
7719 self.assertEqual(A6[int, str, bool], Base[[int, str, bool]])
7724 self.assertEqual(A7[int], Base[[int, int]])
7729 self.assertEqual(A8[int], Base[[int, list[int]]])
7734 self.assertEqual(A9[int, str], Base[Tuple[int, str], int, str])
7739 self.assertEqual(A10[[int, str]], Base[[int, str]])
7747 self.assertEqual(B1[[int, str], [bool]], DoubleP[[int, str], [bool]])
7750 B2 = DoubleP[[int, str], P2]
7752 self.assertEqual(B2.__args__, ((int, str), P2))
7753 self.assertEqual(B2[[bool, bool]], DoubleP[[int, str], [bool, bool]])
7754 self.assertEqual(B2[[]], DoubleP[[int, str], []])
7759 self.assertEqual(B3[[int, str]], DoubleP[[int, str], [bool, bool]])
7762 B4 = DoubleP[[T, int], [bool, T2]]
7764 self.assertEqual(B4.__args__, ((T, int), (bool, T2)))
7765 self.assertEqual(B4[str, float], DoubleP[[str, int], [bool, float]])
7767 B5 = DoubleP[[*Ts, int], [bool, T2]]
7769 self.assertEqual(B5.__args__, ((*Ts, int), (bool, T2)))
7771 DoubleP[[str, bytes, int], [bool, float]])
7773 B6 = DoubleP[[T, int], [bool, *Ts]]
7775 self.assertEqual(B6.__args__, ((T, int), (bool, *Ts)))
7777 DoubleP[[str, int], [bool, bytes, float]])
7785 self.assertEqual(C1[[int, str], bool], PandT[[int, str], bool])
7787 C2 = PandT[[int, T], T]
7789 self.assertEqual(C2.__args__, ((int, T), T))
7790 self.assertEqual(C2[str], PandT[[int, str], str])
7792 C3 = PandT[[int, *Ts], T]
7794 self.assertEqual(C3.__args__, ((int, *Ts), T))
7795 self.assertEqual(C3[str, bool, bytes], PandT[[int, str, bool], bytes])
7806 G3 = list[C1] | int
7810 C = Callable[[int, str], float]
7811 self.assertEqual(G1[[int, str], float], List[C])
7812 self.assertEqual(G2[[int, str], float], list[C])
7813 self.assertEqual(G3[[int, str], float], list[C] | int)
7819 C1 = Callable[P, int]
7828 C2 = Callable[Concatenate[str, P], int]
7846 dir_items = set(dir(Concatenate[int, P]))
7856 C1 = Callable[Concatenate[int, P], int]
7857 self.assertEqual(C1.__args__, (Concatenate[int, P], int))
7859 C2 = Callable[Concatenate[int, T, P], T]
7860 self.assertEqual(C2.__args__, (Concatenate[int, T, P], T))
7864 C3 = collections.abc.Callable[Concatenate[int, P], int]
7865 self.assertEqual(C3.__args__, (Concatenate[int, P], int))
7867 C4 = collections.abc.Callable[Concatenate[int, T, P], T]
7868 self.assertEqual(C4.__args__, (Concatenate[int, T, P], T))
7876 self.assertEqual(C[int, P2], Concatenate[int, P2])
7877 self.assertEqual(C[int, [str, float]], (int, str, float))
7878 self.assertEqual(C[int, []], (int,))
7879 self.assertEqual(C[int, Concatenate[str, P2]],
7880 Concatenate[int, str, P2])
7881 self.assertEqual(C[int, ...], Concatenate[int, ...])
7883 C = Concatenate[int, P]
7884 self.assertEqual(C[P2], Concatenate[int, P2])
7885 self.assertEqual(C[[str, float]], (int, str, float))
7886 self.assertEqual(C[str, float], (int, str, float))
7887 self.assertEqual(C[[]], (int,))
7888 self.assertEqual(C[Concatenate[str, P2]], Concatenate[int, str, P2])
7889 self.assertEqual(C[...], Concatenate[int, ...])
7893 TypeGuard[int] # OK
7895 def foo(arg) -> TypeGuard[int]: ...
7896 self.assertEqual(gth(foo), {'return': TypeGuard[int]})
7899 TypeGuard[int, str]
7903 cv = TypeGuard[int]
7904 self.assertEqual(repr(cv), 'typing.TypeGuard[int]')
7907 cv = TypeGuard[tuple[int]]
7908 self.assertEqual(repr(cv), 'typing.TypeGuard[tuple[int]]')
7915 class C(type(TypeGuard[int])):
7924 type(TypeGuard[Optional[int]])()
7928 isinstance(1, TypeGuard[int])
7930 issubclass(int, TypeGuard)
7934 SpecialAttrsT = typing.TypeVar('SpecialAttrsT', int, float, complex)
8046 typing.Union[int, float]: 'Union',
8125 dir_items = set(dir(Foo[int]))
8151 id: int
8181 id: int
8212 id: int
8276 Union[str, int],