reacton 1.10.1__tar.gz → 1.10.3__tar.gz

{reacton-1.10.1 → reacton-1.10.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: reacton
-Version: 1.10.1
+Version: 1.10.3
 Dynamic: Summary
 Project-URL: Home, https://www.github.com/widgetti/reacton
 Project-URL: Documentation, https://reacton.solara.dev

reacton-1.10.3/reacton/_version.py

@@ -0,0 +1 @@
+__version__ = "1.10.3"

{reacton-1.10.1 → reacton-1.10.3}/reacton/core.py

@@ -170,6 +170,26 @@ def close_widget(widget: widgets.Widget):
         logger.warning("Widget %r does not have a close method, possibly a close trait was added", widget)
 
 
+def _is_shared_ipyvue_template(widget: widgets.Widget) -> bool:
+    """Is this widget an ipyvue Template that is shared between VueTemplate instances?
+
+    ipyvue keeps a per-file registry of Template widgets (ipyvue/Template.py), so several
+    VueTemplate widgets can point at the same Template. Such a Template outlives the
+    VueTemplate that created it, and we must not close it as an orphan.
+    ipyvue 3 only puts a Template in that registry when there is a real comm, so an
+    unregistered Template belongs to a single VueTemplate and is a normal orphan.
+    """
+    cls = widget.__class__
+    if cls.__name__ != "Template" or cls.__module__ != "ipyvue.Template":
+        return False
+    module = sys.modules.get(cls.__module__)
+    registry = getattr(module, "template_registry", None)
+    if registry is None:
+        # unknown ipyvue version: keep the old, conservative behaviour
+        return True
+    return any(template is widget for template in registry.values())
+
+
 def _event_handler_exception_wrapper(f):
     """Wrap an event handler to catch exceptions and put them in a reacton context.
 
@@ -1322,29 +1342,33 @@ class _RenderContext:
             self._remove_element(self.element, default_key="/", parent_key=ROOT_KEY)
             logger.info("Removing elements done.")
             assert self.context is self.context_root
-        if self.container:
-            self.container.close()
-            if isinstance(self.container, widgets.DOMWidget) and self.container.layout is not None:
-                self.container.layout.close()
-        if self._shared_elements:
-            raise RuntimeError(f"Element not cleaned up: {self._shared_elements}")
-        if self._orphans:
-            orphan_widgets = set([_get_widgets_dict()[k] for k in self._orphans])
-            raise RuntimeError(f"Orphan widgets not cleaned up for widgets: {orphan_widgets}")
-        exceptions = [*self.context.exceptions_children, *self.context_root.exceptions_self]
-        # break the reference cycles through the tree (see _teardown_component_context);
-        # _closing stays True, making stray setters and event handlers no-ops
-        for context in all_contexts:
-            _teardown_component_context(context)
-        self.context = None
-        self.context_root = None  # type: ignore
-        # the root element, container and root widget keep the widget tree alive, and
-        # widgets reference their elements, whose kwargs hold user callbacks - which
-        # capture use_state setters and therefore this render context
-        self.element = None  # type: ignore
-        self.container = None
-        self.last_root_widget = None
-        self._old_element_ids.clear()
+            # everything below used to run outside the lock: a render() that was
+            # blocked on the lock could then interleave with this teardown and
+            # find self.context None mid-render (AssertionError in
+            # Element.__exit__, seen in production behind a prompt kernel close)
+            if self.container:
+                self.container.close()
+                if isinstance(self.container, widgets.DOMWidget) and self.container.layout is not None:
+                    self.container.layout.close()
+            if self._shared_elements:
+                raise RuntimeError(f"Element not cleaned up: {self._shared_elements}")
+            if self._orphans:
+                orphan_widgets = set([_get_widgets_dict()[k] for k in self._orphans])
+                raise RuntimeError(f"Orphan widgets not cleaned up for widgets: {orphan_widgets}")
+            exceptions = [*self.context.exceptions_children, *self.context_root.exceptions_self]
+            # break the reference cycles through the tree (see _teardown_component_context);
+            # _closing stays True, making stray setters and event handlers no-ops
+            for context in all_contexts:
+                _teardown_component_context(context)
+            self.context = None
+            self.context_root = None  # type: ignore
+            # the root element, container and root widget keep the widget tree alive, and
+            # widgets reference their elements, whose kwargs hold user callbacks - which
+            # capture use_state setters and therefore this render context
+            self.element = None  # type: ignore
+            self.container = None
+            self.last_root_widget = None
+            self._old_element_ids.clear()
         if exceptions:
             raise exceptions[0]
 
@@ -1528,6 +1552,35 @@ class _RenderContext:
         else:
             logger.info("No render phase triggered, already rendering")
 
+    def _discard_aborted_pass(self):
+        """Forget everything a render pass staged when it raised before reconciliation.
+
+        The *_next bookkeeping and the chained effects (previous_effect.next) of every
+        context belong to that pass. Mark every context dirty, so the next render()
+        re-executes the components and re-queues their effects from a consistent state.
+        Only for aborts in the render phase: a reconciliation that raised halfway already
+        created widgets, and those need the normal removal path.
+        """
+        # children_next is kept: it also holds contexts pre-created by state_set() (restored
+        # state), and a context created by the aborted pass owns no widgets yet, it is simply
+        # reused or pruned by the next render
+        contexts: List[ComponentContext] = [self.context_root]
+        while contexts:
+            context = contexts.pop()
+            for effect in context.effects:
+                effect.next = None
+            context.root_element_next = None
+            context.elements_next = {}
+            context.exceptions_self = []
+            context.exceptions_children = []
+            context.needs_render = True
+            context.needs_render_descendant = True
+            context.clean_subtree = False
+            contexts.extend(context.children.values())
+            contexts.extend(context.children_next.values())
+        self._shared_elements_next = set()
+        self.context = self.context_root
+
     def render(self, element: Element, container: widgets.Widget = None):
         # render + consolidate
         widget = None
@@ -1547,7 +1600,15 @@ class _RenderContext:
             self._lock_thread = threading.current_thread()
             if was_locked:
                 logger.info("Mutex released, continuing render phase")
+            if self._closing or self.context is None:
+                # close() won the race for the lock (a disconnect can close the
+                # kernel while an update was waiting to render): the tree is
+                # torn down, there is nothing to render into anymore
+                logger.info("Render requested on a closing/closed render context, ignoring")
+                return container
             prev_rc = getattr(local, "rc", None)
+            # an exception that escapes while this is True aborted a render pass (see the except below)
+            in_render_phase = True
             try:
                 local.rc = self
                 self.element = element
@@ -1623,10 +1684,12 @@ class _RenderContext:
 
                         logger.info("Render reconsolidate...")
                         self.reconsolidating = True
+                        in_render_phase = False
                         try:
                             widget = self._reconsolidate(self.element, default_key="/", parent_key=ROOT_KEY)
                         finally:
                             self.reconsolidating = False
+                        in_render_phase = True
                         logger.info("Render reconsolidate done")
                         self.context.root_element = self.context.root_element_next
                         self.context.root_element_next = None
@@ -1675,7 +1738,16 @@ class _RenderContext:
                     self._is_rendering = False
                 self.context = context_prev
                 logger.info("Done with render phase: %r", render_count)
-            except Exception as e:
+            except BaseException as e:
+                # Exceptions raised by components are collected in exceptions_self, so an
+                # exception here comes from the render machinery itself (duplicate key,
+                # hook misuse, ...) or is a cancellation, and aborted a pass halfway. Drop
+                # what that pass staged: otherwise the next render reconciles the last
+                # committed elements, but runs the effects the aborted pass chained, closed
+                # over elements that were never reconciled (get_widget then fails with
+                # "found in a previous render").
+                if in_render_phase:
+                    self._discard_aborted_pass()
                 if DEBUG:
                     # construct a fake traceback (showing how the elements were constructed)
                     if not self.tracebacks:
@@ -1815,8 +1887,13 @@ class _RenderContext:
             needs_render = context.needs_render
             if not needs_render:
                 if el_prev is not None and context_previous is context:
-                    assert not isinstance(el_prev.component, ComponentWidget)
-                    needs_render = el._arguments_changed(el_prev)
+                    if isinstance(el_prev.component, ComponentWidget):
+                        # an earlier pass of this render() call put a widget element at this
+                        # slot (elements_next), while the context is from the last reconciled
+                        # render: nothing to compare the arguments against, so render
+                        needs_render = True
+                    else:
+                        needs_render = el._arguments_changed(el_prev)
                 if context.exceptions_children:
                     # we have exceptions, so we need to render
                     needs_render = True
@@ -2156,7 +2233,7 @@ class _RenderContext:
                 if orphan_ids:
                     for orphan_widget in orphan_widgets:
                         # these are shared widgets
-                        if orphan_widget.__class__.__name__ == "Template" and orphan_widget.__class__.__module__ == "ipyvue.Template":
+                        if _is_shared_ipyvue_template(orphan_widget):
                             orphan_ids -= {orphan_widget.model_id}
                     if el.is_shared:
                         widget = self._shared_widgets[el]
@@ -2475,8 +2552,11 @@ class _RenderContextFast(_RenderContext):
 
         needs_render = context.needs_render
         if not needs_render and el_prev is not None and context_previous is context:
-            assert not isinstance(el_prev.component, ComponentWidget)
-            needs_render = el._arguments_changed(el_prev)
+            if isinstance(el_prev.component, ComponentWidget):
+                # see the classic renderer: a widget element from an earlier pass of this call
+                needs_render = True
+            else:
+                needs_render = el._arguments_changed(el_prev)
         if not needs_render and context.exceptions_children:
             # we have exceptions, so we need to render
             needs_render = True
@@ -2740,7 +2820,7 @@ class _RenderContextFast(_RenderContext):
                     orphan_widgets = set([_get_widgets_dict()[k] for k in orphan_ids])
                     for orphan_widget in orphan_widgets:
                         # these are shared between widgets
-                        if orphan_widget.__class__.__name__ == "Template" and orphan_widget.__class__.__module__ == "ipyvue.Template":
+                        if _is_shared_ipyvue_template(orphan_widget):
                             orphan_ids -= {orphan_widget.model_id}
                     widget = self._shared_widgets[el] if el.is_shared else context.widgets[key]
                     if widget.model_id not in self._orphans:

{reacton-1.10.1 → reacton-1.10.3}/reacton/core_test.py

@@ -2963,6 +2963,66 @@ def test_close_when_overridden():
     rc.close()
 
 
+def test_render_after_close_is_noop():
+    # A disconnect can close the kernel while an update is waiting on the render
+    # lock: the late render used to proceed into the torn-down tree and hit
+    # "assert rc.context is not None" in Element.__exit__ (seen in production).
+    # A render on a closed/closing context must be a no-op instead.
+    @react.component
+    def App():
+        value, _set_value = react.use_state(1)
+        return w.Label(value=str(value))
+
+    box, rc = react.render(App(), handle_error=False)
+    rc.close()
+    rc.render(App(), box)  # must not raise, must not render
+
+
+def test_close_render_race():
+    # close() in one thread while renders queue behind the lock in another:
+    # neither thread may raise (the close teardown must not interleave with a
+    # render that was blocked on the lock).
+    import threading
+
+    for _ in range(20):
+
+        @react.component
+        def App():
+            value, _set_value = react.use_state(1)
+            return w.Label(value=str(value))
+
+        box, rc = react.render(App(), handle_error=False)
+        el = App()
+        errors: List[BaseException] = []
+        barrier = threading.Barrier(2)
+
+        def do_render(rc=rc, el=el, box=box, errors=errors, barrier=barrier):
+            try:
+                barrier.wait()
+                rc.render(el, box)
+            except BaseException as e:  # noqa
+                errors.append(e)
+
+        def do_close(rc=rc, errors=errors, barrier=barrier):
+            try:
+                barrier.wait()
+                rc.close()
+            except BaseException as e:  # noqa
+                errors.append(e)
+
+        t1 = threading.Thread(target=do_render)
+        t2 = threading.Thread(target=do_close)
+        t1.start()
+        t2.start()
+        t1.join()
+        t2.join()
+        # whichever won the lock, the loser must not blow up; if render won,
+        # close ran after and the context must still close cleanly
+        if not rc._closing:
+            rc.close()
+        assert not errors, errors
+
+
 def test_render_perf_child_only():
     render_child = unittest.mock.Mock()
     render_main = unittest.mock.Mock()
@@ -3228,3 +3288,162 @@ def test_key_mutate_protection(Container):
         set_state(1)
     rc.render(w.HTML(value="recover").key("HTML"))
     rc.close()
+
+
+def test_render_nested_pass_widget_to_component_flip():
+    # One render() call, two passes: the first pass puts a widget element at a
+    # slot, a state write during that pass opens a nested pass, and the nested
+    # pass puts back the function component that held the slot in the last
+    # committed render. _render then compares the component element against
+    # the widget element left in elements_next by the first pass and trips
+    # `assert not isinstance(el_prev.component, ComponentWidget)`.
+    set_mode = cast(Callable[[str], None], None)
+
+    set_clicks = cast(Callable[[int], None], None)
+
+    @react.component
+    def Child():
+        nonlocal set_clicks
+        clicks, set_clicks = react.use_state(0)
+        return w.Button(description=f"child {clicks}")
+
+    @react.component
+    def Parent():
+        nonlocal set_mode
+        mode, set_mode = react.use_state("component")
+        if mode == "widget":
+            # a set during render opens a nested pass in the same render() call
+            set_mode("component")
+            return w.Label(description="loading")
+        return Child()
+
+    box, rc = react.render(Parent(), handle_error=False)
+    set_clicks(3)
+    assert box.children[0].description == "child 3"
+    set_mode("widget")
+    assert isinstance(box.children[0], widgets.Button)
+    # nothing was committed in between, so Child was never unmounted and keeps its state
+    assert box.children[0].description == "child 3"
+    rc.close()
+
+
+def test_render_nested_pass_flip_strands_get_widget_effect():
+    # The production chain behind the flip above (Grotto PENG-1257, through
+    # solara's RoutingProvider): the AssertionError escapes render(), and a
+    # parent that re-executed in the aborted nested pass already chained a new
+    # effect closure (previous_effect.next) over its new root element, while
+    # its root_element_next was never set. The next render that does not
+    # re-execute the parent runs that closure, and get_widget on the never
+    # reconciled root raises "was found to be in a previous render".
+    set_mode = cast(Callable[[str], None], None)
+    set_counter = cast(Callable[[int], None], None)
+    set_other = cast(Callable[[int], None], None)
+
+    @react.component
+    def Child():
+        return w.Button(description="child")
+
+    @react.component
+    def Flipper():
+        nonlocal set_mode
+        mode, set_mode = react.use_state("component")
+        if mode == "widget":
+            # a set during render opens a nested pass, and the parent's state
+            # changes too, so the parent re-executes in that nested pass
+            # (in production: a router.push from a subscriber)
+            set_counter(1)
+            set_mode("component")
+            return w.Label(description="loading")
+        return Child()
+
+    @react.component
+    def Other():
+        nonlocal set_other
+        value, set_other = react.use_state(0)
+        return w.Label(description=f"other {value}")
+
+    @react.component
+    def Parent():
+        nonlocal set_counter
+        _counter, set_counter = react.use_state(0)
+
+        def effect():
+            react.get_widget(root)
+
+        react.use_effect(effect)
+        root = w.VBox(children=[Flipper(), Other()])
+        return root
+
+    box, rc = react.render(Parent(), handle_error=False)
+    root = box.children[0]
+    assert root.children[1].description == "other 0"
+    try:
+        set_mode("widget")
+    except AssertionError:
+        # the first stage, covered by test_render_nested_pass_widget_to_component_flip
+        pass
+    # an unrelated state change must not run a stale effect closure
+    set_other(1)
+    assert root.children[1].description == "other 1"
+    rc.close()
+
+
+@pytest.mark.parametrize("abort_in", ["first_pass", "nested_pass"])
+def test_render_escaped_exception_strands_chained_effect(abort_in):
+    # An exception raised by reacton's own bookkeeping inside _render (here a
+    # duplicate key) escapes render() and leaves the tree half updated: a
+    # component that re-executed in the aborted pass already chained a new
+    # effect closure (previous_effect.next) over the elements of that pass, but
+    # its root_element_next was never set. The next render that does not
+    # re-execute that component runs the chained effect against elements that
+    # were never reconciled; with get_widget that is the
+    # "was found to be in a previous render" KeyError.
+    # (Seen in production through solara's RoutingProvider, which calls
+    # get_widget(main) from an effect without dependencies.)
+    set_dup = cast(Callable[[bool], None], None)
+    set_other = cast(Callable[[int], None], None)
+    set_counter = cast(Callable[[int], None], None)
+
+    @react.component
+    def Other():
+        nonlocal set_other
+        value, set_other = react.use_state(0)
+        return w.Label(description=f"other {value}")
+
+    @react.component
+    def Dup(dup: bool, counter: int):
+        aborted = react.use_ref(False)
+        if dup and counter == 0 and abort_in == "nested_pass":
+            # make the parent re-execute in a nested pass of this render() call
+            set_counter(1)
+        abort_now = counter == (1 if abort_in == "nested_pass" else 0)
+        if dup and abort_now and not aborted.current:
+            # abort this pass with an exception from reacton's bookkeeping
+            aborted.current = True
+            return w.VBox(children=[w.Label(description="a").key("dup"), w.Label(description="b").key("dup")])
+        return w.Label(description="no dup")
+
+    @react.component
+    def Parent():
+        nonlocal set_dup, set_counter
+        dup, set_dup = react.use_state(False)
+        counter, set_counter = react.use_state(0)
+
+        def effect():
+            react.get_widget(root)
+
+        react.use_effect(effect)
+        root = w.VBox(children=[Other(), Dup(dup, counter)])
+        return root
+
+    box, rc = react.render(Parent(), handle_error=False)
+    root = box.children[0]
+    assert root.children[0].description == "other 0"
+    # pass 1: Dup bumps the counter, nested pass: Parent re-executes and chains
+    # a new effect closure over its new root, then Dup aborts the pass
+    with pytest.raises(KeyError, match="Duplicate key"):
+        set_dup(True)
+    # an unrelated state change must not run a stale effect closure
+    set_other(1)
+    assert root.children[0].description == "other 1"
+    rc.close()

reacton-1.10.1/reacton/_version.py

@@ -1 +0,0 @@
-__version__ = "1.10.1"