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

shiny-plotly 0.3.2tar.gz → 0.3.3tar.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 (38) hide show

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

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
+## [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.3.3}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: shiny-plotly
-Version: 0.3.2
+Version: 0.3.3
 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
@@ -206,6 +206,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. Shiny suspends an output that is hidden, so charts inside `ui.navset_tab` panels or `ui.accordion` sections are not rendered at all until their panel is shown, and each panel then pays only for its own charts. Charts that must all be visible 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 +235,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 +412,26 @@ 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 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.
 ```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:
+Without it the process 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

{shiny_plotly-0.3.2 → shiny_plotly-0.3.3}/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. Shiny suspends an output that is hidden, so charts inside `ui.navset_tab` panels or `ui.accordion` sections are not rendered at all until their panel is shown, and each panel then pays only for its own charts. Charts that must all be visible 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,26 @@ 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 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.
 ```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:
+Without it the process 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

{shiny_plotly-0.3.2 → shiny_plotly-0.3.3}/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.3.3}/pyproject.toml RENAMED Viewed

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 [project]
 name = "shiny-plotly"
-version = "0.3.2"
+version = "0.3.3"
 description = "Render plotly figures in Shiny for Python with plain plotly.js, without the shinywidgets layer."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -58,6 +58,7 @@ dev = [
   "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

{shiny_plotly-0.3.2 → shiny_plotly-0.3.3}/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.3.3}/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,45 @@ 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)
+            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 +347,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 → shiny_plotly-0.3.3}/src/shiny_plotly/_serve.py RENAMED Viewed

@@ -6,24 +6,27 @@ no ``Cache-Control``, so each visit moves the 4.8 MB bundle or at least revalida
 The bundle's URL is keyed by the plotly version (``/lib/plotly-<version>/plotly.min.js``),
 so it can be served with a year-long ``immutable`` cache and pre-compressed once.
-Shiny gives a package no hook into an ``App`` as it is built; the first hook is the
-session. So the first :class:`~shiny_plotly.render_plotly` (or :func:`~shiny_plotly.fig_to_ui`
-inside a session) of a process adds a route in front of Shiny's mount for the bundle's
-exact path, and a background thread compresses the bundle once per process. Until it
-has finished, the route serves the raw file, with the same cache headers. The page load
-that started the very first session of a process has already requested the bundle
-from Shiny's own mount by then; every request after it is served here.
+Importing ``shiny_plotly`` wraps ``shiny.App.__init__``, so every app built after it gets a
+route for the bundle's exact path in front of Shiny's mount, and a background thread starts
+compressing the bundle once per process. Both happen while the app is being built, before it
+can serve anything, so the first request of the process is already served here; until the
+compression has finished the route serves the raw file with the same cache headers. An app
+built before the import can still ask for the route with :func:`enable_compressed_plotly_js`,
+and each session enables it for its own app, so it is there either way.
 """
 from __future__ import annotations
+import functools
 import gzip
 import hashlib
+import logging
 import os
 import sys
 import threading
 from collections.abc import Iterator
 from pathlib import Path
+from typing import Any
 from starlette.requests import Request
 from starlette.responses import FileResponse, Response
@@ -31,12 +34,25 @@ from starlette.routing import Route
 from ._deps import plotly_js
-__all__ = ("ROUTE_NAME", "CompressedBundle", "bundle", "enable_compressed_plotly_js")
+__all__ = (
+    "ROUTE_NAME",
+    "CompressedBundle",
+    "bundle",
+    "enable_compressed_plotly_js",
+    "enable_for_new_apps",
+)
 ROUTE_NAME = "shiny-plotly-bundle"
 CACHE_CONTROL = "public, max-age=31536000, immutable"
 MEDIA_TYPE = "text/javascript; charset=utf-8"
+logger = logging.getLogger(__name__)
+# How much smaller brotli q9 is than gzip -9 on plotly.min.js (1.22 MB against 1.46 MB on
+# plotly 6.9.0). Only used to size the warning below, which is raised precisely when brotli
+# is absent and the real figure cannot be measured.
+BROTLI_SAVING_PERCENT = 17
 try:
     import brotli
 except ImportError:  # pragma: no cover - optional extra
@@ -81,6 +97,17 @@ class CompressedBundle:
             if brotli is not None:
                 self.encodings["br"] = brotli.compress(raw, quality=9)
             self.encodings["gzip"] = gzip.compress(raw, compresslevel=9, mtime=0)
+            if brotli is None:
+                # Compression runs once per process, so this is said once. Without it a
+                # deployment has no way to notice it is serving the larger encoding: the
+                # bundle is compressed, cached and immutable either way, just bigger.
+                logger.warning(
+                    "shiny-plotly is serving plotly.min.js gzipped (%.2f MB); brotli would "
+                    "be about %d%% smaller. Install shiny-plotly[brotli] for it, or silence "
+                    "this with logging.getLogger('shiny_plotly').setLevel(logging.ERROR).",
+                    len(self.encodings["gzip"]) / 1e6,
+                    BROTLI_SAVING_PERCENT,
+                )
         finally:
             self._ready.set()
@@ -152,13 +179,9 @@ def enable_compressed_plotly_js(app: object) -> bool:
     """
     Serve plotly.min.js compressed and immutable from ``app``, starting now.
-    Every :class:`~shiny_plotly.render_plotly` does this for its app when its first
-    session starts, which is too late for the page load that started that session. A Core
-    app can call it as soon as the ``shiny.App`` exists, so the first visitor of the
-    process gets the compressed bundle too::
-        app = App(app_ui, server)
-        enable_compressed_plotly_js(app)
+    Importing ``shiny_plotly`` already does this for every ``shiny.App`` built afterwards,
+    so an app needs no call of its own. It stays the way in for an app that was constructed
+    before the import, and it is what each session calls for its own app.
     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
@@ -188,6 +211,43 @@ def enable_compressed_plotly_js(app: object) -> bool:
     return True
+# Marks the wrapper below, so a second import (or a module reload) wraps nothing twice.
+_WRAPPED = "_shiny_plotly_wrapped"
+def enable_for_new_apps() -> bool:
+    """
+    Serve the compressed bundle from every ``shiny.App`` built from now on.
+    Wraps ``shiny.App.__init__`` once, at import of this package, and enables the route on
+    each app it builds. Shiny offers a package no other hook into an app that early, and
+    early is the point: the browser asks for plotly.min.js while the page is loading, long
+    before the session that page opens exists, so a route installed by the first session is
+    installed one visitor too late. Express constructs the same ``App``, so it is covered too.
+    Returns True when the wrapper was installed, False when it was already there.
+    """
+    from shiny import App
+    original = App.__init__
+    if getattr(original, _WRAPPED, False):
+        return False
+    @functools.wraps(original)
+    def __init__(self: App, *args: Any, **kwargs: Any) -> None:
+        original(self, *args, **kwargs)
+        try:
+            enable_compressed_plotly_js(self)
+        except Exception:
+            # This app never asked for the route, so nothing here may keep it from being
+            # built; without it the bundle is served by Shiny's own mount, as before.
+            logger.warning("shiny-plotly could not serve plotly.min.js compressed", exc_info=True)
+    setattr(__init__, _WRAPPED, True)
+    App.__init__ = __init__
+    return True
 def enable_for_current_session() -> None:
     """Enable for the app of the active session, if any (no-op outside a session)."""
     from shiny.session import get_current_session

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

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