solara-ui 1.51.1__tar.gz → 1.52.0__tar.gz

{solara_ui-1.51.1 → solara_ui-1.52.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solara-ui
-Version: 1.51.1
+Version: 1.52.0
 Dynamic: Summary
 Project-URL: Home, https://www.github.com/widgetti/solara
 Project-URL: Documentation, https://solara.dev

{solara_ui-1.51.1 → solara_ui-1.52.0}/solara/__init__.py

@@ -1,6 +1,6 @@
 """Build webapps using IPywidgets"""
 
-__version__ = "1.51.1"
+__version__ = "1.52.0"
 github_url = "https://github.com/widgetti/solara"
 git_branch = "master"
 

{solara_ui-1.51.1 → solara_ui-1.52.0}/solara/__main__.py

@@ -13,7 +13,7 @@ import rich
 import rich_click as click
 import uvicorn
 from rich import print as rprint
-from uvicorn.main import LEVEL_CHOICES, LOOP_CHOICES
+from uvicorn.main import LEVEL_CHOICES
 
 import solara
 from solara.server import settings
@@ -242,9 +242,9 @@ if "SOLARA_MODE" in os.environ:
 @click.argument("app")
 @click.option(
     "--loop",
-    type=LOOP_CHOICES,
+    type=str,
     default="auto",
-    help="Event loop implementation.",
+    help="Event loop implementation (see uvicorn documentation for possible values).",
     show_default=True,
 )
 @click.option(

{solara_ui-1.51.1 → solara_ui-1.52.0}/solara/components/component_vue.py

@@ -12,17 +12,32 @@ import solara
 
 P = typing_extensions.ParamSpec("P")
 
-
-def _widget_from_signature(classname, base_class: Type[widgets.Widget], func: Callable[..., None], event_prefix: str) -> Type[widgets.Widget]:
+default_to_json = widgets.widget_serialization["to_json"]
+default_from_json = widgets.widget_serialization["from_json"]
+
+
+def _widget_from_signature(
+    classname,
+    base_class: Type[widgets.Widget],
+    func: Callable[..., None],
+    event_prefix: str,
+    tags: Dict[str, Any],
+    to_json: Dict[str, Callable[[Any, widgets.Widget], Any]],
+    from_json: Dict[str, Callable[[Any, widgets.Widget], Any]],
+) -> Type[widgets.Widget]:
     classprops: Dict[str, Any] = {}
 
     parameters = inspect.signature(func).parameters
     for name, param in parameters.items():
         if name.startswith("event_"):
             event_name = name[6:]
+            event_name_full = name  # LLM's are quick stubborn in wanting to call `event_foo` instead of `foo`
 
             def event_handler(self, data, buffers=None, event_name=event_name, param=param):
                 callback = self._event_callbacks.get(event_name, param.default)
+                if not callback:
+                    # support 'event_foo'
+                    callback = self._event_callbacks.get(event_name_full, None)
                 if callback:
                     if buffers:
                         callback(data, buffers)
@@ -30,6 +45,7 @@ def _widget_from_signature(classname, base_class: Type[widgets.Widget], func: Ca
                         callback(data)
 
             classprops[f"vue_{event_name}"] = event_handler
+            classprops[f"vue_{event_name_full}"] = event_handler
         elif name.startswith("on_") and name[3:] in parameters:
             # callback, will be handled by reacton
             continue
@@ -38,7 +54,9 @@ def _widget_from_signature(classname, base_class: Type[widgets.Widget], func: Ca
                 trait = traitlets.Any()
             else:
                 trait = traitlets.Any(default_value=param.default)
-            classprops[name] = trait.tag(sync=True, **widgets.widget_serialization)
+            tag = dict(sync=True, to_json=to_json.get(name, default_to_json), from_json=from_json.get(name, default_from_json))
+            tag.update(**tags.get(name, {}))
+            classprops[name] = trait.tag(**tag)
     # maps event_foo to a callable
     classprops["_event_callbacks"] = traitlets.Dict(default_value={})
 
@@ -46,7 +64,13 @@ def _widget_from_signature(classname, base_class: Type[widgets.Widget], func: Ca
     return widget_class
 
 
-def _widget_vue(vue_path: str, vuetify=True) -> Callable[[Callable[P, None]], Type[v.VuetifyTemplate]]:
+def _widget_vue(
+    vue_path: str,
+    vuetify=True,
+    to_json: Dict[str, Callable[[Any, widgets.Widget], Any]] = {},
+    from_json: Dict[str, Callable[[Any, widgets.Widget], Any]] = {},
+    tags: Dict[str, Any] = {},
+) -> Callable[[Callable[P, None]], Type[v.VuetifyTemplate]]:
     def decorator(func: Callable[P, None]):
         class VuetifyWidgetSolara(v.VuetifyTemplate):
             template_file = (os.path.abspath(inspect.getfile(func)), vue_path)
@@ -55,14 +79,20 @@ def _widget_vue(vue_path: str, vuetify=True) -> Callable[[Callable[P, None]], Ty
             template_file = (os.path.abspath(inspect.getfile(func)), vue_path)
 
         base_class = VuetifyWidgetSolara if vuetify else VueWidgetSolara
-        widget_class = _widget_from_signature("VueWidgetSolaraSub", base_class, func, "vue_")
+        widget_class = _widget_from_signature("VueWidgetSolaraSub", base_class, func, "vue_", to_json=to_json, from_json=from_json, tags=tags)
 
         return widget_class
 
     return decorator
 
 
-def component_vue(vue_path: str, vuetify=True) -> Callable[[Callable[P, None]], Callable[P, solara.Element]]:
+def component_vue(
+    vue_path: str,
+    vuetify=True,
+    tags: Dict[str, Any] = {},
+    to_json: Dict[str, Callable[[Any, widgets.Widget], Any]] = {},
+    from_json: Dict[str, Callable[[Any, widgets.Widget], Any]] = {},
+) -> Callable[[Callable[P, None]], Callable[P, solara.Element]]:
     """Decorator to create a component backed by a Vue template.
 
     Although many components can be made from the Python side, sometimes it is easier to write components using Vue directly.
@@ -74,14 +104,22 @@ def component_vue(vue_path: str, vuetify=True) -> Callable[[Callable[P, None]],
     are assumed by refer to the same vue property, with `on_foo` being the event handler when `foo` changes from
     the vue template.
 
-    Arguments or the form `event_foo` should be callbacks that can be called from the vue template. They are
-    available as the function `foo` in the vue template.
+    Arguments of the form `event_foo` should be callbacks that can be called from the vue template. They are
+    available as the function `foo` and `event_foo` in the vue template.
+
+    Note that `foo` was kept for backwards compatibility, but LLM's have a tendency to use `event_foo`, so this was
+    changed to `event_foo`.
 
     [See the vue v2 api](https://v2.vuejs.org/v2/api/) for more information on how to use Vue, like `watch`,
     `methods` and lifecycle hooks such as `mounted` and `destroyed`.
 
     See the [Vue component example](/documentation/examples/general/vue_component) for an example of how to use this decorator.
 
+    The underlying trait can be passed extra arguments by passing a dictionary to the `tags` argument.
+    The most common case is to pass a custom serializer and deserializer for the trait, for which we added the
+    strictly typed `to_json` and `from_json` arguments.
+    Otherwise pass a dictionary to the `tags` argument, see the example below for more details.
+
 
     ## Examples
 
@@ -105,6 +143,28 @@ def component_vue(vue_path: str, vuetify=True) -> Callable[[Callable[P, None]],
         pass
     ```
 
+    ## Example with custom serializer and deserializer
+
+    ```python
+    import solara
+
+    def to_json_datetime(value: datetime.date, widget: widgets.Widget) -> str:
+        return value.isoformat()
+
+    def from_json_datetime(value: str, widget: widgets.Widget) -> datetime.date:
+        return datetime.date.fromisoformat(value)
+
+    @solara.component_vue("my_date_component.vue", to_json={"month": to_json_datetime}, from_json={"month": from_json_datetime})
+    def MyDateComponent(month: datetime.date, event_date_clicked: Callable):
+        pass
+
+    # the following will be the same, except that it is less strictly typed
+    @solara.component_vue("my_date_component.vue", tags={"month": {"to_json": to_json_datetime, "from_json": from_json_datetime}})
+    def MyDateComponentSame(month: datetime.date, event_date_clicked: Callable):
+        pass
+
+    ```
+
     ## Arguments
 
      * `vue_path`: The path to the Vue template file.
@@ -113,7 +173,7 @@ def component_vue(vue_path: str, vuetify=True) -> Callable[[Callable[P, None]],
     """
 
     def decorator(func: Callable[P, None]):
-        VueWidgetSolaraSub = _widget_vue(vue_path, vuetify=vuetify)(func)
+        VueWidgetSolaraSub = _widget_vue(vue_path, vuetify=vuetify, to_json=to_json, from_json=from_json, tags=tags)(func)
 
         def wrapper(*args, **kwargs):
             event_callbacks = {}

{solara_ui-1.51.1 → solara_ui-1.52.0}/solara/server/static/solara_bootstrap.py

@@ -119,7 +119,7 @@ async def main():
     ]
     for dep in requirements:
         await micropip.install(dep, keep_going=True)
-    await micropip.install("/wheels/solara-1.51.1-py2.py3-none-any.whl", keep_going=True)
+    await micropip.install("/wheels/solara-1.52.0-py2.py3-none-any.whl", keep_going=True)
     import solara
 
     el = solara.Warning("lala")

{solara_ui-1.51.1 → solara_ui-1.52.0}/tests/integration/api_test.py

@@ -69,6 +69,11 @@ def test_dataframe(page_session: playwright.sync_api.Page, solara_server, solara
         datatable_value_counts = page_session.locator(".solara-data-table").nth(1)
         datatable_value_counts.wait_for()
 
+        # scroll and wait for stability of test
+        datatable_value_counts.locator("th >> text=species_id >> _vue=v-icon").wait_for()
+        datatable_value_counts.locator("th >> text=species_id >> _vue=v-icon").scroll_into_view_if_needed()
+        page_session.wait_for_timeout(1000)
+
         # open the species hover menu
         datatable_value_counts.locator("th >> text=species_id >> _vue=v-icon").hover()
         page_session.locator("text=Value counts for species_id").wait_for()

{solara_ui-1.51.1 → solara_ui-1.52.0}/tests/integration/cdn_test.py

@@ -1,3 +1,4 @@
+import sys
 import playwright.sync_api
 import pytest
 from IPython.display import display
@@ -7,6 +8,7 @@ from .conftest import SERVERS
 # the altair figure uses the CDN
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="Unstable on windows")
 def test_cdn_via_altair(ipywidgets_runner, page_session: playwright.sync_api.Page, request, assert_solara_snapshot):
     if request.node.callspec.params["ipywidgets_runner"] != "solara" and request.node.callspec.params["solara_server"] != SERVERS[0]:
         pytest.skip("No need to run this test for all servers.")

{solara_ui-1.51.1 → solara_ui-1.52.0}/tests/integration/widget_test.py

@@ -1,3 +1,4 @@
+import sys
 import ipywidgets as widgets
 import playwright.sync_api
 import pytest
@@ -64,6 +65,7 @@ def test_widget_ipyaggrid(solara_test, page_session: playwright.sync_api.Page):
     page_session.remove_listener("console", log)
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="Unstable on windows")
 def test_solara_button_all(ipywidgets_runner, page_session: playwright.sync_api.Page, request, assert_solara_snapshot):
     if request.node.callspec.params["ipywidgets_runner"] != "solara" and request.node.callspec.params["solara_server"] != SERVERS[0]:
         pytest.skip("No need to run this test for all servers.")

{solara_ui-1.51.1 → solara_ui-1.52.0}/tests/unit/app_test.py

@@ -144,12 +144,12 @@ def test_watch_module_reload(tmpdir, kernel_context, extra_include_path, no_kern
             # assert "somemod" not in sys.modules
             # breakpoint()
             result = app.run()
-            assert "somemod" in sys.modules
+            somemod2 = sys.modules.get("somemod")
+            assert somemod1 is not somemod2
+            assert somemod2 is not None
             root = solara.RoutingProvider(children=[result], routes=app.routes, pathname="/")
             box, rc = solara.render(root, handle_error=False)
             assert rc.find(v.Card, children=["second"])
-            somemod2 = sys.modules["somemod"]
-            assert somemod1 is not somemod2
         finally:
             app.close()
             if "somemod" in sys.modules:

{solara_ui-1.51.1 → solara_ui-1.52.0}/tests/unit/component_frontend_test.py

@@ -1,5 +1,7 @@
 import unittest.mock
 
+import pytest
+
 import solara
 
 
@@ -17,6 +19,35 @@ def test_component_vue_basic():
     assert widget.name == "Universe"
 
 
+@pytest.mark.parametrize("use_tags", [True, False])
+def test_component_vue_basic_with_custom_serializer(use_tags: bool):
+    if use_tags:
+
+        @solara._component_vue("component_vue_test.vue", tags={"value": {"to_json": lambda x, w: str(x), "from_json": lambda x, w: int(x)}})
+        def ComponentVueTest(value: int, name: str = "World"):
+            pass
+    else:
+
+        @solara._component_vue("component_vue_test.vue", to_json={"value": lambda x, w: str(x)}, from_json={"value": lambda x, w: int(x)})
+        def ComponentVueTest(value: int, name: str = "World"):
+            pass
+
+    box, rc = solara.render(ComponentVueTest(value=1))
+    widget = box.children[0]
+    assert widget.value == 1
+    assert widget.name == "World"
+
+    state = widget.get_state()
+    assert state["value"] == "1"
+    assert state["name"] == "World"
+
+    state["value"] = "2"
+    state["name"] = "Universe"
+    widget.set_state(state)
+    assert widget.value == 2
+    assert widget.name == "Universe"
+
+
 def test_component_vue_callback():
     mock = unittest.mock.Mock()
 
@@ -48,3 +79,6 @@ def test_component_vue_event():
     mock.assert_called_once_with(42)
     widget._handle_event(None, {"event": "foo", "data": 42}, [b"bar"])
     mock.assert_called_with(42, [b"bar"])
+
+    widget._handle_event(None, {"event": "event_foo", "data": 43}, [b"bar2"])
+    mock.assert_called_with(43, [b"bar2"])