PyPI - shiny-plotly - Versions diffs - 0.3.2__tar.gz → 0.4.0__tar.gz - Mend

shiny-plotly 0.3.2tar.gz → 0.4.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (41) hide show

{shiny_plotly-0.3.2 → shiny_plotly-0.4.0}/.gitignore RENAMED Viewed

@@ -6,5 +6,6 @@ __pycache__/
 *.pyc
 .pytest_cache/
 .ruff_cache/
+.coverage
 tmp/
 site/

{shiny_plotly-0.3.2 → shiny_plotly-0.4.0}/CHANGELOG.md RENAMED Viewed

@@ -7,6 +7,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
+## [0.4.0](https://github.com/rvben/shiny-plotly/compare/v0.3.3...v0.4.0) - 2026-08-21
+### Changed
+- `brotli` is a dependency, so a plain `uv add shiny-plotly` serves plotly.min.js in the smaller encoding (1.2 MB on the wire against 1.5 MB gzipped) instead of only where someone thought to ask for it. It carries the marker `sys_platform != 'emscripten'`: under pyodide the compressing route is never installed, so a shinylive export would have downloaded a 307 kB wasm wheel to compress nothing. An install that still ends up without brotli (a lock file older than this release, a platform with no wheel) falls back to gzip and logs the same one-off warning as before, now naming the fix.
+- README: the note on hidden outputs now names every container Shiny defers a chart in (an inactive `ui.navset_tab`, `ui.navset_card_tab`, `ui.navset_pill` or `ui.navset_hidden` panel, a closed `ui.accordion` section, and a false `ui.panel_conditional` from Shiny 1.6.1 on, which is where that last one changed), and says what it does not cover: a chart scrolled below the fold is drawn with the rest at load. A browser test holds every case, so a Shiny release that changes the behavior breaks the suite rather than the advice.
+### Fixed
+- A client that refuses an encoding with `Accept-Encoding: br;q=0.0` is no longer served it. RFC 9110 lets a qvalue of zero be written `q=0`, `q=0.0` or `q=0.000`, and only the first spelling was read as a refusal, so plotly.min.js could arrive in an encoding the client had said it would not take.
+### Removed
+- The `brotli` extra, now that brotli is a plain dependency. An install that still names it (`shiny-plotly[brotli]`) gets the same package, plus a warning from pip or uv that the extra does not exist; drop the `[brotli]`.
+## [0.3.3](https://github.com/rvben/shiny-plotly/compare/v0.3.2...v0.3.3) - 2026-08-21
+### Added
+- A themed chart takes its color mode from the nearest ancestor that carries `data-bs-theme`, itself included, instead of from `<html>` alone. Bootstrap honors the attribute on any element, so `ui.div(..., data_bs_theme="dark")` around part of a page now themes the charts inside it while the rest of the page follows the page mode. The observer watches the whole subtree, so the attribute can be set on a container after the charts are drawn; that is all a control of your own needs to drive the mode, and the README carries the recipe.
+- A warning, said once per process, when `plotly.min.js` is served gzipped because `brotli` is not installed: it names the size being served and the roughly 17% brotli would save. Without it a deployment has no way to notice, since the bundle is compressed, cached and immutable either way, just bigger. Silence it with `logging.getLogger("shiny_plotly").setLevel(logging.ERROR)`.
+- README: what each chart on a page costs to draw, and that Shiny suspends outputs hidden in an inactive `ui.nav_panel`, so charts in tabs are drawn when their tab is first opened rather than on load.
+### Changed
+- Every app serves plotly.min.js compressed and immutable from its first request, with no call of its own: importing `shiny_plotly` wraps `shiny.App.__init__`, so the route is added as each app is built, Core and Express alike. Until now it arrived with the first session, which is after the page load that opened that session had already pulled 4.9 MB from Shiny's static mount with no `Cache-Control` at all; the background compression now starts while the app is being built instead of when the first visitor is already waiting. `enable_compressed_plotly_js(app)` stays for an app constructed before the import, `SHINY_PLOTLY_NO_COMPRESS=1` still leaves Shiny's static serving untouched, and a failure to install the route is logged rather than raised: it can never keep an app from being built.
+- The templates behind `@render_plotly(theme=...)` travel once per session instead of once per figure. A template is about 6.5 kB, and every chart on a page usually shares one pair, so the first themed value carries the pair and every value afterwards names it by content hash: a page of ten charts sends about 13 kB of templates instead of 135 kB. Two outputs on different themes each send their own pair, a module shares the cache with the page around it, and a reconnecting browser gets a new session and so a fresh copy. A render with no session to cache against (a value produced outside a session, or Express's stub session before it connects) still carries its templates inline.
 ## [0.3.2](https://github.com/rvben/shiny-plotly/compare/v0.3.1...v0.3.2) - 2026-08-20
 ### Added

{shiny_plotly-0.3.2 → shiny_plotly-0.4.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: shiny-plotly
-Version: 0.3.2
+Version: 0.4.0
 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
@@ -22,11 +22,10 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
+Requires-Dist: brotli>=1.1; sys_platform != 'emscripten'
 Requires-Dist: htmltools>=0.5.2
 Requires-Dist: plotly>=5.5
 Requires-Dist: shiny>=1.0
-Provides-Extra: brotli
-Requires-Dist: brotli>=1.1; extra == 'brotli'
 Description-Content-Type: text/markdown
 # shiny-plotly
@@ -206,6 +205,12 @@ The rules mirror `output_widget`:
 Plotly alone re-measures a graph only on window resize. `shiny-plotly` ships a small helper script (`shiny-plotly.js`, loaded with every output) that observes each graph's container with a `ResizeObserver`, so a card that changes size without a window resize, for example when a sibling output renders below it, or when a sidebar collapses, re-lays the graph out. The same helper purges a graph once it leaves the document, which releases the window listener and layout state plotly would otherwise keep.
+### Many charts on one page
+Drawing a plotly figure costs the browser a fixed amount of main-thread work per graph, tens of milliseconds for a small one on a current desktop, and the browser draws them one after another. On a dashboard of a dozen charts that per-chart work, not the bytes on the wire, is what the first second is spent on, and it is plotly's own cost: the same figure drawn from shinywidgets or from a static `to_html` export costs the same.
+The lever is drawing fewer charts at once, and Shiny pulls it for you: an output the browser reports as hidden is suspended, so its figure is not rendered at all until it is shown. That covers every container that hides one, whether an inactive panel of `ui.navset_tab`, `ui.navset_card_tab`, `ui.navset_pill` or `ui.navset_hidden`, a closed `ui.accordion` section, or a `ui.panel_conditional` whose condition is false (that last one from Shiny 1.6.1 on; older Shiny drew it at load); each panel then pays only for its own charts, and pays when it is opened. Scrolling is not hiding, though: a chart 3000px down the page is visible as far as the browser is concerned, and is drawn with the rest at load. Charts that must all be visible at once are better served by fewer, denser figures (subplots in one graph div) than by many small ones.
 ### Dark mode
 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:
@@ -229,7 +234,40 @@ def sales():
 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.
+How it works: both templates get 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. 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.
+A template is about 6.5 kB of JSON, so it is sent **once per session** rather than once per render: the first themed value of a session brings the templates over their own message, and every value after it names them by content hash. A dashboard of twelve charts on one theme therefore pays for the theme once, and a re-render of a small figure is not dominated by a template that has not changed. Two outputs whose templates are equal share the copy automatically; nothing has to be declared.
+The mode comes from `data-bs-theme` on the **nearest ancestor of the output that sets one**. Usually that is `<html>`, which is what `ui.input_dark_mode()` maintains, and a page without the attribute anywhere follows the OS `prefers-color-scheme`. Because the lookup is per output, a container can theme the charts inside it against the rest of the page:
+```python
+ui.div(
+    ui.card(output_plotly("preview")),  # always dark, whatever the page does
+    data_bs_theme="dark",
+)
+```
+**Driving the mode yourself.** The attribute is the whole contract, so anything that sets it switches the charts: no shiny-plotly API is involved. To drive it from your own control, write it and the graphs follow on the next frame:
+```python
+app_ui = ui.page_fluid(
+    ui.input_switch("night", "Night mode"),
+    ui.tags.script("""
+        Shiny.addCustomMessageHandler("color-mode", function (message) {
+          document.documentElement.setAttribute("data-bs-theme", message.mode);
+        });
+    """),
+    ui.card(output_plotly("sales")),
+)
+@reactive.effect
+async def _apply_mode():
+    mode = "dark" if input.night() else "light"
+    await session.send_custom_message("color-mode", {"mode": mode})
+```
+The same holds in reverse: a page that already themes itself (a CSS framework, a cookie read at startup, `ui.input_dark_mode()` in a nav bar) needs nothing added, and a chart rendered while the attribute is already `dark` comes up dark on its first draw rather than flashing light first.
 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`:
@@ -373,29 +411,22 @@ A runnable version of the streaming pattern, with a pause switch and a window sl
 - `plotly_js()` is the `HTMLDependency` for plotly.js, served from the installed `plotly` wheel at `/lib/plotly-<version>/plotly.min.js`. Every `output_plotly` and every `fig_to_ui` fragment carries it, so it is optional; add it to the page UI when the first figure is inserted later (`ui.insert_ui`, a `@render.ui` that starts empty) and the bundle should load with the page.
 - `shiny_plotly_js()` is the helper's dependency. Every output and fragment carries it too.
 - `FIGUREWIDGET_MARGINS` is the `{"l": 16, "t": 32, "r": 16, "b": 16}` mapping.
-- `enable_compressed_plotly_js(app)` turns on compressed, immutable serving of plotly.js for a `shiny.App` before its first session (see below).
+- `enable_compressed_plotly_js(app)` adds compressed, immutable serving of plotly.js to a `shiny.App` explicitly. Every app built after `shiny_plotly` is imported already has it; this is the way in for one that was constructed before the import (see below).
 - `extend_traces`, `restyle` and `relayout` take an optional `session=` when called outside the current session's context.
 `render_plotly` needs `output_plotly`; it is an output binding, not a `render.ui`, so `ui.output_ui(id)` does not draw it.
 ### plotly.js on the wire
-Shiny serves HTML dependencies from a plain static mount: no compression, no `Cache-Control`. `plotly.min.js` is 4.9 MB, so once the first session of a process has rendered a figure, `shiny-plotly` adds a route in front of that mount for the bundle's exact path (`/lib/plotly-<version>/plotly.min.js`) that serves it pre-compressed (brotli when the `brotli` package is installed, gzip otherwise; 1.2 MB or 1.5 MB on the wire) with `Cache-Control: public, max-age=31536000, immutable`, `Vary: Accept-Encoding` and an `ETag` per encoding. The URL is keyed by the plotly version, so a browser fetches each version once. Compression runs once per process, in a background thread; until it has finished the route serves the raw file with the same headers.
+Shiny serves HTML dependencies from a plain static mount: no compression, no `Cache-Control`. `plotly.min.js` is 4.9 MB, so `shiny-plotly` adds a route in front of that mount for the bundle's exact path (`/lib/plotly-<version>/plotly.min.js`) that serves it pre-compressed (brotli, 1.2 MB on the wire, or gzip at 1.5 MB where brotli is not installed) with `Cache-Control: public, max-age=31536000, immutable`, `Vary: Accept-Encoding` and an `ETag` per encoding. The URL is keyed by the plotly version, so a browser fetches each version once. Compression runs once per process, in a background thread; until it has finished the route serves the raw file with the same headers.
-```sh
-uv add "shiny-plotly[brotli]"  # optional: brotli instead of gzip
-```
-Two things to know. The page load that starts the very first session of a process has already asked for the bundle before the route exists, so that one visitor gets the raw file from Shiny's mount; everyone after gets the compressed one. A Core app can close that gap by enabling the route as soon as the `App` exists:
+`brotli` is a dependency, so a plain `uv add shiny-plotly` serves the smaller encoding. It is skipped under pyodide, where there is nothing to compress: a shinylive export carries its own assets and the route is not installed at all. An install that ends up without it (a lock file that predates the dependency, a platform with no wheel) falls back to gzip and logs one warning saying which encoding it is serving and what brotli would save, so a deployment can see it is shipping the larger bundle; `logging.getLogger("shiny_plotly").setLevel(logging.ERROR)` silences it.
-```python
-from shiny_plotly import enable_compressed_plotly_js
+The route asks nothing of the app. Importing `shiny_plotly` wraps `shiny.App.__init__`, so every app built afterwards has it, Core and Express alike, and the compression starts while the app is still being built rather than when someone first visits it. The timing is the whole point: the browser asks for plotly.js while the page is loading, well before the session that page opens exists, so a route that waited for a session would arrive one visitor too late, and that visitor would take 4.9 MB with no `Cache-Control` at all.
-app = App(app_ui, server)
-enable_compressed_plotly_js(app)
-```
+An app constructed before `shiny_plotly` is imported is the one case the constructor cannot reach; `enable_compressed_plotly_js(app)` adds the route to it, and returns `False` if it is already there.
-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.
+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: no route is added, and `enable_compressed_plotly_js` returns `False`.
 ### Shinylive
@@ -422,7 +453,7 @@ make bench       # the shinywidgets comparison above, on this machine
 make bench-events  # what a selection over a dense trace costs, capped and uncapped
 ```
-`make test` runs the unit tests and the in-process Shiny end-to-end tests over a real websocket, including the compressed bundle route. `make test-browser` drives the package in headless Chromium: fill sizing, resize without a window event, the graph div surviving a re-render, `uirevision` keeping a dragged zoom, purge once an output leaves the page, full screen, `events=` click, hover, selection and relayout inputs (attached once, also inside a module, a selection above `max_event_points` arriving as count and range), `extend_traces`, `restyle` and `relayout` applied in place (rolling window, one trace or all, held until the first draw, reset by a re-render, inside a module, dropped with a warning for an unknown output), `post_script` click wiring (once, not stacked), the dark mode recipe, error and `None` rendering, on-demand loading of plotly.js and the compressed, cached bundle as a fresh visitor sees it. `make check-wheel` installs the built wheel into a throwaway venv and runs the suite against it, so the published artifact is what was tested. `make check-floor` installs the package with plotly, shiny and htmltools at the oldest versions `pyproject.toml` allows and runs the whole suite again, browser tests included, so the declared lower bounds are tested on every push rather than assumed.
+`make test` runs the unit tests and the in-process Shiny end-to-end tests over a real websocket, including the compressed bundle route. It fails below 100% line and branch coverage of the package: every line is reachable without a browser, and the gate is what keeps behavior that only the Chromium suite can reach from growing. `make test-browser` drives the package in headless Chromium: fill sizing, resize without a window event, the graph div surviving a re-render, `uirevision` keeping a dragged zoom, purge once an output leaves the page, full screen, `events=` click, hover, selection and relayout inputs (attached once, also inside a module, a selection above `max_event_points` arriving as count and range), `extend_traces`, `restyle` and `relayout` applied in place (rolling window, one trace or all, held until the first draw, reset by a re-render, inside a module, dropped with a warning for an unknown output), `post_script` click wiring (once, not stacked), the dark mode recipe, error and `None` rendering, on-demand loading of plotly.js and the compressed, cached bundle as a fresh visitor sees it. `make check-wheel` installs the built wheel into a throwaway venv and runs the suite against it, so the published artifact is what was tested. `make check-floor` installs the package with plotly, shiny and htmltools at the oldest versions `pyproject.toml` allows and runs the whole suite again, browser tests included, so the declared lower bounds are tested on every push rather than assumed.
 ## License

{shiny_plotly-0.3.2 → shiny_plotly-0.4.0}/README.md RENAMED Viewed

@@ -175,6 +175,12 @@ The rules mirror `output_widget`:
 Plotly alone re-measures a graph only on window resize. `shiny-plotly` ships a small helper script (`shiny-plotly.js`, loaded with every output) that observes each graph's container with a `ResizeObserver`, so a card that changes size without a window resize, for example when a sibling output renders below it, or when a sidebar collapses, re-lays the graph out. The same helper purges a graph once it leaves the document, which releases the window listener and layout state plotly would otherwise keep.
+### Many charts on one page
+Drawing a plotly figure costs the browser a fixed amount of main-thread work per graph, tens of milliseconds for a small one on a current desktop, and the browser draws them one after another. On a dashboard of a dozen charts that per-chart work, not the bytes on the wire, is what the first second is spent on, and it is plotly's own cost: the same figure drawn from shinywidgets or from a static `to_html` export costs the same.
+The lever is drawing fewer charts at once, and Shiny pulls it for you: an output the browser reports as hidden is suspended, so its figure is not rendered at all until it is shown. That covers every container that hides one, whether an inactive panel of `ui.navset_tab`, `ui.navset_card_tab`, `ui.navset_pill` or `ui.navset_hidden`, a closed `ui.accordion` section, or a `ui.panel_conditional` whose condition is false (that last one from Shiny 1.6.1 on; older Shiny drew it at load); each panel then pays only for its own charts, and pays when it is opened. Scrolling is not hiding, though: a chart 3000px down the page is visible as far as the browser is concerned, and is drawn with the rest at load. Charts that must all be visible at once are better served by fewer, denser figures (subplots in one graph div) than by many small ones.
 ### Dark mode
 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:
@@ -198,7 +204,40 @@ def sales():
 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.
+How it works: both templates get 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. 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.
+A template is about 6.5 kB of JSON, so it is sent **once per session** rather than once per render: the first themed value of a session brings the templates over their own message, and every value after it names them by content hash. A dashboard of twelve charts on one theme therefore pays for the theme once, and a re-render of a small figure is not dominated by a template that has not changed. Two outputs whose templates are equal share the copy automatically; nothing has to be declared.
+The mode comes from `data-bs-theme` on the **nearest ancestor of the output that sets one**. Usually that is `<html>`, which is what `ui.input_dark_mode()` maintains, and a page without the attribute anywhere follows the OS `prefers-color-scheme`. Because the lookup is per output, a container can theme the charts inside it against the rest of the page:
+```python
+ui.div(
+    ui.card(output_plotly("preview")),  # always dark, whatever the page does
+    data_bs_theme="dark",
+)
+```
+**Driving the mode yourself.** The attribute is the whole contract, so anything that sets it switches the charts: no shiny-plotly API is involved. To drive it from your own control, write it and the graphs follow on the next frame:
+```python
+app_ui = ui.page_fluid(
+    ui.input_switch("night", "Night mode"),
+    ui.tags.script("""
+        Shiny.addCustomMessageHandler("color-mode", function (message) {
+          document.documentElement.setAttribute("data-bs-theme", message.mode);
+        });
+    """),
+    ui.card(output_plotly("sales")),
+)
+@reactive.effect
+async def _apply_mode():
+    mode = "dark" if input.night() else "light"
+    await session.send_custom_message("color-mode", {"mode": mode})
+```
+The same holds in reverse: a page that already themes itself (a CSS framework, a cookie read at startup, `ui.input_dark_mode()` in a nav bar) needs nothing added, and a chart rendered while the attribute is already `dark` comes up dark on its first draw rather than flashing light first.
 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`:
@@ -342,29 +381,22 @@ A runnable version of the streaming pattern, with a pause switch and a window sl
 - `plotly_js()` is the `HTMLDependency` for plotly.js, served from the installed `plotly` wheel at `/lib/plotly-<version>/plotly.min.js`. Every `output_plotly` and every `fig_to_ui` fragment carries it, so it is optional; add it to the page UI when the first figure is inserted later (`ui.insert_ui`, a `@render.ui` that starts empty) and the bundle should load with the page.
 - `shiny_plotly_js()` is the helper's dependency. Every output and fragment carries it too.
 - `FIGUREWIDGET_MARGINS` is the `{"l": 16, "t": 32, "r": 16, "b": 16}` mapping.
-- `enable_compressed_plotly_js(app)` turns on compressed, immutable serving of plotly.js for a `shiny.App` before its first session (see below).
+- `enable_compressed_plotly_js(app)` adds compressed, immutable serving of plotly.js to a `shiny.App` explicitly. Every app built after `shiny_plotly` is imported already has it; this is the way in for one that was constructed before the import (see below).
 - `extend_traces`, `restyle` and `relayout` take an optional `session=` when called outside the current session's context.
 `render_plotly` needs `output_plotly`; it is an output binding, not a `render.ui`, so `ui.output_ui(id)` does not draw it.
 ### plotly.js on the wire
-Shiny serves HTML dependencies from a plain static mount: no compression, no `Cache-Control`. `plotly.min.js` is 4.9 MB, so once the first session of a process has rendered a figure, `shiny-plotly` adds a route in front of that mount for the bundle's exact path (`/lib/plotly-<version>/plotly.min.js`) that serves it pre-compressed (brotli when the `brotli` package is installed, gzip otherwise; 1.2 MB or 1.5 MB on the wire) with `Cache-Control: public, max-age=31536000, immutable`, `Vary: Accept-Encoding` and an `ETag` per encoding. The URL is keyed by the plotly version, so a browser fetches each version once. Compression runs once per process, in a background thread; until it has finished the route serves the raw file with the same headers.
+Shiny serves HTML dependencies from a plain static mount: no compression, no `Cache-Control`. `plotly.min.js` is 4.9 MB, so `shiny-plotly` adds a route in front of that mount for the bundle's exact path (`/lib/plotly-<version>/plotly.min.js`) that serves it pre-compressed (brotli, 1.2 MB on the wire, or gzip at 1.5 MB where brotli is not installed) with `Cache-Control: public, max-age=31536000, immutable`, `Vary: Accept-Encoding` and an `ETag` per encoding. The URL is keyed by the plotly version, so a browser fetches each version once. Compression runs once per process, in a background thread; until it has finished the route serves the raw file with the same headers.
-```sh
-uv add "shiny-plotly[brotli]"  # optional: brotli instead of gzip
-```
-Two things to know. The page load that starts the very first session of a process has already asked for the bundle before the route exists, so that one visitor gets the raw file from Shiny's mount; everyone after gets the compressed one. A Core app can close that gap by enabling the route as soon as the `App` exists:
+`brotli` is a dependency, so a plain `uv add shiny-plotly` serves the smaller encoding. It is skipped under pyodide, where there is nothing to compress: a shinylive export carries its own assets and the route is not installed at all. An install that ends up without it (a lock file that predates the dependency, a platform with no wheel) falls back to gzip and logs one warning saying which encoding it is serving and what brotli would save, so a deployment can see it is shipping the larger bundle; `logging.getLogger("shiny_plotly").setLevel(logging.ERROR)` silences it.
-```python
-from shiny_plotly import enable_compressed_plotly_js
+The route asks nothing of the app. Importing `shiny_plotly` wraps `shiny.App.__init__`, so every app built afterwards has it, Core and Express alike, and the compression starts while the app is still being built rather than when someone first visits it. The timing is the whole point: the browser asks for plotly.js while the page is loading, well before the session that page opens exists, so a route that waited for a session would arrive one visitor too late, and that visitor would take 4.9 MB with no `Cache-Control` at all.
-app = App(app_ui, server)
-enable_compressed_plotly_js(app)
-```
+An app constructed before `shiny_plotly` is imported is the one case the constructor cannot reach; `enable_compressed_plotly_js(app)` adds the route to it, and returns `False` if it is already there.
-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.
+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: no route is added, and `enable_compressed_plotly_js` returns `False`.
 ### Shinylive
@@ -391,7 +423,7 @@ make bench       # the shinywidgets comparison above, on this machine
 make bench-events  # what a selection over a dense trace costs, capped and uncapped
 ```
-`make test` runs the unit tests and the in-process Shiny end-to-end tests over a real websocket, including the compressed bundle route. `make test-browser` drives the package in headless Chromium: fill sizing, resize without a window event, the graph div surviving a re-render, `uirevision` keeping a dragged zoom, purge once an output leaves the page, full screen, `events=` click, hover, selection and relayout inputs (attached once, also inside a module, a selection above `max_event_points` arriving as count and range), `extend_traces`, `restyle` and `relayout` applied in place (rolling window, one trace or all, held until the first draw, reset by a re-render, inside a module, dropped with a warning for an unknown output), `post_script` click wiring (once, not stacked), the dark mode recipe, error and `None` rendering, on-demand loading of plotly.js and the compressed, cached bundle as a fresh visitor sees it. `make check-wheel` installs the built wheel into a throwaway venv and runs the suite against it, so the published artifact is what was tested. `make check-floor` installs the package with plotly, shiny and htmltools at the oldest versions `pyproject.toml` allows and runs the whole suite again, browser tests included, so the declared lower bounds are tested on every push rather than assumed.
+`make test` runs the unit tests and the in-process Shiny end-to-end tests over a real websocket, including the compressed bundle route. It fails below 100% line and branch coverage of the package: every line is reachable without a browser, and the gate is what keeps behavior that only the Chromium suite can reach from growing. `make test-browser` drives the package in headless Chromium: fill sizing, resize without a window event, the graph div surviving a re-render, `uirevision` keeping a dragged zoom, purge once an output leaves the page, full screen, `events=` click, hover, selection and relayout inputs (attached once, also inside a module, a selection above `max_event_points` arriving as count and range), `extend_traces`, `restyle` and `relayout` applied in place (rolling window, one trace or all, held until the first draw, reset by a re-render, inside a module, dropped with a warning for an unknown output), `post_script` click wiring (once, not stacked), the dark mode recipe, error and `None` rendering, on-demand loading of plotly.js and the compressed, cached bundle as a fresh visitor sees it. `make check-wheel` installs the built wheel into a throwaway venv and runs the suite against it, so the published artifact is what was tested. `make check-floor` installs the package with plotly, shiny and htmltools at the oldest versions `pyproject.toml` allows and runs the whole suite again, browser tests included, so the declared lower bounds are tested on every push rather than assumed.
 ## License

{shiny_plotly-0.3.2 → shiny_plotly-0.4.0}/examples/core_app.py RENAMED Viewed

@@ -9,7 +9,7 @@ from itertools import accumulate
 import plotly.graph_objects as go
 from shiny import App, Inputs, Outputs, Session, reactive, render, ui
-from shiny_plotly import enable_compressed_plotly_js, extend_traces, output_plotly, render_plotly
+from shiny_plotly import extend_traces, output_plotly, render_plotly
 app_ui = ui.page_sidebar(
     ui.sidebar(
@@ -99,6 +99,3 @@ def server(input: Inputs, output: Outputs, session: Session):
 app = App(app_ui, server)
-# Optional: serve plotly.js compressed from the very first request instead of from the
-# first session on (see README, "plotly.js on the wire").
-enable_compressed_plotly_js(app)

{shiny_plotly-0.3.2 → shiny_plotly-0.4.0}/pyproject.toml RENAMED Viewed

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 [project]
 name = "shiny-plotly"
-version = "0.3.2"
+version = "0.4.0"
 description = "Render plotly figures in Shiny for Python with plain plotly.js, without the shinywidgets layer."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -33,12 +33,12 @@ dependencies = [
   "shiny>=1.0",
   "plotly>=5.5",
   "htmltools>=0.5.2",
+  # plotly.min.js is served brotli-compressed, about 17% smaller than gzip. Under pyodide
+  # there is nothing to compress (the bundle comes from the shinylive export) and the route
+  # is skipped, so the marker keeps a 307 kB wasm wheel out of every exported app.
+  "brotli>=1.1; sys_platform != 'emscripten'",
 ]
-[project.optional-dependencies]
-# plotly.min.js is served brotli-compressed (about 15% smaller than gzip) when present.
-brotli = ["brotli>=1.1"]
 [project.urls]
 Homepage   = "https://github.com/rvben/shiny-plotly"
 Repository = "https://github.com/rvben/shiny-plotly"
@@ -52,12 +52,13 @@ bench = [
 ]
 dev = [
   "pytest>=8",
+  "pytest-cov>=5",
   "ruff>=0.6",
   "pyright>=1.1.380",
   "httpx2>=2.12.0",
   "pytest-playwright>=0.9.0",
   "numpy>=1.26",
-  "brotli>=1.1",
+  "shinylive-check>=0.1.0",
 ]
 # uv's default cache keys for a local build are the metadata files only, so a source-only
@@ -90,4 +91,4 @@ pythonVersion = "3.10"
 typeCheckingMode = "standard"
 [tool.ruff.lint.isort]
-known-local-folder = ["newplot"]
+known-local-folder = ["helpers", "newplot"]

{shiny_plotly-0.3.2 → shiny_plotly-0.4.0}/src/shiny_plotly/__init__.py RENAMED Viewed

@@ -3,7 +3,7 @@
 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 ._serve import enable_compressed_plotly_js, enable_for_new_apps
 from ._update import (
     add_traces,
     delete_traces,
@@ -32,3 +32,8 @@ __all__ = (
     "shiny_plotly_js",
     "update",
 )
+# From here on every app serves plotly.min.js compressed and immutable, from its first
+# request, with no call of its own; the compression starts while the app is being built.
+# SHINY_PLOTLY_NO_COMPRESS=1 in the environment leaves Shiny's static serving untouched.
+enable_for_new_apps()

{shiny_plotly-0.3.2 → shiny_plotly-0.4.0}/src/shiny_plotly/_html.py RENAMED Viewed

@@ -103,9 +103,15 @@ def fig_to_ui(
 def as_fig_dict(fig: Figure) -> dict[str, Any]:
-    # Figure.to_dict() does no validation (the figure was validated when built), and a
-    # dict is passed through as the caller's JSON; pio.to_html gets validate=False so it
-    # never reconstructs a Figure from it.
+    """
+    The figure as a plain dict carrying a ``layout`` dict, whichever way it was given.
+    Everything downstream reaches into ``layout`` (to fill in margins, to drop a baked-in
+    template), so it is made a dict here rather than guarded against at each of them.
+    """
+    # Figure.to_dict() does no validation (the figure was validated when built), and always
+    # carries a layout; a dict is passed through as the caller's JSON, so pio.to_html gets
+    # validate=False and never reconstructs a Figure from it.
     if isinstance(fig, BaseFigure):
         return fig.to_dict()
     if isinstance(fig, dict):
@@ -116,5 +122,5 @@ def as_fig_dict(fig: Figure) -> dict[str, Any]:
 def fill_in_margins(fig_dict: dict[str, Any]) -> None:
-    layout = fig_dict.setdefault("layout", {})
+    layout = fig_dict["layout"]
     layout["margin"] = {**FIGUREWIDGET_MARGINS, **(layout.get("margin") or {})}

{shiny_plotly-0.3.2 → shiny_plotly-0.4.0}/src/shiny_plotly/_render.py RENAMED Viewed

@@ -1,6 +1,8 @@
 from __future__ import annotations
-from collections.abc import Iterable, Mapping
+import hashlib
+import weakref
+from collections.abc import Iterable, Mapping, MutableMapping
 from typing import Any
 import plotly.io as pio
@@ -8,6 +10,7 @@ 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.session import Session, get_current_session
 from shiny.ui.fill import as_fill_item, as_fillable_container
 from ._deps import plotly_js, shiny_plotly_js
@@ -102,6 +105,27 @@ def _template_json(spec: TemplateSpec) -> dict[str, Any]:
     return out
+# Name of the custom message carrying templates the session has not seen yet.
+TEMPLATE_MESSAGE = "shiny-plotly-template"
+# Keys of the templates each session has already been sent, by root session. A template is
+# about 6.5 kB and every chart on a page usually shares the same one, so it travels once
+# per session and the values afterwards carry only its key. The session holds the set, and
+# a browser that reconnects gets a new session, so the server can never believe the browser
+# has a template it does not; a weak key lets both go when the session ends.
+_sent_templates: MutableMapping[Session, set[str]] = weakref.WeakKeyDictionary()
+def template_body(spec: TemplateSpec) -> str:
+    """One template as the JSON it travels as, through plotly's own encoder."""
+    return str(to_json_plotly(_template_json(spec)))
+def template_key(template_json: str) -> str:
+    """Content address of one serialized template; equal templates share one key."""
+    return hashlib.sha256(template_json.encode(), usedforsecurity=False).hexdigest()[:16]
 def normalize_max_event_points(value: int | None) -> int | None:
     if value is None:
         return None
@@ -211,14 +235,17 @@ class render_plotly(Renderer[Figure]):
         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.
+        dict. Both templates get transparent ``paper_bgcolor`` and ``plot_bgcolor`` so the
+        page shows through (a figure-level background still wins), and a template the
+        figure baked in via ``layout.template`` is dropped. Each template travels once per
+        session, so a page of charts sharing a theme sends one copy of it and every render
+        after that carries only its key. The browser applies the mode's template before the
+        first draw and switches it with ``Plotly.relayout`` when the mode flips: the mode is
+        the ``data-bs-theme`` of the output's nearest ancestor that sets one (what
+        ``ui.input_dark_mode()`` sets on ``<html>``, or a container that themes part of a
+        page), 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__(
@@ -242,15 +269,21 @@ class render_plotly(Renderer[Figure]):
         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)}
-            )
+        # Resolved and serialized once, here, so an unknown name fails at decoration time
+        # and a render costs nothing extra.
+        self._theme_templates: dict[str, str] = {}
+        self._theme_keys: dict[str, Any] | None = None
+        self._themes_json: str | None = None
+        if self.theme is not None:
+            light, dark = (template_body(spec) for spec in self.theme)
+            self._theme_keys = {"light": template_key(light), "dark": template_key(dark)}
+            self._theme_templates = {
+                self._theme_keys["light"]: light,
+                self._theme_keys["dark"]: dark,
+            }
+            # The inline form, for a render with no session to cache against. Built from
+            # the same two strings, so both paths carry byte-identical templates.
+            self._themes_json = f'{{"light":{light},"dark":{dark}}}'
         # Registers _fn (sets output_id from its name) when used as a bare decorator.
         super().__init__(_fn)  # type: ignore[arg-type]
@@ -265,16 +298,43 @@ class render_plotly(Renderer[Figure]):
     def auto_output_ui(self) -> Tag:
         return output_plotly(self.output_id)
+    async def _cache_templates(self) -> dict[str, Any] | None:
+        """
+        The keys of this renderer's templates, once the session is known to hold them.
+        ``None`` when there is no session to cache against (a render outside a session, or
+        Express's stub session, which drops custom messages), and the templates then travel
+        inline with the value instead.
+        """
+        session = get_current_session()
+        if session is None or session.is_stub_session():
+            return None
+        sent = _sent_templates.setdefault(session.root_scope(), set())
+        new = {key: body for key, body in self._theme_templates.items() if key not in sent}
+        if new:
+            # Sent from inside the render, so it is its own websocket message ahead of the
+            # one carrying the values: the browser has the template before it is asked to
+            # draw with it. Batching it into the value message would invert that, since
+            # Shiny dispatches its custom handlers after its output values.
+            await session.send_custom_message(TEMPLATE_MESSAGE, {"templates": new})
+            # Recorded only once the send has gone through. A repeat send costs a message
+            # the browser overwrites with the same bytes, while a key recorded for a
+            # template that never arrived would leave the figure unthemed for the session.
+            sent.update(new)
+        return self._theme_keys
     async def transform(self, value: Figure) -> Jsonifiable:
         fig_dict = as_fig_dict(value)
         if self.figurewidget_margins:
             fill_in_margins(fig_dict)
-        if self._themes_json is not None:
+        themes_json, theme_keys = self._themes_json, None
+        if self._theme_templates:
             # 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)
+            fig_dict["layout"].pop("template", None)
+            theme_keys = await self._cache_templates()
+            if theme_keys is not None:
+                themes_json = None
         return {
             # Serialised by plotly, not Shiny: numpy and pandas values, datetimes and the
             # compact base64 array encoding only work through plotly's encoder.
@@ -285,5 +345,6 @@ 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,
+            "themes": themes_json,
+            "theme_keys": theme_keys,
         }

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

shiny-plotly 0.3.2tar.gz → 0.4.0tar.gz