solara-ui 1.56.0__tar.gz → 1.57.1__tar.gz

{solara_ui-1.56.0 → solara_ui-1.57.1}/.gitignore

@@ -67,6 +67,7 @@ python/.idea
 test/.idea
 venv
 .venv
+uv.lock
 tmp
 python/vaex/version.py # gets generated
 **/*.egg-info/

{solara_ui-1.56.0 → solara_ui-1.57.1}/PKG-INFO

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

{solara_ui-1.56.0 → solara_ui-1.57.1}/solara/__init__.py

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

{solara_ui-1.56.0 → solara_ui-1.57.1}/solara/components/figure_altair.py

@@ -25,11 +25,15 @@ def FigureAltair(
 
     with alt.renderers.enable("mimetype"):
         bundle = chart._repr_mimebundle_()[0]
-        key4 = "application/vnd.vegalite.v4+json"
-        key5 = "application/vnd.vegalite.v5+json"
-        if key4 not in bundle and key5 not in bundle:
-            raise KeyError(f"{key4} and {key5} not in mimebundle:\n\n{bundle}")
-        spec = bundle.get(key5, bundle.get(key4))
+        # Find the Vega-Lite spec from the bundle (supports v4, v5, v6+)
+        # MIME type format varies: v4/v5 use "+json" suffix, v6 uses ".json"
+        spec = None
+        for key in bundle:
+            if key.startswith("application/vnd.vegalite.v"):
+                spec = bundle[key]
+                break
+        if spec is None:
+            raise KeyError(f"No Vega-Lite MIME type found in mimebundle: {list(bundle.keys())}")
         return solara.widgets.VegaLite.element(
             spec=spec, on_click=on_click, listen_to_click=on_click is not None, on_hover=on_hover, listen_to_hover=on_hover is not None
         )

{solara_ui-1.56.0 → solara_ui-1.57.1}/solara/components/file_browser.py

@@ -1,3 +1,4 @@
+import asyncio
 import os
 from os.path import isfile, join
 from pathlib import Path
@@ -8,6 +9,11 @@ import humanize
 import ipyvuetify as vy
 import traitlets
 
+try:
+    import watchfiles
+except ModuleNotFoundError:
+    watchfiles = None  # type: ignore
+
 import solara
 from solara.components import Div
 
@@ -84,6 +90,7 @@ def FileBrowser(
     on_file_name: Optional[Callable[[str], None]] = None,
     start_directory=None,
     can_select=False,
+    watch: bool = False,
 ):
     """File/directory browser at the server side.
 
@@ -109,6 +116,8 @@ def FileBrowser(
      * `directory_first`: If `True` directories are shown before files. Default: `False`.
      * `on_file_name`: (deprecated) Use on_file_open instead.
      * `start_directory`: (deprecated) Use directory instead.
+     * `watch`: If `True`, watch the current directory for file changes and automatically refresh the file list.
+        Requires the `watchfiles` package to be installed.
     """
     if start_directory is not None:
         directory = start_directory  # pragma: no cover
@@ -122,6 +131,8 @@ def FileBrowser(
     warning, set_warning = solara.use_state(cast(Optional[str], None))
     scroll_pos_stack, set_scroll_pos_stack = solara.use_state(cast(List[int], []))
     scroll_pos, set_scroll_pos = solara.use_state(0)
+    # Counter to trigger re-render when files change
+    file_change_counter, set_file_change_counter = solara.use_state(0)
     selected_private, set_selected_private = use_reactive_or_value(
         selected,
         on_value=on_path_select if can_select else lambda x: None,
@@ -137,12 +148,48 @@ def FileBrowser(
             # if we select a file, we need to make sure the directory is correct
             # NOTE: although we expect a Path, abuse might make it a string
             if isinstance(selected_private, Path):
-                # Note that we do not call .resolve() before using .parent, otherwise /some/path/.. will
-                # set the current directory to /, moving up two levels.
-                current_dir.value = selected_private.parent.resolve()
+                # Only sync directory from selected if the path is absolute.
+                # Relative paths would resolve against the process CWD, not the
+                # current directory shown in the FileBrowser, leading to incorrect paths.
+                if selected_private.is_absolute():
+                    # Note that we do not call .resolve() before using .parent, otherwise /some/path/.. will
+                    # set the current directory to /, moving up two levels.
+                    current_dir.value = selected_private.parent.resolve()
 
     solara.use_effect(sync_directory_from_selected, [selected_private])
 
+    def watch_directory():
+        if not watch:
+            return
+        if not watchfiles:
+            logger.warning("watchfiles not installed, cannot watch directory")
+            return
+
+        # Check if there's a running event loop before creating the coroutine
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            # No running event loop (e.g., in unit tests or non-server environments)
+            logger.warning("No running event loop, cannot watch directory for changes")
+            return
+
+        dir_to_watch = current_dir.value
+
+        async def watch_task():
+            try:
+                async for _ in watchfiles.awatch(dir_to_watch):
+                    logger.debug("Directory %s changed, refreshing file list", dir_to_watch)
+                    set_file_change_counter(lambda x: x + 1)
+            except RuntimeError:
+                pass  # swallow the RuntimeError: Already borrowed errors from watchfiles
+            except Exception:
+                logger.exception("Error watching directory")
+
+        future = asyncio.create_task(watch_task())
+        return future.cancel
+
+    solara.use_effect(watch_directory, [watch, current_dir.value])
+
     def change_dir(new_dir: Path):
         if os.access(new_dir, os.R_OK):
             current_dir.value = new_dir

{solara_ui-1.56.0 → solara_ui-1.57.1}/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.56.0-py2.py3-none-any.whl", keep_going=True)
+    await micropip.install("/wheels/solara-1.57.1-py2.py3-none-any.whl", keep_going=True)
     import solara
 
     el = solara.Warning("lala")

{solara_ui-1.56.0 → solara_ui-1.57.1}/solara/website/pages/changelog/changelog.md

@@ -1,5 +1,88 @@
 # Solara Changelog
 
+## Version 1.57.0
+
+   * Feature: Add `watch` option to `FileBrowser` for automatic file change detection. [a0c75202](https://github.com/widgetti/solara/commit/a0c75202)
+   * Bug Fix: Prevent `FileBrowser` from using relative paths for directory sync. [7be73e88](https://github.com/widgetti/solara/commit/7be73e88)
+
+## Version 1.56.0
+
+   * Feature: On disconnect and reconnect, force a page reload. [8d6fb2f1](https://github.com/widgetti/solara/commit/8d6fb2f1)
+   * Feature: Allow `data` function in `FileDownload` to be a coroutine. [a395f090](https://github.com/widgetti/solara/commit/a395f090)
+   * Breaking change: Drop Python 3.7 support. [abd9400d](https://github.com/widgetti/solara/commit/abd9400d)
+
+## Version 1.55.1
+
+   * Bug Fix: False positive for returns in async defs for hook use validation. [67381dc6](https://github.com/widgetti/solara/commit/67381dc6)
+
+## Version 1.55.0
+
+   * Feature: Allows tasks to have their own kernel context. [3a97835a](https://github.com/widgetti/solara/commit/3a97835a)
+   * Bug Fix: Python 3.14 compatibility - fix RuntimeError in BaseSettings iteration. [4bf31d5a](https://github.com/widgetti/solara/commit/4bf31d5a)
+
+## Version 1.54.0
+
+   * Feature: Use different port in `pytest-ipywidgets` for different workers in `pytest-xdist`. [7e924e21](https://github.com/widgetti/solara/commit/7e924e21)
+
+## Version 1.53.0
+
+   * Feature: With `--log-level=info` we can see where a reactive variable was set. [771df82f](https://github.com/widgetti/solara/commit/771df82f)
+   * Bug Fix: Hash and search were flipped, causing strange URLs/locations. [375fd9ba](https://github.com/widgetti/solara/commit/375fd9ba)
+
+## Version 1.52.0
+
+   * Feature: In Vue template, support both `event_foo` and `foo` to avoid LLM confusion. [3ba93278](https://github.com/widgetti/solara/commit/3ba93278)
+   * Feature: Allow custom serializers in Vue components. [cd1beabb](https://github.com/widgetti/solara/commit/cd1beabb)
+   * Bug Fix: Exclude breaking ipykernel releases. [9858c013](https://github.com/widgetti/solara/commit/9858c013)
+   * Bug Fix: Support modern versions of uvicorn. [ce2abebd](https://github.com/widgetti/solara/commit/ce2abebd)
+
+## Version 1.51.1
+
+   * Bug Fix: Enhance thread init patching to handle latest anyio (4.10.0) which may not populate name field properly. [93f78c6f](https://github.com/widgetti/solara/commit/93f78c6f)
+
+## Version 1.51.0
+
+   * Feature: Configure the initial title before the app runs/loads. [4515a8c3](https://github.com/widgetti/solara/commit/4515a8c3)
+   * Bug Fix: Do not crash on `use_close_menu`. [d0032943](https://github.com/widgetti/solara/commit/d0032943)
+
+## Version 1.50.1
+
+   * Bug Fix: `FileBrowser` could go two directories up if ".." was selected. [68e99e58](https://github.com/widgetti/solara/commit/68e99e58)
+   * Bug Fix: Tornado async gives no issues with event loops. [6706f6ed](https://github.com/widgetti/solara/commit/6706f6ed)
+
+## Version 1.50.0
+
+   * Feature: Support `Optional[str]` / optional for `InputText`. [814a8a6c](https://github.com/widgetti/solara/commit/814a8a6c)
+   * Feature: Give more control over the underlying Vuetify text input. [c5b47a84](https://github.com/widgetti/solara/commit/c5b47a84)
+   * Bug Fix: Sanitize infinite values in `/resourcez` JSON response. [6aacbff4](https://github.com/widgetti/solara/commit/6aacbff4)
+
+## Version 1.49.0
+
+   * Feature: Control selected file or directory externally in `FileBrowser`. [73a26dde](https://github.com/widgetti/solara/commit/73a26dde)
+   * Feature: Support relative paths in `FileBrowser`. [4b172244](https://github.com/widgetti/solara/commit/4b172244)
+
+## Version 1.48.0
+
+   * Feature: Expose `col_num` and `row_height` options for `GridLayout`. [8f40eeb5](https://github.com/widgetti/solara/commit/8f40eeb5)
+   * Feature: Warn if task is being called from a component. [e454b953](https://github.com/widgetti/solara/commit/e454b953)
+   * Bug Fix: Decrease `chunk_size` for `FileDrop` to 1MB to avoid Modal max 2MB limit. [fa65d5a1](https://github.com/widgetti/solara/commit/fa65d5a1)
+   * Bug Fix: Resolve logger warnings. [#1059](https://github.com/widgetti/solara/pull/1059)
+   * Bug Fix: A `use_task` with `dependencies=None` (user called) can have arguments. [da2f8cfe](https://github.com/widgetti/solara/commit/da2f8cfe)
+
+## Version 1.47.0
+
+   * Feature: Add `on_layer_updated` to `GridLayout`. [1163b89d](https://github.com/widgetti/solara/commit/1163b89d)
+   * Bug Fix: Classes were not applied to `ColumnsResponsive` when `wrap` was `False`. [ce879dad](https://github.com/widgetti/solara/commit/ce879dad)
+   * Bug Fix: Tasks did not have a stable key, causing hot reloads to miss values. [e1567f9d](https://github.com/widgetti/solara/commit/e1567f9d)
+   * Bug Fix: Re-run app on hot reload before running `on_kernel_start` callbacks. [cf4f5c1a](https://github.com/widgetti/solara/commit/cf4f5c1a)
+   * Bug Fix: Display port in runtime error when server is running. [cafe757c](https://github.com/widgetti/solara/commit/cafe757c)
+
+## Version 1.46.0
+
+   * Feature: When tasks fail to set results, handle it gracefully. [e6c1ce07](https://github.com/widgetti/solara/commit/e6c1ce07)
+   * Bug Fix: Follow ASGI spec and also check if text or bytes are `None` (Modal fix). [396c58ac](https://github.com/widgetti/solara/commit/396c58ac)
+   * Bug Fix: Make task threads daemon, so the Solara server can stop when tasks are running. [da346063](https://github.com/widgetti/solara/commit/da346063)
+
 ## Version 1.45.0
 
    * Bug Fix: Correctly handle expected websocket errors instead of logging them. [#1013](https://github.com/widgetti/solara/pull/1013)

solara_ui-1.57.1/tests/unit/figure_altair_test.py

@@ -0,0 +1,75 @@
+import unittest.mock
+
+import pytest
+
+import solara
+import solara.widgets
+
+
+class MockChart:
+    """Mock Altair chart that returns a configurable mimebundle."""
+
+    def __init__(self, bundle):
+        self._bundle = bundle
+
+    def _repr_mimebundle_(self):
+        return (self._bundle, {})
+
+
+@pytest.fixture
+def mock_altair_renderers():
+    """Mock altair.renderers.enable to be a no-op context manager."""
+    import contextlib
+
+    import altair as alt
+
+    @contextlib.contextmanager
+    def mock_enable(renderer):
+        yield
+
+    with unittest.mock.patch.object(alt.renderers, "enable", mock_enable):
+        yield
+
+
+def test_figure_altair_v4(mock_altair_renderers):
+    spec = {"$schema": "https://vega.github.io/schema/vega-lite/v4.json", "data": {"values": []}}
+    chart = MockChart({"application/vnd.vegalite.v4+json": spec})
+
+    el = solara.FigureAltair(chart)
+    _, rc = solara.render(el, handle_error=False)
+    widget = rc.find(solara.widgets.VegaLite).widget
+    assert widget.spec == spec
+    rc.close()
+
+
+def test_figure_altair_v5(mock_altair_renderers):
+    spec = {"$schema": "https://vega.github.io/schema/vega-lite/v5.json", "data": {"values": []}}
+    chart = MockChart({"application/vnd.vegalite.v5+json": spec})
+
+    el = solara.FigureAltair(chart)
+    _, rc = solara.render(el, handle_error=False)
+    widget = rc.find(solara.widgets.VegaLite).widget
+    assert widget.spec == spec
+    rc.close()
+
+
+def test_figure_altair_v6(mock_altair_renderers):
+    """Test that Altair 6+ with v6 MIME type works (uses .json suffix instead of +json)."""
+    spec = {"$schema": "https://vega.github.io/schema/vega-lite/v6.json", "data": {"values": []}}
+    # Altair 6 uses ".json" suffix instead of "+json"
+    chart = MockChart({"application/vnd.vegalite.v6.json": spec})
+
+    el = solara.FigureAltair(chart)
+    _, rc = solara.render(el, handle_error=False)
+    widget = rc.find(solara.widgets.VegaLite).widget
+    assert widget.spec == spec
+    rc.close()
+
+
+def test_figure_altair_no_vegalite_mime(mock_altair_renderers):
+    """Test that a KeyError is raised when no Vega-Lite MIME type is found."""
+    chart = MockChart({"text/plain": "some text"})
+
+    el = solara.FigureAltair(chart)
+    with pytest.raises(KeyError, match="No Vega-Lite MIME type found"):
+        solara.render(el, handle_error=False)

{solara_ui-1.56.0 → solara_ui-1.57.1}/tests/unit/file_browser_test.py

@@ -1,3 +1,4 @@
+import asyncio
 import platform
 import unittest.mock
 from pathlib import Path
@@ -290,3 +291,197 @@ def test_file_browser_programmatic_select():
     selected.value = current_dir.value / ".." / "unit" / ".."
     assert current_dir.value == HERE.parent
     rc.close()
+
+
+def test_file_browser_watch_no_event_loop(tmpdir: Path):
+    """Test that watch=True gracefully handles no running event loop."""
+    tmpdir = Path(tmpdir)
+    (tmpdir / "test.txt").write_text("test")
+
+    # When watch=True but no event loop is available, it should log a warning but not crash
+    with unittest.mock.patch.object(solara.components.file_browser.logger, "warning") as mock_warning:
+
+        @solara.component
+        def Test():
+            return solara.FileBrowser(tmpdir, watch=True)
+
+        div, rc = solara.render_fixed(Test(), handle_error=False)
+        file_list: solara.components.file_browser.FileListWidget = div.children[1]
+
+        # Verify files are still shown correctly
+        files = {k["name"] for k in file_list.files}
+        assert "test.txt" in files
+
+        # Verify warning was logged about no event loop
+        mock_warning.assert_called_with("No running event loop, cannot watch directory for changes")
+        rc.close()
+
+
+def test_file_browser_watch_disabled_by_default():
+    """Test that watch is disabled by default (no warning when watchfiles not available)."""
+
+    @solara.component
+    def Test():
+        return solara.FileBrowser(HERE.parent)
+
+    # This should work without any issues even if watchfiles is not installed
+    div, rc = solara.render_fixed(Test(), handle_error=False)
+    file_list: solara.components.file_browser.FileListWidget = div.children[1]
+    assert "file_browser_test.py" in file_list
+    rc.close()
+
+
+def test_file_browser_watch_no_watchfiles(tmpdir: Path):
+    """Test that watch=True logs a warning when watchfiles is not installed."""
+    tmpdir = Path(tmpdir)
+    (tmpdir / "test.txt").write_text("test")
+
+    with unittest.mock.patch.object(solara.components.file_browser, "watchfiles", None):
+        with unittest.mock.patch.object(solara.components.file_browser.logger, "warning") as mock_warning:
+
+            @solara.component
+            def Test():
+                return solara.FileBrowser(tmpdir, watch=True)
+
+            div, rc = solara.render_fixed(Test(), handle_error=False)
+
+            # Give the effect a chance to run
+            import time
+
+            time.sleep(0.1)
+
+            mock_warning.assert_called_with("watchfiles not installed, cannot watch directory")
+            rc.close()
+
+
+@pytest.mark.asyncio
+async def test_file_browser_watch_detects_new_file(tmpdir: Path):
+    """Test that watch=True actually detects when a new file is added."""
+    tmpdir = Path(tmpdir)
+    (tmpdir / "initial.txt").write_text("initial")
+
+    files_changed_event = asyncio.Event()
+
+    @solara.component
+    def Test():
+        return solara.FileBrowser(tmpdir, watch=True)
+
+    div, rc = solara.render_fixed(Test(), handle_error=False)
+    file_list: solara.components.file_browser.FileListWidget = div.children[1]
+
+    # Verify initial state
+    initial_files = {k["name"] for k in file_list.files}
+    assert "initial.txt" in initial_files
+    assert "new_file.txt" not in initial_files
+
+    # Set up observer to detect when files trait changes
+    def on_files_change(change):
+        files_changed_event.set()
+
+    file_list.observe(on_files_change, "files")
+
+    # Give the watcher task a moment to start
+    await asyncio.sleep(0.1)
+
+    # Create a new file - this should trigger the watcher
+    (tmpdir / "new_file.txt").write_text("new content")
+
+    # Wait for the watcher to detect the change
+    try:
+        await asyncio.wait_for(files_changed_event.wait(), timeout=5.0)
+    except asyncio.TimeoutError:
+        pytest.fail("File change was not detected within timeout")
+
+    # Verify the new file is now in the list
+    new_files = {k["name"] for k in file_list.files}
+    assert "new_file.txt" in new_files
+    assert "initial.txt" in new_files
+
+    rc.close()
+
+
+@pytest.mark.asyncio
+async def test_file_browser_watch_detects_deleted_file(tmpdir: Path):
+    """Test that watch=True detects when a file is deleted."""
+    tmpdir = Path(tmpdir)
+    (tmpdir / "file1.txt").write_text("content1")
+    (tmpdir / "file2.txt").write_text("content2")
+
+    files_changed_event = asyncio.Event()
+
+    @solara.component
+    def Test():
+        return solara.FileBrowser(tmpdir, watch=True)
+
+    div, rc = solara.render_fixed(Test(), handle_error=False)
+    file_list: solara.components.file_browser.FileListWidget = div.children[1]
+
+    # Verify initial state
+    initial_files = {k["name"] for k in file_list.files}
+    assert "file1.txt" in initial_files
+    assert "file2.txt" in initial_files
+
+    # Set up observer
+    def on_files_change(change):
+        files_changed_event.set()
+
+    file_list.observe(on_files_change, "files")
+
+    # Give the watcher task a moment to start
+    await asyncio.sleep(0.1)
+
+    # Delete a file
+    (tmpdir / "file2.txt").unlink()
+
+    # Wait for the watcher to detect the change
+    try:
+        await asyncio.wait_for(files_changed_event.wait(), timeout=5.0)
+    except asyncio.TimeoutError:
+        pytest.fail("File deletion was not detected within timeout")
+
+    # Verify file2 is gone
+    new_files = {k["name"] for k in file_list.files}
+    assert "file1.txt" in new_files
+    assert "file2.txt" not in new_files
+
+    rc.close()
+
+
+def test_file_browser_selected_relative_path_after_full_path(tmpdir: Path):
+    """Test that FileBrowser handles setting selected to a relative path after a full path.
+
+    Regression test for issue where:
+    1. User sets selected to a full path like /some/path/subdir/file.txt
+    2. User then sets selected to a relative path like subdir/file.txt
+    3. The current_dir would incorrectly become /some/path/subdir/subdir
+       because the relative path's parent was appended to the existing directory.
+    """
+    tmpdir = Path(tmpdir)
+    subdir = tmpdir / "subdir"
+    subdir.mkdir()
+    (subdir / "file.txt").write_text("content")
+
+    selected = solara.reactive(cast(Optional[Path], None))
+
+    @solara.component
+    def Test():
+        return solara.FileBrowser(tmpdir, selected=selected, can_select=True)
+
+    div, rc = solara.render_fixed(Test(), handle_error=False)
+
+    # First, set selected to a full path
+    full_path = subdir / "file.txt"
+    selected.value = full_path
+
+    # Verify we're now in the subdir
+    current_dir_text = div.children[0].children[0]
+    assert str(subdir) in current_dir_text
+
+    # Now set selected to a relative path (simulating user setting selected to "subdir/file.txt")
+    # This should work and stay in the same subdir, not create /subdir/subdir
+    relative_path = Path("subdir") / "file.txt"
+    selected.value = relative_path
+
+    # This should not raise FileNotFoundError
+    # The current_dir should resolve relative to cwd, not to the previous current_dir
+    rc.close()