Lines Matching defs:Annotated
34 from typing import Annotated, ForwardRef
4733 a: Annotated['ClassVar[int]', (3, 5)] = 4
4734 b: Annotated['Final[int]', "const"] = 4
5177 title: Annotated[Annotated[Required[str], "foobar"], "another level"]
5180 year: NotRequired[Annotated[int, 2000]]
5183 title: Annotated[Required[str], "foobar"]
5184 year: NotRequired[Annotated[int, 2000]]
5187 title: Annotated[Annotated[Required[str], "foobar"], "another level"]
5188 year: NotRequired[Annotated[int, 2000]]
5191 title: Annotated['Annotated[Required[str], "foobar"]', "another level"]
5192 year: NotRequired['Annotated[int, 2000]']
5331 X = Annotated[int, (1, 10)]
5338 {'x': List[Annotated[int, (1, 10)]]}
5342 X = Annotated[int, (1, 10)]
5349 {'x': list[Annotated[int, (1, 10)]]}
5352 BA = Tuple[Annotated[T, (1, 0)], ...]
5360 BA = tuple[Annotated[T, (1, 0)], ...]
5368 def barfoo2(x: typing.Callable[..., Annotated[List[T], "const"]],
5369 y: typing.Union[int, Annotated[T, "mutable"]]): ...
5381 BA3 = typing.Annotated[int | float, "const"]
5389 {"x": typing.Annotated[int | float, "const"]}
5393 def with_union(x: int | list[Annotated[str, 'meta']]): ...
5398 {'x': int | list[Annotated[str, 'meta']]},
5403 Const = Annotated[T, "Const"]
5430 def annotated_with_none_default(x: Annotated[int, 'data'] = None): ...
5437 {'x': Annotated[int, 'data']},
5490 'title': Annotated[Required[str], "foobar"],
5491 'year': NotRequired[Annotated[int, 2000]],
5496 'title': Annotated[Required[str], "foobar", "another level"],
5497 'year': NotRequired[Annotated[int, 2000]],
5502 'title': Annotated[Required[str], "foobar", "another level"],
5503 'year': NotRequired[Annotated[int, 2000]],
5508 'a': Annotated[Required[int], "a", "b", "c"]
5518 "title": Annotated[Required[str], "foobar", "another level"],
5519 "year": NotRequired[Annotated[int, 2000]]
5550 self.assertIs(get_origin(Annotated[T, 'thing']), Annotated)
5586 self.assertEqual(get_args(Annotated[T, 'one', 2, ['three']]), (T, 'one', 2, ['three']))
7121 'Type Annotated cannot be instantiated',
7123 Annotated()
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])
7151 L = Annotated[List[T], "my decoration"]
7152 LI = Annotated[List[int], "my decoration"]
7153 self.assertEqual(L[int], Annotated[List[int], "my decoration"])
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]}
7183 A = Annotated[C, "a decoration"]
7191 MyCount = Annotated[typing.Counter[T], "my decoration"]
7196 A = Annotated["int", (5, 6)]
7201 A = Annotated[T, (5, 6)]
7207 Annotated[T, (5, 7)].x
7213 A = Annotated[C, "a decoration"]
7220 classvar: Annotated[ClassVar[int], "a decoration"] = 4
7221 const: Annotated[Final[int], "Const"] = 4
7227 with self.assertRaisesRegex(TypeError, "Cannot subclass .*Annotated"):
7228 class C(Annotated):
7233 isinstance(5, Annotated[int, "positive"])
7237 issubclass(int, Annotated[int, "positive"])
7241 Annotated[int]
7249 x = Annotated[t, "a"]
7262 G = Annotated[_Annotated_test_G[int], "A decoration"]
7277 S = Annotated[T, dec2]
7278 self.assertEqual(S[int], Annotated[int, dec2])
7280 self.assertEqual(S[Annotated[int, dec]], Annotated[int, dec, dec2])
7281 L = Annotated[List[T], dec]
7283 self.assertEqual(L[int], Annotated[List[int], dec])
7287 self.assertEqual(S[L[int]], Annotated[List[int], dec, dec2])
7289 D = Annotated[typing.Dict[KT, VT], dec]
7290 self.assertEqual(D[str, int], Annotated[typing.Dict[str, int], dec])
7294 It = Annotated[int, dec]
7309 A = Annotated[tuple[*Ts], dec]
7310 self.assertEqual(A[int], Annotated[tuple[int], dec])
7311 self.assertEqual(A[str, int], Annotated[tuple[str, int], dec])
7313 Annotated[*Ts, dec]
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])
7319 Annotated[Unpack[Ts], dec]
7321 C = Annotated[tuple[T, *Ts], dec]
7322 self.assertEqual(C[int], Annotated[tuple[int], dec])
7323 self.assertEqual(C[int, str], Annotated[tuple[int, str], dec])
7326 Annotated[tuple[int, str, float], 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]
7341 E = Annotated[tuple[*Ts, T], dec]
7342 self.assertEqual(E[int], Annotated[tuple[int], dec])
7343 self.assertEqual(E[int, str], Annotated[tuple[int, str], dec])
7346 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]
7361 G = Annotated[tuple[T1, *Ts, T2], dec]
7362 self.assertEqual(G[int, str], Annotated[tuple[int, str], dec])
7365 Annotated[tuple[int, str, float], dec]
7369 Annotated[tuple[int, str, bool, 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]
7393 # G is Annotated[tuple[T1, *Ts, T2], dec].
7398 (I, Annotated[tuple[T3, *Ts2, T4], dec]),
7399 (J, Annotated[tuple[T3, Unpack[Ts2], T4], 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]),
7405 Annotated[tuple[int, str, bool, float], dec]),
7407 Annotated[tuple[int, str, bool, float], dec]),
7417 X = List[Annotated[T, 5]]
7418 self.assertEqual(X[int], List[Annotated[int, 5]])
7421 class X(Annotated[int, (1, 10)]): ...
7423 "Annotated should be transparent.")
8019 typing.Annotated: 'Annotated',
8036 typing.Annotated[Any, "Annotation"]: 'Annotated',
8283 Annotated,
8284 Annotated[T, ''],