shiny-plotly 0.1.0__tar.gz

shiny_plotly-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+.venv/
+.wheel-venv/
+dist/
+__pycache__/
+*.pyc
+.pytest_cache/
+.ruff_cache/
+tmp/

shiny_plotly-0.1.0/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-08-19
+
+### Added
+
+- `@render_plotly`: a `shiny.render.ui` subclass that renders a `plotly.graph_objects.Figure` (or its dict) as HTML drawn with `Plotly.newPlot`. Works in Core and Express, sync or async, bare or with options; `None` renders nothing.
+- `output_plotly(id, width=, height=)`: fill-aware placeholder, a drop-in for `output_widget`. No height fills the container from a 400px basis; an explicit height is fixed and opts out of filling.
+- `fig_to_ui(...)`: the lower-level fragment builder for use from `@render.ui` or any htmltools context.
+- `plotly_js()`: `HTMLDependency` serving plotly.js straight from the installed `plotly` wheel at `/lib/plotly-<version>/plotly.min.js`; every figure carries it, so a page-level call is optional.
+- `shiny_plotly_js()` and the `shiny-plotly.js` helper: a `ResizeObserver` keeps each graph sized to its container when the container changes without a window resize, and purges a graph once Shiny replaces the output holding it.
+- `figurewidget_margins=True` fills in unset margin sides with the values shinywidgets applies to a `FigureWidget` (l16/t32/r16/b16), for pixel-identical migrations.
+- `config` (merged over `{"responsive": True}`) and `post_script` (with `{plot_id}` substitution) options for forwarding plotly events to Shiny inputs.
+- Test suite: unit tests, in-process Shiny end-to-end tests over a real websocket, and a headless Chromium suite covering sizing, resize tracking, purge on re-render, full screen and `post_script` wiring.
+
+[Unreleased]: https://github.com/rvben/shiny-plotly/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/rvben/shiny-plotly/releases/tag/v0.1.0

shiny_plotly-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ruben J. Jongejan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

shiny_plotly-0.1.0/PKG-INFO

@@ -0,0 +1,229 @@
+Metadata-Version: 2.5
+Name: shiny-plotly
+Version: 0.1.0
+Summary: Render plotly figures in Shiny for Python as plain HTML, without the shinywidgets layer.
+Project-URL: Homepage, https://github.com/rvben/shiny-plotly
+Project-URL: Repository, https://github.com/rvben/shiny-plotly
+Project-URL: Changelog, https://github.com/rvben/shiny-plotly/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/rvben/shiny-plotly/issues
+Author-email: "Ruben J. Jongejan" <ruben.jongejan@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: dashboard,html,plotly,render,shiny
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: htmltools>=0.5
+Requires-Dist: plotly>=5.0
+Requires-Dist: shiny>=1.0
+Description-Content-Type: text/markdown
+
+# shiny-plotly
+
+Render [plotly](https://plotly.com/python/) figures in [Shiny for Python](https://shiny.posit.co/py/) as plain HTML, without the shinywidgets layer.
+
+*An independent project, not affiliated with or endorsed by Posit or Plotly.*
+
+[![PyPI](https://img.shields.io/pypi/v/shiny-plotly)](https://pypi.org/project/shiny-plotly/)
+[![CI](https://github.com/rvben/shiny-plotly/actions/workflows/ci.yml/badge.svg)](https://github.com/rvben/shiny-plotly/actions/workflows/ci.yml)
+
+```python
+from shiny_plotly import output_plotly, render_plotly
+
+# UI
+output_plotly("sales")
+
+
+# server
+@render_plotly
+def sales():
+    return go.Figure(go.Bar(x=months, y=totals))
+```
+
+That is the whole API surface for the common case. The figure is serialized with plotly's own `to_html`, sent to the browser as a UI fragment, and drawn with `Plotly.newPlot`. No ipywidgets, no kernel comm, no anywidget. Every render replaces the figure, which is how most dashboards already use `@render_widget`.
+
+## Why
+
+`shinywidgets` renders a plotly figure by wrapping it in a `FigureWidget` and shipping it through the ipywidgets comm protocol. That machinery earns its keep when the app mutates a figure in place (`fig.data[0].y = ...`) and wants the browser to patch it. Most Shiny apps do not do that; they rebuild the figure inside a reactive function and let Shiny re-render the output. For those apps the widget layer is overhead:
+
+- extra dependencies (`ipywidgets`, `anywidget`, `shinywidgets`) and their JavaScript bundles on every page;
+- a second rendering path next to Shiny's own, with its own quirks around sizing and full screen;
+- figures held as widget state on the server for the life of the session.
+
+`shiny-plotly` renders the figure the way plotly itself does, as HTML plus `Plotly.newPlot`, and uses Shiny's `render.ui` for delivery. The plotly.js bundle is served straight from the installed `plotly` wheel, keyed by its version, so nothing is copied or vendored.
+
+## Install
+
+```sh
+uv add shiny-plotly
+# or
+pip install shiny-plotly
+```
+
+Requires Python 3.10+, `shiny>=1.0`, `plotly>=5.0`.
+
+## Use
+
+### Core
+
+```python
+import random
+from itertools import accumulate
+
+import plotly.graph_objects as go
+from shiny import App, ui
+
+from shiny_plotly import output_plotly, plotly_js, render_plotly
+
+app_ui = ui.page_fillable(
+    ui.input_slider("n", "Points", 10, 500, 100),
+    ui.card(
+        ui.card_header("Fills the card; try full screen"),
+        output_plotly("walk"),
+        full_screen=True,
+    ),
+    plotly_js(),  # optional: load plotly.js with the page instead of with the first figure
+)
+
+
+def server(input, output, session):
+    @render_plotly
+    def walk():
+        rng = random.Random(input.n())
+        y = list(accumulate(rng.gauss(0, 1) for _ in range(input.n())))
+        return go.Figure(go.Scatter(y=y, mode="lines"))
+
+
+app = App(app_ui, server)
+```
+
+Anything that is a `plotly.graph_objects.Figure` works, including what `plotly.express` builds (install `plotly[express]` for that).
+
+### Express
+
+```python
+import random
+from itertools import accumulate
+
+import plotly.graph_objects as go
+from shiny.express import input, ui
+
+from shiny_plotly import render_plotly
+
+ui.page_opts(fillable=True)
+
+with ui.sidebar():
+    ui.input_slider("n", "Points", 10, 500, 100)
+
+with ui.card(full_screen=True):
+
+    @render_plotly
+    def walk():
+        rng = random.Random(input.n())
+        y = list(accumulate(rng.gauss(0, 1) for _ in range(input.n())))
+        return go.Figure(go.Scatter(y=y, mode="lines"))
+```
+
+The decorator creates its own output placeholder in Express, just like `@render_widget` does.
+
+### Options
+
+```python
+@render_plotly(
+    height="300px",  # fixed height; default None fills the container
+    width="100%",
+    figurewidget_margins=True,  # the l16/t32/r16/b16 margins shinywidgets applies
+    config={"displaylogo": False},
+    post_script=CLICK_TO_INPUT,  # JavaScript run after the plot is drawn
+)
+def sales(): ...
+```
+
+`None` from the render function renders nothing. The function may be sync or async. It may also return `fig.to_dict()` instead of a `Figure`.
+
+### Migrating from shinywidgets
+
+| shinywidgets | shiny-plotly |
+| --- | --- |
+| `from shinywidgets import output_widget, render_widget` | `from shiny_plotly import output_plotly, render_plotly` |
+| `output_widget("id")` | `output_plotly("id")` |
+| `output_widget("id", height="300px")` | `output_plotly("id", height="300px")` |
+| `@render_widget` | `@render_plotly` |
+| (FigureWidget margins, applied implicitly) | `@render_plotly(figurewidget_margins=True)` |
+
+Two things change on purpose:
+
+- **Margins.** shinywidgets sets tight margins (`l=16, t=32, r=16, b=16`) on every FigureWidget; plotly's own defaults are `80/100/80/80`. `shiny-plotly` uses plotly's defaults unless you pass `figurewidget_margins=True`, which fills in only the sides your figure leaves unset. Set margins explicitly on the figure if you want something else.
+- **In-place mutation.** A `FigureWidget` you keep on the server and mutate (`fig.data[0].y = ...`, `fig.add_trace(...)` after render) is exactly what shinywidgets is for. `shiny-plotly` has no channel for that; return a new figure from the render function and let Shiny re-render. If your app depends on in-place widget updates, stay on shinywidgets for those outputs. Both packages can coexist in one app.
+
+### Sizing
+
+The rules mirror `output_widget`:
+
+- `height=None` (default): the plot fills its container. Inside `ui.card(full_screen=True)`, a fillable page or a sidebar layout it grows and shrinks with the card, from a 400px basis. Outside a fill layout it is 400px tall.
+- `height="300px"` (on the decorator or on `output_plotly`): the plot is exactly that tall and opts out of filling.
+
+Plotly alone re-measures a graph only on window resize. `shiny-plotly` ships a small helper script (`shiny-plotly.js`, loaded with every figure) 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 Shiny has replaced the output holding it, which releases the window listener and layout state plotly would otherwise keep for every render.
+
+### Events back to Shiny
+
+`post_script` runs after `Plotly.newPlot` resolves; `{plot_id}` is replaced with the graph div's id.
+
+```python
+CLICK_TO_INPUT = """
+document.getElementById('{plot_id}').on('plotly_click', function (ev) {
+    var p = ev.points[0];
+    Shiny.setInputValue('clicked', {x: p.x, y: p.y}, {priority: 'event'});
+});
+"""
+
+
+@render_plotly(post_script=CLICK_TO_INPUT)
+def scatter(): ...
+
+
+@render.text
+def click_info():
+    if not input.clicked.is_set():
+        return "Click a point."
+    pt = input.clicked()
+    return f"x={pt['x']}, y={pt['y']}"
+```
+
+`input.clicked()` raises a silent exception while the input has never been set, so check `is_set()` first when the output should show something before the first click.
+
+### Lower level
+
+- `fig_to_ui(fig, div_id=None, *, height, width, figurewidget_margins, config, post_script)` returns the `TagList` a render produces: the plotly.js dependency, the helper dependency and the `<div class="shiny-plotly">` holding the figure. Use it from a plain `@render.ui` that composes several things, or from any htmltools context.
+- `plotly_js()` is the `HTMLDependency` for plotly.js, served from the installed `plotly` wheel at `/lib/plotly-<version>/plotly.min.js`. Every figure carries it, so it is optional; add it to the page UI to load the bundle up front instead of with the first figure.
+- `shiny_plotly_js()` is the helper's dependency. Every figure carries it too.
+- `FIGUREWIDGET_MARGINS` is the `{"l": 16, "t": 32, "r": 16, "b": 16}` mapping.
+
+## Examples
+
+```sh
+uv run --with shiny-plotly shiny run examples/core_app.py
+uv run --with shiny-plotly shiny run examples/express_app.py
+```
+
+## Development
+
+```sh
+make sync        # uv sync --all-groups
+make browsers    # playwright install chromium, once
+make check       # lint, typecheck, unit + e2e tests, browser tests, wheel check
+```
+
+`make test` runs the unit tests and the in-process Shiny end-to-end tests over a real websocket. `make test-browser` drives the package in headless Chromium: fill sizing, resize without a window event, purge on re-render, full screen, `post_script` click wiring and on-demand loading of plotly.js. `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.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

shiny_plotly-0.1.0/README.md

@@ -0,0 +1,201 @@
+# shiny-plotly
+
+Render [plotly](https://plotly.com/python/) figures in [Shiny for Python](https://shiny.posit.co/py/) as plain HTML, without the shinywidgets layer.
+
+*An independent project, not affiliated with or endorsed by Posit or Plotly.*
+
+[![PyPI](https://img.shields.io/pypi/v/shiny-plotly)](https://pypi.org/project/shiny-plotly/)
+[![CI](https://github.com/rvben/shiny-plotly/actions/workflows/ci.yml/badge.svg)](https://github.com/rvben/shiny-plotly/actions/workflows/ci.yml)
+
+```python
+from shiny_plotly import output_plotly, render_plotly
+
+# UI
+output_plotly("sales")
+
+
+# server
+@render_plotly
+def sales():
+    return go.Figure(go.Bar(x=months, y=totals))
+```
+
+That is the whole API surface for the common case. The figure is serialized with plotly's own `to_html`, sent to the browser as a UI fragment, and drawn with `Plotly.newPlot`. No ipywidgets, no kernel comm, no anywidget. Every render replaces the figure, which is how most dashboards already use `@render_widget`.
+
+## Why
+
+`shinywidgets` renders a plotly figure by wrapping it in a `FigureWidget` and shipping it through the ipywidgets comm protocol. That machinery earns its keep when the app mutates a figure in place (`fig.data[0].y = ...`) and wants the browser to patch it. Most Shiny apps do not do that; they rebuild the figure inside a reactive function and let Shiny re-render the output. For those apps the widget layer is overhead:
+
+- extra dependencies (`ipywidgets`, `anywidget`, `shinywidgets`) and their JavaScript bundles on every page;
+- a second rendering path next to Shiny's own, with its own quirks around sizing and full screen;
+- figures held as widget state on the server for the life of the session.
+
+`shiny-plotly` renders the figure the way plotly itself does, as HTML plus `Plotly.newPlot`, and uses Shiny's `render.ui` for delivery. The plotly.js bundle is served straight from the installed `plotly` wheel, keyed by its version, so nothing is copied or vendored.
+
+## Install
+
+```sh
+uv add shiny-plotly
+# or
+pip install shiny-plotly
+```
+
+Requires Python 3.10+, `shiny>=1.0`, `plotly>=5.0`.
+
+## Use
+
+### Core
+
+```python
+import random
+from itertools import accumulate
+
+import plotly.graph_objects as go
+from shiny import App, ui
+
+from shiny_plotly import output_plotly, plotly_js, render_plotly
+
+app_ui = ui.page_fillable(
+    ui.input_slider("n", "Points", 10, 500, 100),
+    ui.card(
+        ui.card_header("Fills the card; try full screen"),
+        output_plotly("walk"),
+        full_screen=True,
+    ),
+    plotly_js(),  # optional: load plotly.js with the page instead of with the first figure
+)
+
+
+def server(input, output, session):
+    @render_plotly
+    def walk():
+        rng = random.Random(input.n())
+        y = list(accumulate(rng.gauss(0, 1) for _ in range(input.n())))
+        return go.Figure(go.Scatter(y=y, mode="lines"))
+
+
+app = App(app_ui, server)
+```
+
+Anything that is a `plotly.graph_objects.Figure` works, including what `plotly.express` builds (install `plotly[express]` for that).
+
+### Express
+
+```python
+import random
+from itertools import accumulate
+
+import plotly.graph_objects as go
+from shiny.express import input, ui
+
+from shiny_plotly import render_plotly
+
+ui.page_opts(fillable=True)
+
+with ui.sidebar():
+    ui.input_slider("n", "Points", 10, 500, 100)
+
+with ui.card(full_screen=True):
+
+    @render_plotly
+    def walk():
+        rng = random.Random(input.n())
+        y = list(accumulate(rng.gauss(0, 1) for _ in range(input.n())))
+        return go.Figure(go.Scatter(y=y, mode="lines"))
+```
+
+The decorator creates its own output placeholder in Express, just like `@render_widget` does.
+
+### Options
+
+```python
+@render_plotly(
+    height="300px",  # fixed height; default None fills the container
+    width="100%",
+    figurewidget_margins=True,  # the l16/t32/r16/b16 margins shinywidgets applies
+    config={"displaylogo": False},
+    post_script=CLICK_TO_INPUT,  # JavaScript run after the plot is drawn
+)
+def sales(): ...
+```
+
+`None` from the render function renders nothing. The function may be sync or async. It may also return `fig.to_dict()` instead of a `Figure`.
+
+### Migrating from shinywidgets
+
+| shinywidgets | shiny-plotly |
+| --- | --- |
+| `from shinywidgets import output_widget, render_widget` | `from shiny_plotly import output_plotly, render_plotly` |
+| `output_widget("id")` | `output_plotly("id")` |
+| `output_widget("id", height="300px")` | `output_plotly("id", height="300px")` |
+| `@render_widget` | `@render_plotly` |
+| (FigureWidget margins, applied implicitly) | `@render_plotly(figurewidget_margins=True)` |
+
+Two things change on purpose:
+
+- **Margins.** shinywidgets sets tight margins (`l=16, t=32, r=16, b=16`) on every FigureWidget; plotly's own defaults are `80/100/80/80`. `shiny-plotly` uses plotly's defaults unless you pass `figurewidget_margins=True`, which fills in only the sides your figure leaves unset. Set margins explicitly on the figure if you want something else.
+- **In-place mutation.** A `FigureWidget` you keep on the server and mutate (`fig.data[0].y = ...`, `fig.add_trace(...)` after render) is exactly what shinywidgets is for. `shiny-plotly` has no channel for that; return a new figure from the render function and let Shiny re-render. If your app depends on in-place widget updates, stay on shinywidgets for those outputs. Both packages can coexist in one app.
+
+### Sizing
+
+The rules mirror `output_widget`:
+
+- `height=None` (default): the plot fills its container. Inside `ui.card(full_screen=True)`, a fillable page or a sidebar layout it grows and shrinks with the card, from a 400px basis. Outside a fill layout it is 400px tall.
+- `height="300px"` (on the decorator or on `output_plotly`): the plot is exactly that tall and opts out of filling.
+
+Plotly alone re-measures a graph only on window resize. `shiny-plotly` ships a small helper script (`shiny-plotly.js`, loaded with every figure) 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 Shiny has replaced the output holding it, which releases the window listener and layout state plotly would otherwise keep for every render.
+
+### Events back to Shiny
+
+`post_script` runs after `Plotly.newPlot` resolves; `{plot_id}` is replaced with the graph div's id.
+
+```python
+CLICK_TO_INPUT = """
+document.getElementById('{plot_id}').on('plotly_click', function (ev) {
+    var p = ev.points[0];
+    Shiny.setInputValue('clicked', {x: p.x, y: p.y}, {priority: 'event'});
+});
+"""
+
+
+@render_plotly(post_script=CLICK_TO_INPUT)
+def scatter(): ...
+
+
+@render.text
+def click_info():
+    if not input.clicked.is_set():
+        return "Click a point."
+    pt = input.clicked()
+    return f"x={pt['x']}, y={pt['y']}"
+```
+
+`input.clicked()` raises a silent exception while the input has never been set, so check `is_set()` first when the output should show something before the first click.
+
+### Lower level
+
+- `fig_to_ui(fig, div_id=None, *, height, width, figurewidget_margins, config, post_script)` returns the `TagList` a render produces: the plotly.js dependency, the helper dependency and the `<div class="shiny-plotly">` holding the figure. Use it from a plain `@render.ui` that composes several things, or from any htmltools context.
+- `plotly_js()` is the `HTMLDependency` for plotly.js, served from the installed `plotly` wheel at `/lib/plotly-<version>/plotly.min.js`. Every figure carries it, so it is optional; add it to the page UI to load the bundle up front instead of with the first figure.
+- `shiny_plotly_js()` is the helper's dependency. Every figure carries it too.
+- `FIGUREWIDGET_MARGINS` is the `{"l": 16, "t": 32, "r": 16, "b": 16}` mapping.
+
+## Examples
+
+```sh
+uv run --with shiny-plotly shiny run examples/core_app.py
+uv run --with shiny-plotly shiny run examples/express_app.py
+```
+
+## Development
+
+```sh
+make sync        # uv sync --all-groups
+make browsers    # playwright install chromium, once
+make check       # lint, typecheck, unit + e2e tests, browser tests, wheel check
+```
+
+`make test` runs the unit tests and the in-process Shiny end-to-end tests over a real websocket. `make test-browser` drives the package in headless Chromium: fill sizing, resize without a window event, purge on re-render, full screen, `post_script` click wiring and on-demand loading of plotly.js. `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.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

shiny_plotly-0.1.0/examples/core_app.py

@@ -0,0 +1,84 @@
+"""Shiny Core example: three plotly charts rendered without shinywidgets.
+
+Run with:  uv run --with shiny-plotly shiny run examples/core_app.py
+"""
+
+import random
+from itertools import accumulate
+
+import plotly.graph_objects as go
+from shiny import App, Inputs, Outputs, Session, reactive, render, ui
+
+from shiny_plotly import output_plotly, plotly_js, render_plotly
+
+# Forwards plotly click events to a Shiny input. {plot_id} is the graph div's id.
+CLICK_TO_INPUT = """
+document.getElementById('{plot_id}').on('plotly_click', function (ev) {
+    var p = ev.points[0];
+    Shiny.setInputValue('clicked', {x: p.x, y: p.y}, {priority: 'event'});
+});
+"""
+
+app_ui = ui.page_sidebar(
+    ui.sidebar(
+        ui.input_slider("n", "Points", min=10, max=500, value=100),
+        ui.input_select("kind", "Trace", {"scatter": "Scatter", "bar": "Bar"}),
+        ui.output_text("click_info"),
+    ),
+    ui.layout_columns(
+        ui.card(
+            ui.card_header("Fills the card; try full screen"),
+            output_plotly("main_plot"),
+            full_screen=True,
+        ),
+        ui.card(
+            ui.card_header("FigureWidget margins preset"),
+            output_plotly("compact_plot"),
+            full_screen=True,
+        ),
+    ),
+    ui.card(
+        ui.card_header("Fixed height, click a point"),
+        output_plotly("fixed_plot"),
+    ),
+    plotly_js(),
+    title="shiny-plotly",
+    fillable=True,
+)
+
+
+def server(input: Inputs, output: Outputs, session: Session):
+    @reactive.calc
+    def data():
+        rng = random.Random(input.n())
+        x = list(range(input.n()))
+        return x, list(accumulate(rng.gauss(0, 1) for _ in x))
+
+    @render_plotly
+    def main_plot():
+        x, y = data()
+        if input.kind() == "scatter":
+            trace = go.Scatter(x=x, y=y, mode="lines")
+        else:
+            trace = go.Bar(x=x, y=y)
+        return go.Figure(trace).update_layout(title=f"{input.n()} points")
+
+    @render_plotly(figurewidget_margins=True)
+    def compact_plot():
+        x, y = data()
+        return go.Figure(go.Scatter(x=x, y=[abs(v) for v in y], fill="tozeroy"))
+
+    @render_plotly(height="260px", post_script=CLICK_TO_INPUT, config={"displaylogo": False})
+    def fixed_plot():
+        x, y = data()
+        return go.Figure(go.Scatter(x=x, y=y, mode="markers"))
+
+    @render.text
+    def click_info():
+        if not input.clicked.is_set():
+            return "Click a point in the bottom chart."
+        pt = input.clicked()
+        return f"Clicked x={pt['x']}, y={pt['y']:.2f}"
+
+
+app = App(app_ui, server)

shiny_plotly-0.1.0/examples/express_app.py

@@ -0,0 +1,27 @@
+"""Shiny Express example: the decorator creates its own output placeholder.
+
+Run with:  uv run --with shiny-plotly shiny run examples/express_app.py
+"""
+
+import random
+from itertools import accumulate
+
+import plotly.graph_objects as go
+from shiny.express import input, ui
+
+from shiny_plotly import plotly_js, render_plotly
+
+ui.page_opts(title="shiny-plotly (Express)", fillable=True)
+plotly_js()
+
+with ui.sidebar():
+    ui.input_slider("n", "Points", min=10, max=500, value=100)
+
+with ui.card(full_screen=True):
+    ui.card_header("Random walk")
+
+    @render_plotly
+    def walk():
+        rng = random.Random(input.n())
+        y = list(accumulate(rng.gauss(0, 1) for _ in range(input.n())))
+        return go.Figure(go.Scatter(y=y, mode="lines"))

shiny_plotly-0.1.0/pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "shiny-plotly"
+version = "0.1.0"
+description = "Render plotly figures in Shiny for Python as plain HTML, without the shinywidgets layer."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+  { name = "Ruben J. Jongejan", email = "ruben.jongejan@gmail.com" },
+]
+keywords = ["shiny", "plotly", "dashboard", "render", "html"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Scientific/Engineering :: Visualization",
+  "Typing :: Typed",
+]
+dependencies = [
+  "shiny>=1.0",
+  "plotly>=5.0",
+  "htmltools>=0.5",
+]
+
+[project.urls]
+Homepage   = "https://github.com/rvben/shiny-plotly"
+Repository = "https://github.com/rvben/shiny-plotly"
+Changelog  = "https://github.com/rvben/shiny-plotly/blob/main/CHANGELOG.md"
+Issues     = "https://github.com/rvben/shiny-plotly/issues"
+
+[dependency-groups]
+dev = [
+  "pytest>=8",
+  "pytest-asyncio>=0.24",
+  "ruff>=0.6",
+  "pyright>=1.1.380",
+  "httpx2>=2.12.0",
+  "pytest-playwright>=0.9.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/shiny_plotly"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/shiny_plotly", "tests", "examples", "README.md", "CHANGELOG.md", "LICENSE"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+filterwarnings = ["error"]
+markers = ["browser: drives the package in a real Chromium through playwright"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
+
+[tool.pyright]
+include = ["src", "tests", "examples"]
+pythonVersion = "3.10"
+typeCheckingMode = "standard"
+
+[tool.ruff.lint.isort]
+known-local-folder = ["newplot"]