feat: add support for resolving string annotations in typed method discovery

Author: bot

src/iop/messages/dispatch.py

@@ -306,8 +306,9 @@ def get_handler_info(host: Any, method_name: str) -> tuple[str, str] | None:
         if len(params) != 1:
             return None
 
+        method = getattr(host, method_name)
         param: Parameter = next(iter(params.values()))
-        annotation = param.annotation
+        annotation = _resolve_annotation(host, method, param.annotation)
 
         if annotation == Parameter.empty:
             return None
@@ -322,6 +323,42 @@ def get_handler_info(host: Any, method_name: str) -> tuple[str, str] | None:
         return None
 
 
+def _resolve_annotation(host: Any, method: Callable, annotation: Any) -> Any:
+    if not isinstance(annotation, str):
+        return annotation
+
+    globalns = _annotation_globalns(method)
+    localns = _annotation_localns(host)
+
+    try:
+        resolved = eval(annotation, globalns, localns)  # noqa: B307
+    except Exception:
+        resolved = annotation
+
+    if isinstance(resolved, str):
+        # Quoted postponed annotations evaluate to a string first.
+        try:
+            resolved = eval(resolved, globalns, localns)  # noqa: B307
+        except Exception:
+            if "." in resolved:
+                return resolved
+            return Parameter.empty
+
+    return resolved
+
+
+def _annotation_globalns(method: Callable) -> dict[str, Any]:
+    function = getattr(method, "__func__", method)
+    return getattr(function, "__globals__", {})
+
+
+def _annotation_localns(host: Any) -> dict[str, Any]:
+    namespace: dict[str, Any] = {}
+    for klass in reversed(type(host).__mro__):
+        namespace.update(vars(klass))
+    return namespace
+
+
 def _message_class_name(message_type: Any) -> str | None:
     if isinstance(message_type, str):
         return message_type

src/tests/unit/test_dispatch.py

@@ -287,6 +287,40 @@ def log_warning(self, message):
     assert logs == []
 
 
+def test_typed_method_discovery_resolves_string_annotations():
+    class Host:
+        def on_message(self, request):
+            return "fallback"
+
+        def handle_message(self, request: "MessageTest"):
+            return "handled"
+
+    host = Host()
+    create_dispatch(host)
+
+    assert host.DISPATCH == [
+        (f"{MessageTest.__module__}.{MessageTest.__name__}", "handle_message")
+    ]
+    assert dispatch_message(host, MessageTest(text="test", number=1)) == "handled"
+
+
+def test_typed_method_discovery_ignores_unresolved_bare_string_annotations():
+    class Host:
+        def on_message(self, request):
+            return "fallback"
+
+        def handle_message(self, request):
+            return "handled"
+
+    Host.handle_message.__annotations__["request"] = "UnknownMessage"
+
+    host = Host()
+    create_dispatch(host)
+
+    assert host.DISPATCH == []
+    assert dispatch_message(host, MessageTest(text="test", number=1)) == "fallback"
+
+
 def test_duplicate_legacy_mappings_log_discarded_handler():
     logs = []