shiny-plotly 0.3.1__tar.gz → 0.3.2__tar.gz

{shiny_plotly-0.3.1 → shiny_plotly-0.3.2}/.gitignore

@@ -7,3 +7,4 @@ __pycache__/
 .pytest_cache/
 .ruff_cache/
 tmp/
+site/

{shiny_plotly-0.3.1 → shiny_plotly-0.3.2}/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.2](https://github.com/rvben/shiny-plotly/compare/v0.3.1...v0.3.2) - 2026-08-20
+
+### Added
+
+- Three more forwardable events: `doubleclick` arrives as a running count of plot-area double-clicks (plotly hands the event no data; the count's change invalidates the input); `legendclick` and `legenddoubleclick` arrive as the clicked trace's `curve_number`, `expanded_index`, `name` and pre-toggle `visible`, plus `label` for trace types whose legend items are labels. The default toggle and isolate behaviors still happen.
+- `examples/streaming_app.py`: a live rolling window fed by `extend_traces`, with a pause switch and a window slider; a browser test drives the example file itself and proves the stream flows and pauses.
+- A live demo at https://rvben.github.io/shiny-plotly/: `examples/shinylive/app.py` grew into a two-tab showcase (a streaming figure, click and box-select events, a dark mode toggle), deployed to GitHub Pages by a workflow that builds the site from the checkout's own wheel (`make site`) and gates the deploy on a headless Chromium watching both tabs render (`make site-check`). The committed example still installs from PyPI, so `uvx shinylive export examples/shinylive site` keeps working as documented.
+
 ## [0.3.1](https://github.com/rvben/shiny-plotly/compare/v0.3.0...v0.3.1) - 2026-08-20
 
 ### Added

{shiny_plotly-0.3.1 → shiny_plotly-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: shiny-plotly
-Version: 0.3.1
+Version: 0.3.2
 Summary: Render plotly figures in Shiny for Python with plain plotly.js, without the shinywidgets layer.
 Project-URL: Homepage, https://github.com/rvben/shiny-plotly
 Project-URL: Repository, https://github.com/rvben/shiny-plotly
@@ -38,6 +38,8 @@ Render [plotly](https://plotly.com/python/) figures in [Shiny for Python](https:
 [![PyPI](https://img.shields.io/pypi/v/shiny-plotly)](https://pypi.org/project/shiny-plotly/)
 [![CI](https://github.com/rvben/shiny-plotly/actions/workflows/ci.yml/badge.svg)](https://github.com/rvben/shiny-plotly/actions/workflows/ci.yml)
 
+**[Try the live demo](https://rvben.github.io/shiny-plotly/)**: a streaming figure and forwarded plotly events, running entirely in your browser through shinylive.
+
 ```python
 from shiny_plotly import output_plotly, render_plotly
 
@@ -247,7 +249,7 @@ def sales():
 
 ### Events back to Shiny
 
-`events=` names the plotly events to forward; each arrives as `input.<id>_<event>`, namespaced like the output inside a module. Four are available: `click`, `hover`, `selected` and `relayout`.
+`events=` names the plotly events to forward; each arrives as `input.<id>_<event>`, namespaced like the output inside a module. Seven are available: `click`, `doubleclick`, `hover`, `selected`, `relayout`, `legendclick` and `legenddoubleclick`.
 
 ```python
 @render_plotly(events=("click", "selected"))
@@ -270,6 +272,9 @@ What arrives is plotly's own event data, cut to what serializes, the same way Da
 | `hover` | `{"points": [...]}` while over a point, `None` once the pointer leaves; debounced (100 ms) |
 | `selected` | `{"points": [...], "range": {"x": [..], "y": [..]}}` for a box, `lassoPoints` for a lasso; `None` after a double-click deselect; above `max_event_points` the points give way to `point_count` (below) |
 | `relayout` | plotly's relayout data as is: `{"xaxis.range[0]": ..., "xaxis.range[1]": ...}` after a zoom or pan, `{"xaxis.autorange": True, ...}` after a reset, `{"dragmode": "pan"}` from the mode bar, `{"autosize": True}` after a resize |
+| `doubleclick` | a running count of double-clicks on the plot area (the gesture that resets the axes); plotly hands the event no data, and the count's change is what invalidates the input |
+| `legendclick` | `{"curve_number": 1, "expanded_index": 1, "name": "beta", "visible": True}` for the trace whose legend item was clicked, `visible` as it stood before the click's toggle (`True` or `"legendonly"`); trace types whose legend items are labels (pie, funnelarea) add `label`; fires on every click, and the default toggle still happens |
+| `legenddoubleclick` | same value as `legendclick`; the default isolate-this-trace behavior still happens |
 
 Each point carries plotly's scalar fields for that trace type (`curveNumber`, `pointNumber`, `pointIndex`, `x`, `y`, `z`, `text`, `label`, `value`, `lat`, `lon`, ...) plus `customdata` (as a plain list, also when it was a numpy array), `bbox` and `pointNumbers` when present. `input.<id>_<event>()` raises a silent exception until the event has fired once, so check `is_set()` when the output should show something before that.
 
@@ -312,15 +317,14 @@ The value is never silently cut: `points` is a full list or `None`, and `point_c
 For anything else, `post_script` runs once, after the first figure is drawn, with `{plot_id}` replaced by the graph div's id. Re-renders go through `Plotly.react` into the same graph div, so handlers attached either way stay attached and are never stacked.
 
 ```python
-LEGEND_TO_INPUT = """
-document.getElementById('{plot_id}').on('plotly_legendclick', function (ev) {
-    Shiny.setInputValue('legend', ev.curveNumber, {priority: 'event'});
-    return true;  // let plotly toggle the trace as usual
+ANNOTATION_TO_INPUT = """
+document.getElementById('{plot_id}').on('plotly_clickannotation', function (ev) {
+    Shiny.setInputValue('annotation', ev.index, {priority: 'event'});
 });
 """
 
 
-@render_plotly(post_script=LEGEND_TO_INPUT)
+@render_plotly(post_script=ANNOTATION_TO_INPUT)
 def scatter(): ...
 ```
 
@@ -361,6 +365,8 @@ async def _highlight():
 
 The values go through plotly's encoder, so numpy arrays, pandas columns and datetimes work. The id is namespaced inside a module, like the output. An update reaches the figure that is drawn at that moment; one sent while the output has no figure (its first render is still running, it sits in a hidden tab, it shows an error or was emptied by `None`) is held and applied, in order, right after the output's next draw. A re-render replaces the figure, updates included, with what the render function returns: the server stays the source of truth, and a figure that should keep its streamed points across a re-render builds them in from server-side state.
 
+A runnable version of the streaming pattern, with a pause switch and a window slider, is `examples/streaming_app.py`.
+
 ### Lower level
 
 - `fig_to_ui(fig, div_id=None, *, height, width, figurewidget_margins, config, post_script)` returns a `TagList` holding the plotly.js dependency, the helper dependency and a `<div class="shiny-plotly">` that draws the figure with `Plotly.newPlot` (plotly's own `to_html` fragment). Use it from a plain `@render.ui` that composes a figure with other UI, or from any htmltools context. Each render draws a fresh graph; an output that is only a figure is better served by `render_plotly`.
@@ -393,7 +399,7 @@ And if a reverse proxy in front of the app does its own compression and caching,
 
 ### Shinylive
 
-Apps using `shiny-plotly` run under [Shinylive](https://shiny.posit.co/py/get-started/shinylive.html) (pyodide in the browser) as well; list `shiny-plotly` in the app's `requirements.txt` next to `plotly`. There is no HTTP server in the browser and pyodide cannot start threads, so the compression route above stands down under pyodide (`enable_compressed_plotly_js` returns `False`); everything else, rendering, events, in-place updates and themes, is browser-side already. Verified against a real `shinylive export`; `examples/shinylive/` is a ready-to-export app.
+Apps using `shiny-plotly` run under [Shinylive](https://shiny.posit.co/py/get-started/shinylive.html) (pyodide in the browser) as well; list `shiny-plotly` in the app's `requirements.txt` next to `plotly`. There is no HTTP server in the browser and pyodide cannot start threads, so the compression route above stands down under pyodide (`enable_compressed_plotly_js` returns `False`); everything else, rendering, events, in-place updates and themes, is browser-side already. Verified against a real `shinylive export`; `examples/shinylive/` is a ready-to-export app, and its deployed copy is the [live demo](https://rvben.github.io/shiny-plotly/). The Pages workflow builds that demo from the current checkout's wheel (`make site`) and deploys only after a headless Chromium has watched both tabs render (`make site-check`).
 
 ## Examples
 
@@ -402,6 +408,7 @@ uv run --with shiny-plotly shiny run examples/core_app.py     # fill, margins, a
 uv run --with shiny-plotly shiny run examples/express_app.py  # the Express flavor
 uv run --with shiny-plotly shiny run examples/dark_app.py     # theme="auto" and a custom (light, dark) pair
 uv run --with shiny-plotly shiny run examples/events_app.py   # box selections over a 50k-point trace
+uv run --with shiny-plotly shiny run examples/streaming_app.py # a rolling window fed by extend_traces
 uvx shinylive export examples/shinylive site                  # the same package, running in the browser
 ```
 

{shiny_plotly-0.3.1 → shiny_plotly-0.3.2}/README.md

@@ -7,6 +7,8 @@ Render [plotly](https://plotly.com/python/) figures in [Shiny for Python](https:
 [![PyPI](https://img.shields.io/pypi/v/shiny-plotly)](https://pypi.org/project/shiny-plotly/)
 [![CI](https://github.com/rvben/shiny-plotly/actions/workflows/ci.yml/badge.svg)](https://github.com/rvben/shiny-plotly/actions/workflows/ci.yml)
 
+**[Try the live demo](https://rvben.github.io/shiny-plotly/)**: a streaming figure and forwarded plotly events, running entirely in your browser through shinylive.
+
 ```python
 from shiny_plotly import output_plotly, render_plotly
 
@@ -216,7 +218,7 @@ def sales():
 
 ### Events back to Shiny
 
-`events=` names the plotly events to forward; each arrives as `input.<id>_<event>`, namespaced like the output inside a module. Four are available: `click`, `hover`, `selected` and `relayout`.
+`events=` names the plotly events to forward; each arrives as `input.<id>_<event>`, namespaced like the output inside a module. Seven are available: `click`, `doubleclick`, `hover`, `selected`, `relayout`, `legendclick` and `legenddoubleclick`.
 
 ```python
 @render_plotly(events=("click", "selected"))
@@ -239,6 +241,9 @@ What arrives is plotly's own event data, cut to what serializes, the same way Da
 | `hover` | `{"points": [...]}` while over a point, `None` once the pointer leaves; debounced (100 ms) |
 | `selected` | `{"points": [...], "range": {"x": [..], "y": [..]}}` for a box, `lassoPoints` for a lasso; `None` after a double-click deselect; above `max_event_points` the points give way to `point_count` (below) |
 | `relayout` | plotly's relayout data as is: `{"xaxis.range[0]": ..., "xaxis.range[1]": ...}` after a zoom or pan, `{"xaxis.autorange": True, ...}` after a reset, `{"dragmode": "pan"}` from the mode bar, `{"autosize": True}` after a resize |
+| `doubleclick` | a running count of double-clicks on the plot area (the gesture that resets the axes); plotly hands the event no data, and the count's change is what invalidates the input |
+| `legendclick` | `{"curve_number": 1, "expanded_index": 1, "name": "beta", "visible": True}` for the trace whose legend item was clicked, `visible` as it stood before the click's toggle (`True` or `"legendonly"`); trace types whose legend items are labels (pie, funnelarea) add `label`; fires on every click, and the default toggle still happens |
+| `legenddoubleclick` | same value as `legendclick`; the default isolate-this-trace behavior still happens |
 
 Each point carries plotly's scalar fields for that trace type (`curveNumber`, `pointNumber`, `pointIndex`, `x`, `y`, `z`, `text`, `label`, `value`, `lat`, `lon`, ...) plus `customdata` (as a plain list, also when it was a numpy array), `bbox` and `pointNumbers` when present. `input.<id>_<event>()` raises a silent exception until the event has fired once, so check `is_set()` when the output should show something before that.
 
@@ -281,15 +286,14 @@ The value is never silently cut: `points` is a full list or `None`, and `point_c
 For anything else, `post_script` runs once, after the first figure is drawn, with `{plot_id}` replaced by the graph div's id. Re-renders go through `Plotly.react` into the same graph div, so handlers attached either way stay attached and are never stacked.
 
 ```python
-LEGEND_TO_INPUT = """
-document.getElementById('{plot_id}').on('plotly_legendclick', function (ev) {
-    Shiny.setInputValue('legend', ev.curveNumber, {priority: 'event'});
-    return true;  // let plotly toggle the trace as usual
+ANNOTATION_TO_INPUT = """
+document.getElementById('{plot_id}').on('plotly_clickannotation', function (ev) {
+    Shiny.setInputValue('annotation', ev.index, {priority: 'event'});
 });
 """
 
 
-@render_plotly(post_script=LEGEND_TO_INPUT)
+@render_plotly(post_script=ANNOTATION_TO_INPUT)
 def scatter(): ...
 ```
 
@@ -330,6 +334,8 @@ async def _highlight():
 
 The values go through plotly's encoder, so numpy arrays, pandas columns and datetimes work. The id is namespaced inside a module, like the output. An update reaches the figure that is drawn at that moment; one sent while the output has no figure (its first render is still running, it sits in a hidden tab, it shows an error or was emptied by `None`) is held and applied, in order, right after the output's next draw. A re-render replaces the figure, updates included, with what the render function returns: the server stays the source of truth, and a figure that should keep its streamed points across a re-render builds them in from server-side state.
 
+A runnable version of the streaming pattern, with a pause switch and a window slider, is `examples/streaming_app.py`.
+
 ### Lower level
 
 - `fig_to_ui(fig, div_id=None, *, height, width, figurewidget_margins, config, post_script)` returns a `TagList` holding the plotly.js dependency, the helper dependency and a `<div class="shiny-plotly">` that draws the figure with `Plotly.newPlot` (plotly's own `to_html` fragment). Use it from a plain `@render.ui` that composes a figure with other UI, or from any htmltools context. Each render draws a fresh graph; an output that is only a figure is better served by `render_plotly`.
@@ -362,7 +368,7 @@ And if a reverse proxy in front of the app does its own compression and caching,
 
 ### Shinylive
 
-Apps using `shiny-plotly` run under [Shinylive](https://shiny.posit.co/py/get-started/shinylive.html) (pyodide in the browser) as well; list `shiny-plotly` in the app's `requirements.txt` next to `plotly`. There is no HTTP server in the browser and pyodide cannot start threads, so the compression route above stands down under pyodide (`enable_compressed_plotly_js` returns `False`); everything else, rendering, events, in-place updates and themes, is browser-side already. Verified against a real `shinylive export`; `examples/shinylive/` is a ready-to-export app.
+Apps using `shiny-plotly` run under [Shinylive](https://shiny.posit.co/py/get-started/shinylive.html) (pyodide in the browser) as well; list `shiny-plotly` in the app's `requirements.txt` next to `plotly`. There is no HTTP server in the browser and pyodide cannot start threads, so the compression route above stands down under pyodide (`enable_compressed_plotly_js` returns `False`); everything else, rendering, events, in-place updates and themes, is browser-side already. Verified against a real `shinylive export`; `examples/shinylive/` is a ready-to-export app, and its deployed copy is the [live demo](https://rvben.github.io/shiny-plotly/). The Pages workflow builds that demo from the current checkout's wheel (`make site`) and deploys only after a headless Chromium has watched both tabs render (`make site-check`).
 
 ## Examples
 
@@ -371,6 +377,7 @@ uv run --with shiny-plotly shiny run examples/core_app.py     # fill, margins, a
 uv run --with shiny-plotly shiny run examples/express_app.py  # the Express flavor
 uv run --with shiny-plotly shiny run examples/dark_app.py     # theme="auto" and a custom (light, dark) pair
 uv run --with shiny-plotly shiny run examples/events_app.py   # box selections over a 50k-point trace
+uv run --with shiny-plotly shiny run examples/streaming_app.py # a rolling window fed by extend_traces
 uvx shinylive export examples/shinylive site                  # the same package, running in the browser
 ```
 

shiny_plotly-0.3.2/examples/shinylive/app.py

@@ -0,0 +1,114 @@
+"""The live demo behind https://rvben.github.io/shiny-plotly/, running in the browser.
+
+The whole app runs in the browser via pyodide: no server. Two tabs show the package's
+two sides. Stream draws one empty figure and feeds it through ``extend_traces``, one
+small message per tick, no re-render. Explore forwards plotly's click and box-select
+events to Shiny inputs. Both figures follow the page's color mode via ``theme="auto"``
+and the toggle in the corner.
+
+Export this directory to a static site and serve it:
+
+    uvx shinylive export examples/shinylive site
+    python -m http.server 8000 -d site
+
+That installs the released package from PyPI (requirements.txt); the deployed demo is
+built by ``make site``, which installs the wheel from the current checkout instead.
+"""
+
+import random
+from datetime import datetime
+
+import plotly.graph_objects as go
+from shiny import App, Inputs, Outputs, Session, reactive, render, ui
+
+from shiny_plotly import extend_traces, output_plotly, render_plotly
+
+TICK_SECONDS = 0.5
+CLUSTERS = {"alpha": (0.0, 0.0), "beta": (3.0, 2.0), "gamma": (1.0, 4.0)}
+
+app_ui = ui.page_fillable(
+    ui.div(
+        ui.tags.b("shiny-plotly"),
+        ui.span("plotly figures in Shiny for Python, without shinywidgets", class_="text-muted"),
+        ui.div(ui.input_dark_mode(), class_="ms-auto"),
+        class_="d-flex align-items-center gap-3",
+    ),
+    ui.navset_card_underline(
+        ui.nav_panel(
+            "Stream",
+            ui.layout_columns(
+                ui.input_switch("run", "Stream", value=True),
+                ui.input_slider("window", "Window (points)", min=50, max=500, value=200, step=50),
+                col_widths=(3, 9),
+            ),
+            output_plotly("stream"),
+        ),
+        ui.nav_panel(
+            "Explore",
+            output_plotly("explore"),
+            ui.layout_columns(ui.output_text("clicked"), ui.output_text("picked")),
+        ),
+    ),
+    title="shiny-plotly demo",
+)
+
+
+def server(input: Inputs, output: Outputs, session: Session):
+    # Per-session: each visitor gets their own stream.
+    state = {"a": 20.0, "b": 50.0}
+
+    @render_plotly(theme="auto")
+    def stream():
+        fig = go.Figure(
+            [
+                go.Scatter(x=[], y=[], mode="lines", name="sensor a"),
+                go.Scatter(x=[], y=[], mode="lines", name="sensor b"),
+            ]
+        )
+        return fig.update_layout(uirevision="keep")
+
+    @reactive.effect
+    async def _tick():
+        reactive.invalidate_later(TICK_SECONDS)
+        if not input.run():
+            return
+        now = datetime.now()
+        state["a"] += random.uniform(-1.0, 1.0)
+        state["b"] += random.uniform(-2.0, 2.0)
+        # One column of new values per trace; max_points keeps the rolling window.
+        await extend_traces(
+            "stream",
+            {"x": [[now], [now]], "y": [[state["a"]], [state["b"]]]},
+            max_points=input.window(),
+        )
+
+    @render_plotly(theme="auto", events=("click", "selected"))
+    def explore():
+        rng = random.Random(7)
+        fig = go.Figure()
+        for name, (cx, cy) in CLUSTERS.items():
+            fig.add_scatter(
+                x=[cx + rng.gauss(0, 0.8) for _ in range(40)],
+                y=[cy + rng.gauss(0, 0.8) for _ in range(40)],
+                mode="markers",
+                name=name,
+            )
+        # Select mode from the start, so a plain drag is a box selection.
+        return fig.update_layout(dragmode="select")
+
+    @render.text
+    def clicked():
+        if not input.explore_click.is_set():
+            return "Click a point."
+        point = input.explore_click()["points"][0]
+        name = list(CLUSTERS)[point["curveNumber"]]
+        return f"Clicked {name} at ({point['x']:.2f}, {point['y']:.2f})."
+
+    @render.text
+    def picked():
+        if not input.explore_selected.is_set() or input.explore_selected() is None:
+            return "Drag a box to select points."
+        return f"{len(input.explore_selected()['points'])} points selected."
+
+
+app = App(app_ui, server)

shiny_plotly-0.3.2/examples/streaming_app.py

@@ -0,0 +1,69 @@
+"""Streaming example: a live rolling window fed by extend_traces, no re-render.
+
+The figure is drawn once, empty; every point after that arrives through
+``extend_traces``, which appends in the browser and drops the oldest points past the
+window. Nothing re-renders, so the stream costs one small message per tick and a zoom
+or pan the user dragged stays where they put it. The switch pauses the stream; the
+slider resizes the window from the next tick on.
+
+Run with:  uv run --with shiny-plotly shiny run examples/streaming_app.py
+"""
+
+import random
+from datetime import datetime
+
+import plotly.graph_objects as go
+from shiny import App, Inputs, Outputs, Session, reactive, ui
+
+from shiny_plotly import extend_traces, output_plotly, render_plotly
+
+TICK_SECONDS = 0.25
+
+app_ui = ui.page_fillable(
+    ui.layout_columns(
+        ui.input_switch("run", "Stream", value=True),
+        ui.input_slider("window", "Window (points)", min=50, max=1000, value=300, step=50),
+        col_widths=(3, 9),
+    ),
+    ui.card(
+        ui.card_header("Two sensors, one point per tick"),
+        output_plotly("stream"),
+        full_screen=True,
+    ),
+    title="shiny-plotly streaming",
+)
+
+
+def server(input: Inputs, output: Outputs, session: Session):
+    # Per-session: each visitor gets their own stream.
+    state = {"a": 20.0, "b": 50.0}
+
+    @render_plotly(theme="auto")
+    def stream():
+        fig = go.Figure(
+            [
+                go.Scatter(x=[], y=[], mode="lines", name="sensor a"),
+                go.Scatter(x=[], y=[], mode="lines", name="sensor b"),
+            ]
+        )
+        return fig.update_layout(uirevision="keep")
+
+    @reactive.effect
+    async def _tick():
+        reactive.invalidate_later(TICK_SECONDS)
+        if not input.run():
+            return
+        now = datetime.now()
+        state["a"] += random.uniform(-1.0, 1.0)
+        state["b"] += random.uniform(-2.0, 2.0)
+        # One column of new values per trace; max_points keeps the rolling window. Sent
+        # while the first (empty) figure is still on its way, the update is held in the
+        # browser and applied right after the draw, so nothing is lost at startup.
+        await extend_traces(
+            "stream",
+            {"x": [[now], [now]], "y": [[state["a"]], [state["b"]]]},
+            max_points=input.window(),
+        )
+
+
+app = App(app_ui, server)

{shiny_plotly-0.3.1 → shiny_plotly-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "shiny-plotly"
-version = "0.3.1"
+version = "0.3.2"
 description = "Render plotly figures in Shiny for Python with plain plotly.js, without the shinywidgets layer."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -85,7 +85,7 @@ target-version = "py310"
 select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
 
 [tool.pyright]
-include = ["src", "tests", "examples", "bench"]
+include = ["src", "tests", "examples", "bench", "tools"]
 pythonVersion = "3.10"
 typeCheckingMode = "standard"
 

{shiny_plotly-0.3.1 → shiny_plotly-0.3.2}/src/shiny_plotly/_render.py

@@ -17,7 +17,15 @@ from ._serve import enable_compressed_plotly_js
 __all__ = ("DEFAULT_MAX_EVENT_POINTS", "EVENTS", "output_plotly", "render_plotly")
 
 # Plotly events that can be forwarded to Shiny inputs, in the order they are sent.
-EVENTS = ("click", "hover", "selected", "relayout")
+EVENTS = (
+    "click",
+    "doubleclick",
+    "hover",
+    "selected",
+    "relayout",
+    "legendclick",
+    "legenddoubleclick",
+)
 
 # Points per event above which the browser sends the count and the selection's geometry
 # instead of the points. Each point is about 100 bytes of JSON; at this cap an event is
@@ -170,18 +178,26 @@ class render_plotly(Renderer[Figure]):
         ``{plot_id}`` replaced by the graph div's id. For anything the ``events`` option
         does not cover; handlers attached here stay attached across re-renders.
     events
-        Plotly events to forward to Shiny inputs: any of ``"click"``, ``"hover"``,
-        ``"selected"`` and ``"relayout"`` (one name or an iterable of names). Each arrives
-        as ``input.<id>_<event>``, namespaced like the output inside a module.
+        Plotly events to forward to Shiny inputs: any of ``"click"``, ``"doubleclick"``,
+        ``"hover"``, ``"selected"``, ``"relayout"``, ``"legendclick"`` and
+        ``"legenddoubleclick"`` (one name or an iterable of names). Each arrives as
+        ``input.<id>_<event>``, namespaced like the output inside a module.
         ``click``, ``hover`` and ``selected`` carry ``{"points": [...]}`` where each point
         holds plotly's scalar fields (``curveNumber``, ``pointNumber``, ``pointIndex``,
         ``x``, ``y``, ``z``, ``text``, ``label``, ``value``, ...) plus ``customdata``,
         ``bbox`` and ``pointNumbers`` when present; a box or lasso selection adds ``range``
         or ``lassoPoints``. ``relayout`` carries plotly's relayout data as is (zoom and pan
         ranges, ``autorange``, ``dragmode``; a resize reports ``{"autosize": true}``).
-        A click fires on every click, repeated or not; hover is debounced and becomes
-        ``None`` once the pointer leaves the graph; a double-click deselect sets
-        ``selected`` to ``None``.
+        ``doubleclick`` (the double-click on the plot area that resets the axes) carries a
+        running count of double-clicks, since plotly hands it no data; the change is what
+        invalidates the input. ``legendclick`` and ``legenddoubleclick`` carry
+        ``{"curve_number", "expanded_index", "name", "visible"}`` for the trace whose
+        legend item was clicked, with ``visible`` as it stood before the click's toggle
+        (``True`` or ``"legendonly"``), plus ``label`` for trace types whose legend items
+        are labels (pie, funnelarea); the default toggle still happens.
+        A click fires on every click, repeated or not, and so do the legend events; hover
+        is debounced and becomes ``None`` once the pointer leaves the graph; a
+        double-click deselect sets ``selected`` to ``None``.
     max_event_points
         The most points one event carries, 10 000 by default. An event with more points
         (a box or lasso over a dense trace) arrives with ``"points": None`` and

{shiny_plotly-0.3.1 → shiny_plotly-0.3.2}/src/shiny_plotly/www/shiny-plotly.js

@@ -162,6 +162,20 @@
     return out;
   }
 
+  // A legend event names a trace, not points: the trace's index and, because the event
+  // fires before the default toggle, the visibility the click is about to change. For a
+  // trace type whose legend items are labels (pie, funnelarea) plotly adds the label.
+  function legendData(gd, ev) {
+    var out = { curve_number: ev.curveNumber, expanded_index: ev.expandedIndex };
+    var trace = gd._fullData && gd._fullData[ev.curveNumber];
+    if (trace) {
+      out.name = trace.name;
+      out.visible = trace.visible;
+    }
+    if (ev.label !== undefined) out.label = ev.label;
+    return out;
+  }
+
   // Wires the requested plotly events of one graph div to inputs named <output id>_<event>.
   // Called once per graph div, right after its first draw; Plotly.react keeps the handlers.
   function attachEvents(gd, outputId, names, maxPoints) {
@@ -189,6 +203,18 @@
         gd.on("plotly_deselect", function () { send("selected", null); });
       } else if (name === "relayout") {
         gd.on("plotly_relayout", function (ev) { send("relayout", relayoutData(ev)); });
+      } else if (name === "doubleclick") {
+        // The event hands its handler nothing, so the value is a count kept on the graph
+        // div: it changes on every double-click, which is what invalidates the input.
+        gd.on("plotly_doubleclick", function () {
+          gd._shinyPlotlyDblclicks = (gd._shinyPlotlyDblclicks || 0) + 1;
+          send("doubleclick", gd._shinyPlotlyDblclicks);
+        });
+      } else if (name === "legendclick" || name === "legenddoubleclick") {
+        // priority event, like click: a repeated click on the same item counts again.
+        gd.on("plotly_" + name, function (ev) {
+          send(name, legendData(gd, ev), { priority: "event" });
+        });
       }
     });
   }

{shiny_plotly-0.3.1 → shiny_plotly-0.3.2}/tests/browser/apps.py

@@ -127,12 +127,16 @@ def make_events_app() -> App:
         output_plotly("fig", height="300px", width="500px"),
         output_plotly("sel", height="300px", width="500px"),
         output_plotly("dense", height="300px", width="500px"),
+        output_plotly("leg", height="300px", width="500px"),
         ui.output_text("click_out"),
         ui.output_text("click_count"),
         ui.output_text("hover_out"),
         ui.output_text("relayout_out"),
         ui.output_text("selected_out"),
         ui.output_text("dense_out"),
+        ui.output_text("legendclick_out"),
+        ui.output_text("legenddbl_out"),
+        ui.output_text("dbl_out"),
         events_mod_ui("m"),
     )
 
@@ -156,6 +160,12 @@ def make_events_app() -> App:
             fig = go.Figure(go.Scatter(x=list(range(8)), y=[1] * 8, mode="markers"))
             return fig.update_layout(dragmode="select")
 
+        @render_plotly(events=("doubleclick", "legendclick", "legenddoubleclick"))
+        def leg():
+            return go.Figure(
+                [go.Scatter(y=[1, 2], name="alpha"), go.Scatter(y=[2, 1], name="beta")]
+            )
+
         @reactive.effect
         @reactive.event(input.fig_click)
         def _count():
@@ -185,6 +195,20 @@ def make_events_app() -> App:
         def dense_out():
             return as_text(input.dense_selected()) if input.dense_selected.is_set() else "-"
 
+        @render.text
+        def legendclick_out():
+            return as_text(input.leg_legendclick()) if input.leg_legendclick.is_set() else "-"
+
+        @render.text
+        def legenddbl_out():
+            if not input.leg_legenddoubleclick.is_set():
+                return "-"
+            return as_text(input.leg_legenddoubleclick())
+
+        @render.text
+        def dbl_out():
+            return as_text(input.leg_doubleclick()) if input.leg_doubleclick.is_set() else "-"
+
         events_mod_server("m")
 
     return App(app_ui, server)

{shiny_plotly-0.3.1 → shiny_plotly-0.3.2}/tests/browser/conftest.py

@@ -1,12 +1,15 @@
 """Run the browser test apps on a real uvicorn server for the playwright tests."""
 
+import importlib.util
 import threading
 import time
 from collections.abc import Iterator
+from pathlib import Path
 
 import pytest
 import uvicorn
 from playwright.sync_api import Page
+from shiny import App
 from starlette.applications import Starlette
 from starlette.routing import Mount
 
@@ -20,6 +23,16 @@ from .apps import (
 )
 
 
+def load_example(name: str) -> App:
+    """The ``app`` of an example file, imported as is: the tests drive the real example."""
+    path = Path(__file__).parent.parent.parent / "examples" / name
+    spec = importlib.util.spec_from_file_location(path.stem, path)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module.app
+
+
 @pytest.fixture(scope="session")
 def server_url() -> Iterator[str]:
     root = Starlette(
@@ -29,6 +42,8 @@ def server_url() -> Iterator[str]:
             Mount("/live", app=make_live_app()),
             Mount("/dark", app=make_dark_app()),
             Mount("/theme", app=make_theme_app()),
+            Mount("/stream", app=load_example("streaming_app.py")),
+            Mount("/demo", app=load_example("shinylive/app.py")),
             Mount("/", app=make_app()),
         ]
     )

{shiny_plotly-0.3.1 → shiny_plotly-0.3.2}/tests/browser/test_events.py

@@ -16,6 +16,7 @@ def app(page: Page, server_url: str, errors: list[str]) -> Iterator[Page]:
     page.goto(server_url + "/events/")
     expect(page.locator(f"#fig {SVG}").first).to_be_visible()
     expect(page.locator(f"#sel {SVG}").first).to_be_visible()
+    expect(page.locator(f"#leg {SVG}").first).to_be_visible()
     expect(page.locator(f"#m-fig {SVG}").first).to_be_visible()
     expect(page.locator("#click_out")).to_have_text("-")
     yield page
@@ -152,6 +153,58 @@ def test_a_selection_above_max_event_points_arrives_as_count_and_range_without_p
     assert "point_count" not in event
 
 
+def legend_item(page: Page, output_id: str, index: int) -> Locator:
+    return page.locator(f"#{output_id} .legend .traces").nth(index)
+
+
+def plot_dblclick(page: Page, output_id: str) -> None:
+    drag_area = page.locator(f"#{output_id} .nsewdrag")
+    drag_area.scroll_into_view_if_needed()  # mouse coordinates are viewport coordinates
+    box = drag_area.bounding_box()
+    assert box is not None
+    page.mouse.dblclick(box["x"] + box["width"] * 0.5, box["y"] + box["height"] * 0.5)
+
+
+def test_a_legend_click_reports_the_trace_and_its_pre_toggle_visibility(app: Page):
+    legend_item(app, "leg", 1).click(force=True)
+
+    wait_for_change(app, "legendclick_out", "-")
+    first = received(app, "legendclick_out")
+    assert first == {"curve_number": 1, "expanded_index": 1, "name": "beta", "visible": True}
+
+    # Past plotly's double-click window, so the second click is a single click again, on a
+    # trace the first click has hidden by now.
+    app.wait_for_timeout(400)
+    previous = app.locator("#legendclick_out").inner_text()
+    legend_item(app, "leg", 1).click(force=True)
+
+    wait_for_change(app, "legendclick_out", previous)
+    second = received(app, "legendclick_out")
+    assert isinstance(second, dict)
+    assert second["visible"] == "legendonly", "the state before this click's toggle"
+
+
+def test_a_legend_double_click_arrives_with_the_trace(app: Page):
+    legend_item(app, "leg", 0).dblclick(force=True)
+
+    wait_for_change(app, "legenddbl_out", "-")
+    event = received(app, "legenddbl_out")
+    assert isinstance(event, dict)
+    assert event["curve_number"] == 0
+    assert event["name"] == "alpha"
+
+
+def test_a_double_click_on_the_plot_arrives_as_a_running_count(app: Page):
+    plot_dblclick(app, "leg")
+
+    expect(app.locator("#dbl_out")).to_have_text("1")
+
+    app.wait_for_timeout(400)
+    plot_dblclick(app, "leg")
+
+    expect(app.locator("#dbl_out")).to_have_text("2")
+
+
 def test_inputs_are_namespaced_inside_a_module(app: Page):
     bar(app, "m-fig", 2).click(force=True)
 

shiny_plotly-0.3.2/tests/browser/test_shinylive_demo.py

@@ -0,0 +1,48 @@
+"""The shinylive demo app, served as is: what ships to Pages works before it ships."""
+
+from collections.abc import Iterator
+
+import pytest
+from playwright.sync_api import Page, expect
+
+pytestmark = pytest.mark.browser
+
+GD = "document.querySelector('#stream .plotly-graph-div')"
+
+
+@pytest.fixture
+def app(page: Page, server_url: str, errors: list[str]) -> Iterator[Page]:
+    page.goto(server_url + "/demo/")
+    expect(page.locator("#stream svg.main-svg").first).to_be_visible()
+    yield page
+    assert errors == []
+
+
+def test_the_stream_tab_accumulates_points(app: Page):
+    app.wait_for_function(
+        f"() => {{ const gd = {GD}; return gd && gd.data && gd.data[0].x.length >= 3; }}"
+    )
+
+    assert app.evaluate(f"{GD}.data[1].x.length") >= 3, "both traces stream"
+
+
+def test_the_explore_tab_reports_a_click_and_a_selection(app: Page):
+    app.get_by_role("tab", name="Explore").click()
+    expect(app.locator("#explore svg.main-svg").first).to_be_visible()
+    expect(app.locator("#clicked")).to_have_text("Click a point.")
+
+    app.locator("#explore .scatterlayer .point").first.click(force=True)
+
+    expect(app.locator("#clicked")).not_to_have_text("Click a point.")
+
+    # The figure starts in select mode, so a plain drag is a box selection.
+    drag_area = app.locator("#explore .nsewdrag")
+    drag_area.scroll_into_view_if_needed()
+    box = drag_area.bounding_box()
+    assert box is not None
+    app.mouse.move(box["x"] + box["width"] * 0.1, box["y"] + box["height"] * 0.1)
+    app.mouse.down()
+    app.mouse.move(box["x"] + box["width"] * 0.9, box["y"] + box["height"] * 0.9, steps=8)
+    app.mouse.up()
+
+    expect(app.locator("#picked")).to_contain_text("points selected")

shiny_plotly-0.3.2/tests/browser/test_streaming_example.py

@@ -0,0 +1,39 @@
+"""The streaming example, served as is: points flow in without a re-render and pause."""
+
+from collections.abc import Iterator
+
+import pytest
+from playwright.sync_api import Page, expect
+
+pytestmark = pytest.mark.browser
+
+GD = "document.querySelector('#stream .plotly-graph-div')"
+
+
+@pytest.fixture
+def app(page: Page, server_url: str, errors: list[str]) -> Iterator[Page]:
+    page.goto(server_url + "/stream/")
+    expect(page.locator("#stream svg.main-svg").first).to_be_visible()
+    yield page
+    assert errors == []
+
+
+def trace_len(page: Page) -> int:
+    return page.evaluate(f"{GD}.data[0].x.length")
+
+
+def test_points_accumulate_through_extend_traces_and_the_switch_pauses(app: Page):
+    # Ticks arrive every 250 ms; the first ones were sent before the empty figure was
+    # drawn and must have been held and applied, not lost.
+    app.wait_for_function(
+        f"() => {{ const gd = {GD}; return gd && gd.data && gd.data[0].x.length >= 3; }}"
+    )
+    assert app.evaluate(f"{GD}.data[1].x.length") >= 3, "both traces stream"
+
+    app.locator("#run").click()  # the switch: pause
+
+    app.wait_for_timeout(300)  # a tick already in flight may still land
+    paused_at = trace_len(app)
+    app.wait_for_timeout(900)
+
+    assert trace_len(app) == paused_at, "no ticks after the pause settled"

{shiny_plotly-0.3.1 → shiny_plotly-0.3.2}/tests/test_examples.py

@@ -13,6 +13,7 @@ CORE_EXAMPLES = (
     "core_app.py",
     "events_app.py",
     "dark_app.py",
+    "streaming_app.py",
     "shinylive/app.py",
 )
 

{shiny_plotly-0.3.1 → shiny_plotly-0.3.2}/tests/test_render_plotly.py

@@ -95,13 +95,22 @@ def test_a_single_event_name_is_accepted_as_a_string():
 
 
 def test_unknown_event_names_fail_at_decoration_time():
-    with pytest.raises(ValueError, match=r"plotly_clack.*click, hover, selected, relayout"):
+    expected = "click, doubleclick, hover, selected, relayout, legendclick, legenddoubleclick"
+    with pytest.raises(ValueError, match=rf"plotly_clack.*{expected}"):
 
         @render_plotly(events=("click", "plotly_clack"))
         def sales():
             return bar()
 
 
+def test_the_double_click_and_legend_events_are_accepted():
+    @render_plotly(events=("legenddoubleclick", "doubleclick", "legendclick"))
+    def sales():
+        return bar()
+
+    assert sales.events == ("doubleclick", "legendclick", "legenddoubleclick")
+
+
 def test_max_event_points_defaults_to_ten_thousand_and_is_recorded():
     @render_plotly
     def sales():

shiny_plotly-0.3.1/examples/shinylive/app.py

@@ -1,33 +0,0 @@
-"""Shinylive example: the whole app runs in the browser via pyodide, no server.
-
-Export this directory to a static site and serve it:
-
-    uvx shinylive export examples/shinylive site
-    python -m http.server 8000 -d site
-"""
-
-import random
-from itertools import accumulate
-
-import plotly.graph_objects as go
-from shiny import App, Inputs, Outputs, Session, ui
-
-from shiny_plotly import output_plotly, render_plotly
-
-app_ui = ui.page_fillable(
-    ui.input_slider("n", "Points", min=10, max=500, value=100),
-    ui.card(output_plotly("walk"), full_screen=True),
-    title="shiny-plotly on shinylive",
-)
-
-
-def server(input: Inputs, output: Outputs, session: Session):
-    # theme="auto" follows the embedding page's color mode, OS preference included.
-    @render_plotly(theme="auto")
-    def walk():
-        rng = random.Random(input.n())
-        y = list(accumulate(rng.gauss(0, 1) for _ in range(input.n())))
-        return go.Figure(go.Scatter(y=y, mode="lines"))
-
-
-app = App(app_ui, server)