reacton 1.8.1__tar.gz → 1.8.3__tar.gz

{reacton-1.8.1 → reacton-1.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: reacton
-Version: 1.8.1
+Version: 1.8.3
 Project-URL: Home, https://www.github.com/widgetti/reacton
 Project-URL: Documentation, https://reacton.solara.dev
 Project-URL: Source code, https://www.github.com/widgetti/reacton

reacton-1.8.3/reacton/_version.py

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

{reacton-1.8.1 → reacton-1.8.3}/reacton/core.py

@@ -770,14 +770,42 @@ def get_widget(el: Element):
 
 
 def use_state(initial: T, key: str = None, eq: Callable[[Any, Any], bool] = None) -> Tuple[T, Callable[[Union[T, Callable[[T], T]]], None]]:
-    """Returns a (value, setter) tuple that is used to manage state in a component.
+    """Returns a `(value, setter)` tuple that is used to manage state in a component.
 
     This function can only be called from a component function.
 
-    The value returns the current state (which equals initial at the first render call).
-    Or the value that was last
+    The value returns the current state (which equals `initial` at the first render call). Or the value that was last set using the setter.
+
+    Note that the setter function can be used in two ways.
+
+    Directly setting the value:
+
+    ```python
+    @reacton.component
+    def ButtonClick():
+        clicks, set_clicks = reacton.use_state(0)
+        def my_click_handler():
+            set_clicks(clicks+1)
+        button = w.Button(description=f"Clicked {clicks} times",
+                        on_click=my_click_handler)
+        return button
+    ```
+
+    Updating the value based on the previous/current value.
+
+    ```python
+    @reacton.component
+    def ButtonClick():
+        clicks, set_clicks = reacton.use_state(0)
+        def my_click_handler():
+            set_clicks(lambda prev: prev+1)
+        button = w.Button(description=f"Clicked {clicks} times",
+                        on_click=my_click_handler)
+        return button
+    ```
+
+    The last one avoid issues with stale data, which means you have a reference to the value of an old render pass (not present in this simple example).
 
-    Subsequent
     """
     rc = _get_render_context()
     return rc.use_state(initial, key, eq)
@@ -839,7 +867,7 @@ def use_reducer(reduce: Callable[[T, U], T], initial_state: T) -> Tuple[T, Calla
     return state, dispatch
 
 
-def use_memo(f, dependencies=None, debug_name: str = None):
+def use_memo(f: Callable[[], T], dependencies=None, debug_name: str = None) -> T:
     if debug_name is None:
         debug_name = f.__name__
     rc = _get_render_context()
@@ -1217,15 +1245,15 @@ class _RenderContext:
             memo = (value, dependencies)
             self.context.memo.append(memo)
             self.context.memo_index += 1
-            logger.info("Initial memo = %r for index %r (debug-name: %r)", memo, self.context.memo_index - 1, name)
+            logger.debug("Initial memo = %r for index %r (debug-name: %r)", memo, self.context.memo_index - 1, name)
             return value
         else:
             memo = self.context.memo[self.context.memo_index]
             value, dependencies_previous = memo
             if utils.equals(dependencies_previous, dependencies):
-                logger.info("Got memo hit = %r for index %r (debug-name: %r)", memo, self.context.memo_index, name)
+                logger.debug("Got memo hit = %r for index %r (debug-name: %r)", memo, self.context.memo_index, name)
             else:
-                logger.info("Replace memo with = %r for index %r (debug-name: %r)", memo, self.context.memo_index, name)
+                logger.debug("Replace memo with = %r for index %r (debug-name: %r)", memo, self.context.memo_index, name)
                 value = f()
                 memo = (value, dependencies)
                 self.context.memo[self.context.memo_index] = memo
@@ -1243,11 +1271,11 @@ class _RenderContext:
                 self.context.state_metadata[key] = len(initial)
             elif utils.isinstance_lazy(initial, "pandas.DataFrame"):
                 self.context.state_metadata[key] = utils.dataframe_fingerprint(initial)
-            logger.info("Initial state = %r for key %r (%r)", initial, key, id(self.context))
+            logger.debug("Initial state = %r for key %r (%r)", initial, key, id(self.context))
             return initial, self.make_setter(key, self.context, eq)
         else:
             state = self.context.state[key]
-            logger.info("Got state = %r for key %r (%r)", state, key, id(self.context))
+            logger.debug("Got state = %r for key %r (%r)", state, key, id(self.context))
             return state, self.make_setter(key, self.context, eq)
 
     def make_setter(self, key, context: ComponentContext, eq: Callable[[Any, Any], bool] = None):
@@ -1258,16 +1286,8 @@ class _RenderContext:
         # I am not sure exactly why, but this will at least make
         # it easier for Python to garbage collect, since it will
         # avoid circular references
-        context_ref = weakref.ref(context)
-        self_ref = weakref.ref(self)
-        del context
-        del self
 
         def set_(value):
-            context = context_ref()
-            assert context is not None
-            self = self_ref()
-            assert self is not None
             if callable(value):
                 value = value(context.state[key])
             logger.info("Set state = %r for key %r (previous value was %r) (%r)", value, key, context.state[key], id(self.context))
@@ -1344,12 +1364,12 @@ class _RenderContext:
         if len(self.context.effects) <= self.context.effect_index:
             self.context.effect_index += 1
             self.context.effects.append(Effect(effect, dependencies))
-            logger.info("Initial effect = %r for index %r (%r)", effect, self.context.effect_index - 1, dependencies)
+            logger.debug("Initial effect = %r for index %r (%r)", effect, self.context.effect_index - 1, dependencies)
         else:
             previous_effect = self.context.effects[self.context.effect_index]
             # we always set it, even replacing it when we didn't execute it
             # in the consolidation phase we decide what to do (e.g. skip it)
-            logger.info("Setting next effect = %r for index %r (%r)", effect, self.context.effect_index, dependencies)
+            logger.debug("Setting next effect = %r for index %r (%r)", effect, self.context.effect_index, dependencies)
             if previous_effect.executed:
                 # line up...
                 previous_effect.next = Effect(effect, dependencies)
@@ -1494,7 +1514,11 @@ class _RenderContext:
                                         "make sure your root component always returns the same component type"
                                     )
                         if container:
-                            container.children = [widget]
+                            if widget is None:
+                                # Exception occurred, and we cannot render the widget
+                                container.children = []
+                            else:
+                                container.children = [widget]
 
                         if self.context_root.exceptions_children or self.context_root.exceptions_self:
                             # an exception bubbled up during reconsolidate
@@ -1852,7 +1876,7 @@ class _RenderContext:
                             # if we have a next, it means that effect itself is executed
                             # TODO: custom equals
                             if effect.next.dependencies is not None and utils.equals(effect.dependencies, effect.next.dependencies):
-                                logger.info("No need to add effect, dependencies are the same (%r %r)", effect.callable, effect.dependencies)
+                                logger.debug("No need to add effect, dependencies are the same (%r %r)", effect.callable, effect.dependencies)
                                 # not needed, just remove the reference
                                 effect.next = None
                             else:
@@ -1936,34 +1960,48 @@ class _RenderContext:
                         raise RuntimeError(f"Element ({el}) was already in self._shared_widgets")
                     else:
                         logger.info("Creating new widget: %r %r", el, key)
-                        widget, orphan_ids = el._create_widget(kwargs)
-
+                        widget = None
+                        if not context.exceptions_children:
+                            try:
+                                widget, orphan_ids = el._create_widget(kwargs)
+                            except BaseException as e:
+                                context.exceptions_self.append(e)
+                                self._rerender_needed_reasons.append(RerenderReason(reason="Exception ocurred during reconciliation (creating widget)"))
+                                self._rerender_needed = True
                         if el.is_shared:
                             self._shared_widgets[el] = widget
                         else:
                             context.widgets[key] = widget
                 elif el_prev is not None and el_prev.component == el.component:
-                    logger.info("Updating widget: %r  → %r %r", el_prev, el, key)
+                    logger.debug("Updating widget: %r  → %r %r", el_prev, el, key)
                     assert el_prev is not None
                     # TODO: remove event listeners while doing so
                     # assign to _widgets[el] first, before errors can occur
                     kwargs = reconsolidate_children()
-                    try:
-                        el._update_widget(widget_previous, el_prev, kwargs)
-                    except BaseException as e:
-                        context.exceptions_self.append(e)
-                        self._rerender_needed_reasons.append(RerenderReason(reason="Exception ocurred during reconciliation (updating widget)"))
-                        self._rerender_needed = True
+                    if not context.exceptions_children:
+                        try:
+                            el._update_widget(widget_previous, el_prev, kwargs)
+                        except BaseException as e:
+                            context.exceptions_self.append(e)
+                            self._rerender_needed_reasons.append(RerenderReason(reason="Exception ocurred during reconciliation (updating widget)"))
+                            self._rerender_needed = True
                     if el.is_shared:
                         self._shared_widgets[el] = widget_previous
                     else:
                         context.widgets[key] = widget_previous
                 else:
                     assert el_prev is not None, "widget_previous is not None, but el_prev is"
-                    logger.info("Replacing widget: %r → %r %r", el_prev, el, key)
+                    logger.debug("Replacing widget: %r → %r %r", el_prev, el, key)
                     self._remove_element(el_prev, key, parent_key=parent_key)
                     kwargs = reconsolidate_children()
-                    widget, orphan_ids = el._create_widget(kwargs)
+                    widget = None
+                    if not context.exceptions_children:
+                        try:
+                            widget, orphan_ids = el._create_widget(kwargs)
+                        except BaseException as e:
+                            context.exceptions_self.append(e)
+                            self._rerender_needed_reasons.append(RerenderReason(reason="Exception ocurred during reconciliation (updating widget)"))
+                            self._rerender_needed = True
                     if el.is_shared:
                         self._shared_widgets[el] = widget
                     else:
@@ -2050,7 +2088,7 @@ class _RenderContext:
         assert key is not None
         assert self.context is not None
         context = self.context
-        logger.info("Remove: (%s, %s) %r", parent_key, key, el)
+        logger.debug("Remove: (%s, %s) %r", parent_key, key, el)
 
         if el.is_shared:
             if el not in self._shared_elements:
@@ -2098,17 +2136,18 @@ class _RenderContext:
                 widget = self._shared_widgets[el]
             else:
                 widget = context.widgets[key]
-            assert widget.comm is not None
-            assert widget.model_id in _get_widgets_dict()
-
-            for orphan in self._orphans.get(widget.model_id, set()):
-                orphan_widget = _get_widgets_dict().get(orphan)
-                if orphan_widget:
-                    close_widget(orphan_widget)
-            if widget.model_id in self._orphans:
-                del self._orphans[widget.model_id]
-            el._cleanup_callbacks(widget)
-            el._close_widget(widget)
+            if widget is not None:
+                assert widget.comm is not None
+                assert widget.model_id in _get_widgets_dict()
+
+                for orphan in self._orphans.get(widget.model_id, set()):
+                    orphan_widget = _get_widgets_dict().get(orphan)
+                    if orphan_widget:
+                        close_widget(orphan_widget)
+                if widget.model_id in self._orphans:
+                    del self._orphans[widget.model_id]
+                el._cleanup_callbacks(widget)
+                el._close_widget(widget)
         if el.is_shared:
             del self._shared_widgets[el]
         else:

{reacton-1.8.1 → reacton-1.8.3}/reacton/core_test.py

@@ -1913,10 +1913,8 @@ def test_recover_exception_in_cleanup_child(Container1, Container2):
     with pytest.raises(Exception):
         rc.render(Container1(children=[Container2()]))
 
-    try:
+    with pytest.raises(Exception, match=".*fail.*"):
         rc.close()
-    except Exception as e:
-        assert e.args[0] == "fail"
 
 
 def test_recover_exception_in_cleanup():
@@ -1957,25 +1955,46 @@ def test_recover_exception_in_cleanup():
     rc.close()
 
 
-def test_recover_exception_in_widget_update():
+def test_recover_exception_in_widget_update(Container1, Container2):
     set_fail = None
 
+    @react.component
+    def Child(value):
+        with v.Container() as main:
+            v.Btn(children=[value])
+        return main
+
     @react.component
     def Test():
         nonlocal set_fail
         fail, set_fail = react.use_state(False)
-        value = 1
+        value = "ok"
         if fail:
-            value = "fail"  # type: ignore
-        return w.IntSlider(value=value)
+            value = 1  # type: ignore
+        if not fail:
+            with Container1() as main:
+                v.Btn(children=[value])
+        else:
+            with Container2() as main:
+                Child(value=value)
+        return main
 
-    # with pytest.raises(Exception):
     box, rc = react.render(Test())
-    assert rc.find(ipywidgets.IntSlider)
+    assert rc.find(ipyvuetify.Btn)
     assert set_fail is not None
     set_fail(True)
     assert not rc._is_rendering
-    assert not rc.find(ipywidgets.IntSlider)
+    assert not rc.find(ipyvuetify.Btn)
+    rc.close()
+
+    box, rc = react.render(Test(), handle_error=False)
+    assert rc.find(ipyvuetify.Btn)
+    assert set_fail is not None
+    with pytest.raises(Exception, match=".*Could not create widget.*"):
+        set_fail(True)
+    set_fail(True)
+    assert not rc._is_rendering
+    rc.render(w.HTML(value="recover"))
     rc.close()
 
 
@@ -3103,10 +3122,18 @@ def test_event_multiple():
     rc.close()
 
 
-def test_memory_leak(ButtonComponent):
+@reacton.component
+def UseMemoComponent():
+    rc = core.get_render_context()
+    reacton.use_memo(lambda: [rc], [])
+    return w.Button()
+
+
+@pytest.mark.parametrize("component", [w.Button, ButtonComponentFunction, UseMemoComponent])
+def test_memory_leak(component):
     # we make sure that there is not reference to the context
     # after we close it
-    box, rc = react.render(ButtonComponent(), handle_error=False)
+    box, rc = react.render(component(), handle_error=False)
     rc.close()
     # useful for debugging
     # import objgraph

reacton-1.8.1/reacton/_version.py

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