| """Tests for the annotations module.""" |
| |
| import annotationlib |
| import builtins |
| import collections |
| import functools |
| import itertools |
| import pickle |
| import unittest |
| from annotationlib import ( |
| Format, |
| ForwardRef, |
| get_annotations, |
| get_annotate_function, |
| annotations_to_string, |
| value_to_string, |
| ) |
| from typing import Unpack |
| |
| from test import support |
| from test.test_inspect import inspect_stock_annotations |
| from test.test_inspect import inspect_stringized_annotations |
| from test.test_inspect import inspect_stringized_annotations_2 |
| from test.test_inspect import inspect_stringized_annotations_pep695 |
| |
| |
| def times_three(fn): |
| @functools.wraps(fn) |
| def wrapper(a, b): |
| return fn(a * 3, b * 3) |
| |
| return wrapper |
| |
| |
| class MyClass: |
| def __repr__(self): |
| return "my repr" |
| |
| |
| class TestFormat(unittest.TestCase): |
| def test_enum(self): |
| self.assertEqual(Format.VALUE.value, 1) |
| self.assertEqual(Format.VALUE, 1) |
| |
| self.assertEqual(Format.FORWARDREF.value, 2) |
| self.assertEqual(Format.FORWARDREF, 2) |
| |
| self.assertEqual(Format.STRING.value, 3) |
| self.assertEqual(Format.STRING, 3) |
| |
| |
| class TestForwardRefFormat(unittest.TestCase): |
| def test_closure(self): |
| def inner(arg: x): |
| pass |
| |
| anno = annotationlib.get_annotations(inner, format=Format.FORWARDREF) |
| fwdref = anno["arg"] |
| self.assertIsInstance(fwdref, annotationlib.ForwardRef) |
| self.assertEqual(fwdref.__forward_arg__, "x") |
| with self.assertRaises(NameError): |
| fwdref.evaluate() |
| |
| x = 1 |
| self.assertEqual(fwdref.evaluate(), x) |
| |
| anno = annotationlib.get_annotations(inner, format=Format.FORWARDREF) |
| self.assertEqual(anno["arg"], x) |
| |
| def test_function(self): |
| def f(x: int, y: doesntexist): |
| pass |
| |
| anno = annotationlib.get_annotations(f, format=Format.FORWARDREF) |
| self.assertIs(anno["x"], int) |
| fwdref = anno["y"] |
| self.assertIsInstance(fwdref, annotationlib.ForwardRef) |
| self.assertEqual(fwdref.__forward_arg__, "doesntexist") |
| with self.assertRaises(NameError): |
| fwdref.evaluate() |
| self.assertEqual(fwdref.evaluate(globals={"doesntexist": 1}), 1) |
| |
| def test_nonexistent_attribute(self): |
| def f( |
| x: some.module, |
| y: some[module], |
| z: some(module), |
| alpha: some | obj, |
| beta: +some, |
| gamma: some < obj, |
| ): |
| pass |
| |
| anno = annotationlib.get_annotations(f, format=Format.FORWARDREF) |
| x_anno = anno["x"] |
| self.assertIsInstance(x_anno, ForwardRef) |
| self.assertEqual(x_anno, ForwardRef("some.module")) |
| |
| y_anno = anno["y"] |
| self.assertIsInstance(y_anno, ForwardRef) |
| self.assertEqual(y_anno, ForwardRef("some[module]")) |
| |
| z_anno = anno["z"] |
| self.assertIsInstance(z_anno, ForwardRef) |
| self.assertEqual(z_anno, ForwardRef("some(module)")) |
| |
| alpha_anno = anno["alpha"] |
| self.assertIsInstance(alpha_anno, ForwardRef) |
| self.assertEqual(alpha_anno, ForwardRef("some | obj")) |
| |
| beta_anno = anno["beta"] |
| self.assertIsInstance(beta_anno, ForwardRef) |
| self.assertEqual(beta_anno, ForwardRef("+some")) |
| |
| gamma_anno = anno["gamma"] |
| self.assertIsInstance(gamma_anno, ForwardRef) |
| self.assertEqual(gamma_anno, ForwardRef("some < obj")) |
| |
| |
| class TestSourceFormat(unittest.TestCase): |
| def test_closure(self): |
| x = 0 |
| |
| def inner(arg: x): |
| pass |
| |
| anno = annotationlib.get_annotations(inner, format=Format.STRING) |
| self.assertEqual(anno, {"arg": "x"}) |
| |
| def test_closure_undefined(self): |
| if False: |
| x = 0 |
| |
| def inner(arg: x): |
| pass |
| |
| anno = annotationlib.get_annotations(inner, format=Format.STRING) |
| self.assertEqual(anno, {"arg": "x"}) |
| |
| def test_function(self): |
| def f(x: int, y: doesntexist): |
| pass |
| |
| anno = annotationlib.get_annotations(f, format=Format.STRING) |
| self.assertEqual(anno, {"x": "int", "y": "doesntexist"}) |
| |
| def test_expressions(self): |
| def f( |
| add: a + b, |
| sub: a - b, |
| mul: a * b, |
| matmul: a @ b, |
| truediv: a / b, |
| mod: a % b, |
| lshift: a << b, |
| rshift: a >> b, |
| or_: a | b, |
| xor: a ^ b, |
| and_: a & b, |
| floordiv: a // b, |
| pow_: a**b, |
| lt: a < b, |
| le: a <= b, |
| eq: a == b, |
| ne: a != b, |
| gt: a > b, |
| ge: a >= b, |
| invert: ~a, |
| neg: -a, |
| pos: +a, |
| getitem: a[b], |
| getattr: a.b, |
| call: a(b, *c, d=e), # **kwargs are not supported |
| *args: *a, |
| ): |
| pass |
| |
| anno = annotationlib.get_annotations(f, format=Format.STRING) |
| self.assertEqual( |
| anno, |
| { |
| "add": "a + b", |
| "sub": "a - b", |
| "mul": "a * b", |
| "matmul": "a @ b", |
| "truediv": "a / b", |
| "mod": "a % b", |
| "lshift": "a << b", |
| "rshift": "a >> b", |
| "or_": "a | b", |
| "xor": "a ^ b", |
| "and_": "a & b", |
| "floordiv": "a // b", |
| "pow_": "a ** b", |
| "lt": "a < b", |
| "le": "a <= b", |
| "eq": "a == b", |
| "ne": "a != b", |
| "gt": "a > b", |
| "ge": "a >= b", |
| "invert": "~a", |
| "neg": "-a", |
| "pos": "+a", |
| "getitem": "a[b]", |
| "getattr": "a.b", |
| "call": "a(b, *c, d=e)", |
| "args": "*a", |
| }, |
| ) |
| |
| def test_reverse_ops(self): |
| def f( |
| radd: 1 + a, |
| rsub: 1 - a, |
| rmul: 1 * a, |
| rmatmul: 1 @ a, |
| rtruediv: 1 / a, |
| rmod: 1 % a, |
| rlshift: 1 << a, |
| rrshift: 1 >> a, |
| ror: 1 | a, |
| rxor: 1 ^ a, |
| rand: 1 & a, |
| rfloordiv: 1 // a, |
| rpow: 1**a, |
| ): |
| pass |
| |
| anno = annotationlib.get_annotations(f, format=Format.STRING) |
| self.assertEqual( |
| anno, |
| { |
| "radd": "1 + a", |
| "rsub": "1 - a", |
| "rmul": "1 * a", |
| "rmatmul": "1 @ a", |
| "rtruediv": "1 / a", |
| "rmod": "1 % a", |
| "rlshift": "1 << a", |
| "rrshift": "1 >> a", |
| "ror": "1 | a", |
| "rxor": "1 ^ a", |
| "rand": "1 & a", |
| "rfloordiv": "1 // a", |
| "rpow": "1 ** a", |
| }, |
| ) |
| |
| def test_nested_expressions(self): |
| def f( |
| nested: list[Annotated[set[int], "set of ints", 4j]], |
| set: {a + b}, # single element because order is not guaranteed |
| dict: {a + b: c + d, "key": e + g}, |
| list: [a, b, c], |
| tuple: (a, b, c), |
| slice: (a[b:c], a[b:c:d], a[:c], a[b:], a[:], a[::d], a[b::d]), |
| extended_slice: a[:, :, c:d], |
| unpack1: [*a], |
| unpack2: [*a, b, c], |
| ): |
| pass |
| |
| anno = annotationlib.get_annotations(f, format=Format.STRING) |
| self.assertEqual( |
| anno, |
| { |
| "nested": "list[Annotated[set[int], 'set of ints', 4j]]", |
| "set": "{a + b}", |
| "dict": "{a + b: c + d, 'key': e + g}", |
| "list": "[a, b, c]", |
| "tuple": "(a, b, c)", |
| "slice": "(a[b:c], a[b:c:d], a[:c], a[b:], a[:], a[::d], a[b::d])", |
| "extended_slice": "a[:, :, c:d]", |
| "unpack1": "[*a]", |
| "unpack2": "[*a, b, c]", |
| }, |
| ) |
| |
| def test_unsupported_operations(self): |
| format_msg = "Cannot stringify annotation containing string formatting" |
| |
| def f(fstring: f"{a}"): |
| pass |
| |
| with self.assertRaisesRegex(TypeError, format_msg): |
| annotationlib.get_annotations(f, format=Format.STRING) |
| |
| def f(fstring_format: f"{a:02d}"): |
| pass |
| |
| with self.assertRaisesRegex(TypeError, format_msg): |
| annotationlib.get_annotations(f, format=Format.STRING) |
| |
| |
| class TestForwardRefClass(unittest.TestCase): |
| def test_special_attrs(self): |
| # Forward refs provide a different introspection API. __name__ and |
| # __qualname__ make little sense for forward refs as they can store |
| # complex typing expressions. |
| fr = annotationlib.ForwardRef("set[Any]") |
| self.assertFalse(hasattr(fr, "__name__")) |
| self.assertFalse(hasattr(fr, "__qualname__")) |
| self.assertEqual(fr.__module__, "annotationlib") |
| # Forward refs are currently unpicklable once they contain a code object. |
| fr.__forward_code__ # fill the cache |
| for proto in range(pickle.HIGHEST_PROTOCOL + 1): |
| with self.assertRaises(TypeError): |
| pickle.dumps(fr, proto) |
| |
| def test_evaluate_with_type_params(self): |
| class Gen[T]: |
| alias = int |
| |
| with self.assertRaises(NameError): |
| ForwardRef("T").evaluate() |
| with self.assertRaises(NameError): |
| ForwardRef("T").evaluate(type_params=()) |
| with self.assertRaises(NameError): |
| ForwardRef("T").evaluate(owner=int) |
| |
| (T,) = Gen.__type_params__ |
| self.assertIs(ForwardRef("T").evaluate(type_params=Gen.__type_params__), T) |
| self.assertIs(ForwardRef("T").evaluate(owner=Gen), T) |
| |
| with self.assertRaises(NameError): |
| ForwardRef("alias").evaluate(type_params=Gen.__type_params__) |
| self.assertIs(ForwardRef("alias").evaluate(owner=Gen), int) |
| # If you pass custom locals, we don't look at the owner's locals |
| with self.assertRaises(NameError): |
| ForwardRef("alias").evaluate(owner=Gen, locals={}) |
| # But if the name exists in the locals, it works |
| self.assertIs( |
| ForwardRef("alias").evaluate(owner=Gen, locals={"alias": str}), str |
| ) |
| |
| def test_fwdref_with_module(self): |
| self.assertIs(ForwardRef("Format", module="annotationlib").evaluate(), Format) |
| self.assertIs( |
| ForwardRef("Counter", module="collections").evaluate(), collections.Counter |
| ) |
| self.assertEqual( |
| ForwardRef("Counter[int]", module="collections").evaluate(), |
| collections.Counter[int], |
| ) |
| |
| with self.assertRaises(NameError): |
| # If globals are passed explicitly, we don't look at the module dict |
| ForwardRef("Format", module="annotationlib").evaluate(globals={}) |
| |
| def test_fwdref_to_builtin(self): |
| self.assertIs(ForwardRef("int").evaluate(), int) |
| self.assertIs(ForwardRef("int", module="collections").evaluate(), int) |
| self.assertIs(ForwardRef("int", owner=str).evaluate(), int) |
| |
| # builtins are still searched with explicit globals |
| self.assertIs(ForwardRef("int").evaluate(globals={}), int) |
| |
| # explicit values in globals have precedence |
| obj = object() |
| self.assertIs(ForwardRef("int").evaluate(globals={"int": obj}), obj) |
| |
| def test_fwdref_value_is_cached(self): |
| fr = ForwardRef("hello") |
| with self.assertRaises(NameError): |
| fr.evaluate() |
| self.assertIs(fr.evaluate(globals={"hello": str}), str) |
| self.assertIs(fr.evaluate(), str) |
| |
| def test_fwdref_with_owner(self): |
| self.assertEqual( |
| ForwardRef("Counter[int]", owner=collections).evaluate(), |
| collections.Counter[int], |
| ) |
| |
| def test_name_lookup_without_eval(self): |
| # test the codepath where we look up simple names directly in the |
| # namespaces without going through eval() |
| self.assertIs(ForwardRef("int").evaluate(), int) |
| self.assertIs(ForwardRef("int").evaluate(locals={"int": str}), str) |
| self.assertIs( |
| ForwardRef("int").evaluate(locals={"int": float}, globals={"int": str}), |
| float, |
| ) |
| self.assertIs(ForwardRef("int").evaluate(globals={"int": str}), str) |
| with support.swap_attr(builtins, "int", dict): |
| self.assertIs(ForwardRef("int").evaluate(), dict) |
| |
| with self.assertRaises(NameError): |
| ForwardRef("doesntexist").evaluate() |
| |
| def test_fwdref_invalid_syntax(self): |
| fr = ForwardRef("if") |
| with self.assertRaises(SyntaxError): |
| fr.evaluate() |
| fr = ForwardRef("1+") |
| with self.assertRaises(SyntaxError): |
| fr.evaluate() |
| |
| |
| class TestGetAnnotations(unittest.TestCase): |
| def test_builtin_type(self): |
| self.assertEqual(annotationlib.get_annotations(int), {}) |
| self.assertEqual(annotationlib.get_annotations(object), {}) |
| |
| def test_custom_metaclass(self): |
| class Meta(type): |
| pass |
| |
| class C(metaclass=Meta): |
| x: int |
| |
| self.assertEqual(annotationlib.get_annotations(C), {"x": int}) |
| |
| def test_missing_dunder_dict(self): |
| class NoDict(type): |
| @property |
| def __dict__(cls): |
| raise AttributeError |
| |
| b: str |
| |
| class C1(metaclass=NoDict): |
| a: int |
| |
| self.assertEqual(annotationlib.get_annotations(C1), {"a": int}) |
| self.assertEqual( |
| annotationlib.get_annotations(C1, format=Format.FORWARDREF), |
| {"a": int}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(C1, format=Format.STRING), |
| {"a": "int"}, |
| ) |
| self.assertEqual(annotationlib.get_annotations(NoDict), {"b": str}) |
| self.assertEqual( |
| annotationlib.get_annotations(NoDict, format=Format.FORWARDREF), |
| {"b": str}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(NoDict, format=Format.STRING), |
| {"b": "str"}, |
| ) |
| |
| def test_format(self): |
| def f1(a: int): |
| pass |
| |
| def f2(a: undefined): |
| pass |
| |
| self.assertEqual( |
| annotationlib.get_annotations(f1, format=Format.VALUE), |
| {"a": int}, |
| ) |
| self.assertEqual(annotationlib.get_annotations(f1, format=1), {"a": int}) |
| |
| fwd = annotationlib.ForwardRef("undefined") |
| self.assertEqual( |
| annotationlib.get_annotations(f2, format=Format.FORWARDREF), |
| {"a": fwd}, |
| ) |
| self.assertEqual(annotationlib.get_annotations(f2, format=2), {"a": fwd}) |
| |
| self.assertEqual( |
| annotationlib.get_annotations(f1, format=Format.STRING), |
| {"a": "int"}, |
| ) |
| self.assertEqual(annotationlib.get_annotations(f1, format=3), {"a": "int"}) |
| |
| with self.assertRaises(ValueError): |
| annotationlib.get_annotations(f1, format=0) |
| |
| with self.assertRaises(ValueError): |
| annotationlib.get_annotations(f1, format=4) |
| |
| def test_custom_object_with_annotations(self): |
| class C: |
| def __init__(self): |
| self.__annotations__ = {"x": int, "y": str} |
| |
| self.assertEqual(annotationlib.get_annotations(C()), {"x": int, "y": str}) |
| |
| def test_custom_format_eval_str(self): |
| def foo(): |
| pass |
| |
| with self.assertRaises(ValueError): |
| annotationlib.get_annotations(foo, format=Format.FORWARDREF, eval_str=True) |
| annotationlib.get_annotations(foo, format=Format.STRING, eval_str=True) |
| |
| def test_stock_annotations(self): |
| def foo(a: int, b: str): |
| pass |
| |
| for format in (Format.VALUE, Format.FORWARDREF): |
| with self.subTest(format=format): |
| self.assertEqual( |
| annotationlib.get_annotations(foo, format=format), |
| {"a": int, "b": str}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(foo, format=Format.STRING), |
| {"a": "int", "b": "str"}, |
| ) |
| |
| foo.__annotations__ = {"a": "foo", "b": "str"} |
| for format in Format: |
| with self.subTest(format=format): |
| self.assertEqual( |
| annotationlib.get_annotations(foo, format=format), |
| {"a": "foo", "b": "str"}, |
| ) |
| |
| self.assertEqual( |
| annotationlib.get_annotations(foo, eval_str=True, locals=locals()), |
| {"a": foo, "b": str}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(foo, eval_str=True, globals=locals()), |
| {"a": foo, "b": str}, |
| ) |
| |
| def test_stock_annotations_in_module(self): |
| isa = inspect_stock_annotations |
| |
| for kwargs in [ |
| {}, |
| {"eval_str": False}, |
| {"format": Format.VALUE}, |
| {"format": Format.FORWARDREF}, |
| {"format": Format.VALUE, "eval_str": False}, |
| {"format": Format.FORWARDREF, "eval_str": False}, |
| ]: |
| with self.subTest(**kwargs): |
| self.assertEqual( |
| annotationlib.get_annotations(isa, **kwargs), {"a": int, "b": str} |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.MyClass, **kwargs), |
| {"a": int, "b": str}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.function, **kwargs), |
| {"a": int, "b": str, "return": isa.MyClass}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.function2, **kwargs), |
| {"a": int, "b": "str", "c": isa.MyClass, "return": isa.MyClass}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.function3, **kwargs), |
| {"a": "int", "b": "str", "c": "MyClass"}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(annotationlib, **kwargs), {} |
| ) # annotations module has no annotations |
| self.assertEqual( |
| annotationlib.get_annotations(isa.UnannotatedClass, **kwargs), {} |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.unannotated_function, **kwargs), |
| {}, |
| ) |
| |
| for kwargs in [ |
| {"eval_str": True}, |
| {"format": Format.VALUE, "eval_str": True}, |
| ]: |
| with self.subTest(**kwargs): |
| self.assertEqual( |
| annotationlib.get_annotations(isa, **kwargs), {"a": int, "b": str} |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.MyClass, **kwargs), |
| {"a": int, "b": str}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.function, **kwargs), |
| {"a": int, "b": str, "return": isa.MyClass}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.function2, **kwargs), |
| {"a": int, "b": str, "c": isa.MyClass, "return": isa.MyClass}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.function3, **kwargs), |
| {"a": int, "b": str, "c": isa.MyClass}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(annotationlib, **kwargs), {} |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.UnannotatedClass, **kwargs), {} |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.unannotated_function, **kwargs), |
| {}, |
| ) |
| |
| self.assertEqual( |
| annotationlib.get_annotations(isa, format=Format.STRING), |
| {"a": "int", "b": "str"}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.MyClass, format=Format.STRING), |
| {"a": "int", "b": "str"}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.function, format=Format.STRING), |
| {"a": "int", "b": "str", "return": "MyClass"}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.function2, format=Format.STRING), |
| {"a": "int", "b": "str", "c": "MyClass", "return": "MyClass"}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.function3, format=Format.STRING), |
| {"a": "int", "b": "str", "c": "MyClass"}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(annotationlib, format=Format.STRING), |
| {}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.UnannotatedClass, format=Format.STRING), |
| {}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations( |
| isa.unannotated_function, format=Format.STRING |
| ), |
| {}, |
| ) |
| |
| def test_stock_annotations_on_wrapper(self): |
| isa = inspect_stock_annotations |
| |
| wrapped = times_three(isa.function) |
| self.assertEqual(wrapped(1, "x"), isa.MyClass(3, "xxx")) |
| self.assertIsNot(wrapped.__globals__, isa.function.__globals__) |
| self.assertEqual( |
| annotationlib.get_annotations(wrapped), |
| {"a": int, "b": str, "return": isa.MyClass}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(wrapped, format=Format.FORWARDREF), |
| {"a": int, "b": str, "return": isa.MyClass}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(wrapped, format=Format.STRING), |
| {"a": "int", "b": "str", "return": "MyClass"}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(wrapped, eval_str=True), |
| {"a": int, "b": str, "return": isa.MyClass}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(wrapped, eval_str=False), |
| {"a": int, "b": str, "return": isa.MyClass}, |
| ) |
| |
| def test_stringized_annotations_in_module(self): |
| isa = inspect_stringized_annotations |
| for kwargs in [ |
| {}, |
| {"eval_str": False}, |
| {"format": Format.VALUE}, |
| {"format": Format.FORWARDREF}, |
| {"format": Format.STRING}, |
| {"format": Format.VALUE, "eval_str": False}, |
| {"format": Format.FORWARDREF, "eval_str": False}, |
| {"format": Format.STRING, "eval_str": False}, |
| ]: |
| with self.subTest(**kwargs): |
| self.assertEqual( |
| annotationlib.get_annotations(isa, **kwargs), |
| {"a": "int", "b": "str"}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.MyClass, **kwargs), |
| {"a": "int", "b": "str"}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.function, **kwargs), |
| {"a": "int", "b": "str", "return": "MyClass"}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.function2, **kwargs), |
| {"a": "int", "b": "'str'", "c": "MyClass", "return": "MyClass"}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.function3, **kwargs), |
| {"a": "'int'", "b": "'str'", "c": "'MyClass'"}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.UnannotatedClass, **kwargs), {} |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.unannotated_function, **kwargs), |
| {}, |
| ) |
| |
| for kwargs in [ |
| {"eval_str": True}, |
| {"format": Format.VALUE, "eval_str": True}, |
| ]: |
| with self.subTest(**kwargs): |
| self.assertEqual( |
| annotationlib.get_annotations(isa, **kwargs), {"a": int, "b": str} |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.MyClass, **kwargs), |
| {"a": int, "b": str}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.function, **kwargs), |
| {"a": int, "b": str, "return": isa.MyClass}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.function2, **kwargs), |
| {"a": int, "b": "str", "c": isa.MyClass, "return": isa.MyClass}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.function3, **kwargs), |
| {"a": "int", "b": "str", "c": "MyClass"}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.UnannotatedClass, **kwargs), {} |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(isa.unannotated_function, **kwargs), |
| {}, |
| ) |
| |
| def test_stringized_annotations_in_empty_module(self): |
| isa2 = inspect_stringized_annotations_2 |
| self.assertEqual(annotationlib.get_annotations(isa2), {}) |
| self.assertEqual(annotationlib.get_annotations(isa2, eval_str=True), {}) |
| self.assertEqual(annotationlib.get_annotations(isa2, eval_str=False), {}) |
| |
| def test_stringized_annotations_on_wrapper(self): |
| isa = inspect_stringized_annotations |
| wrapped = times_three(isa.function) |
| self.assertEqual(wrapped(1, "x"), isa.MyClass(3, "xxx")) |
| self.assertIsNot(wrapped.__globals__, isa.function.__globals__) |
| self.assertEqual( |
| annotationlib.get_annotations(wrapped), |
| {"a": "int", "b": "str", "return": "MyClass"}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(wrapped, eval_str=True), |
| {"a": int, "b": str, "return": isa.MyClass}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(wrapped, eval_str=False), |
| {"a": "int", "b": "str", "return": "MyClass"}, |
| ) |
| |
| def test_stringized_annotations_on_class(self): |
| isa = inspect_stringized_annotations |
| # test that local namespace lookups work |
| self.assertEqual( |
| annotationlib.get_annotations(isa.MyClassWithLocalAnnotations), |
| {"x": "mytype"}, |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations( |
| isa.MyClassWithLocalAnnotations, eval_str=True |
| ), |
| {"x": int}, |
| ) |
| |
| def test_modify_annotations(self): |
| def f(x: int): |
| pass |
| |
| self.assertEqual(annotationlib.get_annotations(f), {"x": int}) |
| self.assertEqual( |
| annotationlib.get_annotations(f, format=Format.FORWARDREF), |
| {"x": int}, |
| ) |
| |
| f.__annotations__["x"] = str |
| # The modification is reflected in VALUE (the default) |
| self.assertEqual(annotationlib.get_annotations(f), {"x": str}) |
| # ... and also in FORWARDREF, which tries __annotations__ if available |
| self.assertEqual( |
| annotationlib.get_annotations(f, format=Format.FORWARDREF), |
| {"x": str}, |
| ) |
| # ... but not in STRING which always uses __annotate__ |
| self.assertEqual( |
| annotationlib.get_annotations(f, format=Format.STRING), |
| {"x": "int"}, |
| ) |
| |
| def test_non_dict_annotations(self): |
| class WeirdAnnotations: |
| @property |
| def __annotations__(self): |
| return "not a dict" |
| |
| wa = WeirdAnnotations() |
| for format in Format: |
| with ( |
| self.subTest(format=format), |
| self.assertRaisesRegex( |
| ValueError, r".*__annotations__ is neither a dict nor None" |
| ), |
| ): |
| annotationlib.get_annotations(wa, format=format) |
| |
| def test_annotations_on_custom_object(self): |
| class HasAnnotations: |
| @property |
| def __annotations__(self): |
| return {"x": int} |
| |
| ha = HasAnnotations() |
| self.assertEqual( |
| annotationlib.get_annotations(ha, format=Format.VALUE), {"x": int} |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(ha, format=Format.FORWARDREF), {"x": int} |
| ) |
| |
| self.assertEqual( |
| annotationlib.get_annotations(ha, format=Format.STRING), {"x": "int"} |
| ) |
| |
| def test_raising_annotations_on_custom_object(self): |
| class HasRaisingAnnotations: |
| @property |
| def __annotations__(self): |
| return {"x": undefined} |
| |
| hra = HasRaisingAnnotations() |
| |
| with self.assertRaises(NameError): |
| annotationlib.get_annotations(hra, format=Format.VALUE) |
| |
| with self.assertRaises(NameError): |
| annotationlib.get_annotations(hra, format=Format.FORWARDREF) |
| |
| undefined = float |
| self.assertEqual( |
| annotationlib.get_annotations(hra, format=Format.VALUE), {"x": float} |
| ) |
| |
| def test_forwardref_prefers_annotations(self): |
| class HasBoth: |
| @property |
| def __annotations__(self): |
| return {"x": int} |
| |
| @property |
| def __annotate__(self): |
| return lambda format: {"x": str} |
| |
| hb = HasBoth() |
| self.assertEqual( |
| annotationlib.get_annotations(hb, format=Format.VALUE), {"x": int} |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(hb, format=Format.FORWARDREF), {"x": int} |
| ) |
| self.assertEqual( |
| annotationlib.get_annotations(hb, format=Format.STRING), {"x": str} |
| ) |
| |
| def test_pep695_generic_class_with_future_annotations(self): |
| ann_module695 = inspect_stringized_annotations_pep695 |
| A_annotations = annotationlib.get_annotations(ann_module695.A, eval_str=True) |
| A_type_params = ann_module695.A.__type_params__ |
| self.assertIs(A_annotations["x"], A_type_params[0]) |
| self.assertEqual(A_annotations["y"].__args__[0], Unpack[A_type_params[1]]) |
| self.assertIs(A_annotations["z"].__args__[0], A_type_params[2]) |
| |
| def test_pep695_generic_class_with_future_annotations_and_local_shadowing(self): |
| B_annotations = annotationlib.get_annotations( |
| inspect_stringized_annotations_pep695.B, eval_str=True |
| ) |
| self.assertEqual(B_annotations, {"x": int, "y": str, "z": bytes}) |
| |
| def test_pep695_generic_class_with_future_annotations_name_clash_with_global_vars( |
| self, |
| ): |
| ann_module695 = inspect_stringized_annotations_pep695 |
| C_annotations = annotationlib.get_annotations(ann_module695.C, eval_str=True) |
| self.assertEqual( |
| set(C_annotations.values()), set(ann_module695.C.__type_params__) |
| ) |
| |
| def test_pep_695_generic_function_with_future_annotations(self): |
| ann_module695 = inspect_stringized_annotations_pep695 |
| generic_func_annotations = annotationlib.get_annotations( |
| ann_module695.generic_function, eval_str=True |
| ) |
| func_t_params = ann_module695.generic_function.__type_params__ |
| self.assertEqual( |
| generic_func_annotations.keys(), {"x", "y", "z", "zz", "return"} |
| ) |
| self.assertIs(generic_func_annotations["x"], func_t_params[0]) |
| self.assertEqual(generic_func_annotations["y"], Unpack[func_t_params[1]]) |
| self.assertIs(generic_func_annotations["z"].__origin__, func_t_params[2]) |
| self.assertIs(generic_func_annotations["zz"].__origin__, func_t_params[2]) |
| |
| def test_pep_695_generic_function_with_future_annotations_name_clash_with_global_vars( |
| self, |
| ): |
| self.assertEqual( |
| set( |
| annotationlib.get_annotations( |
| inspect_stringized_annotations_pep695.generic_function_2, |
| eval_str=True, |
| ).values() |
| ), |
| set( |
| inspect_stringized_annotations_pep695.generic_function_2.__type_params__ |
| ), |
| ) |
| |
| def test_pep_695_generic_method_with_future_annotations(self): |
| ann_module695 = inspect_stringized_annotations_pep695 |
| generic_method_annotations = annotationlib.get_annotations( |
| ann_module695.D.generic_method, eval_str=True |
| ) |
| params = { |
| param.__name__: param |
| for param in ann_module695.D.generic_method.__type_params__ |
| } |
| self.assertEqual( |
| generic_method_annotations, |
| {"x": params["Foo"], "y": params["Bar"], "return": None}, |
| ) |
| |
| def test_pep_695_generic_method_with_future_annotations_name_clash_with_global_vars( |
| self, |
| ): |
| self.assertEqual( |
| set( |
| annotationlib.get_annotations( |
| inspect_stringized_annotations_pep695.D.generic_method_2, |
| eval_str=True, |
| ).values() |
| ), |
| set( |
| inspect_stringized_annotations_pep695.D.generic_method_2.__type_params__ |
| ), |
| ) |
| |
| def test_pep_695_generic_method_with_future_annotations_name_clash_with_global_and_local_vars( |
| self, |
| ): |
| self.assertEqual( |
| annotationlib.get_annotations( |
| inspect_stringized_annotations_pep695.E, eval_str=True |
| ), |
| {"x": str}, |
| ) |
| |
| def test_pep_695_generics_with_future_annotations_nested_in_function(self): |
| results = inspect_stringized_annotations_pep695.nested() |
| |
| self.assertEqual( |
| set(results.F_annotations.values()), set(results.F.__type_params__) |
| ) |
| self.assertEqual( |
| set(results.F_meth_annotations.values()), |
| set(results.F.generic_method.__type_params__), |
| ) |
| self.assertNotEqual( |
| set(results.F_meth_annotations.values()), set(results.F.__type_params__) |
| ) |
| self.assertEqual( |
| set(results.F_meth_annotations.values()).intersection( |
| results.F.__type_params__ |
| ), |
| set(), |
| ) |
| |
| self.assertEqual(results.G_annotations, {"x": str}) |
| |
| self.assertEqual( |
| set(results.generic_func_annotations.values()), |
| set(results.generic_func.__type_params__), |
| ) |
| |
| |
| class TestCallEvaluateFunction(unittest.TestCase): |
| def test_evaluation(self): |
| def evaluate(format, exc=NotImplementedError): |
| if format != 1: |
| raise exc |
| return undefined |
| |
| with self.assertRaises(NameError): |
| annotationlib.call_evaluate_function(evaluate, Format.VALUE) |
| self.assertEqual( |
| annotationlib.call_evaluate_function(evaluate, Format.FORWARDREF), |
| annotationlib.ForwardRef("undefined"), |
| ) |
| self.assertEqual( |
| annotationlib.call_evaluate_function(evaluate, Format.STRING), |
| "undefined", |
| ) |
| |
| |
| class MetaclassTests(unittest.TestCase): |
| def test_annotated_meta(self): |
| class Meta(type): |
| a: int |
| |
| class X(metaclass=Meta): |
| pass |
| |
| class Y(metaclass=Meta): |
| b: float |
| |
| self.assertEqual(get_annotations(Meta), {"a": int}) |
| self.assertEqual(get_annotate_function(Meta)(Format.VALUE), {"a": int}) |
| |
| self.assertEqual(get_annotations(X), {}) |
| self.assertIs(get_annotate_function(X), None) |
| |
| self.assertEqual(get_annotations(Y), {"b": float}) |
| self.assertEqual(get_annotate_function(Y)(Format.VALUE), {"b": float}) |
| |
| def test_unannotated_meta(self): |
| class Meta(type): |
| pass |
| |
| class X(metaclass=Meta): |
| a: str |
| |
| class Y(X): |
| pass |
| |
| self.assertEqual(get_annotations(Meta), {}) |
| self.assertIs(get_annotate_function(Meta), None) |
| |
| self.assertEqual(get_annotations(Y), {}) |
| self.assertIs(get_annotate_function(Y), None) |
| |
| self.assertEqual(get_annotations(X), {"a": str}) |
| self.assertEqual(get_annotate_function(X)(Format.VALUE), {"a": str}) |
| |
| def test_ordering(self): |
| # Based on a sample by David Ellis |
| # https://discuss.python.org/t/pep-749-implementing-pep-649/54974/38 |
| |
| def make_classes(): |
| class Meta(type): |
| a: int |
| expected_annotations = {"a": int} |
| |
| class A(type, metaclass=Meta): |
| b: float |
| expected_annotations = {"b": float} |
| |
| class B(metaclass=A): |
| c: str |
| expected_annotations = {"c": str} |
| |
| class C(B): |
| expected_annotations = {} |
| |
| class D(metaclass=Meta): |
| expected_annotations = {} |
| |
| return Meta, A, B, C, D |
| |
| classes = make_classes() |
| class_count = len(classes) |
| for order in itertools.permutations(range(class_count), class_count): |
| names = ", ".join(classes[i].__name__ for i in order) |
| with self.subTest(names=names): |
| classes = make_classes() # Regenerate classes |
| for i in order: |
| get_annotations(classes[i]) |
| for c in classes: |
| with self.subTest(c=c): |
| self.assertEqual(get_annotations(c), c.expected_annotations) |
| annotate_func = get_annotate_function(c) |
| if c.expected_annotations: |
| self.assertEqual( |
| annotate_func(Format.VALUE), c.expected_annotations |
| ) |
| else: |
| self.assertIs(annotate_func, None) |
| |
| |
| class TestGetAnnotateFunction(unittest.TestCase): |
| def test_static_class(self): |
| self.assertIsNone(get_annotate_function(object)) |
| self.assertIsNone(get_annotate_function(int)) |
| |
| def test_unannotated_class(self): |
| class C: |
| pass |
| |
| self.assertIsNone(get_annotate_function(C)) |
| |
| D = type("D", (), {}) |
| self.assertIsNone(get_annotate_function(D)) |
| |
| def test_annotated_class(self): |
| class C: |
| a: int |
| |
| self.assertEqual(get_annotate_function(C)(Format.VALUE), {"a": int}) |
| |
| |
| class TestToSource(unittest.TestCase): |
| def test_value_to_string(self): |
| self.assertEqual(value_to_string(int), "int") |
| self.assertEqual(value_to_string(MyClass), "test.test_annotationlib.MyClass") |
| self.assertEqual(value_to_string(len), "len") |
| self.assertEqual(value_to_string(value_to_string), "value_to_string") |
| self.assertEqual(value_to_string(times_three), "times_three") |
| self.assertEqual(value_to_string(...), "...") |
| self.assertEqual(value_to_string(None), "None") |
| self.assertEqual(value_to_string(1), "1") |
| self.assertEqual(value_to_string("1"), "'1'") |
| self.assertEqual(value_to_string(Format.VALUE), repr(Format.VALUE)) |
| self.assertEqual(value_to_string(MyClass()), "my repr") |
| |
| def test_annotations_to_string(self): |
| self.assertEqual(annotations_to_string({}), {}) |
| self.assertEqual(annotations_to_string({"x": int}), {"x": "int"}) |
| self.assertEqual(annotations_to_string({"x": "int"}), {"x": "int"}) |
| self.assertEqual( |
| annotations_to_string({"x": int, "y": str}), {"x": "int", "y": "str"} |
| ) |
| |
| |
| class TestAnnotationLib(unittest.TestCase): |
| def test__all__(self): |
| support.check__all__(self, annotationlib) |
