reacton 1.10.5__tar.gz → 1.11.0__tar.gz

{reacton-1.10.5 → reacton-1.11.0}/PKG-INFO

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

reacton-1.11.0/reacton/_version.py

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

{reacton-1.10.5 → reacton-1.11.0}/reacton/core.py

@@ -88,30 +88,43 @@ _get_widgets_dict = _widgets_dict_getter()
 # via the widget constructed hook: diffing the global widgets dict per widget
 # creation is O(total widgets), and solara replaces that dict with a context
 # aware mapping we should not depend on.
-_construction_recording: Optional[List["widgets.Widget"]] = None
+# The recording is per thread, so no lock is held while a widget is constructed:
+# construction opens a comm, and in a server that send can wait for a slow client,
+# which with a process wide lock stalled widget creation on every other thread.
+class _ConstructionRecording(threading.local):
+    # where the widgets constructed on this thread go, between _start_recording_constructed and
+    # _stop_recording_constructed
+    constructed: Optional[List["widgets.Widget"]] = None
+
+
+_construction_recording = _ConstructionRecording()
 _chained_construction_callback: Optional[Callable] = None
 
 
 def _record_constructed_widget(widget: "widgets.Widget"):
-    if _construction_recording is not None:
-        _construction_recording.append(widget)
+    constructed = _construction_recording.constructed
+    if constructed is not None:
+        constructed.append(widget)
     if _chained_construction_callback is not None:
         _chained_construction_callback(widget)
 
 
-def _start_recording_constructed(recording: List["widgets.Widget"]):
-    global _construction_recording, _chained_construction_callback
+def _start_recording_constructed(recording: List["widgets.Widget"]) -> Optional[List["widgets.Widget"]]:
+    """Record the widgets this thread constructs; returns what to pass to _stop_recording_constructed."""
+    global _chained_construction_callback
     current = getattr(widgets.Widget, "_widget_construction_callback", None)
     if current is not _record_constructed_widget:
         # first time, or someone else registered a callback after us: chain it
         _chained_construction_callback = current
         widgets.Widget.on_widget_constructed(_record_constructed_widget)
-    _construction_recording = recording
+    # a widget whose constructor renders records in its own list; the outer recording continues afterwards
+    previous = _construction_recording.constructed
+    _construction_recording.constructed = recording
+    return previous
 
 
-def _stop_recording_constructed():
-    global _construction_recording
-    _construction_recording = None
+def _stop_recording_constructed(previous: Optional[List["widgets.Widget"]]):
+    _construction_recording.constructed = previous
 
 
 _last_rc = None  # used for testing
@@ -334,7 +347,6 @@ class Element(Generic[W]):
     # to make every unique on_value callback to a unique wrapper
     # so that we can remove the listeners
     _callback_wrappers: Dict[Tuple[str, str, Callable], Callable] = {}
-    create_lock: ContextManager = threading.Lock()
     _shared = False
 
     def __init__(self, component, args=None, kwargs=None):
@@ -499,32 +511,30 @@ class Element(Generic[W]):
         # we can't use our own kwarg, since that contains elements, not widgets
         kwargs, listeners = self._split_kwargs(kwargs)
         assert isinstance(self.component, ComponentWidget)
-        # The recording is global state, so we need a lock.
-        with self.create_lock:
-            rc = get_render_context(required=True)
-            recorded: List[widgets.Widget] = []
-            _start_recording_constructed(recorded)
+        rc = get_render_context(required=True)
+        recorded: List[widgets.Widget] = []
+        previous_recording = _start_recording_constructed(recorded)
+        try:
             try:
-                try:
-                    widget = self.component.widget(**kwargs)
-                    hold_trait_notifications = widget.hold_trait_notifications
-
-                    @contextlib.contextmanager
-                    def hold_trait_notifications_extra(*args, **kwargs):
-                        with rc, hold_trait_notifications(*args, **kwargs):
-                            yield
-
-                    widget.hold_trait_notifications = hold_trait_notifications_extra
-
-                    if self._meta:
-                        widget._react_meta = dict(self._meta)
-                except Exception as e:
-                    raise RuntimeError(f"Could not create widget {self.component.widget} with {kwargs}") from e
-                for name, callback in listeners.items():
-                    if callback is not None:
-                        self._add_widget_event_listener(widget, name, callback)
-            finally:
-                _stop_recording_constructed()
+                widget = self.component.widget(**kwargs)
+                hold_trait_notifications = widget.hold_trait_notifications
+
+                @contextlib.contextmanager
+                def hold_trait_notifications_extra(*args, **kwargs):
+                    with rc, hold_trait_notifications(*args, **kwargs):
+                        yield
+
+                widget.hold_trait_notifications = hold_trait_notifications_extra
+
+                if self._meta:
+                    widget._react_meta = dict(self._meta)
+            except Exception as e:
+                raise RuntimeError(f"Could not create widget {self.component.widget} with {kwargs}") from e
+            for name, callback in listeners.items():
+                if callback is not None:
+                    self._add_widget_event_listener(widget, name, callback)
+        finally:
+            _stop_recording_constructed(previous_recording)
         widgets_dict = _get_widgets_dict()
         orphans = {w.model_id for w in recorded if w is not widget and w.comm is not None and w.model_id in widgets_dict}
         return widget, orphans
@@ -1334,6 +1344,9 @@ class _RenderContext:
 
     def __init__(self, element: Element, container: widgets.Widget = None, children_trait="children", handle_error: bool = True, initial_state=None):
         self.element = element
+        # the last requested root element: the thread that holds the render lock copies it to
+        # self.element at the start of each pass (see render)
+        self._element_next = element
         self.container = container
         self.children_next_trait = children_trait
         self.first_render = True
@@ -1345,6 +1358,9 @@ class _RenderContext:
         self.last_root_widget: widgets.Widget = None
         self._is_rendering = False
         self._rerender_needed = False
+        self._state_set_by_other_thread = False
+        # used for tests only: called when a render loop is done, right after its last look at _rerender_needed
+        self._on_render_loop_done: Optional[Callable[[], None]] = None
         # 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.
@@ -1400,15 +1416,27 @@ class _RenderContext:
     _find = find  # for backward compatibility
 
     def close(self):
+        # close() waits for the render lock, so it cannot run in its own render: it would wait for itself
+        if self._lock_thread == threading.current_thread():
+            raise RuntimeError("close() called during a render of this render context, current thread: %r" % threading.current_thread())
+        if self._closing:
+            # closed or closing: a second close(), or an effect cleanup that calls close() during close()
+            return
         with self.thread_lock:
+            if self._closing:
+                return  # another thread closed us while we waited for the lock
             self._closing = True
             # snapshot the component contexts before _remove_element detaches them from
             # their parents: detached contexts would escape the teardown below while the
             # setter/handler closures in their state still reference them and us
-            all_contexts: List[ComponentContext] = []
+            # by id: after a failed render, a context can be in both children and children_next, and
+            # a visit per path to it is 2**depth visits
+            all_contexts: Dict[int, ComponentContext] = {}
 
             def collect(context: ComponentContext):
-                all_contexts.append(context)
+                if id(context) in all_contexts:
+                    return
+                all_contexts[id(context)] = context
                 for child in list(context.children.values()) + list(context.children_next.values()):
                     collect(child)
 
@@ -1433,7 +1461,7 @@ class _RenderContext:
             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:
+            for context in all_contexts.values():
                 _teardown_component_context(context)
             self.context = None
             self.context_root = None  # type: ignore
@@ -1441,6 +1469,7 @@ class _RenderContext:
             # 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._element_next = None  # type: ignore
             self.container = None
             self.last_root_widget = None
             self._old_element_ids.clear()
@@ -1564,6 +1593,9 @@ class _RenderContext:
                 # TODO: enable
                 context.needs_render = True
                 _mark_needs_render_ancestors(context)
+                if self._lock_thread is not threading.current_thread():
+                    # not part of the render loop of the thread that renders (see render)
+                    self._state_set_by_other_thread = True
                 if self._rerender_needed is False:
                     if DEBUG:
                         trigger_stack = traceback.format_stack()
@@ -1590,8 +1622,13 @@ class _RenderContext:
             return
         # a forced update re-walks the whole tree, no subtree skipping
         self._walk_all = True
+        # mark before we look at _is_rendering, like a setter: a render that is ending then sees the
+        # mark after it released the lock (see render), or we see that no render runs
+        if self._rerender_needed is False:
+            self._rerender_needed_reasons.append(RerenderReason(reason="forced update"))
+            self._rerender_needed = True
         if not self._is_rendering:
-            self.render(self.element, self.container)
+            self.render()
 
     def use_effect(self, effect: EffectCallable, dependencies=None):
         assert self.context is not None
@@ -1613,17 +1650,13 @@ class _RenderContext:
             self.context.effect_index += 1
 
     def update(self, element: Element):
-        self._walk_all = True
-        if self._is_rendering:
-            self.element = element
-            self._rerender_needed_reasons.append(RerenderReason(reason="root element changed"))
-            self._rerender_needed = True
-        else:
-            self.render(element, self.container)
+        # the element first: force_update marks, and the render takes _element_next after it saw the mark
+        self._element_next = element
+        self.force_update()
 
     def _possible_rerender(self):
         if not self._is_rendering and self._batch_counter.current() == 0:
-            self.render(self.element, self.container)
+            self.render()
         else:
             logger.info("No render phase triggered, already rendering")
 
@@ -1640,8 +1673,12 @@ class _RenderContext:
         # 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]
+        seen: Set[int] = set()  # a context can be in both children and children_next (see close)
         while contexts:
             context = contexts.pop()
+            if id(context) in seen:
+                continue
+            seen.add(id(context))
             for effect in context.effects:
                 effect.next = None
             context.root_element_next = None
@@ -1656,41 +1693,60 @@ class _RenderContext:
         self._shared_elements_next = set()
         self.context = self.context_root
 
-    def render(self, element: Element, container: widgets.Widget = None):
+    def render(self, element: Optional[Element] = None, container: widgets.Widget = None):
         # render + consolidate
+        # We never wait for the render lock: the caller may hold a lock that the render needs (a
+        # deadlock). So we first mark the request, then only try the lock. When another thread holds
+        # it, that thread renders the request: it takes _element_next at the start of each pass, and
+        # looks at _rerender_needed again after it released the lock (below).
+        widget, rendered = self._render_once(element, container)
+        # A request from another thread (a setter, update(), render()) sets _rerender_needed, and leaves
+        # the render to us while we render or hold the render lock. We released the lock, and look again
+        # now: either we see the request here, or that thread got the lock and renders it itself. A loop,
+        # not a recursion: this can repeat many times in a row while another thread changes state.
+        while rendered and self._rerender_needed and not self._is_rendering and self._batch_counter.current() == 0:
+            widget, rendered = self._render_once(None, container)
+        return widget
+
+    def _render_once(self, element: Optional[Element], container: widgets.Widget) -> Tuple[Any, bool]:
+        # returns the root widget, and whether we rendered (False: another thread holds the render
+        # lock and renders our request, or we are closed, or we rendered an error message)
+        if self._lock_thread == threading.current_thread():
+            raise RuntimeError("Recursive render detected (avoided deadlock), current thread: %r" % threading.current_thread())
         widget = None
         if container is None:
             container = self.container
-        was_locked = False
-        if self.thread_lock.locked():
-            if self._lock_thread == threading.current_thread():
-                raise RuntimeError("Recursive render detected (avoided deadlock), current thread: %r" % threading.current_thread())
-            logger.info(
-                "Render phase still in progress, waiting for mutex to release (locked obtained by %r, we are in thread %r)",
-                self._lock_thread,
-                threading.current_thread(),
-            )
-            was_locked = True
-        with self.thread_lock:
+        if element is not None:
+            self._element_next = element
+        if self._rerender_needed is False:
+            self._rerender_needed_reasons.append(RerenderReason(reason="render requested"))
+            self._rerender_needed = True
+        locked = False
+        try:
+            # acquire inside the try, in one statement with the assignment: an exception raised
+            # on the next line (an interrupt, a cancel from a trace function) still releases the lock
+            locked = self.thread_lock.acquire(blocking=False)
+            if not locked:
+                logger.info("Render phase in progress in thread %r, leaving the render to it", self._lock_thread)
+                return container, False
             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
+                return container, False
             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
-                del element
                 main_render_phase = not self._is_rendering
                 render_count = self.render_count  # make a copy
+                # clear before taking the element: a request that comes in between is seen by the loop
                 self._rerender_needed = False
+                self._state_set_by_other_thread = False
+                self.element = self._element_next
                 logger.info("Render phase: %r %r of %r", self.render_count, "main" if main_render_phase else "(nested)", self.element)
                 self.render_count += 1
                 self._is_rendering = True
@@ -1715,11 +1771,18 @@ class _RenderContext:
                 if main_render_phase:
                     stable = False
                     render_counts = 0
+                    render_limit = 50
                     while not stable and not self.context_root.exceptions_children:
                         # we started the rendering loop (main_render_phase is True), so we keep going
                         # but if an exception bubbled up, we should stop
                         while self._rerender_needed and not self.context_root.exceptions_children:
-                            if render_counts > 50:
+                            if self._state_set_by_other_thread:
+                                # another thread changed state during a pass (a progress update for
+                                # instance): that is not a render loop of our own, so allow more passes.
+                                # But not without end: our caller would not return, and close() waits.
+                                self._state_set_by_other_thread = False
+                                render_limit = 100
+                            if render_counts > render_limit:
 
                                 def format(reason: RerenderReason):
                                     f = f"Reason: {reason.reason}\nValue changed from {reason.prev_value} to {reason.next_value}\n"
@@ -1729,13 +1792,17 @@ class _RenderContext:
                                         f += f"Triggered at: {''.join(reason.trigger_stack)}\n"
                                     return f
 
-                                msg = f"Too many renders triggered, your render loop does not stop\nLast reason: {format(self._rerender_needed_reasons[-1])}\n"
+                                msg = "Too many renders triggered, your render loop does not stop\n"
+                                if render_limit > 50:
+                                    msg += "Another thread changes state during every render pass: add a pause between its changes\n"
+                                msg += f"Last reason: {format(self._rerender_needed_reasons[-1])}\n"
                                 if len(self._rerender_needed_reasons) >= 2:
                                     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
+                            self.element = self._element_next
                             self._shared_elements_next = set()
                             self.context.exception_handler = False
                             self.context.exceptions_children = []
@@ -1809,6 +1876,8 @@ class _RenderContext:
                             stable = False
                         else:
                             stable = True
+                            if self._on_render_loop_done is not None:
+                                self._on_render_loop_done()
 
                     self._is_rendering = False
                 self.context = context_prev
@@ -1835,13 +1904,18 @@ 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
+            # read the errors of this render while we hold the lock: once it is released, close()
+            # on another thread can tear the tree down (self.context is None then)
+            exceptions = [*self.context.exceptions_children, *self.context_root.exceptions_self]
+        finally:
+            if locked:
+                # clear before the lock is released, on every way out (also the return for a closed
+                # render context): a stale _lock_thread makes the checks for a render or close() in
+                # its own render fire for a thread that merely rendered last
+                self._lock_thread = None
+                self.thread_lock.release()
 
-        exceptions = [*self.context.exceptions_children, *self.context_root.exceptions_self]
         if exceptions:
             exc = exceptions[0]
             if DEBUG:
@@ -1858,10 +1932,10 @@ class _RenderContext:
                     value = html.escape(error)
                 from . import ipywidgets as w
 
-                return self.render(w.HTML(value="<pre>" + value + "</pre>", layout=w.Layout(overflow="auto")), self.container)
+                return self.render(w.HTML(value="<pre>" + value + "</pre>", layout=w.Layout(overflow="auto")), self.container), False
             else:
                 raise exc
-        return widget
+        return widget, True
 
     def _render(self, element: Element, default_key: str, parent_key: str):
         if not isinstance(element, Element):

{reacton-1.10.5 → reacton-1.11.0}/reacton/core_test.py

@@ -4304,3 +4304,136 @@ def test_keyed_child_out_of_removed_wrapper_keeps_its_effects():
     assert log == ["run"]
     rc.close()
     assert log == ["run", "cleanup"]
+
+
+def test_widget_construction_does_not_block_other_threads():
+    # A widget construction that blocks (in a server: the comm_open send to a client that stopped
+    # reading) used to hold a process wide lock, so no other thread could create widgets.
+    entered, release = threading.Event(), threading.Event()
+
+    class BlockingButton(ipywidgets.Button):
+        def __init__(self, **kwargs):
+            super().__init__(**kwargs)
+            if threading.current_thread().name == "slow":
+                entered.set()
+                release.wait(10)
+
+    BlockingButtonElement = reacton.core.ComponentWidget(BlockingButton)
+
+    @reacton.component
+    def Slow():
+        return BlockingButtonElement(description="slow")
+
+    @reacton.component
+    def Fast():
+        return w.Button(description="fast")
+
+    results: dict = {}
+
+    def render(name, component):
+        results[name] = reacton.render(component(), handle_error=False)
+
+    slow = threading.Thread(target=render, args=("slow", Slow), name="slow", daemon=True)
+    slow.start()
+    try:
+        assert entered.wait(10)
+        fast = threading.Thread(target=render, args=("fast", Fast), name="fast", daemon=True)
+        fast.start()
+        fast.join(5)
+        assert "fast" in results, "widget creation waited for a widget construction on another thread"
+    finally:
+        release.set()
+        slow.join(10)
+    for name in ["slow", "fast"]:
+        box, rc = results[name]
+        button = box.children[0]
+        # side-effect widgets are still attributed to their own render context
+        assert rc._orphans[button.model_id] == {button.layout.model_id, button.style.model_id}
+        rc.close()
+
+
+def test_widget_created_by_another_thread_is_not_an_orphan():
+    # the recording is per thread: a widget that user code creates on another thread while a
+    # render constructs a widget must not be recorded as that widget's side effect (and closed
+    # with it)
+    entered, release = threading.Event(), threading.Event()
+
+    class BlockingButton(ipywidgets.Button):
+        def __init__(self, **kwargs):
+            super().__init__(**kwargs)
+            entered.set()
+            release.wait(10)
+
+    BlockingButtonElement = reacton.core.ComponentWidget(BlockingButton)
+
+    @reacton.component
+    def Slow():
+        return BlockingButtonElement(description="slow")
+
+    results: dict = {}
+    render = threading.Thread(target=lambda: results.update(result=reacton.render(Slow(), handle_error=False)), daemon=True)
+    render.start()
+    try:
+        assert entered.wait(10)
+        unrelated = ipywidgets.IntSlider()
+    finally:
+        release.set()
+        render.join(10)
+    box, rc = results["result"]
+    button = box.children[0]
+    assert unrelated.model_id not in rc._orphans[button.model_id]
+    rc.close()
+    assert unrelated.comm is not None, "a widget of another thread was closed as an orphan"
+    for widget in [unrelated, unrelated.layout, unrelated.style]:
+        widget.close()
+
+
+def test_record_constructed_nested():
+    # a widget whose constructor renders reacton records in its own list, and the outer recording
+    # continues afterwards
+    outer: list = []
+    inner: list = []
+    previous_outer = core._start_recording_constructed(outer)
+    try:
+        before = ipywidgets.Button()
+        previous_inner = core._start_recording_constructed(inner)
+        try:
+            nested = ipywidgets.Button()
+        finally:
+            core._stop_recording_constructed(previous_inner)
+        after = ipywidgets.Button()
+    finally:
+        core._stop_recording_constructed(previous_outer)
+    assert core._construction_recording.constructed is None
+    assert before in outer and after in outer and nested not in outer
+    assert nested in inner and before not in inner
+    for widget in outer + inner:
+        widget.close()
+
+
+def test_close_after_a_failed_render_of_a_deep_tree_is_fast():
+    # After a render that failed, a component context can be in both children and children_next of
+    # its parent. close() visited such a context once for every path to it: twice per level, 2**depth
+    # visits, which hangs for a deep tree.
+    depth = 22
+    setters = {}
+
+    def make(n):
+        @react.component
+        def Level():
+            if n == 0:
+                value, setters["value"] = react.use_state(0)
+                if value == 1:
+                    raise ValueError("fail")
+                return w.Button(description="leaf")
+            return w.VBox(children=[make(n - 1)()])
+
+        return Level
+
+    box, rc = react.render(make(depth)(), handle_error=False)
+    with pytest.raises(ValueError):
+        setters["value"](1)
+    start = time.monotonic()
+    with pytest.raises(ValueError):
+        rc.close()  # close() raises the error of the failed render again
+    assert time.monotonic() - start < 2

reacton-1.11.0/reacton/threads_test.py

@@ -0,0 +1,562 @@
+import logging
+import sys
+import threading
+
+import pytest
+
+import reacton
+import reacton.ipywidgets as w
+
+TIMEOUT = 10
+
+
+def test_state_change_from_another_thread_after_the_last_check_is_rendered():
+    # A setter on another thread leaves the render to a running render loop. When it runs just
+    # after the loop took its last look at _rerender_needed, its change must still be rendered.
+    setters = {}
+
+    @reacton.component
+    def Test():
+        a, setters["a"] = reacton.use_state(0)
+        b, setters["b"] = reacton.use_state(0)
+        return w.Button(description=f"{a} {b}")
+
+    box, rc = reacton.render(Test(), handle_error=False)
+    other = threading.Thread(target=lambda: setters["b"](1))
+
+    def set_b_on_other_thread():
+        rc._on_render_loop_done = None
+        other.start()
+        # the setter returns at once when it leaves the render to us,
+        # or it waits for our render lock when it renders the change itself
+        other.join(0.5)
+
+    rc._on_render_loop_done = set_b_on_other_thread
+    setters["a"](1)
+    other.join(TIMEOUT)
+    assert not other.is_alive()
+    assert box.children[0].description == "1 1"
+    rc.close()
+
+
+def test_state_changes_from_another_thread_are_not_a_render_loop():
+    # Another thread changes state once during each render pass (a progress bar, for instance),
+    # more often than the "Too many renders" limit allows for a render loop.
+    n = 60
+    setters = {}
+    remaining = [0]
+    go, done = threading.Semaphore(0), threading.Semaphore(0)
+
+    @reacton.component
+    def Test():
+        trigger, setters["trigger"] = reacton.use_state(0)
+        progress, setters["progress"] = reacton.use_state(0)
+        if remaining[0] > 0:
+            go.release()  # the other thread changes state during this pass
+            assert done.acquire(timeout=TIMEOUT)
+        return w.Button(description=f"{trigger} {progress}")
+
+    box, rc = reacton.render(Test(), handle_error=False)
+
+    def report_progress():
+        for i in range(n):
+            assert go.acquire(timeout=TIMEOUT)
+            setters["progress"](i + 1)
+            remaining[0] -= 1
+            done.release()
+
+    other = threading.Thread(target=report_progress)
+    other.start()
+    remaining[0] = n
+    setters["trigger"](1)
+    other.join(TIMEOUT)
+    assert not other.is_alive()
+    assert box.children[0].description == f"1 {n}"
+    rc.close()
+
+
+@pytest.mark.parametrize("request_render", ["set_state", "update", "render", "force_update"])
+def test_render_request_while_holding_a_user_lock_does_not_deadlock(request_render):
+    # Another thread holds its own lock while it asks for a render (a state change, update(), render()
+    # or force_update()), and the render on this thread takes that lock in an effect. If the other
+    # thread waits for the render lock (held by this thread), this thread waits for the user lock
+    # (held by the other thread): a deadlock. The effect uses a timeout to break it.
+    user_lock = threading.RLock()
+    deadlocked = []
+    setters = {}
+
+    @reacton.component
+    def Test(label=""):
+        a, setters["a"] = reacton.use_state(0)
+        b, setters["b"] = reacton.use_state(0)
+
+        def effect():
+            if user_lock.acquire(timeout=2):
+                user_lock.release()
+            else:
+                deadlocked.append(True)
+
+        reacton.use_effect(effect, [a])
+        return w.Button(description=f"{label}{a} {b}")
+
+    box, rc = reacton.render(Test(), handle_error=False)
+    requests = {
+        "set_state": lambda: setters["b"](1),
+        "update": lambda: rc.update(Test(label="new ")),
+        "render": lambda: rc.render(Test(label="new ")),
+        "force_update": lambda: rc.force_update(),
+    }
+    expected = {"set_state": "1 1", "update": "new 1 0", "render": "new 1 0", "force_update": "1 0"}
+
+    def request_holding_user_lock():
+        with user_lock:
+            requests[request_render]()
+
+    other = threading.Thread(target=request_holding_user_lock)
+
+    class RequestAtRenderStart(logging.Filter):
+        # "Render phase: " is logged after the render took the render lock, but before it renders
+        def filter(self, record):
+            if str(record.msg).startswith("Render phase: ") and other.ident is None:
+                other.start()
+                # returns at once when the other thread does not wait for the render lock
+                other.join(0.5)
+            return True
+
+    logger = logging.getLogger("reacton")
+    level = logger.level
+    request = RequestAtRenderStart()
+    logger.setLevel(logging.INFO)
+    logger.addFilter(request)
+    try:
+        setters["a"](1)
+    finally:
+        logger.removeFilter(request)
+        logger.setLevel(level)
+    other.join(TIMEOUT)
+    assert not other.is_alive()
+    assert not deadlocked, "the other thread waited for the render lock while it held the user lock"
+    assert box.children[0].description == expected[request_render]
+    rc.close()
+
+
+def _run_in_thread(target):
+    # a thread that is still alive after TIMEOUT hangs; errors[0] is what target raised, if anything
+    errors: list = []
+
+    def run():
+        try:
+            target()
+        except BaseException as e:
+            errors.append(e)
+
+    thread = threading.Thread(target=run, daemon=True)
+    thread.start()
+    thread.join(TIMEOUT)
+    return thread, errors
+
+
+def test_close_from_its_own_render_raises_instead_of_hanging():
+    # close() waits for the render lock, which its own render holds: it would wait for itself
+    close_errors: list = []
+    setters = {}
+
+    @reacton.component
+    def Test():
+        a, setters["a"] = reacton.use_state(0)
+
+        def effect():
+            if a == 1:
+                try:
+                    rc.close()
+                except RuntimeError as e:
+                    close_errors.append(e)
+
+        reacton.use_effect(effect, [a])
+        return w.Button(description=f"{a}")
+
+    box, rc = reacton.render(Test(), handle_error=False)
+    thread, errors = _run_in_thread(lambda: setters["a"](1))
+    assert not thread.is_alive(), "close() from its own render hangs"
+    assert not errors, errors
+    assert len(close_errors) == 1
+    rc.close()
+
+
+def test_close_during_or_after_close_returns():
+    # an effect cleanup, which runs during close(), calls close() again: that must not wait for the
+    # render lock that the first close() holds. A close() after close() is a no-op as well.
+    @reacton.component
+    def Test():
+        reacton.use_effect(lambda: lambda: rc.close(), [])  # the cleanup calls close()
+        return w.Button()
+
+    box, rc = reacton.render(Test(), handle_error=False)
+    thread, errors = _run_in_thread(rc.close)
+    assert not thread.is_alive(), "close() from a cleanup during close() hangs"
+    assert not errors, errors
+    rc.close()
+
+
+def test_render_loop_for_another_thread_is_bounded():
+    # Another thread changes state during every render pass, and does not stop (a loop without a
+    # pause). The thread that renders must not keep rendering those changes forever: it would not
+    # return, and close() waits for it. It stops with "Too many renders", which names the cause.
+    setters = {}
+    stop = threading.Event()
+    go, done = threading.Semaphore(0), threading.Semaphore(0)
+
+    @reacton.component
+    def Test():
+        trigger, setters["trigger"] = reacton.use_state(0)
+        progress, setters["progress"] = reacton.use_state(0)
+        if trigger and not stop.is_set():
+            go.release()  # the other thread changes state during this pass
+            done.acquire(timeout=TIMEOUT)
+        return w.Button(description=f"{trigger} {progress}")
+
+    box, rc = reacton.render(Test(), handle_error=False)
+
+    def report_progress():
+        i = 0
+        while not stop.is_set():
+            if go.acquire(timeout=0.1):
+                i += 1
+                setters["progress"](i)
+                done.release()
+
+    other = threading.Thread(target=report_progress, daemon=True)
+    other.start()
+    thread, errors = _run_in_thread(lambda: setters["trigger"](1))
+    returned_by_itself = not thread.is_alive()
+    stop.set()
+    thread.join(TIMEOUT)
+    other.join(TIMEOUT)
+    assert returned_by_itself, "the render kept rendering the changes of another thread"
+    assert len(errors) == 1 and "another thread" in str(errors[0]).lower(), errors
+    rc.close()
+
+
+def test_many_changes_after_the_last_look_in_a_row_do_not_recurse():
+    # A change after the last look of the render loop is rendered after the render lock is released
+    # (see the lost-update test above). When that happens many times in a row, the renders must not
+    # nest (a RecursionError).
+    setters = {}
+
+    @reacton.component
+    def Test():
+        a, setters["a"] = reacton.use_state(0)
+        return w.Button(description=f"{a}")
+
+    box, rc = reacton.render(Test(), handle_error=False)
+    n = 2000
+
+    def change_after_the_last_look():
+        a = int(box.children[0].description)
+        if 0 < a < n:
+            setters["a"](a + 1)  # a render is running: this only marks _rerender_needed
+
+    rc._on_render_loop_done = change_after_the_last_look
+    setters["a"](1)
+    assert box.children[0].description == f"{n}"
+    rc.close()
+
+
+def test_own_render_loop_stops_after_about_50_passes():
+    # A component that changes its own state on every render: "Too many renders" after about 50
+    # passes. The higher limit is only for changes from other threads, not for every render that a
+    # state change (from outside a render) started.
+    renders = []
+    setters = {}
+
+    @reacton.component
+    def Test():
+        a, setters["a"] = reacton.use_state(0)
+        renders.append(a)
+        if a > 0:
+            setters["a"](a + 1)  # never stops
+        return w.Button(description=f"{a}")
+
+    box, rc = reacton.render(Test(), handle_error=False)
+    renders.clear()
+    with pytest.raises(RuntimeError, match="Too many renders"):
+        setters["a"](1)
+    assert len(renders) < 60, len(renders)
+    rc.close()
+
+
+def test_force_update_after_the_last_look_is_rendered():
+    # force_update() from another thread, just after the render loop took its last look (an event
+    # handler that routes an exception to the render does this). It must mark before it looks at
+    # _is_rendering, like a setter, or the render that is ending does not see it, and no render
+    # follows. update() does the same (it calls force_update()).
+    setters = {}
+
+    @reacton.component
+    def Test():
+        a, setters["a"] = reacton.use_state(0)
+        return w.Button(description=f"{a}")
+
+    box, rc = reacton.render(Test(), handle_error=False)
+    other = threading.Thread(target=rc.force_update)
+
+    def force_update_on_other_thread():
+        rc._on_render_loop_done = None
+        other.start()
+        other.join(TIMEOUT)
+
+    rc._on_render_loop_done = force_update_on_other_thread
+    render_count = rc.render_count
+    setters["a"](1)
+    other.join(TIMEOUT)
+    assert not other.is_alive()
+    assert rc.render_count == render_count + 2, "no render for the forced update"  # a=1, then the forced update
+    rc.close()
+
+
+def test_render_on_a_closed_render_context_leaves_nothing_behind():
+    # A render that gets the render lock after close() returns without a pass. It left its thread as
+    # the lock owner: a later close() or render() on that thread raised, as if called in its own render.
+    @reacton.component
+    def Test():
+        return w.Button(description="hi")
+
+    box, rc = reacton.render(Test(), handle_error=False)
+    rc.close()
+    rc.render()
+    rc.close()
+    rc.render()
+
+
+def test_close_right_after_a_render_released_the_render_lock():
+    # close() on another thread, right after a render released the render lock. The render read the
+    # errors of its pass after the release, from a tree that close() had torn down (AttributeError).
+    setters = {}
+
+    @reacton.component
+    def Test():
+        a, setters["a"] = reacton.use_state(0)
+        return w.Button(description=f"{a}")
+
+    box, rc = reacton.render(Test(), handle_error=False)
+    close_errors: list = []
+
+    class LockWithHook:
+        # the render lock, which runs close() on another thread right after the first release
+        def __init__(self, lock):
+            self._lock = lock
+            self.armed = True
+
+        def acquire(self, blocking=True):
+            return self._lock.acquire(blocking)
+
+        def release(self):
+            self._lock.release()
+            if self.armed:
+                self.armed = False
+                thread, errors = _run_in_thread(rc.close)
+                close_errors.extend(errors)
+
+        def locked(self):
+            return self._lock.locked()
+
+        def __enter__(self):
+            self._lock.acquire()
+
+        def __exit__(self, *args):
+            self.release()
+
+    rc.thread_lock = LockWithHook(rc.thread_lock)  # type: ignore
+    setters["a"](1)
+    assert not close_errors, close_errors
+    assert rc._closing
+
+
+def test_exception_right_after_the_render_lock_is_taken_does_not_leak_it():
+    # An exception on the first line after the render lock is taken (an interrupt, or a cancel from a
+    # trace function, like solara's cancel_guard) must still release the lock: a leaked render lock
+    # stops every later render.
+    setters = {}
+
+    @reacton.component
+    def Test():
+        a, setters["a"] = reacton.use_state(0)
+        return w.Button(description=f"{a}")
+
+    box, rc = reacton.render(Test(), handle_error=False)
+    core_file = reacton.core.__file__
+    fired: list = []
+
+    class Cancelled(Exception):
+        pass
+
+    def trace(frame, event, arg):
+        if not fired and frame.f_code.co_filename == core_file and rc.thread_lock.locked() and not rc._is_rendering:
+            fired.append((frame.f_code.co_name, frame.f_lineno))
+            raise Cancelled()
+        return trace
+
+    def set_a_with_trace():
+        sys.settrace(trace)
+        try:
+            setters["a"](1)
+        finally:
+            sys.settrace(None)
+
+    thread, errors = _run_in_thread(set_a_with_trace)
+    assert fired, "the trace function never ran while the render lock was taken"
+    assert len(errors) == 1 and isinstance(errors[0], Cancelled), errors
+    assert not rc.thread_lock.locked(), f"the render lock leaked after an exception at {fired}"
+    setters["a"](2)
+    assert box.children[0].description == "2"
+    rc.close()
+
+
+def test_render_from_its_own_render_raises():
+    # render() from its own render would leave the render to itself (it holds the render lock)
+    render_errors: list = []
+    setters = {}
+
+    @reacton.component
+    def Test():
+        a, setters["a"] = reacton.use_state(0)
+
+        def effect():
+            if a == 1:
+                try:
+                    rc.render(Test())
+                except RuntimeError as e:
+                    render_errors.append(e)
+
+        reacton.use_effect(effect, [a])
+        return w.Button(description=f"{a}")
+
+    box, rc = reacton.render(Test(), handle_error=False)
+    thread, errors = _run_in_thread(lambda: setters["a"](1))
+    assert not thread.is_alive(), "render() from its own render hangs"
+    assert not errors, errors
+    assert len(render_errors) == 1 and "Recursive render" in str(render_errors[0]), render_errors
+    rc.close()
+
+
+def test_state_change_during_a_render_only_marks():
+    # D3: a state change from another thread during a running render only marks. It does not try the
+    # render lock: the running render loop sees the mark.
+    setters = {}
+    go, done = threading.Semaphore(0), threading.Semaphore(0)
+    armed = [False]
+
+    @reacton.component
+    def Test():
+        a, setters["a"] = reacton.use_state(0)
+        b, setters["b"] = reacton.use_state(0)
+        if armed[0]:
+            armed[0] = False
+            go.release()  # the other thread changes state during this pass
+            assert done.acquire(timeout=TIMEOUT)
+        return w.Button(description=f"{a} {b}")
+
+    box, rc = reacton.render(Test(), handle_error=False)
+    render_calls = []
+    render_once = rc._render_once
+
+    def counting_render_once(*args, **kwargs):
+        render_calls.append(threading.current_thread())
+        return render_once(*args, **kwargs)
+
+    rc._render_once = counting_render_once  # type: ignore
+
+    def set_b():
+        assert go.acquire(timeout=TIMEOUT)
+        setters["b"](1)
+        done.release()
+
+    other = threading.Thread(target=set_b)
+    other.start()
+    armed[0] = True
+    setters["a"](1)
+    other.join(TIMEOUT)
+    assert other not in render_calls, "the state change during a render tried the render lock"
+    assert box.children[0].description == "1 1"
+    rc.close()
+
+
+def test_element_request_right_after_a_pass_took_the_element_is_rendered():
+    # D4: a pass first clears _rerender_needed, then takes _element_next. An element request that lands
+    # right after the take leaves its mark set, so one more pass renders its element.
+    setters = {}
+
+    @reacton.component
+    def Test(label="old"):
+        a, setters["a"] = reacton.use_state(0)
+        return w.Button(description=f"{label} {a}")
+
+    box, rc = reacton.render(Test(), handle_error=False)
+    renderer = threading.current_thread()
+    other = threading.Thread(target=lambda: rc.update(Test(label="new")))
+
+    class RequestRightAfterTheTake(type(rc)):  # type: ignore
+        @property
+        def _element_next(self):
+            element = self.__dict__["_element_next"]
+            if other.ident is None and self._lock_thread is renderer:
+                # the renderer takes the element for its pass: another thread requests a new one now
+                other.start()
+                other.join(TIMEOUT)
+            return element
+
+        @_element_next.setter
+        def _element_next(self, element):
+            self.__dict__["_element_next"] = element
+
+    rc.__class__ = RequestRightAfterTheTake
+    setters["a"](1)
+    other.join(TIMEOUT)
+    assert not other.is_alive()
+    assert box.children[0].description == "new 1"
+    rc.close()
+
+
+def test_two_close_calls_at_the_same_time_tear_down_once():
+    # D8: two close() calls both pass the first _closing check. The second waits for the render lock,
+    # and must check again once it has it: a second teardown of a torn-down tree fails.
+    @reacton.component
+    def Test():
+        return w.Button(description="hi")
+
+    box, rc = reacton.render(Test(), handle_error=False)
+    second: list = []
+
+    class LockWithHook:
+        # the render lock; the first close() starts the second one after it took the lock
+        def __init__(self, lock):
+            self._lock = lock
+            self.second_waits = threading.Event()
+
+        def acquire(self, blocking=True):
+            return self._lock.acquire(blocking)
+
+        def release(self):
+            self._lock.release()
+
+        def locked(self):
+            return self._lock.locked()
+
+        def __enter__(self):
+            if not second:
+                self._lock.acquire()
+                second.append(threading.Thread(target=lambda: second.append(_run_in_thread(rc.close)[1])))
+                second[0].start()
+                # the second close() passed its first check, and waits for the lock
+                assert self.second_waits.wait(TIMEOUT)
+            else:
+                self.second_waits.set()
+                self._lock.acquire()
+
+        def __exit__(self, *args):
+            self._lock.release()
+
+    rc.thread_lock = LockWithHook(rc.thread_lock)  # type: ignore
+    rc.close()
+    second[0].join(TIMEOUT)
+    assert second[1:] == [[]], second[1:]  # the second close() raised nothing

reacton-1.10.5/reacton/_version.py

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