reacton 1.1.1__tar.gz → 1.2.1__tar.gz

{reacton-1.1.1 → reacton-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: reacton
-Version: 1.1.1
+Version: 1.2.1
 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.2.1/reacton/_version.py

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

{reacton-1.1.1 → reacton-1.2.1}/reacton/core.py

@@ -37,10 +37,12 @@ from warnings import warn
 
 import ipywidgets
 import ipywidgets as widgets
+import traitlets
 import typing_extensions
 from typing_extensions import Literal, Protocol
 
 import reacton.logging  # noqa: F401  # has sidefx
+import reacton.patch_display  # noqa: F401  # has sidefx
 
 from . import _version, patch, utils  # noqa: F401
 
@@ -529,6 +531,70 @@ class ComponentFunction(Component):
         self.value_name = value_name
         functools.update_wrapper(self, f)
 
+    def widget(self, **kwargs):
+        return self.widget_class()(**kwargs)
+
+    def widget_class(self):
+        parameters = inspect.signature(self.f).parameters
+        args = list(parameters.keys())
+        listeners = set()
+        normal_kwargs = set()
+        for name in args:
+            if name.startswith("on_"):
+                listeners.add(name)
+            else:
+                normal_kwargs.add(name)
+        component = self
+
+        class Container(widgets.VBox, widgets.ValueWidget):
+            description = traitlets.Unicode()
+
+            def __init__(self, **kwargs):
+                super().__init__(**kwargs)
+                self._children = []
+                traits = {}
+
+                for name in normal_kwargs:
+                    if name != "children":  # children is a special trait we keep
+                        if name in normal_kwargs:
+                            trait = traitlets.Any(default_value=parameters[name].default)
+                        else:
+                            trait = traitlets.Any()
+                        traits[name] = trait
+                Container.add_traits(self, **traits)
+                for name, value in kwargs.items():
+                    if name in normal_kwargs:
+                        setattr(self, name, value)
+                for name in normal_kwargs:
+                    self.observe(self._rerender, name)
+                el = self._create_el()
+                self.rc = _RenderContext(el, self)
+                self.rc.render(el, self)
+
+            def _create_el(self):
+                kwargs = {}
+                for name in normal_kwargs:
+                    if name != "children":
+                        kwargs[name] = getattr(self, name)
+                for name in listeners:
+                    propname = name[3:]
+
+                    def closure(propname=propname):
+                        def setter(value):
+                            setattr(self, propname, value)
+
+                        return setter
+
+                    kwargs[name] = closure()
+                logger.info("calling component with kwargs: %r", kwargs)
+                return component(**kwargs)
+
+            def _rerender(self, change):
+                el = self._create_el()
+                self.rc.update(el)
+
+        return Container
+
     def __eq__(self, rhs):
         if self is rhs:
             return True
@@ -1115,6 +1181,14 @@ class _RenderContext:
                 self.context.effects[self.context.effect_index] = Effect(effect, dependencies)
             self.context.effect_index += 1
 
+    def update(self, element: Element):
+        if self._is_rendering:
+            self.element = element
+            self._rerender_needed = True
+            self._rerender_needed_reason = "root element changed"
+        else:
+            self.render(element, self.container)
+
     def render(self, element: Element, container: widgets.Widget = None):
         # render + consolidate
         widget = None
@@ -1136,11 +1210,12 @@ class _RenderContext:
             try:
                 local.rc = self
                 self.element = element
+                del element
                 main_render_phase = not self._is_rendering
                 render_count = self.render_count  # make a copy
                 self._rerender_needed = False
                 self._rerender_needed_reason = None
-                logger.info("Render phase: %r %r", self.render_count, "main" if main_render_phase else "(nested)")
+                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
                 # if we got called recursively, self.context is not the root context
@@ -1149,12 +1224,12 @@ class _RenderContext:
                 self.context.exception_handler = False
                 self.context.exceptions_children = []
                 self.context.exceptions_self = []
-                self.context.root_element_next = element
+                self.context.root_element_next = self.element
                 assert self.context is not None
 
                 try:
                     self._shared_elements_next = set()
-                    self._render(element, "/", parent_key=ROOT_KEY)
+                    self._render(self.element, "/", parent_key=ROOT_KEY)
                     self.first_render = False
                 except BaseException:
                     self._is_rendering = False
@@ -1177,7 +1252,7 @@ class _RenderContext:
                             self.context.exceptions_children = []
                             self.context.exceptions_self = []
 
-                            self._render(element, "/", parent_key=ROOT_KEY)
+                            self._render(self.element, "/", parent_key=ROOT_KEY)
                             logger.info("Render done: %r %r", self._rerender_needed, self._rerender_needed_reason)
                             assert self.context is self.context_root
                             render_counts += 1
@@ -1193,7 +1268,7 @@ class _RenderContext:
                             break
 
                         logger.info("Render reconsolidate...")
-                        widget = self._reconsolidate(element, default_key="/", parent_key=ROOT_KEY)
+                        widget = self._reconsolidate(self.element, default_key="/", parent_key=ROOT_KEY)
                         logger.info("Render reconsolidate done")
                         self.context.root_element = self.context.root_element_next
                         self.context.root_element_next = None
@@ -1205,7 +1280,7 @@ class _RenderContext:
                             logger.debug("\t%r %x", el, id(el))
                         # RESET
                         assert self.context is self.context_root
-                        if element.is_shared:
+                        if self.element.is_shared:
                             assert widget in self._shared_widgets.values()
                         else:
                             assert widget in self.context_root.widgets.values()

{reacton-1.1.1 → reacton-1.2.1}/reacton/core_test.py

@@ -11,6 +11,7 @@ import numpy as np
 import pandas as pd
 import pytest
 import traitlets
+from IPython.display import display
 
 import reacton as react
 import reacton.core
@@ -2719,3 +2720,81 @@ def test_implicit_component():
     assert rc.find(widgets.Button)[0].widget.description == "hoeba: 1"
     assert rc.find(widgets.Button)[1].widget.description == "hoeba: 2"
     rc.close()
+
+
+def test_create_widget():
+    @react.component
+    def Test(a: int = 1, label="lala", on_a=None, children=[]):
+        # adding children shouldn't change the children trait
+        assert children == []
+        return w.IntSlider(value=a, on_value=on_a, description=label)
+
+    widget: widgets.Widget = Test.widget(a=1)  # type: ignore
+    assert widget.trait_metadata("children", "to_json") is not None
+    mock = unittest.mock.Mock()
+    widget.trait_names() == ["a", "label"]
+    widget.observe(mock, "a")
+    assert widget.label == "lala"
+    widget.a = 2
+    mock.assert_called_once_with({"name": "a", "old": 1, "new": 2, "owner": widget, "type": "change"})
+    slider = widget.children[0]
+    assert isinstance(slider, widgets.IntSlider)
+    slider.value = 3
+    mock.assert_called_with({"name": "a", "old": 2, "new": 3, "owner": widget, "type": "change"})
+
+    widget.rc.close()
+
+    @reacton.component
+    def BiSlider(value, on_value):
+        x, y = value
+        with w.VBox() as main:
+            w.IntSlider(min=0, max=10, value=x, on_value=lambda x: on_value((x, y)))
+            w.IntSlider(min=0, max=x**2, value=y, on_value=lambda y: on_value((x, y)))
+        return main
+
+    widget: widgets.Widget = BiSlider.widget(value=(3, 4))  # type: ignore
+    slider1 = widget.children[0].children[0]
+    slider2 = widget.children[0].children[1]
+    assert slider1.value == 3
+    assert slider2.value == 4
+    widget.value = (2, 3)
+    assert slider1.value == 2
+    assert slider2.value == 3
+
+    slider1.value = 3
+    assert slider2.max == 9
+    widget.rc.close()
+
+
+def test_display_element():
+    button = w.Button(description="hoeba")
+    from IPython.core.interactiveshell import InteractiveShell
+
+    store = InteractiveShell.instance().display_pub.publish
+    InteractiveShell.instance().display_pub.publish = unittest.mock.Mock()
+
+    @react.component
+    def Test():
+        with w.VBox() as box:
+            display(button)
+        return box
+
+    box, rc = react.render(Test(), handle_error=False)
+    assert rc.find(widgets.Button).widget.description == "hoeba"
+    InteractiveShell.instance().display_pub.publish.assert_not_called()
+    rc.close()
+    InteractiveShell.instance().display_pub.publish = store
+
+
+def test_display_dataframe():
+    df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+
+    @react.component
+    def Test():
+        with w.VBox() as box:
+            display(df)
+        return box
+
+    box, rc = react.render(Test(), handle_error=False)
+    # assert rc.find(widgets.Button).widget.description == "hoeba"
+    rc.close()

{reacton-1.1.1 → reacton-1.2.1}/reacton/find.py

@@ -50,6 +50,9 @@ class Finder(collections.abc.Sequence, Generic[W]):
             parent = parent.parent
         return parent
 
+    def __repr__(self):
+        return "Finder structure:\n%r" % self._current_structure()
+
     def _reexecute_find(self):
         finder = self._root()
         for query in self.queries:
@@ -86,7 +89,7 @@ class Finder(collections.abc.Sequence, Generic[W]):
     def matches(self, **matches):
         self.assert_matches(**matches)
 
-    def wait_for(self, state="attached", timeout=1):
+    def wait_for(self, state="attached", timeout=1, iteration_delay=0.01):
         start = time.time()
         finder = self
         while time.time() - start < timeout:
@@ -98,7 +101,7 @@ class Finder(collections.abc.Sequence, Generic[W]):
                     return finder
             else:
                 raise ValueError(f"Unknown state {state}, expected 'attached' or 'detached'")
-            time.sleep(0.001)
+            time.sleep(iteration_delay)
             finder = self._reexecute_find()
         raise TimeoutError(f"Timeout waiting for {self}, current structure:\n{self._current_structure()}")
 

{reacton-1.1.1 → reacton-1.2.1}/reacton/generate.py

@@ -173,16 +173,16 @@ class CodeGen(Generic[W]):
             # TODO: we can special case this (Tuple is subclass of Instance)
             # but it's fixed length
             if isinstance(trait, traitlets.traitlets.Instance):
-                if trait.klass.__name__ == "array":
+                if trait.klass.__name__ == "array":  # type: ignore
                     import pdb
 
                     pdb.set_trace()
                 if trait.klass.__module__ == "builtins":
-                    return trait.klass.__name__
+                    return trait.klass.__name__  # type: ignore
                 else:
-                    type_name = str(trait.klass.__module__) + "." + trait.klass.__name__
+                    type_name = str(trait.klass.__module__) + "." + trait.klass.__name__  # type: ignore
                     type_name = type_name_alias.get(type_name, type_name)
-                    if issubclass(trait.klass, widgets.Widget):
+                    if issubclass(trait.klass, widgets.Widget):  # type: ignore
                         element_class_name_type = "Element"  # self.get_element_class
                         type_name = f"{element_class_name_type}[{type_name}]"
                     return type_name

{reacton-1.1.1 → reacton-1.2.1}/reacton/patch.py

@@ -13,8 +13,8 @@ class Callable(traitlets.traitlets.TraitType):
 
 # for py36 we are stuck with a version that does not have this
 if not hasattr(traitlets.traitlets, "Callable"):
-    traitlets.traitlets.Callable = Callable
-    traitlets.Callable = Callable
+    traitlets.traitlets.Callable = Callable  # type: ignore
+    traitlets.Callable = Callable  # type: ignore
 
 if not hasattr(traitlets.traitlets.TraitType, "default"):
 
@@ -33,4 +33,4 @@ if not hasattr(traitlets.traitlets.TraitType, "default"):
             # Undefined will raise in TraitType.get
             return self.default_value
 
-    traitlets.traitlets.TraitType.default = default
+    traitlets.traitlets.TraitType.default = default  # type: ignore

reacton-1.2.1/reacton/patch_display.py

@@ -0,0 +1,45 @@
+from IPython.core.formatters import BaseFormatter
+from IPython.core.interactiveshell import InteractiveShell
+
+ipython_display_formatter_original = InteractiveShell.instance().display_formatter.ipython_display_formatter
+original_display_publisher_publish = InteractiveShell.instance().display_pub.publish
+
+
+def publish(data, metadata=None, *args, **kwargs):
+    """Will intercept a display call and add the display data to an output widget when in a reacton context/render function."""
+    from .core import get_render_context
+
+    rc = get_render_context(required=False)
+    if rc is not None:
+        from .ipywidgets import Output
+
+        Output(outputs=[{"output_type": "display_data", "data": data, "metadata": metadata}])
+    else:
+        return original_display_publisher_publish(data, metadata, *args, **kwargs)
+
+
+class ReactonDisplayFormatter(BaseFormatter):
+    """Add direct support for adding elements to a container.
+
+    Example:
+
+    with w.VBox():
+        display(button)
+
+    """
+
+    def __call__(self, obj):
+        from .core import Element, get_render_context  # noqa
+
+        rc = get_render_context(required=False)
+        if rc is not None:
+            if rc.container_adders:
+                if isinstance(obj, Element):
+                    # add directly as a child
+                    rc.container_adders[-1].add(obj)
+                    return True  # we handled it
+        return ipython_display_formatter_original(obj)
+
+
+InteractiveShell.instance().display_formatter.ipython_display_formatter = ReactonDisplayFormatter()
+InteractiveShell.instance().display_pub.publish = publish

{reacton-1.1.1 → reacton-1.2.1}/reacton/utils.py

@@ -45,7 +45,7 @@ def equals(a, b):
         return same_component(a.component, b.component) and equals(a.args, b.args) and equals(a.kwargs, b.kwargs)
     elif isinstance(a, types.FunctionType):
         return a.__code__ == b.__code__ and (
-            (a.__closure__ == b.__closure__) or equals([c.cell_contents for c in a.__closure__ or ()], [c.cell_contents for c in b.__closure__ or ()])
+            (equals(a.__closure__, b.__closure__)) or equals([c.cell_contents for c in a.__closure__ or ()], [c.cell_contents for c in b.__closure__ or ()])
         )
     elif isinstance(a, dict) and isinstance(b, dict):
         if len(a) != len(b):

{reacton-1.1.1 → reacton-1.2.1}/reacton/utils_test.py

@@ -51,15 +51,15 @@ def test_equals():
     assert equals(dar1, dar2)
     assert not equals(dar1, dar3)
 
-    def make_function(a):
+    def make_function(a, ar1, ar2):
         def func(x):
-            return x**a
+            return x**a + (ar1 == ar2)
 
         return func
 
-    f1 = make_function(1)
-    f2 = make_function(1)
-    f3 = make_function(2)
+    f1 = make_function(1, ar1, ar2)
+    f2 = make_function(1, ar1, ar2)
+    f3 = make_function(2, ar2, ar2)
     assert f1 == f1
     assert f1 != f2
     assert equals(f1, f1)

reacton-1.1.1/reacton/_version.py

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