grimoireplot 0.0.2__tar.gz → 0.0.3__tar.gz

{grimoireplot-0.0.2 → grimoireplot-0.0.3}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.3
 Name: grimoireplot
-Version: 0.0.2
+Version: 0.0.3
 Summary: GrimoirePlot is a live dashboard of plotly-compatible plots of remote data
 Author: William Droz
 Author-email: William Droz <william.droz@idiap.ch>
 Classifier: License :: OSI Approved :: MIT License
 Requires-Dist: aiohttp[speedups]>=3.13.3
 Requires-Dist: loguru>=0.7.3
-Requires-Dist: nicegui>=3.5.0,<4
+Requires-Dist: nicegui>=3.14.0,<4
 Requires-Dist: plotly>=6.5.2
 Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: requests>=2.32.5

grimoireplot-0.0.3/grimoireplot/plot_live_update.py

@@ -0,0 +1,212 @@
+# SPDX-FileCopyrightText: Copyright © 2026 Idiap Research Institute <contact@idiap.ch>
+# SPDX-FileContributor: William Droz <william.droz@idiap.ch>
+# SPDX-License-Identifier: MIT
+
+"""Live Plotly updates using NiceGUI's built-in plotly APIs.
+
+Follows the patterns from NiceGUI's plotly documentation:
+https://nicegui.io/documentation/plotly#plot_updates
+
+- Dict figures with mutable trace lists (not go.Figure) for extendTraces
+- ``plot.run_plot_method('extendTraces', ...)`` for append-only live data
+- ``plot.run_plot_method('relayout', ...)`` for layout-only changes
+- Mutate ``plot.figure`` in place + ``plot.update()`` for structural changes
+  (NiceGUI calls Plotly.react on the client when config is unchanged)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from nicegui import ui
+
+from grimoireplot.ui_elements import style_plotly_figure
+
+
+def plot_uirevision(grimoire_name: str, chapter_name: str, plot_name: str) -> str:
+    """Stable uirevision key so Plotly preserves axis ranges across updates."""
+    return f"{grimoire_name}/{chapter_name}/{plot_name}"
+
+
+def normalize_figure_dict(fig_data: dict) -> dict:
+    """Return a dict figure suitable for NiceGUI live updates.
+
+    NiceGUI recommends the declarative dict interface so trace ``x``/``y`` stay
+    mutable lists that can be appended and synced with extendTraces.
+    """
+    normalized: dict[str, Any] = {
+        "data": [],
+        "layout": dict(fig_data.get("layout", {})),
+    }
+    if "config" in fig_data:
+        normalized["config"] = dict(fig_data["config"])
+
+    for trace in fig_data.get("data", []):
+        trace_copy = dict(trace)
+        for axis in ("x", "y"):
+            values = trace.get(axis)
+            if isinstance(values, list):
+                trace_copy[axis] = list(values)
+        normalized["data"].append(trace_copy)
+
+    return normalized
+
+
+def prepare_figure(fig_data: dict, uirevision: str) -> dict:
+    """Normalize, theme, and set uirevision on incoming figure data."""
+    styled = style_plotly_figure(normalize_figure_dict(fig_data))
+    styled["layout"]["uirevision"] = uirevision
+    return styled
+
+
+def _title_text(layout: dict) -> str | None:
+    title = layout.get("title")
+    if isinstance(title, dict):
+        return title.get("text")
+    if isinstance(title, str):
+        return title
+    return None
+
+
+def _axis_title_text(layout: dict, axis: str) -> str | None:
+    axis_layout = layout.get(axis, {})
+    if not isinstance(axis_layout, dict):
+        return None
+    title = axis_layout.get("title")
+    if isinstance(title, dict):
+        return title.get("text")
+    if isinstance(title, str):
+        return title
+    return None
+
+
+def layout_relayout_diff(old_layout: dict, new_layout: dict) -> dict[str, Any]:
+    """Return plotly.js relayout keys for layout fields that changed."""
+    diff: dict[str, Any] = {}
+
+    new_title = _title_text(new_layout)
+    if _title_text(old_layout) != new_title:
+        diff["title.text"] = new_title
+
+    for axis in ("xaxis", "yaxis"):
+        new_axis_title = _axis_title_text(new_layout, axis)
+        if _axis_title_text(old_layout, axis) != new_axis_title:
+            diff[f"{axis}.title.text"] = new_axis_title
+
+    return diff
+
+
+def _trace_type(trace: dict) -> str:
+    return trace.get("type", "scatter")
+
+
+def trace_data_appended(
+    old_trace: dict, new_trace: dict
+) -> tuple[list[Any], list[Any]] | None:
+    """Return appended (x, y) if new_trace extends old_trace, else None."""
+    if _trace_type(old_trace) != _trace_type(new_trace):
+        return None
+
+    old_x, old_y = old_trace.get("x", []), old_trace.get("y", [])
+    new_x, new_y = new_trace.get("x", []), new_trace.get("y", [])
+
+    if not isinstance(old_x, list) or not isinstance(new_x, list):
+        return None
+    if not isinstance(old_y, list) or not isinstance(new_y, list):
+        return None
+    if len(new_x) < len(old_x) or len(new_y) < len(old_y):
+        return None
+    if new_x[: len(old_x)] != old_x or new_y[: len(old_y)] != old_y:
+        return None
+
+    return (new_x[len(old_x) :], new_y[len(old_y) :])
+
+
+def _figure_dict(chart: ui.plotly) -> dict | None:
+    figure = chart.figure
+    return figure if isinstance(figure, dict) else None
+
+
+def try_extend_traces_update(
+    chart: ui.plotly, new_fig_data: dict, uirevision: str
+) -> bool:
+    """Use NiceGUI's run_plot_method('extendTraces') when traces only grow."""
+    current = _figure_dict(chart)
+    if current is None:
+        return False
+
+    styled = prepare_figure(new_fig_data, uirevision)
+
+    old_data = current.get("data", [])
+    new_data = styled.get("data", [])
+    if len(old_data) != len(new_data) or not old_data:
+        return False
+
+    extend_x: list[list[Any]] = []
+    extend_y: list[list[Any]] = []
+    trace_indices: list[int] = []
+
+    for index, (old_trace, new_trace) in enumerate(zip(old_data, new_data)):
+        appended = trace_data_appended(old_trace, new_trace)
+        if appended is None:
+            return False
+        added_x, added_y = appended
+        if added_x:
+            extend_x.append(added_x)
+            extend_y.append(added_y)
+            trace_indices.append(index)
+
+    relayout_diff = layout_relayout_diff(
+        current.get("layout", {}), styled.get("layout", {})
+    )
+
+    if not trace_indices and not relayout_diff:
+        return True
+
+    if trace_indices:
+        chart.run_plot_method(
+            "extendTraces", {"x": extend_x, "y": extend_y}, trace_indices
+        )
+        for trace_index, added_x, added_y in zip(trace_indices, extend_x, extend_y):
+            current["data"][trace_index]["x"].extend(added_x)
+            current["data"][trace_index]["y"].extend(added_y)
+
+    if relayout_diff:
+        chart.run_plot_method("relayout", relayout_diff)
+
+    current.setdefault("layout", {}).update(styled["layout"])
+    current["layout"]["uirevision"] = uirevision
+    if "config" in styled:
+        current["config"] = styled["config"]
+
+    return True
+
+
+def mutate_figure_and_update(
+    chart: ui.plotly, new_fig_data: dict, uirevision: str
+) -> None:
+    """Mutate plot.figure in place and call plot.update() (Plotly.react on client)."""
+    styled = prepare_figure(new_fig_data, uirevision)
+
+    figure = _figure_dict(chart)
+    if figure is None:
+        chart.figure = styled
+        chart.update()
+        return
+
+    figure["data"] = styled["data"]
+    figure["layout"] = styled["layout"]
+    if "config" in styled:
+        figure["config"] = styled["config"]
+    chart.update()
+
+
+def update_plotly_chart(chart: ui.plotly, new_fig_data: dict, uirevision: str) -> None:
+    """Pick the lightest NiceGUI/Plotly update path for the incoming figure."""
+    if not try_extend_traces_update(chart, new_fig_data, uirevision):
+        mutate_figure_and_update(chart, new_fig_data, uirevision)
+
+
+# Backwards-compatible aliases used by ui.py
+try_incremental_update = try_extend_traces_update
+apply_full_chart_update = mutate_figure_and_update

{grimoireplot-0.0.2 → grimoireplot-0.0.3}/grimoireplot/server.py

@@ -2,6 +2,7 @@
 # SPDX-FileContributor: William Droz <william.droz@idiap.ch>
 # SPDX-License-Identifier: MIT
 
+import json
 import time
 import logging
 from functools import wraps
@@ -18,7 +19,7 @@ from grimoireplot.models import (
     delete_grimoire,
 )
 
-from grimoireplot.ui import dashboard_ui, refresh_chapter_plots
+from grimoireplot.ui import dashboard_ui, refresh_chapter_plots, update_plot_chart
 from grimoireplot.ui_elements import setup_theme
 
 _GRIMOIRE_SECRET = get_grimoire_secret()
@@ -82,8 +83,17 @@ def my_app(host: str = "localhost", port: int = 8080):
             plot_name=add_plot_request.plot_name,
             json_data=add_plot_request.json_data,
         )
-        # Try to refresh only the specific chapter's plots
-        # If the chapter doesn't exist in UI yet (new grimoire/chapter), refresh the whole dashboard
+        # Update existing charts in place for live plots; fall back to UI refresh for new plots
+        fig_data = json.loads(add_plot_request.json_data)
+        if update_plot_chart(
+            add_plot_request.grimoire_name,
+            add_plot_request.chapter_name,
+            add_plot_request.plot_name,
+            fig_data,
+        ):
+            return {"status": "success", "plot_name": plot.name}
+
+        # New plot or chapter not yet rendered: refresh chapter or whole dashboard
         if not refresh_chapter_plots(
             add_plot_request.grimoire_name, add_plot_request.chapter_name
         ):

{grimoireplot-0.0.2 → grimoireplot-0.0.3}/grimoireplot/ui.py

@@ -32,10 +32,55 @@ from grimoireplot.ui_elements import (
     create_btn_ghost,
     create_btn_danger,
 )
+from grimoireplot.plot_live_update import plot_uirevision, update_plotly_chart
 
 # Store refreshable instances for each chapter's plots
 _chapter_plot_refreshables: dict[tuple[str, str], ui.refreshable] = {}
 
+# Live plot charts keyed by (grimoire_name, chapter_name, plot_name)
+_plot_charts: dict[tuple[str, str, str], ui.plotly] = {}
+
+
+def _plot_key(
+    grimoire_name: str, chapter_name: str, plot_name: str
+) -> tuple[str, str, str]:
+    return (grimoire_name, chapter_name, plot_name)
+
+
+def clear_plot_charts_for_chapter(grimoire_name: str, chapter_name: str) -> None:
+    """Remove chart references for a chapter before it is re-rendered."""
+    keys_to_remove = [
+        key
+        for key in _plot_charts
+        if key[0] == grimoire_name and key[1] == chapter_name
+    ]
+    for key in keys_to_remove:
+        _plot_charts.pop(key, None)
+
+
+def clear_all_plot_charts() -> None:
+    """Remove all live plot chart references."""
+    _plot_charts.clear()
+
+
+def update_plot_chart(
+    grimoire_name: str, chapter_name: str, plot_name: str, fig_data: dict
+) -> bool:
+    """Update an existing plot chart using NiceGUI's built-in plotly APIs.
+
+    Returns True if the chart was found and updated, False if a full refresh is needed.
+    """
+    chart = _plot_charts.get(_plot_key(grimoire_name, chapter_name, plot_name))
+    if chart is None:
+        return False
+
+    update_plotly_chart(
+        chart,
+        fig_data,
+        plot_uirevision(grimoire_name, chapter_name, plot_name),
+    )
+    return True
+
 
 def refresh_chapter_plots(grimoire_name: str, chapter_name: str) -> bool:
     """Refresh only the plots for a specific chapter.
@@ -44,6 +89,7 @@ def refresh_chapter_plots(grimoire_name: str, chapter_name: str) -> bool:
     """
     key = (grimoire_name, chapter_name)
     if key in _chapter_plot_refreshables:
+        clear_plot_charts_for_chapter(grimoire_name, chapter_name)
         _chapter_plot_refreshables[key].refresh()
         return True
     return False
@@ -63,6 +109,7 @@ def clear_chapter_refreshable(grimoire_name: str, chapter_name: str):
 def clear_all_chapter_refreshables():
     """Clear all chapter refreshables (called on full dashboard refresh)."""
     _chapter_plot_refreshables.clear()
+    clear_all_plot_charts()
 
 
 def _confirm_delete(name: str, delete_fn, on_deleted=None):
@@ -188,8 +235,12 @@ def render_plot(plot: Plot, grimoire_name: str, chapter_name: str):
 
     try:
         fig = json.loads(plot.json_data)
+        fig.setdefault("layout", {})["uirevision"] = plot_uirevision(
+            grimoire_name, chapter_name, plot.name
+        )
         with create_plot_container():
-            create_plotly_chart(fig)
+            chart = create_plotly_chart(fig)
+            _plot_charts[_plot_key(grimoire_name, chapter_name, plot.name)] = chart
             create_delete_badge(
                 lambda _, g=grimoire_name, c=chapter_name, p=plot: _confirm_delete(
                     p.name, lambda name: delete_plot(g, c, name), on_deleted=on_deleted

{grimoireplot-0.0.2 → grimoireplot-0.0.3}/grimoireplot/ui_elements.py

@@ -649,18 +649,8 @@ def create_confirm_dialog(
 # ============================================================================
 
 
-def create_plotly_chart(fig_data: dict) -> ui.plotly:
-    """Create a styled Plotly chart.
-
-    Applies dark theme styling to the chart.
-
-    Args:
-        fig_data: Plotly figure data dict.
-
-    Returns:
-        Styled plotly component.
-    """
-    # Ensure dark theme layout
+def style_plotly_figure(fig_data: dict) -> dict:
+    """Apply GrimoirePlot dark theme styling to a Plotly figure dict."""
     if "layout" not in fig_data:
         fig_data["layout"] = {}
 
@@ -671,10 +661,9 @@ def create_plotly_chart(fig_data: dict) -> ui.plotly:
     layout.setdefault("height", 450)
     layout.setdefault("autosize", True)
 
-    # Disable Plotly animations
+    # Disable Plotly animations for smoother live updates
     layout.setdefault("transition", {"duration": 0})
 
-    # Style axes
     for axis in ["xaxis", "yaxis"]:
         if axis not in layout:
             layout[axis] = {}
@@ -682,7 +671,6 @@ def create_plotly_chart(fig_data: dict) -> ui.plotly:
         layout[axis].setdefault("linecolor", "rgba(139, 92, 246, 0.3)")
         layout[axis].setdefault("tickcolor", "#64748B")
 
-    # Style legend
     layout.setdefault(
         "legend",
         {
@@ -692,12 +680,31 @@ def create_plotly_chart(fig_data: dict) -> ui.plotly:
         },
     )
 
-    # Enable responsive mode via Plotly config
     if "config" not in fig_data:
         fig_data["config"] = {}
     fig_data["config"].setdefault("responsive", True)
 
-    chart = ui.plotly(fig_data).classes("w-full").style("height: 450px;")
+    return fig_data
+
+
+def create_plotly_chart(fig_data: dict) -> ui.plotly:
+    """Create a styled Plotly chart.
+
+    Uses the dict figure interface recommended by NiceGUI for live updates.
+
+    Args:
+        fig_data: Plotly figure data dict.
+
+    Returns:
+        Styled plotly component.
+    """
+    from grimoireplot.plot_live_update import normalize_figure_dict
+
+    chart = (
+        ui.plotly(style_plotly_figure(normalize_figure_dict(fig_data)))
+        .classes("w-full")
+        .style("height: 450px;")
+    )
     return chart
 
 

{grimoireplot-0.0.2 → grimoireplot-0.0.3}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "uv_build"
 
 [project]
 name = "grimoireplot"
-version = "0.0.2"
+version = "0.0.3"
 description = "GrimoirePlot is a live dashboard of plotly-compatible plots of remote data"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -20,7 +20,7 @@ classifiers = ["License :: OSI Approved :: MIT License"]
 dependencies = [
     "aiohttp[speedups]>=3.13.3",
     "loguru>=0.7.3",
-    "nicegui>=3.5.0,<4",
+    "nicegui>=3.14.0,<4",
     "plotly>=6.5.2",
     "python-dotenv>=1.2.1",
     "requests>=2.32.5",