nr/fake hint fixes (#30)

* fix: Fixed an error when evaluating `FakeHint` objects when an argument to a type-hint such as `Annotated` was the constant value `True`, `False`, `None`, `0` or `1`.

* Add `FakeProvider.execute()

* remove visiting of ast.Constant

Author: NiklasRosenstein

.changelog/_unreleased.toml

@@ -0,0 +1,5 @@
+[[entries]]
+id = "e7afde99-2c2d-493a-bb4e-120d56e41a36"
+type = "fix"
+description = "Fixed an error when evaluating `FakeHint` objects when an argument to a type-hint such as `Annotated` was the constant value `True`, `False`, `None`, `0` or `1`."
+author = "@NiklasRosenstein"

pyproject.toml

@@ -32,6 +32,7 @@ types-dataclasses = "^0.6.5"
 isort = "^5.10.1"
 flake8 = "^4.0.1"
 black = "^22.3.0"
+astor = "^0.8.1"
 
 [tool.poetry.group.docs]
 optional = true

src/typeapi/future/astrewrite.py

@@ -11,10 +11,16 @@
 T_AST = t.TypeVar("T_AST", bound=ast.AST)
 
 
-def rewrite_expr(source: str, lookup_target: str) -> CodeType:
+def rewrite_expr_to_ast(source: str, lookup_target: str) -> "ast.Expression | ast.Module":
     expr = ast.parse(source, "<expr>", "eval")
     expr = DynamicLookupRewriter(lookup_target).visit(expr)
     ast.fix_missing_locations(expr)
+    assert isinstance(expr, (ast.Expression, ast.Module)), type(expr)
+    return expr
+
+
+def rewrite_expr(source: str, lookup_target: str) -> CodeType:
+    expr = rewrite_expr_to_ast(source, lookup_target)
     return t.cast(CodeType, compile(expr, "<expr>", "eval"))  # type: ignore[redundant-cast]  # Redundant in 3.7+
 
 
@@ -81,13 +87,6 @@ def visit_Name(self, node: ast.Name) -> ast.AST:
             ctx=node.ctx,
         )
 
-    if hasattr(ast, "Constant"):  # Introduced in Python 3.8
-
-        def visit_Constant(self, node: ast.Constant) -> ast.AST:
-            if node.value in (None, True, False):
-                return self.visit_Name(ast.Name(id=str(node.value), ctx=ast.Load()))
-            return self.generic_visit(node)
-
     def visit_Assign(self, assign: ast.Assign) -> ast.AST:
         if len(assign.targets) == 1 and isinstance(assign.targets[0], ast.Name):
             name = assign.targets[0]

src/typeapi/future/astrewrite_test.py

@@ -0,0 +1,20 @@
+import ast
+import re
+
+import astor  # type: ignore[import]
+
+from typeapi.future.astrewrite import rewrite_expr_to_ast
+
+
+def to_source(ast: ast.AST) -> str:
+    # We can't set the line width of the generated code, so we use this to narrow expressions
+    # down into a single line. We're still left with some space for example when a line break
+    # occurred after a parentheses, `[\n    0]` will result in `[ 0]`.
+    return re.sub(r" +", " ", astor.to_source(ast).replace("\n", ""))
+
+
+def test__rewrite_expr__deals_with_literals() -> None:
+    assert (
+        to_source(rewrite_expr_to_ast("Annotated[int | str, 0, '42', Decimal(...)]", "__dict__"))
+        == "__dict__['Annotated'][__dict__['int'] | __dict__['str'], 0, '42', __dict__[ 'Decimal'](...)]"
+    )

src/typeapi/future/fake.py

@@ -5,6 +5,8 @@
 import builtins
 from typing import Any, Optional, Tuple, Union
 
+from typeapi.future.astrewrite import rewrite_expr
+
 from ..utils import HasGetitem, get_subscriptable_type_hint_from_origin
 
 
@@ -20,8 +22,10 @@ def __init__(self, origin: Any, args: Optional[Tuple["FakeHint", ...]] = None) -
     def __repr__(self) -> str:
         return f"FakeHint({self.origin}, args={self.args})"
 
-    def __or__(self, other: "FakeHint") -> "FakeHint":
-        assert isinstance(other, FakeHint)
+    def __or__(self, other: "FakeHint | None") -> "FakeHint":
+        if other is None:
+            other = FakeHint(None)
+        assert isinstance(other, FakeHint), type(other)
         if self.origin == Union:
             assert self.args is not None
             return FakeHint(Union, self.args + (other,))
@@ -55,6 +59,14 @@ def evaluate(self) -> Any:
 
 
 class FakeProvider:
+    """
+    This class serves as a lookup target when executing Python typing expressions. It wraps all lookups
+    returned by *content* in #FakeHint objects (this is achieved in combination with #rewrite_expr()).
+    This constructs a hierarchy of the operations performed in the expression as #FakeHint objects which
+    can then be evaluated using #FakeHint.evaluate() to simulate modern Python typing features (such as
+    advanced union syntax using the `|` operator and built-in type subscripting to generalize templates).
+    """
+
     def __init__(self, content: HasGetitem[str, Any]) -> None:
         self.content = content
 
@@ -64,3 +76,20 @@ def __getitem__(self, key: str) -> FakeHint:
         except KeyError:
             value = vars(builtins)[key]
         return FakeHint(get_subscriptable_type_hint_from_origin(value))
+
+    def execute(self, expr: str) -> FakeHint:
+        """
+        Executes a type-hint expression and returns the #FakeHint for it which can then be evaluated with
+        #FakeHint.evaluate() to construct the actual Python `typing` type hint object.
+        """
+
+        code = rewrite_expr(expr, "__dict__")
+        result = eval(code, {"__dict__": self})
+
+        # We don't wrap all expressions into FakeHint objects via rewrite_expr(), but only names. If the expressions
+        # was a literal string for example, we need to turn that into a FakeHint.
+        if not isinstance(result, FakeHint):
+            result = FakeHint(result)
+
+        assert isinstance(result, FakeHint)
+        return result

src/typeapi/future/fake_test.py

@@ -1,8 +1,9 @@
-from typing import List, Optional, Union
+from typing import Any, List, Optional, Union
 
 import pytest
 
-from typeapi.future.fake import FakeHint
+from typeapi.future.astrewrite import rewrite_expr
+from typeapi.future.fake import FakeHint, FakeProvider
 
 
 def test__FakeHint__evaluate() -> None:
@@ -35,6 +36,7 @@ def test__FakeHint__getattr() -> None:
 
 def test__FakeHint__Optional() -> None:
     assert FakeHint(Optional)[FakeHint(int)].evaluate() == Optional[int]
+    assert (FakeHint(None) | FakeHint(int)).evaluate() == Optional[int]
 
 
 def test__FakeHint__callable() -> None:
@@ -43,3 +45,10 @@ def test__FakeHint__callable() -> None:
     with pytest.raises(RuntimeError) as excinfo:
         FakeHint(Optional)[FakeHint(int)]("foobar")
     assert str(excinfo.value) == "FakeHint(typing.Optional, args=(FakeHint(<class 'int'>, args=None),)) is not callable"
+
+
+@pytest.mark.parametrize("val", ["FooBar", 0, 42.3, True, False, None])
+def test__FakeHint__from_constant(val: Any) -> None:
+    scope = {"__dict__": FakeProvider({})}
+    expr = eval(rewrite_expr(repr(val), "__dict__"), scope)
+    assert expr == val

src/typeapi/typehint.py

@@ -553,31 +553,12 @@ def parameterize(self, parameter_map: Mapping[object, Any]) -> TypeHint:
         )
 
     def evaluate(self, context: "HasGetitem[str, Any] | None" = None) -> TypeHint:
-        from .future.astrewrite import rewrite_expr
-        from .future.fake import FakeHint, FakeProvider
+        from .future.fake import FakeProvider
 
         if context is None:
             context = self.get_context()
 
-        code = rewrite_expr(self.expr, "__dict__")
-        scope = {"__dict__": FakeProvider(context)}
-        hint = eval(code, scope, {})
-
-        assert isinstance(hint, FakeHint), (self.expr, FakeHint)
-        hint = hint.evaluate()
-
-        # # Even though eval expects a Mapping, we know for forward references that we'll only
-        # # need to have __getitem__() as they are pure expressions.
-        # retyped_context = cast(Mapping[str, Any], FakeProvider(context))
-
-        # if IS_PYTHON_AT_LAST_3_6:
-        #     hint = eval(code, scope, {})
-        # elif IS_PYTHON_AT_LAST_3_8:
-        #     # Mypy doesn't know about the third arg
-        #     hint = self.ref._evaluate(scope, {})  # type: ignore[arg-type]
-        # else:
-        #     hint = self.ref._evaluate(scope, {}, set())  # type: ignore[arg-type,call-arg]
-
+        hint = FakeProvider(context).execute(self.expr).evaluate()
         return TypeHint(hint).evaluate(context)
 
     @property