refactor: Improve objects conversion to annotation during dynamic analysis

Issue-369: #369

Author: pawamoy

src/_griffe/agents/inspector.py

@@ -562,15 +562,19 @@ def _convert_object_to_annotation(obj: Any, parent: Module | Class) -> str | Exp
     # can come from modules which did *not* import them,
     # so `inspect.signature` returns actual Python objects
     # that we must deal with.
-    if not isinstance(obj, str):
+    if isinstance(obj, str):
+        annotation = obj
+    else:
+        # Always give precedence to the object's representation...
+        obj_repr = repr(obj)
         if hasattr(obj, "__name__"):  # noqa: SIM108
-            # Simple types like `int`, `str`, custom classes, etc..
-            obj = obj.__name__
+            # ...unless it contains chevrons (which likely means it's a class),
+            # in which case we use the object's name.
+            annotation = obj.__name__ if "<" in obj_repr else obj_repr
         else:
-            # Other, more complex types: hope for the best.
-            obj = repr(obj)
+            annotation = obj_repr
     try:
-        annotation_node = compile(obj, mode="eval", filename="<>", flags=ast.PyCF_ONLY_AST, optimize=2)
+        annotation_node = compile(annotation, mode="eval", filename="<>", flags=ast.PyCF_ONLY_AST, optimize=2)
     except SyntaxError:
         return obj
     return safe_get_annotation(annotation_node.body, parent=parent)  # type: ignore[attr-defined]

tests/test_inspector.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import sys
+
 import pytest
 
 from griffe import inspect, temporary_inspected_module, temporary_inspected_package, temporary_pypackage
@@ -30,6 +32,29 @@ def test_annotations_from_classes() -> None:
         assert returns.canonical_path == f"{module.name}.A"
 
 
+# YORE: EOL 3.9: Remove line.
+@pytest.mark.skipif(sys.version_info < (3, 10), reason="Type unions not supported on 3.9")
+@pytest.mark.parametrize(
+    ("annotation", "expected"),
+    [
+        ("tuple[int, str]", "tuple[int, str]"),
+        ("Union[int, str]", "typing.Union[int, str]"),
+        ("int | str", "int | str"),
+        ("int | Literal[1]", "typing.Union[int, typing.Literal[1]]"),
+    ],
+)
+def test_annotations_from_types(annotation: str, expected: str) -> None:
+    """Assert annotations are correctly converted to string."""
+    with temporary_inspected_module(
+        f"""
+        from typing import Literal, Union
+        def func(param: {annotation}): ...
+        """,
+    ) as module:
+        param = module["func"].parameters["param"]
+        assert str(param.annotation) == expected
+
+
 def test_class_level_imports() -> None:
     """Assert annotations using class-level imports are resolved."""
     with temporary_inspected_module(