reacton 1.10.2__tar.gz → 1.10.4__tar.gz

{reacton-1.10.2 → reacton-1.10.4}/PKG-INFO

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

reacton-1.10.4/reacton/_version.py

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

{reacton-1.10.2 → reacton-1.10.4}/reacton/core.py

@@ -7,11 +7,13 @@ ReactJS - ipywidgets relation:
 
 """
 
+import collections
 import contextlib
 import copy
 import functools
 import inspect
 import logging
+import os
 import sys
 import threading
 import traceback
@@ -24,6 +26,7 @@ from typing import (
     Any,
     Callable,
     ContextManager,
+    Deque,
     Dict,
     Generic,
     List,
@@ -170,6 +173,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.
 
@@ -187,6 +210,10 @@ def _event_handler_exception_wrapper(f):
             # we add it to exceptions_children, not exception_self
             # this allows a component to catch the exception of a direct child
             context.exceptions_children.append(e)
+            # force_update walks the whole tree, but when another thread is rendering it
+            # only sets a flag that this render may clear: mark the path to this context
+            # so the fast renderer does not skip it on the next render
+            _mark_needs_render_ancestors(context)
             rc.force_update()
 
     return wrapper
@@ -211,8 +238,12 @@ def same_component(c1, c2):
 
 def _mark_needs_render_ancestors(context: "ComponentContext"):
     """Let the render phase find its way down to a context that needs work, without walking subtrees that do not."""
+    # walk up to the root: stopping at the first ancestor that is already marked would
+    # assume its ancestors are marked too, which does not hold for a subtree that is
+    # being removed (it can carry a flag from before), so the live ancestors above it
+    # would stay unmarked and skip e.g. a cleanup exception
     parent = context.parent
-    while parent is not None and not parent.needs_render_descendant:
+    while parent is not None:
         parent.needs_render_descendant = True
         parent = parent.parent
 
@@ -235,6 +266,34 @@ def _values_identical(a, b):
     return False
 
 
+_missing = object()
+
+
+def _widget_holds_values(widget: widgets.Widget, kwargs: Dict[str, Any]) -> bool:
+    """Does the widget already hold these (resolved) kwargs, so that setting them is a no-op?
+
+    Only for the same element as last render: its event listeners are the same callbacks,
+    and no argument was dropped. Compares by identity, where a list and a tuple with the
+    same items count as the same (a Tuple trait stores a list as a tuple).
+    """
+    for name, value in kwargs.items():
+        if name.startswith("on_") and not widget.has_trait(name):
+            continue
+        if not _value_held(value, getattr(widget, name, _missing)):
+            return False
+    return True
+
+
+def _value_held(value, held) -> bool:
+    if value is held:
+        return True
+    if isinstance(value, (list, tuple)):
+        return type(held) in (list, tuple) and len(value) == len(held) and all(_value_held(x, y) for x, y in zip(value, held))
+    if type(value) is dict:
+        return type(held) is dict and len(value) == len(held) and all(k in held and _value_held(v, held[k]) for k, v in value.items())
+    return False
+
+
 def _with_tracebacks(e, tracebacks):
     # copy it, and we need with_traceback for unknown reasons not to cause
     # an infinite loop
@@ -1146,6 +1205,11 @@ class ComponentContext:
     # the render phase skipped this whole subtree (nothing changed), so the
     # reconciliation phase can reuse the previous result without walking
     clean_subtree: bool = False
+    # Fast renderer only: stale component effect cleanups are run at the same
+    # point where the default renderer removes stale elements, while widget
+    # closing stays deferred to the fast renderer's stale sweep.
+    fast_stale_effect_keys: Optional[List[str]] = None
+    fast_stale_effects_cleaned: Set[str] = field(default_factory=set)
 
     # elements created in this context go there
     owns: Set[Element] = field(default_factory=set)
@@ -1204,6 +1268,8 @@ def _teardown_component_context(context: ComponentContext):
     context.exceptions_self = []
     context.exceptions_children = []
     context.context_managers = []
+    context.fast_stale_effect_keys = None
+    context.fast_stale_effects_cleaned = set()
 
 
 @dataclass
@@ -1240,6 +1306,30 @@ class Effect:
 
 class _RenderContext:
     context: Optional[ComponentContext] = None
+    # the element that an element of another type replaces, and its context, while
+    # reconciliation removes it (see _remove_replaced)
+    _replaced: Optional[Tuple[ComponentContext, Element]] = None
+
+    def _remove_replaced(self, el_prev: Element, key: str, parent_key: str):
+        """Remove the element at key, which an element of another type replaces."""
+        assert self.context is not None
+        replaced = self._replaced
+        self._replaced = (self.context, el_prev)
+        try:
+            self._remove_element(el_prev, key, parent_key=parent_key)
+        finally:
+            self._replaced = replaced
+
+    def _keep_keyed_child(self, context: ComponentContext, el: Element, key: str) -> bool:
+        # An explicit key is the same in any container of a component, so a child with an
+        # explicit key that the new tree still uses (it moved out of the replaced element, or
+        # stays under the new one) is not removed with the replaced element: reconciliation
+        # updates it where the new tree has it. Shared elements keep the old behavior: their
+        # bookkeeping (_shared_elements, _shared_widgets) needs the removal.
+        replaced = self._replaced
+        return (
+            replaced is not None and context is replaced[0] and el is not replaced[1] and el._key is not None and not el.is_shared and key in context.used_keys
+        )
 
     def __init__(self, element: Element, container: widgets.Widget = None, children_trait="children", handle_error: bool = True, initial_state=None):
         self.element = element
@@ -1254,7 +1344,11 @@ class _RenderContext:
         self.last_root_widget: widgets.Widget = None
         self._is_rendering = False
         self._rerender_needed = False
-        self._rerender_needed_reasons: List[RerenderReason] = []
+        # the reasons are only read for the "too many renders" error message, and a reason
+        # holds the previous and next state value: keeping all of them kept every old state
+        # value alive until close(). REACTON_RERENDER_REASONS keeps more, for debugging.
+        max_reasons = max(1, int(os.environ.get("REACTON_RERENDER_REASONS", "2")))
+        self._rerender_needed_reasons: Deque[RerenderReason] = collections.deque(maxlen=max_reasons)
         self.thread_lock = threading.Lock()
         self._closing = False
         self.tracebacks: List[TracebackType] = []
@@ -1532,6 +1626,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
@@ -1558,6 +1681,8 @@ class _RenderContext:
                 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
@@ -1603,10 +1728,10 @@ class _RenderContext:
                                         f += f"Triggered at: {''.join(reason.trigger_stack)}\n"
                                     return f
 
-                                self._rerender_needed_reasons[-1]
                                 msg = f"Too many renders triggered, your render loop does not stop\nLast reason: {format(self._rerender_needed_reasons[-1])}\n"
                                 if len(self._rerender_needed_reasons) >= 2:
-                                    msg += f"Previous reasons: {format(self._rerender_needed_reasons[-2])}\n"
+                                    previous = reversed(list(self._rerender_needed_reasons)[:-1])
+                                    msg += f"Previous reasons: {''.join(format(reason) for reason in previous)}\n"
                                 raise RuntimeError(msg)
                             logger.info("Entering nested render phase: %r", self._rerender_needed_reasons[-1])
                             self._rerender_needed = False
@@ -1633,10 +1758,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
@@ -1685,7 +1812,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:
@@ -1698,6 +1834,10 @@ class _RenderContext:
             finally:
                 local.rc = prev_rc  # type: ignore
                 self._is_rendering = False
+                # clear before the lock is released: a stale _lock_thread makes the
+                # recursion guard above fire for a thread that merely rendered last,
+                # while a *different* thread holds the lock (false "Recursive render")
+                self._lock_thread = None
                 assert self.context is self.context_root
 
         exceptions = [*self.context.exceptions_children, *self.context_root.exceptions_self]
@@ -1825,8 +1965,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
@@ -1973,7 +2118,7 @@ class _RenderContext:
         try:
             if isinstance(el.component, ComponentFunction):
                 if el_prev and isinstance(el_prev.component, ComponentWidget):
-                    self._remove_element(el_prev, default_key=key, parent_key=parent_key)
+                    self._remove_replaced(el_prev, key, parent_key=parent_key)
                 new_parent_key = join_key(parent_key, key)
                 try:
                     # TODO: test suite passes when this block if commented out
@@ -2034,6 +2179,7 @@ class _RenderContext:
                                     try:
                                         effect.cleanup()
                                     except BaseException as e:
+                                        logger.exception("Effect cleanup %r raised exception %r", effect.callable, e)
                                         context.exceptions_self.append(e)
                                         self._rerender_needed_reasons.append(RerenderReason(reason="Exception ocurred during effect"))
                                         self._rerender_needed = True
@@ -2045,6 +2191,7 @@ class _RenderContext:
                                         continue
                                     effect()
                                 except BaseException as e:
+                                    logger.exception("Effect %r raised exception %r", effect.callable, e)
                                     context.exceptions_self.append(e)
                                     self._rerender_needed_reasons.append(RerenderReason(reason="Exception ocurred during effect"))
                                     self._rerender_needed = True
@@ -2056,6 +2203,7 @@ class _RenderContext:
                                     continue
                                 effect()
                             except BaseException as e:
+                                logger.exception("Effect %r raised exception %r", effect.callable, e)
                                 context.exceptions_self.append(e)
                                 self._rerender_needed_reasons.append(RerenderReason(reason="Exception ocurred during effect"))
                                 self._rerender_needed = True
@@ -2147,7 +2295,7 @@ class _RenderContext:
                 else:
                     assert el_prev is not None, "widget_previous is not None, but el_prev is"
                     logger.debug("Replacing widget: %r → %r %r", el_prev, el, key)
-                    self._remove_element(el_prev, key, parent_key=parent_key)
+                    self._remove_replaced(el_prev, key, parent_key=parent_key)
                     kwargs = reconsolidate_children()
                     widget = None
                     if not context.exceptions_children:
@@ -2166,7 +2314,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]
@@ -2243,6 +2391,9 @@ class _RenderContext:
         context = self.context
         logger.debug("Remove: (%s, %s) %r", parent_key, key, el)
 
+        if self._keep_keyed_child(context, el, key):
+            return
+
         if el.is_shared:
             if el not in self._shared_elements:
                 return
@@ -2269,6 +2420,7 @@ class _RenderContext:
                         if not effect._cleaned_up:
                             effect.cleanup()
                     except BaseException as e:
+                        logger.exception("Effect cleanup %r raised exception %r", effect.callable, e)
                         child_context.exceptions_self.append(e)
                         self._rerender_needed_reasons.append(RerenderReason(reason="Exception ocurred during effect"))
                         self._rerender_needed = True
@@ -2379,10 +2531,20 @@ class _RenderContextFast(_RenderContext):
     # without walking either.
     # ------------------------------------------------------------------
 
+    # > 0 while the render phase walks the new children of a widget, or the arguments of a
+    # shared element, that replaces an element of another type (see _render_arguments)
+    _replacing = 0
+
     def _set_rerender_needed(self, reason: str):
         self._rerender_needed_reasons.append(RerenderReason(reason=reason))
         self._rerender_needed = True
 
+    def _has_effect_work(self, context: "ComponentContext") -> bool:
+        for effect in context.effects:
+            if not effect.executed or effect.next is not None:
+                return True
+        return False
+
     def _render(self, element: Element, default_key: str, parent_key: str):
         if not isinstance(element, Element):
             raise TypeError(f"Expected element, not {element}")
@@ -2395,6 +2557,8 @@ class _RenderContextFast(_RenderContext):
             # the root element of a component determines which keys are in use,
             # everything else is stale and gets removed during reconciliation
             context.used_keys.clear()
+            context.fast_stale_effect_keys = None
+            context.fast_stale_effects_cleaned.clear()
 
         el = element
         key = el._key
@@ -2427,7 +2591,7 @@ class _RenderContextFast(_RenderContext):
                 del context.children_next[key]
             # the element arguments are part of this component's element tree
             if el.kwargs:
-                self._visit_children(el, key, parent_key, self._render)
+                self._render_arguments(el, key, parent_key)
             return
 
         assert isinstance(el.component, ComponentFunction)
@@ -2435,7 +2599,7 @@ class _RenderContextFast(_RenderContext):
             # arguments of a shared element belong to the context it is rendered in;
             # for non-shared component elements the component function decides
             # what ends up in the tree
-            self._visit_children(el, key, parent_key, self._render)
+            self._render_arguments(el, key, parent_key)
 
         context_previous = context.children_next.get(key)
         if context_previous is None:
@@ -2445,10 +2609,12 @@ class _RenderContextFast(_RenderContext):
             not self._walk_all
             and el is el_prev
             and not el.is_shared
+            and not self._replacing
             and context_previous is not None
             and context.children.get(key) is context_previous
             and not context_previous.needs_render
             and not context_previous.needs_render_descendant
+            and not self._has_effect_work(context_previous)
             and not context_previous.exceptions_self
             and not context_previous.exceptions_children
             and context_previous.root_element is not None
@@ -2485,8 +2651,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
@@ -2627,7 +2796,7 @@ class _RenderContextFast(_RenderContext):
 
                 if el_prev and isinstance(el_prev.component, ComponentWidget):
                     # a widget element was replaced by a component element at this key
-                    self._remove_element(el_prev, default_key=key, parent_key=parent_key)
+                    self._remove_replaced(el_prev, key, parent_key=parent_key)
                 new_parent_key = join_key(parent_key, key)
                 try:
                     if el.is_shared and (el.args or el.kwargs):
@@ -2720,20 +2889,22 @@ class _RenderContextFast(_RenderContext):
                     # update the existing widget in place
                     kwargs = self._visit_children_values(el.kwargs, key, parent_key, self._reconsolidate)
                     if not context.exceptions_children:
-                        if el is not el_prev or not _values_identical(kwargs, el.kwargs):
+                        # the same element whose kwargs hold no elements: nothing can have changed.
+                        # With elements (a container), the kwargs resolve to widgets, so compare
+                        # them with what the widget holds: equal means setting them is a no-op
+                        # (and a value changed from the frontend is still set back)
+                        if el is not el_prev or not (_values_identical(kwargs, el.kwargs) or _widget_holds_values(widget_previous, kwargs)):
                             try:
                                 el._update_widget(widget_previous, el_prev, kwargs)
                             except BaseException as e:
                                 context.exceptions_self.append(e)
                                 self._set_rerender_needed("Exception ocurred during reconciliation (updating widget)")
                                 _mark_needs_render_ancestors(context)
-                        # else: identical element and all children reconciled to the
-                        # same widgets, nothing can have changed
                     self._store_widget(context, el, key, widget_previous)
                 else:
                     assert el_prev is not None, "widget_previous is not None, but el_prev is"
                     # a different widget type at the same key: replace
-                    self._remove_element(el_prev, key, parent_key=parent_key)
+                    self._remove_replaced(el_prev, key, parent_key=parent_key)
                     kwargs = self._visit_children_values(el.kwargs, key, parent_key, self._reconsolidate)
                     widget = None
                     if not context.exceptions_children:
@@ -2750,7 +2921,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:
@@ -2788,6 +2959,7 @@ class _RenderContextFast(_RenderContext):
                 self._shared_elements.add(el)
                 assert el in self._shared_elements_next
                 self._shared_elements_next.remove(el)
+            self._cleanup_stale_effects_for_context(context, parent_key)
 
     def _process_effects(self, child_context: "ComponentContext", context: "ComponentContext"):
         # NOTE: effect/cleanup exceptions are recorded on the context of the
@@ -2806,6 +2978,7 @@ class _RenderContextFast(_RenderContext):
                     try:
                         effect.cleanup()
                     except BaseException as e:
+                        logger.exception("Effect cleanup %r raised exception %r", effect.callable, e)
                         context.exceptions_self.append(e)
                         self._set_rerender_needed("Exception ocurred during effect")
                         _mark_needs_render_ancestors(context)
@@ -2817,6 +2990,7 @@ class _RenderContextFast(_RenderContext):
             try:
                 effect()
             except BaseException as e:
+                logger.exception("Effect %r raised exception %r", effect.callable, e)
                 context.exceptions_self.append(e)
                 self._set_rerender_needed("Exception ocurred during effect")
                 _mark_needs_render_ancestors(context)
@@ -2828,6 +3002,64 @@ class _RenderContextFast(_RenderContext):
         else:
             context.widgets[key] = widget
 
+    def _cleanup_stale_effects_for_context(self, context: "ComponentContext", parent_key: str):
+        if context.fast_stale_effect_keys is None:
+            # reversed, so we can pop from the end and still go in sorted order
+            context.fast_stale_effect_keys = sorted(set(context.elements) - context.used_keys, reverse=True)
+        context_prev = self.context
+        try:
+            while context.fast_stale_effect_keys:
+                stale_key = context.fast_stale_effect_keys.pop()
+                if stale_key not in context.elements or stale_key in context.fast_stale_effects_cleaned:
+                    continue
+                self.context = context
+                self._cleanup_stale_effects(context.elements[stale_key], stale_key, parent_key)
+        finally:
+            self.context = context_prev
+
+    def _cleanup_stale_effects(self, el: Element, default_key: str, parent_key: str):
+        key = el._key
+        if key is None:
+            key = default_key
+        assert key is not None
+        context = self.context
+        assert context is not None
+        if key in context.fast_stale_effects_cleaned:
+            return
+        if el.is_shared and (el in self._shared_elements_next or el not in self._shared_elements):
+            return
+        context.fast_stale_effects_cleaned.add(key)
+
+        if isinstance(el.component, ComponentFunction):
+            if el.is_shared:
+                self._visit_children(el, key, parent_key, self._cleanup_stale_effects)
+            child_context = context.children.get(key)
+            if child_context is None:
+                return
+            try:
+                self.context = child_context
+                child_context.exceptions_self = []
+                child_context.exceptions_children = []
+                for effect in child_context.effects:
+                    try:
+                        if not effect._cleaned_up:
+                            effect.cleanup()
+                    except BaseException as e:
+                        effect._cleaned_up = True
+                        logger.exception("Effect cleanup %r raised exception %r", effect.callable, e)
+                        child_context.exceptions_self.append(e)
+                        self._set_rerender_needed("Exception ocurred during effect")
+                        _mark_needs_render_ancestors(child_context)
+                assert child_context.root_element is not None
+                self._cleanup_stale_effects(child_context.root_element, "/", parent_key=join_key(parent_key, key))
+            finally:
+                self.context = context
+            if child_context.exceptions_self or child_context.exceptions_children and not child_context.exception_handler:
+                context.exceptions_children.extend(child_context.exceptions_self)
+                context.exceptions_children.extend(child_context.exceptions_children)
+        else:
+            self._visit_children(el, key, parent_key, self._cleanup_stale_effects)
+
     def _remove_element(self, el: Element, default_key: str, parent_key):
         key = el._key
         if key is None:
@@ -2836,6 +3068,9 @@ class _RenderContextFast(_RenderContext):
         context = self.context
         assert context is not None
 
+        if self._keep_keyed_child(context, el, key):
+            return
+
         if el.is_shared:
             if el not in self._shared_elements:
                 # another use of this element keeps it alive, or it was already removed
@@ -2860,6 +3095,7 @@ class _RenderContextFast(_RenderContext):
                         if not effect._cleaned_up:
                             effect.cleanup()
                     except BaseException as e:
+                        logger.exception("Effect cleanup %r raised exception %r", effect.callable, e)
                         child_context.exceptions_self.append(e)
                         self._set_rerender_needed("Exception ocurred during effect")
                         _mark_needs_render_ancestors(child_context)
@@ -2931,6 +3167,21 @@ class _RenderContextFast(_RenderContext):
         else:
             return value
 
+    def _render_arguments(self, el: Element, key: str, parent_key: str):
+        """Render the elements in the arguments of a widget element or a shared element."""
+        assert self.context is not None
+        el_reconciled = self.context.elements.get(key)
+        replaced = el_reconciled is not None and el_reconciled.component != el.component
+        if replaced:
+            # a different component at this key: reconciliation removes the old element and
+            # everything below it, so nothing below the new one may be skipped as clean
+            self._replacing += 1
+        try:
+            self._visit_children(el, key, parent_key, self._render)
+        finally:
+            if replaced:
+                self._replacing -= 1
+
     def _remove_stale_root_elements(self, parent_key):
         # remove stale elements of the root context itself
         # (child contexts are swept during their reconciliation)
@@ -2941,8 +3192,6 @@ class _RenderContextFast(_RenderContext):
 
 
 def _render_context_class():
-    import os
-
     return _RenderContextFast if os.environ.get("REACTON_FAST") == "1" else _RenderContext