Lines Matching refs:str
379 T_constraints = TypeVar('T_constraints', int, str)
381 self.assertEqual(T_constraints.__constraints__, (int, str))
426 # use a string because str doesn't implement
435 A = TypeVar('A', str, bytes)
436 self.assertNotEqual(Union[A, str], Union[A])
450 self.assertNotEqual(TypeVar('T', int, str), TypeVar('T', int, str))
470 TypeVar('X', str, float, bound=Employee)
493 self.assertEqual(subst(int|str), int|str)
494 self.assertEqual(subst(Union[int, str]), Union[int, str])
499 (), (int, str), Union,
513 def template_replace(templates: list[str], replacements: dict[str, list[str]]) -> list[tuple[str]]:
637 ('generic[T]', '[int, str]', 'TypeError'),
641 ('generic[T]', '[*tuple_type[int, str]]', 'TypeError'),
687 ('generic[T1, T2]', '[int, str]', 'generic[int, str]'),
688 ('generic[T1, T2]', '[int, str, bool]', '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]'),
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'),
705 ('generic[T1, T2]', '[tuple_type[int, ...], tuple_type[str, ...]]', 'generic[tuple_type[int, ...], tuple_type[str, ...]]'),
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'),
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]'),
784 ('generic[*Ts]', '[int, str]', 'generic[int, str]'),
787 ('generic[*Ts]', '[*tuple_type[int, str]]', 'generic[int, str]'),
788 ('generic[*Ts]', '[str, *tuple_type[int, ...], bool]', 'generic[str, *tuple_type[int, ...], bool]'),
790 ('generic[*Ts]', '[tuple_type[int, ...], tuple_type[str, ...]]', 'generic[tuple_type[int, ...], tuple_type[str, ...]]'),
792 ('generic[*Ts]', '[*tuple_type[int, ...], *tuple_type[str, ...]]', 'TypeError'),
799 ('generic[T, *Ts]', '[int, str]', 'generic[int, str]'),
800 ('generic[T, *Ts]', '[int, str, bool]', 'generic[int, str, bool]'),
803 ('generic[list[T], *Ts]', '[int, str]', 'generic[list[int], str]'),
804 ('generic[list[T], *Ts]', '[int, str, bool]', 'generic[list[int], str, bool]'),
808 ('generic[*Ts, T]', '[int, str]', 'generic[int, str]'),
809 ('generic[*Ts, T]', '[int, str, bool]', 'generic[int, str, bool]'),
812 ('generic[*Ts, list[T]]', '[int, str]', 'generic[int, list[str]]'),
813 ('generic[*Ts, list[T]]', '[int, str, bool]', 'generic[int, str, list[bool]]'),
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]'),
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]'),
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]'),
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]'),
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]'),
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]'),
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]'),
890 Unpack[Tuple[int], Tuple[str]]
892 # *(Tuple[int], Tuple[str]) is just plain tuple unpacking,
976 self.assertEqual(B[float, str], A[float, str])
981 self.assertEqual(C[float, str], A[float, str])
986 self.assertEqual(D[float, str], list[A[float, str]])
991 self.assertEqual(E[float, str], List[A[float, str]])
998 self.assertEqual(F[float, str], A[float, str])
999 self.assertEqual(F[float, str, int], A[float, str, int])
1000 self.assertEqual(F[float, str, int, bytes], A[float, str, int, bytes])
1007 self.assertEqual(G[float, str], A[float, str])
1008 self.assertEqual(G[float, str, int], A[float, str, int])
1009 self.assertEqual(G[float, str, int, bytes], A[float, str, int, bytes])
1017 self.assertEqual(H[float, str],
1018 tuple[list[float], A[()], list[str]])
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]])
1030 self.assertEqual(I[float, str],
1031 Tuple[List[float], A[()], List[str]])
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]
1055 B = A[T, *Ts, str, T2]
1061 C = A[T, Unpack[Ts], str, T2]
1093 self.assertEndsWith(repr(A[float, str]), 'A[float, str]')
1094 self.assertEndsWith(repr(B[float, str]), 'B[float, str]')
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]')
1124 self.assertEndsWith(repr(B[float, str]), 'A[float, str]')
1130 self.assertEndsWith(repr(C[float, str]), 'A[float, str]')
1136 self.assertEndsWith(repr(D[float, str]), 'A[float, str, int]')
1142 self.assertEndsWith(repr(E[float, str]), 'A[float, str, int]')
1148 self.assertEndsWith(repr(F[float, str]), 'A[int, float, str]')
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]')
1168 J = A[*Ts, *tuple[str, ...]]
1169 self.assertEndsWith(repr(J), 'A[*Ts, *tuple[str, ...]]')
1170 self.assertEndsWith(repr(J[()]), 'A[*tuple[str, ...]]')
1171 self.assertEndsWith(repr(J[float]), 'A[float, *tuple[str, ...]]')
1172 self.assertEndsWith(repr(J[float, str]), 'A[float, str, *tuple[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, ...]]')
1218 G = A[int, str]
1219 H = B[int, str]
1220 self.assertEqual(G.__args__, (int, str))
1221 self.assertEqual(H.__args__, (int, str))
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]]})
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))
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)))
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]))
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]
1402 tuple[int, *Ts, str]
1403 tuple[int, bool, *Ts, float, str]
1407 Tuple[int, Unpack[Ts], str]
1408 Tuple[int, bool, Unpack[Ts], float, str]
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]
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]},
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]]},
1573 C[int, str],
1574 C[str, int],
1577 D[int, str],
1578 D[str, int],
1666 issubclass(Union[int, str], int)
1719 u = Union[list[int], dict[str, float]]
1720 self.assertEqual(repr(u), 'typing.Union[list[int], dict[str, float]]')
1724 u = Union[None, str]
1725 self.assertEqual(repr(u), 'typing.Optional[str]')
1726 u = Union[str, None]
1727 self.assertEqual(repr(u), 'typing.Optional[str]')
1728 u = Union[None, str, int]
1729 self.assertEqual(repr(u), 'typing.Union[NoneType, str, int]')
1730 u = Optional[str]
1731 self.assertEqual(repr(u), 'typing.Optional[str]')
1734 dir_items = set(dir(Union[str, int]))
1749 class C(Union[int, str]):
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__)
1788 u = Union[int, str]
1798 A = Union[str, Pattern]
1806 Union[Element, str] # Shouldn't crash
1811 Union[Elem, str] # Nor should this
1847 issubclass(Tuple, Tuple[int, str])
1849 issubclass(tuple, Tuple[int, str])
1901 self.assertNotEqual(C, Callable[[int], str])
1902 self.assertNotEqual(C, Callable[[str], int])
1923 c = Callable[[int], str]
1959 ct2 = Callable[[str, float], int]
1960 self.assertEqual(repr(ct2), f'{fullname}[[str, float], int]')
1961 ctv = Callable[..., str]
1962 self.assertEqual(repr(ctv), f'{fullname}[..., str]')
1963 ct3 = Callable[[str, float], list[int]]
1964 self.assertEqual(repr(ct3), f'{fullname}[[str, float], list[int]]')
1977 typing.List[Callable[..., str]]
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],
2029 self.assertEqual(C1[str], Callable[[int, str], str])
2031 self.assertEqual(C2[int, float, str], Callable[[int, float], str])
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])
2044 self.assertEqual(C5[int, str, float],
2045 Callable[[typing.List[int], tuple[str, int], float], int])
2073 self.assertEqual(C1[[int], str], Callable[[int], str])
2074 self.assertEqual(C1[[int, str], str], Callable[[int, str], str])
2075 self.assertEqual(C1[[], str], Callable[[], str])
2076 self.assertEqual(C1[..., str], Callable[..., str])
2077 self.assertEqual(C1[P2, str], Callable[P2, 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]
2087 self.assertEqual(C2[[int, str]], Callable[[int, str], int])
2094 # X[int, str, float] == X[[int, str, float]]
2096 self.assertEqual(C2[int, str], Callable[[int, str], int])
2098 self.assertEqual(repr(C2[int, str]), f"{fullname}[[int, str], int]")
2110 self.assertEqual(C[[str, float], int], Callable[[int, str, float], int])
2112 self.assertEqual(C[Concatenate[str, P2], int],
2113 Callable[Concatenate[int, str, P2], int])
2120 self.assertEqual(C[[str, float]], Callable[[int, str, float], int])
2121 self.assertEqual(C[str, float], Callable[[int, str, float], int])
2123 self.assertEqual(C[Concatenate[str, P2]],
2124 Callable[Concatenate[int, str, P2], int])
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))
2150 self.assertEqual(C2[list[str]],
2151 My[[Callable[[list[str]], int], list[list[str]]], str])
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]
2177 C1[int, str, str]
2187 c1 = typing.Callable[[int, str], dict]
2188 c2 = collections.abc.Callable[[int, str], dict]
2320 XK = TypeVar('XK', str, bytes)
2341 def __getitem__(self, key: str):
2344 def __setitem__(self, key: str, value):
2347 def get(self, key: str, default=None):
2360 label: str
2365 label: str
2380 def meth(self, arg: str) -> int:
2388 def meth(self, arg: str) -> int:
2686 meth = str.maketrans
3023 P[int, str]
3027 self.assertIsInstance(C[str](), C)
3037 class P(PR[int, str], Protocol):
3041 issubclass(PR[int, str], PR)
3047 def bar(self, x: T) -> str: ...
3050 def bar(self, x: T) -> str: ...
3053 class PSub(P1[str], Protocol):
3059 def bar(self, x: str) -> str:
3125 self.assertTrue(repr(P[int, str]).endswith('P[int, str]'))
3135 self.assertEqual(P[T, T][Tuple[T, S]][int, str],
3136 P[Tuple[int, str], Tuple[int, str]])
3257 self.assertNotIsSubclass(str, typing.SupportsInt)
3261 self.assertNotIsSubclass(str, typing.SupportsFloat)
3271 self.assertNotIsSubclass(str, typing.SupportsComplex)
3281 self.assertNotIsSubclass(str, typing.SupportsBytes)
3286 self.assertNotIsSubclass(str, typing.SupportsAbs)
3292 self.assertNotIsSubclass(str, typing.SupportsRound)
3300 self.assertNotIsSubclass(str, typing.SupportsIndex)
3356 X = SimpleMapping[str, Any]
3359 X[str]
3361 X[str, str]
3362 Y = SimpleMapping[XK, str]
3364 Y[str]
3366 Y[str, str]
3367 SM1 = SimpleMapping[str, int]
3447 self.assertNotEqual(Y, X[T, str])
3449 Z = Y[str]
3450 self.assertEqual(Z, Y[str])
3454 self.assertTrue(str(Z).endswith(
3455 '.C[typing.Tuple[str, int]]'))
3513 self.assertEqual(C[str].x, 'changed')
3514 C[List[str]].z = 'new'
3519 self.assertEqual(C[Tuple[str]]().z, 'new')
3530 self.assertEqual(D[str].z, 'from derived z')
3543 class MyMapping(MutableMapping[str, str]): pass
3548 class MM(MutableMapping[str, str]):
3567 class MM1(MutableMapping[str, str], collections.abc.MutableMapping):
3569 class MM2(collections.abc.MutableMapping, MutableMapping[str, str]):
3575 class C(typing.Dict[str, T]): ...
3576 self.assertEqual(C.__orig_bases__, (typing.Dict[str, T],))
3589 self.assertTrue(naive_dict_check({'x': 1}, typing.Dict[str, int]))
3590 self.assertFalse(naive_dict_check({1: 'x'}, typing.Dict[str, int]))
3592 naive_dict_check({1: 'x'}, typing.Dict[str, T])
3601 self.assertFalse(naive_generic_check(Node[str](), Node[int]))
3602 self.assertFalse(naive_generic_check(Node[str](), List))
3647 self.assertEqual(mod_generics_cache.A[str], mod_generics_cache.A[str])
3649 self.assertEqual(mod_generics_cache.B.A[B.A[str]],
3650 mod_generics_cache.B.A[B.A[str]])
3658 self.assertNotEqual(A[str], B.A[str])
3660 self.assertNotEqual(A[str], mod_generics_cache.A[str])
3661 self.assertNotEqual(A[str], mod_generics_cache.B.A[str])
3665 self.assertNotEqual(Tuple[A[str]], Tuple[B.A[str]])
3667 self.assertNotEqual(Union[str, A[str]], Union[str, mod_generics_cache.A[str]])
3668 self.assertNotEqual(Union[A[str], A[str]],
3669 Union[A[str], mod_generics_cache.A[str]])
3670 self.assertNotEqual(typing.FrozenSet[A[str]],
3671 typing.FrozenSet[mod_generics_cache.B.A[str]])
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]])
3676 .endswith('mod_generics_cache.A[str]]'))
3677 self.assertTrue(repr(Tuple[mod_generics_cache.B.A[str]])
3678 .endswith('mod_generics_cache.B.A[str]]'))
3689 self.assertEqual(Union[T, U][int, Union[int, str]], Union[int, str])
3780 self.assertEqual(T1[int, str].__args__, (int, str))
3788 ## T2[int, str]
3830 class MyDef(typing.DefaultDict[str, T]): ...
3833 class MyChain(typing.ChainMap[str, T]): ...
3872 Union[int, str], ClassVar[List], Tuple[int, ...], Tuple[()],
3873 Callable[[str], bytes],
3881 typing.Type[typing.Mapping], typing.AbstractSet[Tuple[int, str]]]
3894 typing.Iterable[Any], typing.Iterable[int], typing.Dict[int, str],
3907 TPV = TypeVar('TPV', bytes, str)
3922 TLV = TypeVar('TLV', bytes, str)
3956 Optional[List[int]], typing.Mapping[int, str],
4256 a[b][str]
4295 ClassVar[int, str]
4297 ClassVar[int][str]
4333 Final[int, str]
4335 Final[int][str]
4453 self.assertEqual(cast(Union[str, float], 42), 42)
4468 self.assertIs(assert_type(arg, str | float), arg)
4540 typing.ForwardRef(1) # only `str` type is allowed
4684 Value = Union[str, ValueList]
4697 {'foo': List[Union[str, List[Union[str, List['Value']]]]]})
4699 {'foo': Union[str, List[Union[str, List['Value']]]]})
4702 List[Union[str, List[Union[str, List['Value']]]]],
4703 List[Union[str, List['Value']]]
4708 str,
4709 List[Union[str, List['Value']]],
4710 List[Union[str, List[Union[str, List['Value']]]]]
5120 name: str
5124 name: str
5140 Label = TypedDict('Label', [('label', str)])
5160 log_path: str
5163 title: str
5167 title: Required[str]
5171 title: Required[str]
5177 title: Annotated[Annotated[Required[str], "foobar"], "another level"]
5183 title: Annotated[Required[str], "foobar"]
5187 title: Annotated[Annotated[Required[str], "foobar"], "another level"]
5191 title: Annotated['Annotated[Required[str], "foobar"]', "another level"]
5232 ann_module_type_hints = {1: 2, 'f': Tuple[int, int], 'x': int, 'y': str, 'u': int | float}
5252 {'j': str, 'k': str, 'y': Optional[ann_module.C]})
5256 self.assertEqual(gth(ann_module.S), {'x': str, 'y': str})
5298 self.assertEqual(gth(str.join), {})
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']]},
5442 y = str
5445 self.assertEqual(get_type_hints(Foo), {'x': str})
5468 self.assertEqual(hints, {'name': Final[str]})
5482 self.assertEqual(get_type_hints(TotalMovie), {'title': str, 'year': int})
5484 'title': str,
5488 self.assertEqual(get_type_hints(AnnotatedMovie), {'title': str, 'year': int})
5490 'title': Annotated[Required[str], "foobar"],
5494 self.assertEqual(get_type_hints(DeeplyAnnotatedMovie), {'title': str, 'year': int})
5496 'title': Annotated[Required[str], "foobar", "another level"],
5500 self.assertEqual(get_type_hints(WeirdlyQuotedMovie), {'title': str, 'year': int})
5502 'title': Annotated[Required[str], "foobar", "another level"],
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})
5518 "title": Annotated[Required[str], "foobar", "another level"],
5544 self.assertIs(get_origin(Union[int, str]), Union)
5556 self.assertIs(get_origin(list | str), types.UnionType)
5573 self.assertEqual(get_args(Union[int, str]), (int, str))
5576 self.assertEqual(get_args(Union[int, Tuple[T, int]][str]),
5577 (int, Tuple[str, int]))
5582 self.assertEqual(get_args(Union[int, Callable[[Tuple[T, ...]], str]]),
5583 (int, Callable[[Tuple[T, ...]], str]))
5592 self.assertEqual(get_args(collections.abc.Callable[[int], str]), ([int], str))
5593 self.assertEqual(get_args(collections.abc.Callable[..., str]), (..., str))
5594 self.assertEqual(get_args(collections.abc.Callable[[], str]), ([], str))
5595 self.assertEqual(get_args(collections.abc.Callable[[int], str]),
5596 get_args(Callable[[int], str]))
5601 self.assertEqual(get_args(list | str), (list, str))
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]])
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]):
5975 self.assertEqual(len(MMB[str, str]()), 0)
5993 issubclass(MMB[str, str], typing.Mapping)
6116 typing.AsyncContextManager[int, str]
6181 cls.UserName = cls.module.NewType(cls.__qualname__ + '.UserName', str)
6195 self.assertIsInstance(self.UserName('Joe'), str)
6225 self.assertEqual(UserName.__supertype__, str)
6276 name: str
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))
6329 self.assertEqual(str(XRepr(42)), '42 -> 1')
6360 y: str
6388 G[int, str]
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)
6416 NT = NamedTuple("NT", cls=type, self=object, typename=str, fields=list)
6419 a = NT(cls=str, self=42, typename='foo', fields=[('bar', tuple)])
6420 self.assertEqual(a.cls, str)
6444 NamedTuple('Emp', [('name', str)], None)
6446 NamedTuple('Emp', [('_name', 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})
6512 a = TD(cls=str, self=42, typename='foo', _typename=53, fields=[('bar', tuple)], _fields={'baz', set})
6513 self.assertEqual(a['cls'], str)
6526 TypedDict('Emp', [('name', str)], None)
6528 TypedDict(_typename='Emp', name=str, id=int)
6531 Emp = TypedDict('Emp', {'name': str, 'id': 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})
6613 name: str
6616 voice: str
6620 fur_color: str
6624 self.assertEqual(BaseAnimal.__annotations__, {'name': str})
6629 'name': str,
6631 'voice': str,
6637 'fur_color': str,
6638 'name': str,
6640 'voice': str,
6683 two: str
6685 untotal: str
6702 {'one': int, 'two': str, 'child': bool},
6717 {'one': int, 'untotal': str, 'child': bool},
6732 {'one': int, 'untotal': str, 'child': bool},
6747 {'inline': bool, 'untotal': str, 'child': bool},
6768 self.assertIs(is_typeddict(Union[str, int]), False)
6798 c: str
6802 {'a': typing.Optional[T], 'b': int, 'c': str}
6813 self.assertEqual(A[str].__parameters__, ())
6814 self.assertEqual(A[str].__args__, (str,))
6823 self.assertEqual(A2[str].__parameters__, ())
6824 self.assertEqual(A2[str].__args__, (str,))
6837 self.assertEqual(B[str].__parameters__, ())
6838 self.assertEqual(B[str].__args__, (str,))
6839 self.assertEqual(B[str].__origin__, B)
6857 C[str]
6875 self.assertEqual(Point3D[int, str].__origin__, Point3D)
6907 WithImplicitAny[str]
6929 Required[int, str]
6931 Required[int][str]
6975 NotRequired[int, str]
6977 NotRequired[int][str]
7027 def stuff(a: TextIO) -> str:
7068 Pattern[Union[str, bytes]]
7069 Match[Union[bytes, str]]
7072 self.assertEqual(Pattern[str], Pattern[str])
7073 self.assertNotEqual(Pattern[str], Pattern[bytes])
7074 self.assertNotEqual(Pattern[str], Match[str])
7075 self.assertNotEqual(Pattern[str], str)
7078 m = Match[Union[str, bytes]]
7080 m[str]
7083 isinstance(42, Pattern[str])
7086 issubclass(Pattern[bytes], Pattern[str])
7090 self.assertEqual(repr(Pattern[str]), 'typing.Pattern[str]')
7093 self.assertEqual(repr(Match[str]), 'typing.Match[str]')
7112 self.assertEqual(str(ex.exception),
7164 self.assertNotEqual(Annotated[int, 4, 5], Annotated[str, 4, 5])
7244 samples = [typing.Any, typing.Union[int, str],
7245 typing.Optional[str], Tuple[int, ...],
7246 typing.Callable[[str], bytes]]
7290 self.assertEqual(D[str, int], Annotated[typing.Dict[str, int], dec])
7311 self.assertEqual(A[str, int], Annotated[tuple[str, int], dec])
7317 self.assertEqual(B[str, int], Annotated[Tuple[str, 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]
7333 self.assertEqual(D[int, str], Annotated[Tuple[int, str], dec])
7335 D[int, str, float],
7336 Annotated[Tuple[int, str, float], dec]
7343 self.assertEqual(E[int, str], Annotated[tuple[int, str], dec])
7345 E[int, str, float],
7346 Annotated[tuple[int, str, float], 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]
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]
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]),
7540 X[int, P_2, str]
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),))
7576 Z[[int, str], bool]
7586 g: Callable[P2, str]
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)))
7604 G2 = X[int, str, [bytes]]
7605 self.assertEqual(G2.__args__, (int, str, (bytes,)))
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))
7666 bad_args = (42, int, None, T, int|str, Union[int, str])
7672 typing.Callable[P, T][arg, str]
7674 collections.abc.Callable[P, T][arg, str]
7699 self.assertEqual(A3[str], Base[[int, str]])
7704 self.assertEqual(A4[str, bool], Base[[str, int, bool]])
7709 self.assertEqual(A5[str, bool], Base[[str, bool, int]])
7714 self.assertEqual(A5_2[str, bool], Base[[int, str, bool]])
7719 self.assertEqual(A6[int, str, bool], Base[[int, str, bool]])
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]])
7765 self.assertEqual(B4[str, float], DoubleP[[str, int], [bool, float]])
7770 self.assertEqual(B5[str, bytes, float],
7771 DoubleP[[str, bytes, int], [bool, float]])
7776 self.assertEqual(B6[str, bytes, float],
7777 DoubleP[[str, int], [bool, bytes, float]])
7785 self.assertEqual(C1[[int, str], bool], PandT[[int, str], bool])
7790 self.assertEqual(C2[str], PandT[[int, str], str])
7795 self.assertEqual(C3[str, bool, bytes], PandT[[int, str, bool], bytes])
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)
7822 self.assertEqual(C1[str].__parameters__, ())
7823 self.assertEqual(C1[str, T].__parameters__, (T,))
7824 self.assertEqual(C1[Concatenate[str, P2]].__parameters__, (P2,))
7828 C2 = Callable[Concatenate[str, P], int]
7831 self.assertEqual(C2[str].__parameters__, ())
7832 self.assertEqual(C2[str, T].__parameters__, (T,))
7833 self.assertEqual(C2[Concatenate[str, P2]].__parameters__, (P2,))
7877 self.assertEqual(C[int, [str, float]], (int, str, float))
7879 self.assertEqual(C[int, Concatenate[str, P2]],
7880 Concatenate[int, str, P2])
7885 self.assertEqual(C[[str, float]], (int, str, float))
7886 self.assertEqual(C[str, float], (int, str, float))
7888 self.assertEqual(C[Concatenate[str, P2]], Concatenate[int, str, P2])
7899 TypeGuard[int, str]
8056 self.assertEqual(cls.__name__, name, str(cls))
8057 self.assertEqual(cls.__qualname__, name, str(cls))
8058 self.assertEqual(cls.__module__, 'typing', str(cls))
8276 Union[str, int],
8277 Union[str, T],
8282 Callable[[T], str],