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

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

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.1](https://github.com/rvben/shiny-plotly/compare/v0.3.0...v0.3.1) - 2026-08-20
+
+### Added
+
+- `@render_plotly(theme="auto")`: the figure follows the page's color mode in the browser, with no server round-trip. `"auto"` pairs plotly's `"plotly"` and `"plotly_dark"` templates; a `(light, dark)` tuple picks others, each a registered name, a `Template` object or a template dict. Both templates travel with the figure with transparent backgrounds so the page shows through; the browser applies the mode's template before the first draw and switches it with `Plotly.relayout` when `data-bs-theme` (what `ui.input_dark_mode()` sets) or the OS `prefers-color-scheme` flips. Unknown template names raise at decoration time.
+- The in-place update family is complete: `add_traces`, `delete_traces`, `prepend_traces` and `update` (a restyle and a relayout in one redraw) join `extend_traces`, `restyle` and `relayout`. Same contract as the first three: values through plotly's encoder, ids namespaced inside a module, updates held and applied in order while the output has no figure drawn.
+- Examples for dark mode (`examples/dark_app.py`), dense-trace selections (`examples/events_app.py`) and a ready-to-export shinylive app (`examples/shinylive/`); a test keeps every example building.
+
+### Fixed
+
+- Shinylive: under pyodide the compressed plotly.js route is skipped instead of crashing the session. Pyodide cannot start threads, so the compression thread raised `RuntimeError: can't start new thread` from the first `@render_plotly` of every session and no figure ever rendered; there is also nothing to serve there, as the browser loads assets from the shinylive bundle. Verified against a real `shinylive export`: 0.3.0 crashes, this version renders.
+
 ## [0.3.0](https://github.com/rvben/shiny-plotly/compare/v0.2.0...v0.3.0) - 2026-08-20
 
 ### Added

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: shiny-plotly
-Version: 0.3.0
+Version: 0.3.1
 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
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
@@ -83,7 +84,7 @@ uv add shiny-plotly
 pip install shiny-plotly
 ```
 
-Requires Python 3.10+, `shiny>=1.0`, `plotly>=5.0`.
+Requires Python 3.10+, `shiny>=1.0`, `plotly>=5.5`.
 
 ## Use
 
@@ -158,6 +159,7 @@ The decorator creates its own output placeholder in Express, just like `@render_
     config={"displaylogo": False},
     events=("click", "selected"),  # arrive as input.sales_click, input.sales_selected
     max_event_points=10_000,  # above it an event carries the count and range, not the points
+    theme="auto",  # follow the page's color mode in the browser; also takes (light, dark)
     post_script=MORE_JS,  # JavaScript run once, when the graph is first drawn
 )
 def sales(): ...
@@ -204,7 +206,30 @@ Plotly alone re-measures a graph only on window resize. `shiny-plotly` ships a s
 
 ### Dark mode
 
-Plotly does not follow Bootstrap's color mode by itself. Give the dark mode switch an id, read it in the render function to pick the template, and make the figure's backgrounds transparent so the card's own background shows through in both modes:
+Plotly does not follow Bootstrap's color mode by itself. `theme="auto"` makes the figure follow it in the browser, with no server round-trip:
+
+```python
+app_ui = ui.page_fillable(
+    ui.input_dark_mode(),
+    ui.card(output_plotly("sales")),
+)
+
+
+@render_plotly(theme="auto")
+def sales():
+    return px.bar(df, x="month", y="total")
+```
+
+`"auto"` pairs plotly's own templates: `"plotly"` in light mode, `"plotly_dark"` in dark. A `(light, dark)` tuple picks different ones, each a registered name, a plotly `Template` object or a template dict:
+
+```python
+@render_plotly(theme=("seaborn", "plotly_dark"))
+def sales(): ...
+```
+
+How it works: both templates travel with the figure, their `paper_bgcolor` and `plot_bgcolor` made transparent so the card's own background shows through in both modes (backgrounds set on the figure's layout still win). The browser applies the mode's template before the first draw and switches it with `Plotly.relayout` when the mode flips, so the switch is instant and works even while the server is busy. The mode is `data-bs-theme` on `<html>`, which is what `ui.input_dark_mode()` maintains, or the OS `prefers-color-scheme` on a page without that attribute. A template the figure baked in through `layout.template` is dropped for themed outputs; use `theme=None` (the default) where the figure's own template should stand.
+
+The manual alternative, picking the template on the server, still works and is the way to vary anything beyond the template per mode. Give the dark mode switch an id and read it in the render function; flipping the switch then re-renders the figure through `Plotly.react`:
 
 ```python
 app_ui = ui.page_fillable(
@@ -220,8 +245,6 @@ def sales():
     return fig.update_layout(paper_bgcolor="rgba(0,0,0,0)", plot_bgcolor="rgba(0,0,0,0)")
 ```
 
-Flipping the switch re-renders the figure through `Plotly.react`, the same as any other re-render. `input.mode()` is `"light"` or `"dark"` and follows the user's system preference when the switch is not given an initial `mode`.
-
 ### 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`.
@@ -303,7 +326,7 @@ def scatter(): ...
 
 ### Live updates without a re-render
 
-A re-render sends the whole figure. For a stream of points, a colour change or a new title, send just the change: `extend_traces`, `restyle` and `relayout` call the plotly.js functions of the same names on the graph an output holds. All three are coroutines, so the effect that calls them is `async def`.
+A re-render sends the whole figure. For a stream of points, a colour change or a new title, send just the change: `extend_traces`, `prepend_traces`, `add_traces`, `delete_traces`, `restyle`, `relayout` and `update` call the plotly.js functions of the same names on the graph an output holds. All of them are coroutines, so the effect that calls them is `async def`.
 
 ```python
 from shiny_plotly import extend_traces, relayout, restyle
@@ -331,6 +354,10 @@ async def _highlight():
 - `extend_traces(id, data, indices=None, *, max_points=None)`: `data` maps an array attribute to one sequence of new values per trace, in the order of `indices` (`{"x": [[t]], "y": [[v]]}` appends one point to one trace; `{"y": [[1], [2]]}` with `indices=[0, 1]` one point to each of two). `indices` (an int or a list) defaults to every trace; `max_points` drops the oldest points past that many, for a rolling window.
 - `restyle(id, update, indices=None)`: `update` maps attribute paths to values; `{"marker.color": "red"}` applies to every trace in `indices`, a list value applies per trace (`{"opacity": [0.5, 1]}` with `indices=[0, 1]`).
 - `relayout(id, update)`: layout attribute paths, `{"title.text": "Live"}`, `{"xaxis.range": [0, 10]}`, `{"xaxis.autorange": True}`. With `events="relayout"` on the output, the result comes back as `input.<id>_relayout`, the same as a user's zoom.
+- `update(id, restyle=None, relayout=None, indices=None)`: a restyle and a relayout in one redraw, where separate calls would draw twice. At least one of the two is required; `indices` scopes the trace part.
+- `prepend_traces(id, data, indices=None, *, max_points=None)`: the mirror of `extend_traces`; the new values go in front, and `max_points` drops points from the far end.
+- `add_traces(id, traces, indices=None)`: whole new traces, each a graph object (`go.Scatter(y=[1, 2])`) or a dict (`{"y": [1], "type": "bar"}`); `indices` says where they land in the trace order, appended without it.
+- `delete_traces(id, indices)`: removes the traces at `indices`; the rest renumber, as a Python list does on `del`.
 
 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.
 
@@ -364,11 +391,18 @@ enable_compressed_plotly_js(app)
 
 And if a reverse proxy in front of the app does its own compression and caching, or you want Shiny's static serving untouched for any reason, set `SHINY_PLOTLY_NO_COMPRESS=1` in the app's environment; `enable_compressed_plotly_js` then returns `False` and adds nothing.
 
+### 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.
+
 ## Examples
 
 ```sh
-uv run --with shiny-plotly shiny run examples/core_app.py
-uv run --with shiny-plotly shiny run examples/express_app.py
+uv run --with shiny-plotly shiny run examples/core_app.py     # fill, margins, a click input, a live stream
+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
+uvx shinylive export examples/shinylive site                  # the same package, running in the browser
 ```
 
 ## Development

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

@@ -53,7 +53,7 @@ uv add shiny-plotly
 pip install shiny-plotly
 ```
 
-Requires Python 3.10+, `shiny>=1.0`, `plotly>=5.0`.
+Requires Python 3.10+, `shiny>=1.0`, `plotly>=5.5`.
 
 ## Use
 
@@ -128,6 +128,7 @@ The decorator creates its own output placeholder in Express, just like `@render_
     config={"displaylogo": False},
     events=("click", "selected"),  # arrive as input.sales_click, input.sales_selected
     max_event_points=10_000,  # above it an event carries the count and range, not the points
+    theme="auto",  # follow the page's color mode in the browser; also takes (light, dark)
     post_script=MORE_JS,  # JavaScript run once, when the graph is first drawn
 )
 def sales(): ...
@@ -174,7 +175,30 @@ Plotly alone re-measures a graph only on window resize. `shiny-plotly` ships a s
 
 ### Dark mode
 
-Plotly does not follow Bootstrap's color mode by itself. Give the dark mode switch an id, read it in the render function to pick the template, and make the figure's backgrounds transparent so the card's own background shows through in both modes:
+Plotly does not follow Bootstrap's color mode by itself. `theme="auto"` makes the figure follow it in the browser, with no server round-trip:
+
+```python
+app_ui = ui.page_fillable(
+    ui.input_dark_mode(),
+    ui.card(output_plotly("sales")),
+)
+
+
+@render_plotly(theme="auto")
+def sales():
+    return px.bar(df, x="month", y="total")
+```
+
+`"auto"` pairs plotly's own templates: `"plotly"` in light mode, `"plotly_dark"` in dark. A `(light, dark)` tuple picks different ones, each a registered name, a plotly `Template` object or a template dict:
+
+```python
+@render_plotly(theme=("seaborn", "plotly_dark"))
+def sales(): ...
+```
+
+How it works: both templates travel with the figure, their `paper_bgcolor` and `plot_bgcolor` made transparent so the card's own background shows through in both modes (backgrounds set on the figure's layout still win). The browser applies the mode's template before the first draw and switches it with `Plotly.relayout` when the mode flips, so the switch is instant and works even while the server is busy. The mode is `data-bs-theme` on `<html>`, which is what `ui.input_dark_mode()` maintains, or the OS `prefers-color-scheme` on a page without that attribute. A template the figure baked in through `layout.template` is dropped for themed outputs; use `theme=None` (the default) where the figure's own template should stand.
+
+The manual alternative, picking the template on the server, still works and is the way to vary anything beyond the template per mode. Give the dark mode switch an id and read it in the render function; flipping the switch then re-renders the figure through `Plotly.react`:
 
 ```python
 app_ui = ui.page_fillable(
@@ -190,8 +214,6 @@ def sales():
     return fig.update_layout(paper_bgcolor="rgba(0,0,0,0)", plot_bgcolor="rgba(0,0,0,0)")
 ```
 
-Flipping the switch re-renders the figure through `Plotly.react`, the same as any other re-render. `input.mode()` is `"light"` or `"dark"` and follows the user's system preference when the switch is not given an initial `mode`.
-
 ### 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`.
@@ -273,7 +295,7 @@ def scatter(): ...
 
 ### Live updates without a re-render
 
-A re-render sends the whole figure. For a stream of points, a colour change or a new title, send just the change: `extend_traces`, `restyle` and `relayout` call the plotly.js functions of the same names on the graph an output holds. All three are coroutines, so the effect that calls them is `async def`.
+A re-render sends the whole figure. For a stream of points, a colour change or a new title, send just the change: `extend_traces`, `prepend_traces`, `add_traces`, `delete_traces`, `restyle`, `relayout` and `update` call the plotly.js functions of the same names on the graph an output holds. All of them are coroutines, so the effect that calls them is `async def`.
 
 ```python
 from shiny_plotly import extend_traces, relayout, restyle
@@ -301,6 +323,10 @@ async def _highlight():
 - `extend_traces(id, data, indices=None, *, max_points=None)`: `data` maps an array attribute to one sequence of new values per trace, in the order of `indices` (`{"x": [[t]], "y": [[v]]}` appends one point to one trace; `{"y": [[1], [2]]}` with `indices=[0, 1]` one point to each of two). `indices` (an int or a list) defaults to every trace; `max_points` drops the oldest points past that many, for a rolling window.
 - `restyle(id, update, indices=None)`: `update` maps attribute paths to values; `{"marker.color": "red"}` applies to every trace in `indices`, a list value applies per trace (`{"opacity": [0.5, 1]}` with `indices=[0, 1]`).
 - `relayout(id, update)`: layout attribute paths, `{"title.text": "Live"}`, `{"xaxis.range": [0, 10]}`, `{"xaxis.autorange": True}`. With `events="relayout"` on the output, the result comes back as `input.<id>_relayout`, the same as a user's zoom.
+- `update(id, restyle=None, relayout=None, indices=None)`: a restyle and a relayout in one redraw, where separate calls would draw twice. At least one of the two is required; `indices` scopes the trace part.
+- `prepend_traces(id, data, indices=None, *, max_points=None)`: the mirror of `extend_traces`; the new values go in front, and `max_points` drops points from the far end.
+- `add_traces(id, traces, indices=None)`: whole new traces, each a graph object (`go.Scatter(y=[1, 2])`) or a dict (`{"y": [1], "type": "bar"}`); `indices` says where they land in the trace order, appended without it.
+- `delete_traces(id, indices)`: removes the traces at `indices`; the rest renumber, as a Python list does on `del`.
 
 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.
 
@@ -334,11 +360,18 @@ enable_compressed_plotly_js(app)
 
 And if a reverse proxy in front of the app does its own compression and caching, or you want Shiny's static serving untouched for any reason, set `SHINY_PLOTLY_NO_COMPRESS=1` in the app's environment; `enable_compressed_plotly_js` then returns `False` and adds nothing.
 
+### 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.
+
 ## Examples
 
 ```sh
-uv run --with shiny-plotly shiny run examples/core_app.py
-uv run --with shiny-plotly shiny run examples/express_app.py
+uv run --with shiny-plotly shiny run examples/core_app.py     # fill, margins, a click input, a live stream
+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
+uvx shinylive export examples/shinylive site                  # the same package, running in the browser
 ```
 
 ## Development

shiny_plotly-0.3.1/examples/dark_app.py

@@ -0,0 +1,53 @@
+"""Dark mode example: theme="auto" follows the page's color mode in the browser.
+
+Run with:  uv run --with shiny-plotly shiny run examples/dark_app.py
+"""
+
+import plotly.graph_objects as go
+from shiny import App, Inputs, Outputs, Session, ui
+
+from shiny_plotly import output_plotly, render_plotly
+
+MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun"]
+TOTALS = [12, 17, 9, 20, 14, 23]
+
+app_ui = ui.page_fillable(
+    ui.input_dark_mode(),
+    ui.layout_columns(
+        ui.card(
+            ui.card_header("theme='auto': plotly in light, plotly_dark in dark"),
+            output_plotly("auto_themed"),
+            full_screen=True,
+        ),
+        ui.card(
+            ui.card_header("A custom (light, dark) pair"),
+            output_plotly("pair_themed"),
+            full_screen=True,
+        ),
+    ),
+    title="shiny-plotly dark mode",
+)
+
+# Any registered template name, plotly Template object or template dict works in the pair.
+DARK_TEMPLATE = {
+    "layout": {
+        "font": {"color": "#f2f5fa"},
+        "colorway": ["#66c2a5", "#fc8d62", "#8da0cb"],
+    }
+}
+
+
+def server(input: Inputs, output: Outputs, session: Session):
+    # The flip happens in the browser with Plotly.relayout: no server round-trip, and it
+    # works even while the server is busy. Both templates travel with the figure, their
+    # backgrounds made transparent so the card shows through in both modes.
+    @render_plotly(theme="auto")
+    def auto_themed():
+        return go.Figure(go.Bar(x=MONTHS, y=TOTALS))
+
+    @render_plotly(theme=("seaborn", DARK_TEMPLATE))
+    def pair_themed():
+        return go.Figure(go.Scatter(x=MONTHS, y=TOTALS, mode="lines+markers"))
+
+
+app = App(app_ui, server)

shiny_plotly-0.3.1/examples/events_app.py

@@ -0,0 +1,64 @@
+"""Events example: clicks and box selections arrive as Shiny inputs.
+
+The trace holds 50 000 points, above the default max_event_points of 10 000, so a big
+selection arrives as a count plus the box's geometry and the server recounts membership
+from its own data, the pattern the README describes for dense traces.
+
+Run with:  uv run --with shiny-plotly shiny run examples/events_app.py
+"""
+
+import random
+
+import plotly.graph_objects as go
+from shiny import App, Inputs, Outputs, Session, render, ui
+
+from shiny_plotly import output_plotly, render_plotly
+
+rng = random.Random(7)
+N = 50_000
+X = [rng.gauss(0, 1) for _ in range(N)]
+Y = [rng.gauss(0, 1) for _ in range(N)]
+
+app_ui = ui.page_fillable(
+    ui.card(
+        ui.card_header("Drag a box; click a point"),
+        output_plotly("cloud"),
+        full_screen=True,
+    ),
+    ui.output_text("selection_info"),
+    ui.output_text("click_info"),
+    title="shiny-plotly events",
+)
+
+
+def server(input: Inputs, output: Outputs, session: Session):
+    @render_plotly(events=("click", "selected"))
+    def cloud():
+        fig = go.Figure(go.Scattergl(x=X, y=Y, mode="markers", marker={"size": 3}))
+        return fig.update_layout(dragmode="select")
+
+    @render.text
+    def selection_info():
+        if not input.cloud_selected.is_set():
+            return "Selection: none yet."
+        sel = input.cloud_selected()
+        if sel is None:
+            return "Selection: cleared."
+        if sel["points"] is not None:
+            return f"Selection: {len(sel['points'])} points arrived with the event."
+        # Above max_event_points the geometry arrives instead of the points; the data
+        # lives here, so membership is a filter on the box the user dragged.
+        x0, x1 = sorted(sel["range"]["x"])
+        y0, y1 = sorted(sel["range"]["y"])
+        inside = sum(1 for x, y in zip(X, Y, strict=True) if x0 <= x <= x1 and y0 <= y <= y1)
+        return f"Selection: {sel['point_count']} points; recounted {inside} on the server."
+
+    @render.text
+    def click_info():
+        if not input.cloud_click.is_set():
+            return "Click: none yet."
+        pt = input.cloud_click()["points"][0]
+        return f"Click: point {pt['pointNumber']} at x={pt['x']:.2f}, y={pt['y']:.2f}."
+
+
+app = App(app_ui, server)

shiny_plotly-0.3.1/examples/shinylive/app.py

@@ -0,0 +1,33 @@
+"""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)

shiny_plotly-0.3.1/examples/shinylive/requirements.txt

@@ -0,0 +1,3 @@
+# 0.3.0 started a thread at session start, which pyodide cannot do; newer versions skip it.
+shiny-plotly>0.3.0
+plotly

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "shiny-plotly"
-version = "0.3.0"
+version = "0.3.1"
 description = "Render plotly figures in Shiny for Python with plain plotly.js, without the shinywidgets layer."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -22,6 +22,7 @@ classifiers = [
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Topic :: Scientific/Engineering :: Visualization",
   "Typing :: Typed",
 ]
@@ -59,6 +60,12 @@ dev = [
   "brotli>=1.1",
 ]
 
+# uv's default cache keys for a local build are the metadata files only, so a source-only
+# change would keep serving the previously built wheel to `uv pip install .` (check-floor
+# once tested a stale build that way). Key the cache on the shipped source too.
+[tool.uv]
+cache-keys = [{ file = "pyproject.toml" }, { file = "src/**/*" }]
+
 [tool.hatch.build.targets.wheel]
 packages = ["src/shiny_plotly"]
 

{shiny_plotly-0.3.0 → shiny_plotly-0.3.1}/src/shiny_plotly/__init__.py

@@ -4,19 +4,31 @@ from ._deps import __version__, plotly_js, shiny_plotly_js
 from ._html import FIGUREWIDGET_MARGINS, fig_to_ui
 from ._render import DEFAULT_MAX_EVENT_POINTS, output_plotly, render_plotly
 from ._serve import enable_compressed_plotly_js
-from ._update import extend_traces, relayout, restyle
+from ._update import (
+    add_traces,
+    delete_traces,
+    extend_traces,
+    prepend_traces,
+    relayout,
+    restyle,
+    update,
+)
 
 __all__ = (
     "DEFAULT_MAX_EVENT_POINTS",
     "FIGUREWIDGET_MARGINS",
     "__version__",
+    "add_traces",
+    "delete_traces",
     "enable_compressed_plotly_js",
     "extend_traces",
     "fig_to_ui",
     "output_plotly",
     "plotly_js",
+    "prepend_traces",
     "relayout",
     "render_plotly",
     "restyle",
     "shiny_plotly_js",
+    "update",
 )

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

@@ -5,6 +5,7 @@ from typing import Any
 
 import plotly.io as pio
 from htmltools import Tag, css, tags
+from plotly.io.json import to_json_plotly
 from shiny.module import resolve_id
 from shiny.render.renderer import Jsonifiable, Renderer, ValueFn
 from shiny.ui.fill import as_fill_item, as_fillable_container
@@ -40,6 +41,59 @@ def normalize_events(events: str | Iterable[str] | None) -> tuple[str, ...]:
     return tuple(name for name in EVENTS if name in names)
 
 
+# One theme template: a registered name ("plotly_dark"), a plotly Template object, or a
+# template dict ({"layout": {...}, "data": {...}}).
+TemplateSpec = str | Mapping[str, Any] | Any
+
+
+ThemePair = tuple[TemplateSpec, TemplateSpec]
+
+
+def normalize_theme(theme: str | ThemePair | None) -> ThemePair | None:
+    """``None``, or a validated (light, dark) pair of template specs."""
+    if theme is None:
+        return None
+    if isinstance(theme, str):
+        if theme == "auto":
+            return ("plotly", "plotly_dark")
+        raise ValueError(
+            f'theme must be "auto" or a (light, dark) pair of templates, got {theme!r}; '
+            "for one template in both modes, set layout.template on the figure instead"
+        )
+    pair = tuple(theme)
+    if len(pair) != 2:
+        raise ValueError(f"theme must be a (light, dark) pair of templates, got {len(pair)}")
+    for spec in pair:
+        if isinstance(spec, str):
+            if spec not in pio.templates:
+                raise ValueError(
+                    f"unknown template name {spec!r}; the registered names are "
+                    + ", ".join(sorted(pio.templates))
+                )
+        elif not isinstance(spec, Mapping) and not callable(getattr(spec, "to_plotly_json", None)):
+            raise ValueError(
+                "a theme template must be a registered name, a plotly Template object "
+                f"or a template dict, got {type(spec).__name__}"
+            )
+    return pair
+
+
+def _template_json(spec: TemplateSpec) -> dict[str, Any]:
+    """The template as a plain dict, backgrounds made transparent in a copy."""
+    template: Any = pio.templates[spec] if isinstance(spec, str) else spec
+    to_json = getattr(template, "to_plotly_json", None)
+    raw: Any = to_json() if callable(to_json) else template
+    out: dict[str, Any] = dict(raw)
+    layout = dict(out.get("layout") or {})
+    # The page's own background shows through, so the graph matches the surface it sits
+    # on in both modes. A paper_bgcolor or plot_bgcolor set on the figure's layout still
+    # wins, as figure values always do over template values.
+    layout["paper_bgcolor"] = "rgba(0,0,0,0)"
+    layout["plot_bgcolor"] = "rgba(0,0,0,0)"
+    out["layout"] = layout
+    return out
+
+
 def normalize_max_event_points(value: int | None) -> int | None:
     if value is None:
         return None
@@ -136,6 +190,19 @@ class render_plotly(Renderer[Figure]):
         data is. At 10 000 points an event is about 1 MB; ``None`` lifts the cap, and a
         selection of 150 000 points or more then exceeds the 16 MB websocket message
         limit uvicorn applies by default, which closes the session.
+    theme
+        Make the figure follow the page's color mode, in the browser, with no server
+        round-trip. ``"auto"`` uses plotly's own pair: the ``"plotly"`` template in light
+        mode and ``"plotly_dark"`` in dark. A ``(light, dark)`` pair picks the templates,
+        each a registered name (``"seaborn"``), a plotly ``Template`` object or a template
+        dict. Both templates travel with the figure, with transparent ``paper_bgcolor``
+        and ``plot_bgcolor`` so the page shows through (a figure-level background still
+        wins); a template the figure baked in via ``layout.template`` is dropped. The
+        browser applies the mode's template before the first draw and switches it with
+        ``Plotly.relayout`` when the mode flips: it follows ``data-bs-theme`` on ``<html>``
+        (what ``ui.input_dark_mode()`` sets) when present, the OS ``prefers-color-scheme``
+        otherwise. Template names resolve when the decorator runs; an unknown name raises
+        right there. Default ``None``: the figure's own template, fixed.
     """
 
     def __init__(
@@ -149,6 +216,7 @@ class render_plotly(Renderer[Figure]):
         post_script: str | None = None,
         events: str | Iterable[str] | None = None,
         max_event_points: int | None = DEFAULT_MAX_EVENT_POINTS,
+        theme: str | ThemePair | None = None,
     ) -> None:
         self.height = height
         self.width = width
@@ -157,6 +225,16 @@ class render_plotly(Renderer[Figure]):
         self.post_script = post_script
         self.events = normalize_events(events)
         self.max_event_points = normalize_max_event_points(max_event_points)
+        self.theme = normalize_theme(theme)
+        if self.theme is None:
+            self._themes_json = None
+        else:
+            # Resolved and serialized once, here, so an unknown name fails at decoration
+            # time and a render costs nothing extra.
+            light, dark = self.theme
+            self._themes_json = to_json_plotly(
+                {"light": _template_json(light), "dark": _template_json(dark)}
+            )
         # Registers _fn (sets output_id from its name) when used as a bare decorator.
         super().__init__(_fn)  # type: ignore[arg-type]
 
@@ -175,6 +253,12 @@ class render_plotly(Renderer[Figure]):
         fig_dict = as_fig_dict(value)
         if self.figurewidget_margins:
             fill_in_margins(fig_dict)
+        if self._themes_json is not None:
+            # The browser picks the mode's template; the one the figure baked in at
+            # construction would only add dead weight and a flash of the wrong theme.
+            layout = fig_dict.get("layout")
+            if isinstance(layout, dict):
+                layout.pop("template", None)
         return {
             # Serialised by plotly, not Shiny: numpy and pandas values, datetimes and the
             # compact base64 array encoding only work through plotly's encoder.
@@ -185,4 +269,5 @@ class render_plotly(Renderer[Figure]):
             "post_script": self.post_script,
             "events": list(self.events),
             "max_event_points": self.max_event_points,
+            "themes": self._themes_json,
         }

{shiny_plotly-0.3.0 → shiny_plotly-0.3.1}/src/shiny_plotly/_serve.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 import gzip
 import hashlib
 import os
+import sys
 import threading
 from collections.abc import Iterator
 from pathlib import Path
@@ -161,9 +162,11 @@ def enable_compressed_plotly_js(app: object) -> bool:
 
     Returns True when the route was added, False when it was already there, ``app`` is
     not a Shiny app, or ``SHINY_PLOTLY_NO_COMPRESS`` is set in the environment (the escape
-    hatch for deployments that want Shiny's own static serving untouched).
+    hatch for deployments that want Shiny's own static serving untouched). Under pyodide
+    (shinylive) it is False too: threads cannot start there, and the browser loads assets
+    from the shinylive bundle rather than over HTTP, so there is nothing to compress.
     """
-    if os.environ.get("SHINY_PLOTLY_NO_COMPRESS"):
+    if os.environ.get("SHINY_PLOTLY_NO_COMPRESS") or sys.platform == "emscripten":
         return False
     starlette_app = getattr(app, "starlette_app", None)
     lib_prefix = getattr(app, "lib_prefix", None)