Debian Codegraph @

Lib/test/test_type_aliases.py

raw
1 import pickle
2 import types
3 import unittest
4 from test.support import check_syntax_error, run_code
5 from test.typinganndata import mod_generics_cache
6
7 from typing import (
8 Callable, TypeAliasType, TypeVar, TypeVarTuple, ParamSpec, Unpack, get_args,
9 )
10
11
12 class TypeParamsInvalidTest(unittest.TestCase):
13 def test_name_collisions(self):
14 check_syntax_error(self, 'type TA1[A, **A] = None', "duplicate type parameter 'A'")
15 check_syntax_error(self, 'type T[A, *A] = None', "duplicate type parameter 'A'")
16 check_syntax_error(self, 'type T[*A, **A] = None', "duplicate type parameter 'A'")
17
18 def test_name_non_collision_02(self):
19 ns = run_code("""type TA1[A] = lambda A: A""")
20 self.assertIsInstance(ns["TA1"], TypeAliasType)
21 self.assertTrue(callable(ns["TA1"].__value__))
22 self.assertEqual("arg", ns["TA1"].__value__("arg"))
23
24 def test_name_non_collision_03(self):
25 ns = run_code("""
26 class Outer[A]:
27 type TA1[A] = None
28 """
29 )
30 outer_A, = ns["Outer"].__type_params__
31 inner_A, = ns["Outer"].TA1.__type_params__
32 self.assertIsNot(outer_A, inner_A)
33
34
35 class TypeParamsAccessTest(unittest.TestCase):
36 def test_alias_access_01(self):
37 ns = run_code("type TA1[A, B] = dict[A, B]")
38 alias = ns["TA1"]
39 self.assertIsInstance(alias, TypeAliasType)
40 self.assertEqual(alias.__type_params__, get_args(alias.__value__))
41
42 def test_alias_access_02(self):
43 ns = run_code("""
44 type TA1[A, B] = TA1[A, B] | int
45 """
46 )
47 alias = ns["TA1"]
48 self.assertIsInstance(alias, TypeAliasType)
49 A, B = alias.__type_params__
50 self.assertEqual(alias.__value__, alias[A, B] | int)
51
52 def test_alias_access_03(self):
53 ns = run_code("""
54 class Outer[A]:
55 def inner[B](self):
56 type TA1[C] = TA1[A, B] | int
57 return TA1
58 """
59 )
60 cls = ns["Outer"]
61 A, = cls.__type_params__
62 B, = cls.inner.__type_params__
63 alias = cls.inner(None)
64 self.assertIsInstance(alias, TypeAliasType)
65 alias2 = cls.inner(None)
66 self.assertIsNot(alias, alias2)
67 self.assertEqual(len(alias.__type_params__), 1)
68
69 self.assertEqual(alias.__value__, alias[A, B] | int)
70
71
72 class TypeParamsAliasValueTest(unittest.TestCase):
73 def test_alias_value_01(self):
74 type TA1 = int
75
76 self.assertIsInstance(TA1, TypeAliasType)
77 self.assertEqual(TA1.__value__, int)
78 self.assertEqual(TA1.__parameters__, ())
79 self.assertEqual(TA1.__type_params__, ())
80
81 type TA2 = TA1 | str
82
83 self.assertIsInstance(TA2, TypeAliasType)
84 a, b = TA2.__value__.__args__
85 self.assertEqual(a, TA1)
86 self.assertEqual(b, str)
87 self.assertEqual(TA2.__parameters__, ())
88 self.assertEqual(TA2.__type_params__, ())
89
90 def test_alias_value_02(self):
91 class Parent[A]:
92 type TA1[B] = dict[A, B]
93
94 self.assertIsInstance(Parent.TA1, TypeAliasType)
95 self.assertEqual(len(Parent.TA1.__parameters__), 1)
96 self.assertEqual(len(Parent.__parameters__), 1)
97 a, = Parent.__parameters__
98 b, = Parent.TA1.__parameters__
99 self.assertEqual(Parent.__type_params__, (a,))
100 self.assertEqual(Parent.TA1.__type_params__, (b,))
101 self.assertEqual(Parent.TA1.__value__, dict[a, b])
102
103 def test_alias_value_03(self):
104 def outer[A]():
105 type TA1[B] = dict[A, B]
106 return TA1
107
108 o = outer()
109 self.assertIsInstance(o, TypeAliasType)
110 self.assertEqual(len(o.__parameters__), 1)
111 self.assertEqual(len(outer.__type_params__), 1)
112 b = o.__parameters__[0]
113 self.assertEqual(o.__type_params__, (b,))
114
115 def test_alias_value_04(self):
116 def more_generic[T, *Ts, **P]():
117 type TA[T2, *Ts2, **P2] = tuple[Callable[P, tuple[T, *Ts]], Callable[P2, tuple[T2, *Ts2]]]
118 return TA
119
120 alias = more_generic()
121 self.assertIsInstance(alias, TypeAliasType)
122 T2, Ts2, P2 = alias.__type_params__
123 self.assertEqual(alias.__parameters__, (T2, *Ts2, P2))
124 T, Ts, P = more_generic.__type_params__
125 self.assertEqual(alias.__value__, tuple[Callable[P, tuple[T, *Ts]], Callable[P2, tuple[T2, *Ts2]]])
126
127 def test_subscripting(self):
128 type NonGeneric = int
129 type Generic[A] = dict[A, A]
130 type VeryGeneric[T, *Ts, **P] = Callable[P, tuple[T, *Ts]]
131
132 with self.assertRaises(TypeError):
133 NonGeneric[int]
134
135 specialized = Generic[int]
136 self.assertIsInstance(specialized, types.GenericAlias)
137 self.assertIs(specialized.__origin__, Generic)
138 self.assertEqual(specialized.__args__, (int,))
139
140 specialized2 = VeryGeneric[int, str, float, [bool, range]]
141 self.assertIsInstance(specialized2, types.GenericAlias)
142 self.assertIs(specialized2.__origin__, VeryGeneric)
143 self.assertEqual(specialized2.__args__, (int, str, float, [bool, range]))
144
145 def test_repr(self):
146 type Simple = int
147 type VeryGeneric[T, *Ts, **P] = Callable[P, tuple[T, *Ts]]
148
149 self.assertEqual(repr(Simple), "Simple")
150 self.assertEqual(repr(VeryGeneric), "VeryGeneric")
151 self.assertEqual(repr(VeryGeneric[int, bytes, str, [float, object]]),
152 "VeryGeneric[int, bytes, str, [float, object]]")
153 self.assertEqual(repr(VeryGeneric[int, []]),
154 "VeryGeneric[int, []]")
155 self.assertEqual(repr(VeryGeneric[int, [VeryGeneric[int], list[str]]]),
156 "VeryGeneric[int, [VeryGeneric[int], list[str]]]")
157
158 def test_recursive_repr(self):
159 type Recursive = Recursive
160 self.assertEqual(repr(Recursive), "Recursive")
161
162 type X = list[Y]
163 type Y = list[X]
164 self.assertEqual(repr(X), "X")
165 self.assertEqual(repr(Y), "Y")
166
167 type GenericRecursive[X] = list[X | GenericRecursive[X]]
168 self.assertEqual(repr(GenericRecursive), "GenericRecursive")
169 self.assertEqual(repr(GenericRecursive[int]), "GenericRecursive[int]")
170 self.assertEqual(repr(GenericRecursive[GenericRecursive[int]]),
171 "GenericRecursive[GenericRecursive[int]]")
172
173 def test_raising(self):
174 type MissingName = list[_My_X]
175 with self.assertRaisesRegex(
176 NameError,
177 "cannot access free variable '_My_X' where it is not associated with a value",
178 ):
179 MissingName.__value__
180 _My_X = int
181 self.assertEqual(MissingName.__value__, list[int])
182 del _My_X
183 # Cache should still work:
184 self.assertEqual(MissingName.__value__, list[int])
185
186 # Explicit exception:
187 type ExprException = 1 / 0
188 with self.assertRaises(ZeroDivisionError):
189 ExprException.__value__
190
191
192 class TypeAliasConstructorTest(unittest.TestCase):
193 def test_basic(self):
194 TA = TypeAliasType("TA", int)
195 self.assertEqual(TA.__name__, "TA")
196 self.assertIs(TA.__value__, int)
197 self.assertEqual(TA.__type_params__, ())
198 self.assertEqual(TA.__module__, __name__)
199
200 def test_attributes_with_exec(self):
201 ns = {}
202 exec("type TA = int", ns, ns)
203 TA = ns["TA"]
204 self.assertEqual(TA.__name__, "TA")
205 self.assertIs(TA.__value__, int)
206 self.assertEqual(TA.__type_params__, ())
207 self.assertIs(TA.__module__, None)
208
209 def test_generic(self):
210 T = TypeVar("T")
211 TA = TypeAliasType("TA", list[T], type_params=(T,))
212 self.assertEqual(TA.__name__, "TA")
213 self.assertEqual(TA.__value__, list[T])
214 self.assertEqual(TA.__type_params__, (T,))
215 self.assertEqual(TA.__module__, __name__)
216 self.assertIs(type(TA[int]), types.GenericAlias)
217
218 def test_not_generic(self):
219 TA = TypeAliasType("TA", list[int], type_params=())
220 self.assertEqual(TA.__name__, "TA")
221 self.assertEqual(TA.__value__, list[int])
222 self.assertEqual(TA.__type_params__, ())
223 self.assertEqual(TA.__module__, __name__)
224 with self.assertRaisesRegex(
225 TypeError,
226 "Only generic type aliases are subscriptable",
227 ):
228 TA[int]
229
230 def test_type_params_order_with_defaults(self):
231 HasNoDefaultT = TypeVar("HasNoDefaultT")
232 WithDefaultT = TypeVar("WithDefaultT", default=int)
233
234 HasNoDefaultP = ParamSpec("HasNoDefaultP")
235 WithDefaultP = ParamSpec("WithDefaultP", default=HasNoDefaultP)
236
237 HasNoDefaultTT = TypeVarTuple("HasNoDefaultTT")
238 WithDefaultTT = TypeVarTuple("WithDefaultTT", default=HasNoDefaultTT)
239
240 for type_params in [
241 (HasNoDefaultT, WithDefaultT),
242 (HasNoDefaultP, WithDefaultP),
243 (HasNoDefaultTT, WithDefaultTT),
244 ]:
245 with self.subTest(type_params=type_params):
246 TypeAliasType("A", int, type_params=type_params) # ok
247
248 msg = "follows default type parameter"
249 for type_params in [
250 (WithDefaultT, HasNoDefaultT),
251 (WithDefaultP, HasNoDefaultP),
252 (WithDefaultTT, HasNoDefaultTT),
253 (WithDefaultT, HasNoDefaultP), # different types
254 ]:
255 with self.subTest(type_params=type_params):
256 with self.assertRaisesRegex(TypeError, msg):
257 TypeAliasType("A", int, type_params=type_params)
258
259 def test_expects_type_like(self):
260 T = TypeVar("T")
261
262 msg = "Expected a type param"
263 with self.assertRaisesRegex(TypeError, msg):
264 TypeAliasType("A", int, type_params=(1,))
265 with self.assertRaisesRegex(TypeError, msg):
266 TypeAliasType("A", int, type_params=(1, 2))
267 with self.assertRaisesRegex(TypeError, msg):
268 TypeAliasType("A", int, type_params=(T, 2))
269
270 def test_keywords(self):
271 TA = TypeAliasType(name="TA", value=int)
272 self.assertEqual(TA.__name__, "TA")
273 self.assertIs(TA.__value__, int)
274 self.assertEqual(TA.__type_params__, ())
275 self.assertEqual(TA.__module__, __name__)
276
277 def test_errors(self):
278 with self.assertRaises(TypeError):
279 TypeAliasType()
280 with self.assertRaises(TypeError):
281 TypeAliasType("TA")
282 with self.assertRaises(TypeError):
283 TypeAliasType("TA", list, ())
284 with self.assertRaises(TypeError):
285 TypeAliasType("TA", list, type_params=42)
286
287
288 class TypeAliasTypeTest(unittest.TestCase):
289 def test_immutable(self):
290 with self.assertRaises(TypeError):
291 TypeAliasType.whatever = "not allowed"
292
293 def test_no_subclassing(self):
294 with self.assertRaisesRegex(TypeError, "not an acceptable base type"):
295 class MyAlias(TypeAliasType):
296 pass
297
298 def test_union(self):
299 type Alias1 = int
300 type Alias2 = str
301 union = Alias1 | Alias2
302 self.assertIsInstance(union, types.UnionType)
303 self.assertEqual(get_args(union), (Alias1, Alias2))
304 union2 = Alias1 | list[float]
305 self.assertIsInstance(union2, types.UnionType)
306 self.assertEqual(get_args(union2), (Alias1, list[float]))
307 union3 = list[range] | Alias1
308 self.assertIsInstance(union3, types.UnionType)
309 self.assertEqual(get_args(union3), (list[range], Alias1))
310
311 def test_module(self):
312 self.assertEqual(TypeAliasType.__module__, "typing")
313 type Alias = int
314 self.assertEqual(Alias.__module__, __name__)
315 self.assertEqual(mod_generics_cache.Alias.__module__,
316 mod_generics_cache.__name__)
317 self.assertEqual(mod_generics_cache.OldStyle.__module__,
318 mod_generics_cache.__name__)
319
320 def test_unpack(self):
321 type Alias = tuple[int, int]
322 unpacked = (*Alias,)[0]
323 self.assertEqual(unpacked, Unpack[Alias])
324
325 class Foo[*Ts]:
326 pass
327
328 x = Foo[str, *Alias]
329 self.assertEqual(x.__args__, (str, Unpack[Alias]))
330
331
332 # All these type aliases are used for pickling tests:
333 T = TypeVar('T')
334 type SimpleAlias = int
335 type RecursiveAlias = dict[str, RecursiveAlias]
336 type GenericAlias[X] = list[X]
337 type GenericAliasMultipleTypes[X, Y] = dict[X, Y]
338 type RecursiveGenericAlias[X] = dict[str, RecursiveAlias[X]]
339 type BoundGenericAlias[X: int] = set[X]
340 type ConstrainedGenericAlias[LongName: (str, bytes)] = list[LongName]
341 type AllTypesAlias[A, *B, **C] = Callable[C, A] | tuple[*B]
342
343
344 class TypeAliasPickleTest(unittest.TestCase):
345 def test_pickling(self):
346 things_to_test = [
347 SimpleAlias,
348 RecursiveAlias,
349
350 GenericAlias,
351 GenericAlias[T],
352 GenericAlias[int],
353
354 GenericAliasMultipleTypes,
355 GenericAliasMultipleTypes[str, T],
356 GenericAliasMultipleTypes[T, str],
357 GenericAliasMultipleTypes[int, str],
358
359 RecursiveGenericAlias,
360 RecursiveGenericAlias[T],
361 RecursiveGenericAlias[int],
362
363 BoundGenericAlias,
364 BoundGenericAlias[int],
365 BoundGenericAlias[T],
366
367 ConstrainedGenericAlias,
368 ConstrainedGenericAlias[str],
369 ConstrainedGenericAlias[T],
370
371 AllTypesAlias,
372 AllTypesAlias[int, str, T, [T, object]],
373
374 # Other modules:
375 mod_generics_cache.Alias,
376 mod_generics_cache.OldStyle,
377 ]
378 for thing in things_to_test:
379 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
380 with self.subTest(thing=thing, proto=proto):
381 pickled = pickle.dumps(thing, protocol=proto)
382 self.assertEqual(pickle.loads(pickled), thing)
383
384 type ClassLevel = str
385
386 def test_pickling_local(self):
387 type A = int
388 things_to_test = [
389 self.ClassLevel,
390 A,
391 ]
392 for thing in things_to_test:
393 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
394 with self.subTest(thing=thing, proto=proto):
395 with self.assertRaises(pickle.PickleError):
396 pickle.dumps(thing, protocol=proto)
397
398
399 class TypeParamsExoticGlobalsTest(unittest.TestCase):
400 def test_exec_with_unusual_globals(self):
401 class customdict(dict):
402 def __missing__(self, key):
403 return key
404
405 code = compile("type Alias = undefined", "test", "exec")
406 ns = customdict()
407 exec(code, ns)
408 Alias = ns["Alias"]
409 self.assertEqual(Alias.__value__, "undefined")
410
411 code = compile("class A: type Alias = undefined", "test", "exec")
412 ns = customdict()
413 exec(code, ns)
414 Alias = ns["A"].Alias
415 self.assertEqual(Alias.__value__, "undefined")