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

{shiny_plotly-0.3.3 → shiny_plotly-0.4.0}/.gitignore

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

{shiny_plotly-0.3.3 → shiny_plotly-0.4.0}/CHANGELOG.md

@@ -7,6 +7,21 @@ 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

{shiny_plotly-0.3.3 → shiny_plotly-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: shiny-plotly
-Version: 0.3.3
+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
@@ -210,7 +209,7 @@ Plotly alone re-measures a graph only on window resize. `shiny-plotly` ships a s
 
 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.
+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
 
@@ -419,13 +418,9 @@ A runnable version of the streaming pattern, with a pause switch and a window sl
 
 ### 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 `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
-```
-
-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.
+`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.
 
 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.
 
@@ -458,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.3 → shiny_plotly-0.4.0}/README.md

@@ -179,7 +179,7 @@ Plotly alone re-measures a graph only on window resize. `shiny-plotly` ships a s
 
 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.
+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
 
@@ -388,13 +388,9 @@ A runnable version of the streaming pattern, with a pause switch and a window sl
 
 ### 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 `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
-```
-
-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.
+`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.
 
 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.
 
@@ -427,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.3 → shiny_plotly-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "shiny-plotly"
-version = "0.3.3"
+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,12 @@ 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",
 ]
 
@@ -91,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.3 → shiny_plotly-0.4.0}/src/shiny_plotly/_html.py

@@ -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.3 → shiny_plotly-0.4.0}/src/shiny_plotly/_render.py

@@ -331,9 +331,7 @@ class render_plotly(Renderer[Figure]):
         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

{shiny_plotly-0.3.3 → shiny_plotly-0.4.0}/src/shiny_plotly/_serve.py

@@ -55,7 +55,7 @@ BROTLI_SAVING_PERCENT = 17
 
 try:
     import brotli
-except ImportError:  # pragma: no cover - optional extra
+except ImportError:  # pragma: no cover - a dependency, absent only where it was left out
     brotli = None
 
 
@@ -103,8 +103,8 @@ class CompressedBundle:
                 # 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).",
+                    "be about %d%% smaller. Install brotli for it, or silence this with "
+                    "logging.getLogger('shiny_plotly').setLevel(logging.ERROR).",
                     len(self.encodings["gzip"]) / 1e6,
                     BROTLI_SAVING_PERCENT,
                 )
@@ -127,6 +127,24 @@ def bundle() -> CompressedBundle:
         return _bundle
 
 
+def refuses(params: str) -> bool:
+    """
+    Whether the parameters of one ``Accept-Encoding`` entry rule its encoding out.
+
+    RFC 9110 writes a refusal as a qvalue of zero, which is ``q=0`` but equally ``q=0.0``
+    and ``q=0.000``. Anything else leaves the encoding on offer, an unparsable qvalue
+    included: serving a client the encoding it asked for beats guessing at a malformed
+    header.
+    """
+    key, _, value = params.partition("=")
+    if key.strip().lower() != "q":
+        return False
+    try:
+        return float(value) == 0
+    except ValueError:
+        return False
+
+
 def accepted_encodings(accept_encoding: str | None) -> Iterator[str]:
     """Encodings the client accepts, in our order of preference."""
     if not accept_encoding:
@@ -134,7 +152,7 @@ def accepted_encodings(accept_encoding: str | None) -> Iterator[str]:
     offered: set[str] = set()
     for part in accept_encoding.split(","):
         token, _, params = part.partition(";")
-        if params.replace(" ", "").lower() == "q=0":
+        if refuses(params):
             continue
         offered.add(token.strip().lower())
     for encoding in ("br", "gzip"):

{shiny_plotly-0.3.3 → shiny_plotly-0.4.0}/tests/browser/apps.py

@@ -377,14 +377,57 @@ def make_theme_app() -> App:
     return App(app_ui, server)
 
 
-def make_tabs_app() -> App:
-    """Charts in nav panels: Shiny does not render an output that is hidden."""
+def make_hidden_app() -> App:
+    """One chart per way a page can hide one, plus one that is merely below the fold.
+
+    Shiny does not render an output the browser reports as hidden, which is what the
+    README tells readers to lean on. Every container that hides a chart is here, each
+    chart with its own bar count so a reveal proves which one arrived, and the chart
+    3000px down the page is the control: hiding is not scrolling, so that one is drawn
+    at load and its presence proves a test can see a chart when there is one.
+    """
     app_ui = ui.page_fluid(
+        ui.tags.script(
+            # shiny:idle fires once nothing is left to render, so a test can read "not
+            # drawn" without a sleep and know it did not simply look too early.
+            "$(document).on('shiny:idle', function () {"
+            " window.shinyIdleCount = (window.shinyIdleCount || 0) + 1; });"
+        ),
         ui.navset_tab(
-            ui.nav_panel("First", output_plotly("first", height="200px")),
-            ui.nav_panel("Second", output_plotly("second", height="200px")),
+            ui.nav_panel("First", output_plotly("first", height="150px")),
+            ui.nav_panel("Second", output_plotly("second", height="150px")),
             id="tab",
-        )
+        ),
+        ui.navset_card_tab(
+            ui.nav_panel("Card one", "nothing here"),
+            ui.nav_panel("Card two", output_plotly("card", height="150px")),
+            id="card_tab",
+        ),
+        ui.navset_pill(
+            ui.nav_panel("Pill one", "nothing here"),
+            ui.nav_panel("Pill two", output_plotly("pill", height="150px")),
+            id="pill",
+        ),
+        ui.accordion(
+            ui.accordion_panel("Open section", "nothing here", value="open"),
+            ui.accordion_panel("Folded section", output_plotly("folded", height="150px")),
+            id="accordion",
+            open="open",
+            multiple=True,
+        ),
+        ui.input_switch("show_conditional", "Show the conditional chart", value=False),
+        ui.panel_conditional(
+            "input.show_conditional", output_plotly("conditional", height="150px")
+        ),
+        ui.input_switch("show_swapped", "Swap the hidden navset to its chart", value=False),
+        ui.navset_hidden(
+            ui.nav_panel(None, "nothing here", value="nothing"),
+            ui.nav_panel(None, output_plotly("swapped", height="150px"), value="chart"),
+            id="swap",
+            selected="nothing",
+        ),
+        ui.div(style="height: 3000px"),
+        output_plotly("below", height="150px"),
     )
 
     def server(input: Inputs, output: Outputs, session: Session):
@@ -396,6 +439,36 @@ def make_tabs_app() -> App:
         def second():
             return bars(3)
 
+        @render_plotly
+        def card():
+            return bars(4)
+
+        @render_plotly
+        def pill():
+            return bars(5)
+
+        @render_plotly
+        def folded():
+            return bars(6)
+
+        @render_plotly
+        def conditional():
+            return bars(7)
+
+        @render_plotly
+        def swapped():
+            return bars(8)
+
+        @render_plotly
+        def below():
+            return bars(9)
+
+        @reactive.effect
+        def _swap_hidden_navset():
+            # shiny 1.0, the dependency floor, calls this update_navs; 1.7 renamed it.
+            update = getattr(ui, "update_navset", None) or ui.update_navs
+            update("swap", selected="chart" if input.show_swapped() else "nothing")
+
     return App(app_ui, server)
 
 

{shiny_plotly-0.3.3 → shiny_plotly-0.4.0}/tests/browser/conftest.py

@@ -17,11 +17,11 @@ from .apps import (
     make_app,
     make_dark_app,
     make_events_app,
+    make_hidden_app,
     make_lazy_app,
     make_live_app,
     make_own_mode_app,
     make_scoped_theme_app,
-    make_tabs_app,
     make_theme_app,
 )
 
@@ -47,7 +47,7 @@ def server_url() -> Iterator[str]:
             Mount("/theme", app=make_theme_app()),
             Mount("/scoped", app=make_scoped_theme_app()),
             Mount("/own-mode", app=make_own_mode_app()),
-            Mount("/tabs", app=make_tabs_app()),
+            Mount("/hidden", app=make_hidden_app()),
             Mount("/stream", app=load_example("streaming_app.py")),
             Mount("/demo", app=load_example("shinylive/app.py")),
             Mount("/", app=make_app()),

{shiny_plotly-0.3.3 → shiny_plotly-0.4.0}/tests/browser/test_browser.py

@@ -1,10 +1,13 @@
 """Real-browser checks: what the package promises only shows in a rendering engine."""
 
 import re
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
+from dataclasses import dataclass
 
 import pytest
+from packaging.version import Version
 from playwright.sync_api import Page, expect
+from shiny import __version__ as SHINY_VERSION
 
 pytestmark = pytest.mark.browser
 
@@ -231,16 +234,88 @@ def test_none_empties_the_output_and_a_figure_brings_it_back(app: Page):
     expect(app.locator("#fig .bars .point")).to_have_count(3)
 
 
-def test_a_chart_in_a_hidden_tab_is_drawn_when_its_tab_is_opened(page: Page, server_url, errors):
-    """Shiny suspends a hidden output, so tabs spread the per-chart draw cost over time."""
-    page.goto(server_url + "/tabs/")
-    expect(page.locator(f"#first {SVG}").first).to_be_visible()
+@dataclass(frozen=True)
+class HiddenChart:
+    """A chart the /hidden page keeps out of sight, and what brings it into view."""
+
+    container: str
+    output_id: str
+    points: int
+    reveal: Callable[[Page], None]
+
+
+# Shiny suspends an output inside a false ``ui.panel_conditional`` from 1.6.1 on; 1.6.0 and
+# older, the declared floor among them, draw that chart at load. Measured by installing each
+# release and running this case; every other container here defers at every supported version.
+CONDITIONAL_IS_DEFERRED = Version(SHINY_VERSION) >= Version("1.6.1")
+
+HIDDEN_CHARTS = [
+    HiddenChart(
+        "navset_tab", "second", 3, lambda page: page.get_by_role("tab", name="Second").click()
+    ),
+    HiddenChart(
+        "navset_card_tab", "card", 4, lambda page: page.get_by_role("tab", name="Card two").click()
+    ),
+    HiddenChart(
+        "navset_pill", "pill", 5, lambda page: page.get_by_role("tab", name="Pill two").click()
+    ),
+    HiddenChart(
+        "accordion",
+        "folded",
+        6,
+        lambda page: page.get_by_role("button", name="Folded section").click(),
+    ),
+    pytest.param(
+        HiddenChart(
+            "panel_conditional", "conditional", 7, lambda page: page.click("#show_conditional")
+        ),
+        marks=pytest.mark.skipif(
+            not CONDITIONAL_IS_DEFERRED,
+            reason=f"shiny {SHINY_VERSION} draws this one at load; 1.6.1 is where it defers",
+        ),
+    ),
+    HiddenChart("navset_hidden", "swapped", 8, lambda page: page.click("#show_swapped")),
+]
+
+# The open tab panel, and the chart 3000px down the page, which the browser calls visible even
+# though nobody can see it yet. Both are controls: they prove a snapshot of the page sees a
+# chart when there is one, so an id missing from it is an output Shiny suspended rather than a
+# test that looked too early.
+DRAWN_AT_LOAD = sorted(
+    ["first-plotly", "below-plotly"] + ([] if CONDITIONAL_IS_DEFERRED else ["conditional-plotly"])
+)
+
+
+def open_the_hidden_page(page: Page, server_url: str) -> None:
+    """Load /hidden and wait until every output that is going to render has rendered."""
+    page.goto(server_url + "/hidden/")
+    expect(page.locator(f"#below {SVG}").first).to_be_visible()
+    page.wait_for_function("() => window.shinyIdleCount >= 1")
+
+
+def test_only_the_charts_the_visitor_can_see_are_drawn_at_load(page: Page, server_url, errors):
+    """Shiny suspends a hidden output, the lever the README hands a crowded dashboard."""
+    open_the_hidden_page(page, server_url)
+
+    drawn = page.eval_on_selector_all(".plotly-graph-div", "els => els.map(e => e.id).sort()")
+
+    assert drawn == DRAWN_AT_LOAD
+    assert errors == []
+
+
+@pytest.mark.parametrize("case", HIDDEN_CHARTS, ids=lambda case: case.container)
+def test_a_hidden_chart_is_drawn_when_its_container_shows_it(
+    case: HiddenChart, page: Page, server_url, errors
+):
+    """Every container that hides a chart defers it, and pays for it when it is opened."""
+    open_the_hidden_page(page, server_url)
+    assert page.evaluate(f"() => document.getElementById('{case.output_id}-plotly')") is None
 
-    assert page.evaluate("() => document.getElementById('second-plotly')") is None
-    page.get_by_role("tab", name="Second").click()
+    case.reveal(page)
 
-    expect(page.locator(f"#second {SVG}").first).to_be_visible()
-    expect(page.locator("#second .bars .point")).to_have_count(3)
+    expect(page.locator(f"#{case.output_id} {SVG}").first).to_be_visible()
+    # Its own bar count, so the reveal drew this chart rather than any of the others.
+    expect(page.locator(f"#{case.output_id} .bars .point")).to_have_count(case.points)
     assert errors == []
 
 
@@ -286,10 +361,12 @@ def test_the_bundle_arrives_compressed_and_immutable_for_the_next_visitor(
     finally:
         visitor.close()
 
-    assert headers["content-encoding"] in ("br", "gzip")
+    # Chromium offers br over plain http on localhost too, and brotli is a dependency, so
+    # this is the encoding a real visitor gets rather than one of two possibilities.
+    assert headers["content-encoding"] == "br"
     assert headers["cache-control"] == "public, max-age=31536000, immutable"
     assert fresh["decoded"] == _serve.bundle().size, "the whole bundle, whichever plotly"
-    assert fresh["encoded"] < fresh["decoded"] // 3, "brotli or gzip on the wire"
+    assert fresh["encoded"] < fresh["decoded"] // 3, "brotli on the wire"
     assert fresh["transfer"] > fresh["encoded"], "headers plus the compressed body"
     # Chromium would keep a freshly installed bundle for a while on heuristics alone; the
     # header above is what makes this hold for a year, for every install age.

shiny_plotly-0.4.0/tests/helpers.py

@@ -0,0 +1,25 @@
+"""Test helper: run a coroutine from a synchronous test."""
+
+from __future__ import annotations
+
+import asyncio
+import contextvars
+from collections.abc import Coroutine
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, TypeVar
+
+T = TypeVar("T")
+
+
+def run(coro: Coroutine[Any, Any, T]) -> T:
+    """
+    The coroutine on its own loop in a worker thread. The main thread cannot run one
+    while the browser tests' session-wide playwright fixture is alive (its sync API
+    keeps a loop running there), and nothing awaited here needs that loop anyway.
+
+    The caller's context goes with it, so a ``session_context`` around the call is the
+    session the coroutine sees; a plain thread would leave it looking like no session.
+    """
+    context = contextvars.copy_context()
+    with ThreadPoolExecutor(max_workers=1) as pool:
+        return pool.submit(context.run, asyncio.run, coro).result()

{shiny_plotly-0.3.3 → shiny_plotly-0.4.0}/tests/test_compressed_js.py

@@ -1,14 +1,18 @@
 """Compressed, immutable serving of plotly.min.js, from every app's first request on."""
 
 import gzip
+import importlib.metadata
 import logging
 import pathlib
 import threading
 import types
 
+import brotli
+import httpx2._decoders
 import plotly
 import plotly.graph_objects as go
 import pytest
+from packaging.requirements import Requirement
 from shiny import App, Inputs, Outputs, Session, render, ui
 from shiny.express import wrap_express_app
 from starlette.testclient import TestClient
@@ -66,6 +70,19 @@ def client():
         yield client
 
 
+@pytest.fixture
+def brotli_body_as_it_arrived(monkeypatch):
+    """Hand a ``br`` response over undecoded, so the test reads the bytes off the wire.
+
+    httpx decodes ``br`` by calling the installed brotli with ``output_buffer_limit``, which
+    brotli only accepts from 1.2 on, so against brotli 1.1 (the floor this package declares)
+    the call raises before a test sees the response. Dropping the decoder is what httpx itself
+    does when brotli is missing, and what is under test is the encoding shiny-plotly serves,
+    not a client's ability to decode it; a browser doing that is covered by tests/browser.
+    """
+    monkeypatch.delitem(httpx2._decoders.SUPPORTED_DECODERS, "br", raising=False)
+
+
 def test_bundle_is_served_gzipped_and_immutable(client):
     resp = client.get(BUNDLE_URL, headers={"Accept-Encoding": "gzip"})
 
@@ -100,13 +117,13 @@ def test_bundle_revalidation_answers_304_per_encoding(client):
     assert other.headers["etag"] != etag
 
 
-def test_brotli_is_preferred_when_the_module_is_installed(client):
-    pytest.importorskip("brotli")
-
+def test_brotli_is_the_encoding_a_browser_gets(client, brotli_body_as_it_arrived):
+    """brotli is a dependency, so this is what every install serves, not a lucky one."""
     resp = client.get(BUNDLE_URL, headers={"Accept-Encoding": "gzip, br"})
 
     assert resp.headers["content-encoding"] == "br"
-    assert resp.content == RAW
+    assert len(resp.content) < len(RAW) // 3
+    assert brotli.decompress(resp.content) == RAW, "brotli of the exact bundle"
 
 
 def test_head_requests_carry_the_same_headers(client):
@@ -146,7 +163,7 @@ def test_fig_to_ui_inside_render_ui_enables_it_too():
     assert resp.headers["cache-control"] == "public, max-age=31536000, immutable"
 
 
-def test_an_app_serves_the_compressed_bundle_before_any_session_exists():
+def test_an_app_serves_the_compressed_bundle_before_any_session_exists(brotli_body_as_it_arrived):
     """No call, no websocket: the browser asks for the bundle while the page is still loading."""
     app = make_app()
     names = [getattr(r, "name", None) for r in app.starlette_app.router.routes]
@@ -156,7 +173,7 @@ def test_an_app_serves_the_compressed_bundle_before_any_session_exists():
         resp = client.get(BUNDLE_URL, headers={"Accept-Encoding": "gzip, br"})
 
     assert names[0] == _serve.ROUTE_NAME, "installed as the app was built"
-    assert resp.headers["content-encoding"] in {"br", "gzip"}
+    assert resp.headers["content-encoding"] == "br"
     assert resp.headers["cache-control"] == "public, max-age=31536000, immutable"
     assert int(resp.headers["content-length"]) < len(RAW) // 2
 
@@ -279,6 +296,31 @@ def test_gzip_body_is_the_bundle():
     assert gzip.decompress(bundle.encodings["gzip"]) == RAW
 
 
+@pytest.mark.parametrize(
+    ("accept_encoding", "accepted"),
+    [
+        ("gzip, br", ["br", "gzip"]),
+        ("br", ["br"]),
+        ("gzip", ["gzip"]),
+        ("GZIP,  Br ", ["br", "gzip"]),
+        ("*", ["br", "gzip"]),
+        ("gzip;q=1.0, br;q=0.8", ["br", "gzip"]),
+        ("gzip, br;q=0", ["gzip"]),
+        ("gzip, br;q=0.0", ["gzip"]),
+        ("gzip, br;q=0.000", ["gzip"]),
+        ("*;q=0", []),
+        ("identity", []),
+        ("deflate, zstd", []),
+        ("br;q=none-of-that", ["br"]),
+        ("", []),
+        (None, []),
+    ],
+)
+def test_the_encodings_a_client_will_take_are_read_from_its_header(accept_encoding, accepted):
+    """Nothing yielded means the raw file: the route has no encoding the client accepts."""
+    assert list(_serve.accepted_encodings(accept_encoding)) == accepted
+
+
 def stub_bundle(tmp_path: pathlib.Path) -> _serve.CompressedBundle:
     """A bundle over a small stand-in file, so a test compresses bytes rather than 4.8 MB."""
     path = tmp_path / "plotly.min.js"
@@ -300,13 +342,26 @@ def test_serving_the_larger_encoding_is_announced_when_brotli_is_missing(
     assert set(bundle.encodings) == {"gzip"}
     assert len(caplog.records) == 1, "said once per process, not once per request"
     message = caplog.records[0].getMessage()
-    assert "shiny-plotly[brotli]" in message, "the fix is named"
+    assert "Install brotli" in message, "the fix is named"
     assert f"{_serve.BROTLI_SAVING_PERCENT}%" in message
     assert "logging.getLogger('shiny_plotly')" in message, "and so is the way to silence it"
 
 
+def test_brotli_ships_with_the_package_but_not_where_pyodide_runs_it():
+    """A deployment gets the smaller encoding without asking; a shinylive export does not.
+
+    Under pyodide the route is never installed (the bundle comes from the export), so an
+    unmarked dependency would put a 307 kB wasm wheel into every exported app for nothing.
+    """
+    requirements = [Requirement(text) for text in importlib.metadata.requires("shiny-plotly") or []]
+    brotli_requirement = next(r for r in requirements if r.name == "brotli")
+
+    assert brotli_requirement.marker is not None, "unmarked, so pyodide pays for it"
+    assert brotli_requirement.marker.evaluate({"sys_platform": "linux"})
+    assert not brotli_requirement.marker.evaluate({"sys_platform": "emscripten"})
+
+
 def test_nothing_is_announced_when_brotli_is_there(tmp_path, caplog):
-    pytest.importorskip("brotli")
     bundle = stub_bundle(tmp_path)
 
     with caplog.at_level(logging.WARNING, logger=_serve.logger.name):

shiny_plotly-0.4.0/tests/test_examples.py

@@ -0,0 +1,50 @@
+"""Every example in examples/ builds a runnable shiny App."""
+
+import importlib.util
+from pathlib import Path
+
+import pytest
+from shiny import App
+from shiny.express import is_express_app, wrap_express_app
+
+EXAMPLES = Path(__file__).parent.parent / "examples"
+
+# Found rather than listed, so an example is covered from the moment it is written; Shiny's
+# own detector decides which of the two ways each one is built.
+ALL_EXAMPLES = sorted(
+    path.relative_to(EXAMPLES) for path in EXAMPLES.rglob("*.py") if "__pycache__" not in path.parts
+)
+EXPRESS_EXAMPLES = [p for p in ALL_EXAMPLES if is_express_app(p.name, str(EXAMPLES / p.parent))]
+CORE_EXAMPLES = [p for p in ALL_EXAMPLES if p not in EXPRESS_EXAMPLES]
+
+
+def test_the_examples_were_found_and_told_apart():
+    """A glob that matched nothing would leave every test below passing on no examples."""
+    assert set(CORE_EXAMPLES) | set(EXPRESS_EXAMPLES) == set(ALL_EXAMPLES)
+    assert Path("core_app.py") in CORE_EXAMPLES
+    assert Path("shinylive/app.py") in CORE_EXAMPLES, "the search reaches into subdirectories"
+    assert Path("express_app.py") in EXPRESS_EXAMPLES
+
+
+@pytest.mark.parametrize("name", CORE_EXAMPLES, ids=str)
+def test_core_example_builds_an_app(name: Path):
+    path = EXAMPLES / name
+    spec = importlib.util.spec_from_file_location(path.stem, path)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    assert isinstance(module.app, App)
+
+
+@pytest.mark.parametrize("name", EXPRESS_EXAMPLES, ids=str)
+def test_express_example_builds_an_app(name: Path):
+    app = wrap_express_app(EXAMPLES / name)
+
+    assert isinstance(app, App)
+
+
+def test_the_shinylive_example_pins_past_the_version_that_crashed_under_pyodide():
+    requirements = (EXAMPLES / "shinylive" / "requirements.txt").read_text()
+
+    assert "shiny-plotly>0.3.0" in requirements

{shiny_plotly-0.3.3 → shiny_plotly-0.4.0}/tests/test_fig_to_ui.py

@@ -125,6 +125,16 @@ def test_accepts_a_prebuilt_figure_dict_without_revalidating_it():
     assert call.data[0]["not_a_real_attr"] == 1, "a dict goes to JSON as-is; validation would raise"
 
 
+def test_a_figure_dict_with_no_layout_is_given_one():
+    """Margins and themes reach into layout without checking first; this is why they can."""
+    fig_dict = {"data": [{"type": "bar", "y": [1]}]}
+
+    call = parse_newplot(render_html(fig_to_ui(fig_dict, div_id="p", figurewidget_margins=True)))
+
+    assert call.layout["margin"] == FIGUREWIDGET_MARGINS
+    assert fig_dict == {"data": [{"type": "bar", "y": [1]}]}, "the caller's dict is untouched"
+
+
 def test_rejects_values_that_are_not_figures():
     with pytest.raises(TypeError, match=r"go\.Figure"):
         fig_to_ui("not a figure")  # type: ignore[arg-type]

{shiny_plotly-0.3.3 → shiny_plotly-0.4.0}/tests/test_render_plotly.py

@@ -1,18 +1,22 @@
 import json
 from collections.abc import Sequence
 from contextlib import contextmanager
-from typing import Any
+from typing import Any, cast
 
 import plotly
 import plotly.graph_objects as go
 import pytest
 from shiny import App, Inputs, Outputs, Session, module, ui
+from shiny.express._stub_session import ExpressStubSession
 from shiny.render.renderer import Renderer
+from shiny.session import session_context
 from starlette.testclient import TestClient
 
 from shiny_plotly import __version__, output_plotly, plotly_js, render_plotly
 from shiny_plotly._render import TEMPLATE_MESSAGE
 
+from helpers import run
+
 
 def bar() -> go.Figure:
     return go.Figure(go.Bar(x=["a", "b"], y=[1, 2]))
@@ -560,6 +564,43 @@ def test_different_themes_get_different_keys_and_both_travel():
     assert len(flushed.templates) == 3
 
 
+@pytest.mark.parametrize(
+    "session",
+    [
+        pytest.param(None, id="no session at all"),
+        pytest.param(ExpressStubSession(), id="express before the browser connects"),
+    ],
+)
+def test_a_value_with_no_session_to_cache_against_carries_its_templates_inline(session):
+    """Naming keys would name them in a cache nothing is keeping, so the pair travels whole."""
+
+    @render_plotly(theme="auto")
+    def sales():
+        return bar()
+
+    with session_context(session):
+        value = cast(dict[str, Any], run(sales.transform(bar())))
+
+    assert value["theme_keys"] is None, "there is nothing to look a key up in"
+    themes = json.loads(value["themes"])
+    assert themes["light"]["layout"]["font"]["color"] == "#2a3f5f", "the plotly template"
+    assert themes["dark"]["layout"]["font"]["color"] == "#f2f5fa", "the plotly_dark template"
+    assert "template" not in json.loads(value["figure"])["layout"]
+
+
+def test_a_themed_figure_given_as_a_dict_with_no_layout_renders():
+    """Dropping the baked-in template reaches into layout; a dict need not have brought one."""
+
+    @render_plotly(theme="auto")
+    def sales():
+        return {"data": [{"type": "bar", "y": [1, 2]}]}
+
+    value = cast(dict[str, Any], run(sales.transform({"data": [{"type": "bar", "y": [1, 2]}]})))
+
+    assert json.loads(value["figure"])["layout"] == {}
+    assert json.loads(value["themes"])["light"]["layout"]["font"]["color"] == "#2a3f5f"
+
+
 def test_a_theme_dict_template_is_not_mutated_by_the_transparency_fill():
     custom = {"layout": {"font": {"color": "white"}}}
 
@@ -575,8 +616,13 @@ def flush_one(client: TestClient, output_id: str) -> dict:
 
 
 def test_plotly_bundle_is_served_from_the_page_level_dependency():
+    # The route this reaches is about the path, not the encoding, so ask for the file as it is
+    # on disk; what it serves compressed has tests of its own in test_compressed_js.py.
     with TestClient(make_app()) as client:
-        resp = client.get(f"/lib/plotly-{plotly.__version__}/plotly.min.js")
+        resp = client.get(
+            f"/lib/plotly-{plotly.__version__}/plotly.min.js",
+            headers={"Accept-Encoding": "identity"},
+        )
 
     assert resp.status_code == 200
     assert b"Plotly" in resp.content[:200_000]
@@ -592,8 +638,9 @@ def test_bundle_and_helper_are_served_from_the_output_tag_without_a_page_level_c
             return bar()
 
     with TestClient(App(app_ui, server)) as client:
-        bundle = client.get(f"/lib/plotly-{plotly.__version__}/plotly.min.js")
-        helper = client.get(f"/lib/shiny-plotly-{__version__}/shiny-plotly.js")
+        raw = {"Accept-Encoding": "identity"}
+        bundle = client.get(f"/lib/plotly-{plotly.__version__}/plotly.min.js", headers=raw)
+        helper = client.get(f"/lib/shiny-plotly-{__version__}/shiny-plotly.js", headers=raw)
 
     assert bundle.status_code == 200
     assert len(bundle.content) > 1_000_000

{shiny_plotly-0.3.3 → shiny_plotly-0.4.0}/tests/test_update.py

@@ -1,10 +1,6 @@
 """extend_traces, restyle and relayout: in-place updates sent to a drawn figure."""
 
-import asyncio
 import json
-from collections.abc import Coroutine
-from concurrent.futures import ThreadPoolExecutor
-from typing import Any, TypeVar
 
 import plotly.graph_objects as go
 import pytest
@@ -23,17 +19,7 @@ from shiny_plotly import (
     update,
 )
 
-T = TypeVar("T")
-
-
-def run(coro: Coroutine[Any, Any, T]) -> T:
-    """
-    The coroutine on its own loop in a worker thread. The main thread cannot run one
-    while the browser tests' session-wide playwright fixture is alive (its sync API
-    keeps a loop running there), and nothing awaited here needs that loop anyway.
-    """
-    with ThreadPoolExecutor(max_workers=1) as pool:
-        return pool.submit(asyncio.run, coro).result()
+from helpers import run
 
 
 def bar() -> go.Figure:

shiny_plotly-0.3.3/tests/test_examples.py

@@ -1,41 +0,0 @@
-"""Every example in examples/ builds a runnable shiny App."""
-
-import importlib.util
-from pathlib import Path
-
-import pytest
-from shiny import App
-from shiny.express import wrap_express_app
-
-EXAMPLES = Path(__file__).parent.parent / "examples"
-
-CORE_EXAMPLES = (
-    "core_app.py",
-    "events_app.py",
-    "dark_app.py",
-    "streaming_app.py",
-    "shinylive/app.py",
-)
-
-
-@pytest.mark.parametrize("name", CORE_EXAMPLES)
-def test_core_example_builds_an_app(name: str):
-    path = EXAMPLES / name
-    spec = importlib.util.spec_from_file_location(path.stem, path)
-    assert spec is not None and spec.loader is not None
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-
-    assert isinstance(module.app, App)
-
-
-def test_express_example_builds_an_app():
-    app = wrap_express_app(EXAMPLES / "express_app.py")
-
-    assert isinstance(app, App)
-
-
-def test_the_shinylive_example_pins_past_the_version_that_crashed_under_pyodide():
-    requirements = (EXAMPLES / "shinylive" / "requirements.txt").read_text()
-
-    assert "shiny-plotly>0.3.0" in requirements