Resolve ForwardRefs on return annotations (#73)

Author: tlambert03

magicgui/function_gui.py

@@ -83,7 +83,6 @@ def __init__(
             raise TypeError(f"FunctionGui got unexpected keyword argument{s}: {extra}")
         self._function = function
         sig = magic_signature(function, gui_options=param_options)
-        self._return_annotation = sig.return_annotation
         super().__init__(
             layout=layout,
             labels=labels,
@@ -207,7 +206,7 @@ def __call__(self, *args: Any, **kwargs: Any):
             with self._result_widget.changed.blocker():
                 self._result_widget.value = value
 
-        return_type = self._return_annotation
+        return_type = self.return_annotation
         if return_type:
             for callback in _type2callback(return_type):
                 callback(self, value, return_type)

magicgui/type_map.py

@@ -43,8 +43,14 @@ def _is_subclass(obj, superclass):
         return False
 
 
-def _evaluate_forwardref(type_: ForwardRef) -> Any:
+def _evaluate_forwardref(type_: Any) -> Any:
     """Convert typing.ForwardRef into an actual object."""
+    if isinstance(type_, str):
+        type_ = ForwardRef(type_)
+
+    if not isinstance(type_, ForwardRef):
+        return type_
+
     from importlib import import_module
 
     try:
@@ -146,8 +152,7 @@ def pick_widget_type(
         widget_type = options.pop("widget_type")
         return widget_type, options
 
-    if isinstance(annotation, ForwardRef):
-        annotation = _evaluate_forwardref(annotation)
+    annotation = _evaluate_forwardref(annotation)
 
     dtype = _normalize_type(value, annotation)
 
@@ -259,6 +264,8 @@ def register_type(
     ValueError
         If both ``widget_type`` and ``choices`` are None
     """
+    type_ = _evaluate_forwardref(type_)
+
     if not (return_callback or options.get("choices") or widget_type):
         raise ValueError(
             "At least one of `widget_type`, `choices`, or "
@@ -305,6 +312,7 @@ def _type2callback(type_: type) -> List[ReturnCallback]:
         Where a return callback accepts two arguments (gui, value) and does something.
     """
     # look for direct hits
+    type_ = _evaluate_forwardref(type_)
     if type_ in _RETURN_CALLBACKS:
         return _RETURN_CALLBACKS[type_]
     # look for subclasses

magicgui/widgets/_bases.py

@@ -255,7 +255,7 @@ def annotation(self):
 
     @annotation.setter
     def annotation(self, value):
-        if isinstance(value, ForwardRef):
+        if isinstance(value, (str, ForwardRef)):
             from magicgui.type_map import _evaluate_forwardref
 
             value = _evaluate_forwardref(value)
@@ -803,17 +803,34 @@ def __init__(
         return_annotation: Any = None,
         **kwargs,
     ):
+        self._return_annotation = None
         self._labels = labels
         self._layout = layout
         kwargs["backend_kwargs"] = {"layout": layout}
         super().__init__(**kwargs)
         self.changed = EventEmitter(source=self, type="changed")
-        self._return_annotation = return_annotation
+        self.return_annotation = return_annotation
         self.extend(widgets)
         self.parent_changed.connect(self.reset_choices)
         self._initialized = True
         self._unify_label_widths()
 
+    @property
+    def return_annotation(self):
+        """Return annotation to use when converting to :class:`inspect.Signature`.
+
+        ForwardRefs will be resolve when setting the annotation.
+        """
+        return self._return_annotation
+
+    @return_annotation.setter
+    def return_annotation(self, value):
+        if isinstance(value, (str, ForwardRef)):
+            from magicgui.type_map import _evaluate_forwardref
+
+            value = _evaluate_forwardref(value)
+        self._return_annotation = value
+
     def __getattr__(self, name: str):
         """Return attribute ``name``.  Will return a widget if present."""
         for widget in self:
@@ -984,7 +1001,7 @@ def to_signature(self) -> MagicSignature:
         params = [
             MagicParameter.from_widget(w) for w in self if w.name and not w.gui_only
         ]
-        return MagicSignature(params, return_annotation=self._return_annotation)
+        return MagicSignature(params, return_annotation=self.return_annotation)
 
     @classmethod
     def from_signature(cls, sig: inspect.Signature, **kwargs) -> Container:

tests/test_types.py

@@ -1,9 +1,12 @@
 import pytest
 
-from magicgui import magicgui, widgets
+from magicgui import magicgui, register_type, widgets
+from magicgui.function_gui import FunctionGui
 
 
 def test_forward_refs():
+    """Test that forward refs parameter annotations get resolved."""
+
     @magicgui
     def testA(x: "tests.MyInt" = "1"):  # type: ignore  # noqa
         pass
@@ -24,3 +27,30 @@ def testA(x: "testsd.MyInt" = "1"):  # type: ignore  # noqa
             pass
 
     assert "Could not resolve the magicgui forward reference" in str(err.value)
+
+
+def test_forward_refs_return_annotation():
+    """Test that forward refs return annotations get resolved."""
+
+    @magicgui
+    def testA() -> int:
+        return 1
+
+    @magicgui
+    def testB() -> "tests.MyInt":  # type: ignore  # noqa
+        return 1
+
+    from tests import MyInt
+
+    results = []
+    register_type(MyInt, return_callback=lambda *x: results.append(x))
+
+    testA()
+    assert not results
+
+    testB()
+    gui, result, return_annotation = results[0]
+    assert isinstance(gui, FunctionGui)
+    assert result == 1
+    # the forward ref has been resolved
+    assert return_annotation is MyInt