shiny-plotly 0.1.0__py3-none-any.whl

shiny_plotly/__init__.py

@@ -0,0 +1,15 @@
+"""Render plotly figures in Shiny for Python without the shinywidgets layer."""
+
+from ._deps import __version__, plotly_js, shiny_plotly_js
+from ._html import FIGUREWIDGET_MARGINS, fig_to_ui
+from ._render import output_plotly, render_plotly
+
+__all__ = (
+    "FIGUREWIDGET_MARGINS",
+    "__version__",
+    "fig_to_ui",
+    "output_plotly",
+    "plotly_js",
+    "render_plotly",
+    "shiny_plotly_js",
+)

shiny_plotly/_deps.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from importlib.metadata import version
+
+import plotly
+from htmltools import HTMLDependency
+
+__all__ = ("__version__", "plotly_js", "shiny_plotly_js")
+
+__version__ = version("shiny-plotly")
+
+
+def plotly_js() -> HTMLDependency:
+    """
+    The plotly.js bundle, served by Shiny straight from the installed ``plotly`` wheel.
+
+    Shiny serves HTML dependencies under ``/lib/<name>-<version>/``, so the URL is keyed
+    by the installed plotly version and caches correctly across deploys. Nothing is
+    copied or written: the dependency points at ``plotly/package_data/plotly.min.js``,
+    the exact bundle ``plotly.offline.get_plotlyjs()`` would inline.
+
+    Add it once to the page UI so the bundle loads with the page. Every figure rendered by
+    :func:`~shiny_plotly.render_plotly` or :func:`~shiny_plotly.fig_to_ui` also carries it,
+    so an output still works without the page-level call; htmltools de-duplicates.
+    """
+    return HTMLDependency(
+        name="plotly",
+        version=plotly.__version__,
+        source={"package": "plotly", "subdir": "package_data"},
+        script={"src": "plotly.min.js"},
+    )
+
+
+def shiny_plotly_js() -> HTMLDependency:
+    """
+    The small browser helper every rendered figure depends on.
+
+    It keeps each graph sized to its container (plotly alone only reacts to window
+    resizes) and purges a graph once Shiny has replaced the output holding it, so
+    re-rendering outputs do not accumulate plotly state. It rides along with every
+    fragment; there is no need to add it to the page yourself.
+    """
+    return HTMLDependency(
+        name="shiny-plotly",
+        version=__version__,
+        source={"package": "shiny_plotly", "subdir": "www"},
+        script={"src": "shiny-plotly.js"},
+    )

shiny_plotly/_html.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import uuid
+from collections.abc import Mapping
+from types import MappingProxyType
+from typing import Any
+
+import plotly.io as pio
+from htmltools import HTML, Tag, TagList, css, tags
+from plotly.basedatatypes import BaseFigure
+
+from ._deps import plotly_js, shiny_plotly_js
+
+__all__ = ("FIGUREWIDGET_MARGINS", "fig_to_ui")
+
+# The margins shinywidgets installs on every plotly FigureWidget it renders (its
+# set_layout_defaults: template.layout.margin = l16/t32/r16/b16), so a migrated app can
+# keep its exact look. Plotly's own defaults are l80/t100/r80/b80.
+FIGUREWIDGET_MARGINS: Mapping[str, int] = MappingProxyType({"l": 16, "t": 32, "r": 16, "b": 16})
+
+_DEFAULT_CONFIG: Mapping[str, Any] = MappingProxyType({"responsive": True})
+
+# Height of a filling container when nothing constrains it, and its flex basis inside a
+# fill layout; the same 400px shinywidgets gives a FigureWidget.
+_FILL_BASIS = "400px"
+
+# Runs right after Plotly.newPlot resolves: hands the graph div to the browser helper
+# (shiny-plotly.js), which tracks its size and purges it when Shiny replaces the output.
+_TRACK_SCRIPT = "window.shinyPlotly && shinyPlotly.track(document.getElementById('{plot_id}'));"
+
+Figure = BaseFigure | dict[str, Any]
+"""A ``plotly.graph_objects.Figure`` or its JSON dict (``fig.to_dict()``)."""
+
+
+def fig_to_ui(
+    fig: Figure | None,
+    div_id: str | None = None,
+    *,
+    height: str | None = None,
+    width: str = "100%",
+    figurewidget_margins: bool = False,
+    config: Mapping[str, Any] | None = None,
+    post_script: str | None = None,
+) -> TagList | None:
+    """
+    Turn a plotly figure into a Shiny UI fragment that draws it with ``Plotly.newPlot``.
+
+    Parameters
+    ----------
+    fig
+        A ``go.Figure`` or its JSON dict. ``None`` renders nothing (returns ``None``).
+    div_id
+        DOM id of the plotly graph div. A fresh id is generated when omitted.
+    height
+        CSS height of the plot. ``None`` (the default) fills the parent: inside a fill
+        layout (``ui.card(full_screen=True)``, a fillable page, ``output_plotly``) the plot
+        grows and shrinks with it from a 400px basis; anywhere else it is 400px tall. A
+        value such as ``"300px"`` fixes the height and opts out of filling, exactly like
+        ``output_widget(height=...)`` does in shinywidgets.
+    width
+        CSS width of the plot, ``"100%"`` by default.
+    figurewidget_margins
+        Fill in margin sides the figure left unset with :data:`FIGUREWIDGET_MARGINS`, the
+        values shinywidgets applies to a FigureWidget. Sides the figure sets explicitly win.
+        The caller's figure object is never mutated.
+    config
+        Extra ``Plotly.newPlot`` config, merged over ``{"responsive": True}``.
+    post_script
+        JavaScript run after the plot is drawn; ``{plot_id}`` is replaced with the graph div
+        id. The place to bind plotly events back to Shiny inputs.
+    """
+    if fig is None:
+        return None
+    fig_dict = _as_fig_dict(fig)
+    if figurewidget_margins:
+        _fill_in_margins(fig_dict)
+    if div_id is None:
+        div_id = "plotly-" + uuid.uuid4().hex
+
+    fragment = pio.to_html(
+        fig_dict,
+        validate=False,
+        full_html=False,
+        include_plotlyjs=False,
+        include_mathjax=False,
+        div_id=div_id,
+        config={**_DEFAULT_CONFIG, **(config or {})},
+        post_script=[_TRACK_SCRIPT, post_script] if post_script else [_TRACK_SCRIPT],
+    )
+    container: Tag = tags.div(
+        HTML(fragment),
+        class_="shiny-plotly html-fill-item" if height is None else "shiny-plotly",
+        style=css(height=height or _FILL_BASIS, width=width),
+    )
+    return TagList(plotly_js(), shiny_plotly_js(), container)
+
+
+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.
+    if isinstance(fig, BaseFigure):
+        return fig.to_dict()
+    if isinstance(fig, dict):
+        return {**fig, "layout": dict(fig.get("layout") or {})}
+    raise TypeError(
+        f"fig_to_ui() expects a plotly go.Figure (or its dict), got {type(fig).__name__}"
+    )
+
+
+def _fill_in_margins(fig_dict: dict[str, Any]) -> None:
+    layout = fig_dict.setdefault("layout", {})
+    layout["margin"] = {**FIGUREWIDGET_MARGINS, **(layout.get("margin") or {})}

shiny_plotly/_render.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from htmltools import Tag, css
+from shiny import ui as _ui
+from shiny.render import ui as _render_ui
+from shiny.render.renderer import Jsonifiable, ValueFn
+from shiny.session import require_active_session
+
+from ._html import Figure, fig_to_ui
+
+__all__ = ("output_plotly", "render_plotly")
+
+
+def output_plotly(id: str, *, width: str | None = None, height: str | None = None) -> Tag:
+    """
+    Placeholder for a :func:`render_plotly` output. A drop-in for ``output_widget(id)``.
+
+    It is ``ui.output_ui`` made fill-aware: inside ``ui.card(full_screen=True)`` or a
+    fillable page the plot grows and shrinks with its container. Passing ``height`` fixes
+    the output's height instead (the plot fills that height), the same rule
+    ``output_widget`` follows. ``ui.output_ui(id)`` also works when no fill behaviour is
+    wanted.
+    """
+    return _ui.output_ui(
+        id, fill=height is None, fillable=True, style=css(width=width, height=height)
+    )
+
+
+class render_plotly(_render_ui):
+    """
+    Render a plotly figure as plain HTML drawn with ``Plotly.newPlot``.
+
+    A drop-in for ``@render_widget`` when the function returns a ``go.Figure`` (or its
+    dict). Use bare (``@render_plotly``) or with options::
+
+        @render_plotly(height="300px", figurewidget_margins=True)
+        def sales():
+            return px.bar(df, x="month", y="total")
+
+    Returning ``None`` renders nothing. Works in Core and Express; the decorated function
+    may be sync or async.
+
+    Parameters
+    ----------
+    height, width
+        CSS size of the plot. ``height=None`` (default) fills the output; a value such as
+        ``"300px"`` fixes it. See :func:`~shiny_plotly.fig_to_ui`.
+    figurewidget_margins
+        Fill in unset margin sides with the values shinywidgets applies to a FigureWidget
+        (l16/t32/r16/b16), so a migrated app keeps its exact look.
+    config
+        Extra ``Plotly.newPlot`` config, merged over ``{"responsive": True}``.
+    post_script
+        JavaScript run after the plot is drawn, with ``{plot_id}`` replaced by the graph
+        div's id. The place to forward plotly events to Shiny inputs.
+    """
+
+    def __init__(
+        self,
+        _fn: ValueFn[Figure | None] | None = None,
+        *,
+        height: str | None = None,
+        width: str = "100%",
+        figurewidget_margins: bool = False,
+        config: Mapping[str, Any] | None = None,
+        post_script: str | None = None,
+    ) -> None:
+        self.height = height
+        self.width = width
+        self.figurewidget_margins = figurewidget_margins
+        self.config = config
+        self.post_script = post_script
+        # Registers _fn (sets output_id from its name) when used as a bare decorator.
+        super().__init__(_fn)  # type: ignore[arg-type]
+
+    def auto_output_ui(self) -> Tag:
+        return output_plotly(self.output_id)
+
+    async def transform(self, value: Figure) -> Jsonifiable:  # type: ignore[override]
+        session = require_active_session(None)
+        fragment = fig_to_ui(
+            value,
+            div_id=f"{session.ns(self.output_id)}-plotly",
+            height=self.height,
+            width=self.width,
+            figurewidget_margins=self.figurewidget_margins,
+            config=self.config,
+            post_script=self.post_script,
+        )
+        return await super().transform(fragment)

shiny_plotly/www/shiny-plotly.js

@@ -0,0 +1,47 @@
+// Keeps every shiny-plotly graph sized to its container, and releases a graph once Shiny
+// has replaced the output that held it.
+//
+// Plotly re-measures a responsive graph only on window resize, and it registers one window
+// listener per graph div. So a graph whose card changes size without a window resize (a
+// sibling output rendering, a sidebar toggle) stays at its old size, and a graph Shiny has
+// re-rendered is kept alive by that listener forever. One ResizeObserver covers both: a
+// size change re-lays the graph out, and the notification for a detached element (size 0x0,
+// no longer in the document) purges it, which removes the listener and plotly's state.
+(function () {
+  "use strict";
+
+  var observer = null;
+
+  function differs(actual, laidOut) {
+    // Same tolerance plotly's own autosize applies before it redraws.
+    return Math.abs(actual - laidOut) > 1;
+  }
+
+  function onResize(entries) {
+    for (var i = 0; i < entries.length; i++) {
+      var gd = entries[i].target;
+      if (!gd.isConnected) {
+        observer.unobserve(gd);
+        if (window.Plotly) window.Plotly.purge(gd);
+        continue;
+      }
+      var rect = entries[i].contentRect;
+      var layout = gd._fullLayout;
+      if (!layout || (rect.width === 0 && rect.height === 0)) continue;
+      if (differs(rect.width, layout.width) || differs(rect.height, layout.height)) {
+        window.Plotly.Plots.resize(gd);
+      }
+    }
+  }
+
+  window.shinyPlotly = {
+    // Called from the fragment right after Plotly.newPlot resolves, with the graph div.
+    track: function (gd) {
+      if (!gd) return;
+      if (observer === null && typeof ResizeObserver === "function") {
+        observer = new ResizeObserver(onResize);
+      }
+      if (observer !== null) observer.observe(gd);
+    }
+  };
+})();

shiny_plotly-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,10 @@
+shiny_plotly/__init__.py,sha256=FKfM23h6W68_CB6vFaiQtaHlf-yTbSFTp705uaKKaZw,402
+shiny_plotly/_deps.py,sha256=-Pay-nYalROIeX9lyu9HZhCwVfchRrIFP51DQk3UfQ8,1789
+shiny_plotly/_html.py,sha256=vjXxntDCP4J7tz2RHvMwvOxU9Fd9FNW7_4sXMCMA3T8,4483
+shiny_plotly/_render.py,sha256=IlPk4ngFAb3GvccEsDViLTRWR2y-TtbVetcVsFojt2w,3446
+shiny_plotly/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shiny_plotly/www/shiny-plotly.js,sha256=R6HsW8T8qjcBeqL_DR5_yep_kRhxk0_-9Iih1__ZV_I,1794
+shiny_plotly-0.1.0.dist-info/METADATA,sha256=kja8lvqOHWrnDcaoav3HfR6cfHkp3D7OSDlnmUF5Pm4,9839
+shiny_plotly-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+shiny_plotly-0.1.0.dist-info/licenses/LICENSE,sha256=5pr_hilUw8EqNYDfW-9iOtxur_eDNkxklljAsSKi9qo,1074
+shiny_plotly-0.1.0.dist-info/RECORD,,

shiny_plotly-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

shiny_plotly-0.1.0.dist-info/licenses/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.