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

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

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.1](https://github.com/rvben/shiny-plotly/compare/v0.4.0...v0.4.1) - 2026-09-25
+
+### Fixed
+
+- A click, hover or selection on a heatmap (or any trace that addresses a point by row and column) now carries the point's `pointNumber` as `[row, column]` and its `customdata`. Both were dropped: the pair is not a scalar, so it was left out, and looking customdata up by it came back empty. Customdata is now the value plotly itself puts on the point, for every trace type.
+- A `post_script` that throws no longer stops the chart it belongs to. The error is logged to the browser console with the output's id; until now it also left the output never marked as drawn, so updates sent to it were held forever, a themed chart stopped following the color mode, and Shiny reported a client error.
+- Updates held for an output that has no figure drawn, such as one in a closed tab, no longer pile up one per call. Consecutive `extend_traces` calls to the same traces with the same attributes and `max_points` are merged as they arrive, cut to `max_points`, and so are consecutive `prepend_traces` calls. A chart streaming at 50 Hz in a tab closed for ten seconds held 500 updates and drew each one when the tab opened; it now holds one and draws once, to the same result.
+- The in-place updates take a numpy integer for `indices`, where it failed with `TypeError: 'numpy.int64' object is not iterable`, and `extend_traces` and `prepend_traces` take one for `max_points`, as `render_plotly` does for `max_event_points`, where both were refused as not a positive integer. Indices that are not integers (a float, a string, a `bool`) are refused with a `ValueError` naming the argument instead of being sent to the browser.
+- A client that refuses an encoding by name in `Accept-Encoding` is no longer sent it because the header also has a `*`: `gzip;q=0, *` asked for anything but gzip and got gzip. A refusal is also read wherever `q` stands among the entry's parameters.
+- `If-None-Match` for plotly.min.js now matches a weak validator (`W/"..."`, as a proxy may send it) and `*`, returning 304 instead of the whole bundle again.
+- plotly.min.js served raw while its compression is still running, which happens only on the first requests of a process, is marked `Cache-Control: no-cache` instead of immutable for a year. A browser that asked for brotli or gzip revalidates it on the next visit and gets the compressed file, instead of keeping the 4.8 MB raw file in its cache.
+
 ## [0.4.0](https://github.com/rvben/shiny-plotly/compare/v0.3.3...v0.4.0) - 2026-08-21
 
 ### Changed

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: shiny-plotly
-Version: 0.4.0
+Version: 0.4.1
 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
@@ -314,7 +314,7 @@ What arrives is plotly's own event data, cut to what serializes, the same way Da
 | `legendclick` | `{"curve_number": 1, "expanded_index": 1, "name": "beta", "visible": True}` for the trace whose legend item was clicked, `visible` as it stood before the click's toggle (`True` or `"legendonly"`); trace types whose legend items are labels (pie, funnelarea) add `label`; fires on every click, and the default toggle still happens |
 | `legenddoubleclick` | same value as `legendclick`; the default isolate-this-trace behavior still happens |
 
-Each point carries plotly's scalar fields for that trace type (`curveNumber`, `pointNumber`, `pointIndex`, `x`, `y`, `z`, `text`, `label`, `value`, `lat`, `lon`, ...) plus `customdata` (as a plain list, also when it was a numpy array), `bbox` and `pointNumbers` when present. `input.<id>_<event>()` raises a silent exception until the event has fired once, so check `is_set()` when the output should show something before that.
+Each point carries plotly's scalar fields for that trace type (`curveNumber`, `pointNumber`, `pointIndex`, `x`, `y`, `z`, `text`, `label`, `value`, `lat`, `lon`, ...) plus `customdata` (as a plain list, also when it was a numpy array), `bbox` and `pointNumbers` when present. On a 2-D trace such as a heatmap `pointNumber` is the cell's `[row, column]`. `input.<id>_<event>()` raises a silent exception until the event has fired once, so check `is_set()` when the output should show something before that.
 
 #### Dense traces
 
@@ -352,7 +352,7 @@ The value is never silently cut: `points` is a full list or `None`, and `point_c
 
 `click` and `hover` carry one point per trace under the pointer, so the cap matters for `selected`; hover is also debounced (100 ms), so a pointer sweeping across a dense trace sends one event when it rests, not one per point.
 
-For anything else, `post_script` runs once, after the first figure is drawn, with `{plot_id}` replaced by the graph div's id. Re-renders go through `Plotly.react` into the same graph div, so handlers attached either way stay attached and are never stacked.
+For anything else, `post_script` runs once, after the first figure is drawn, with `{plot_id}` replaced by the graph div's id. A script that throws is logged to the browser console and the chart carries on: events, theming and held updates do not depend on it. Re-renders go through `Plotly.react` into the same graph div, so handlers attached either way stay attached and are never stacked.
 
 ```python
 ANNOTATION_TO_INPUT = """
@@ -401,7 +401,7 @@ async def _highlight():
 - `add_traces(id, traces, indices=None)`: whole new traces, each a graph object (`go.Scatter(y=[1, 2])`) or a dict (`{"y": [1], "type": "bar"}`); `indices` says where they land in the trace order, appended without it.
 - `delete_traces(id, indices)`: removes the traces at `indices`; the rest renumber, as a Python list does on `del`.
 
-The values go through plotly's encoder, so numpy arrays, pandas columns and datetimes work. The id is namespaced inside a module, like the output. An update reaches the figure that is drawn at that moment; one sent while the output has no figure (its first render is still running, it sits in a hidden tab, it shows an error or was emptied by `None`) is held and applied, in order, right after the output's next draw. A re-render replaces the figure, updates included, with what the render function returns: the server stays the source of truth, and a figure that should keep its streamed points across a re-render builds them in from server-side state.
+The values go through plotly's encoder, so numpy arrays, pandas columns and datetimes work. The id is namespaced inside a module, like the output. An update reaches the figure that is drawn at that moment; one sent while the output has no figure (its first render is still running, it sits in a hidden tab, it shows an error or was emptied by `None`) is held and applied, in order, right after the output's next draw. Consecutive held `extend_traces` calls with the same traces, attributes and `max_points` are merged into one as they arrive, and so are consecutive `prepend_traces` calls, cut to `max_points` as they go: a stream into a chart in a closed tab costs one redraw when the tab opens and, with a cap, holds no more points than the chart will keep. A re-render replaces the figure, updates included, with what the render function returns: the server stays the source of truth, and a figure that should keep its streamed points across a re-render builds them in from server-side state.
 
 A runnable version of the streaming pattern, with a pause switch and a window slider, is `examples/streaming_app.py`.
 
@@ -418,7 +418,7 @@ 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, 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.
+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 `Cache-Control: no-cache` to a browser that asked for an encoding still being compressed, so its next visit revalidates and swaps in the compressed body rather than keeping the raw one for a year.
 
 `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.
 

{shiny_plotly-0.4.0 → shiny_plotly-0.4.1}/README.md

@@ -284,7 +284,7 @@ What arrives is plotly's own event data, cut to what serializes, the same way Da
 | `legendclick` | `{"curve_number": 1, "expanded_index": 1, "name": "beta", "visible": True}` for the trace whose legend item was clicked, `visible` as it stood before the click's toggle (`True` or `"legendonly"`); trace types whose legend items are labels (pie, funnelarea) add `label`; fires on every click, and the default toggle still happens |
 | `legenddoubleclick` | same value as `legendclick`; the default isolate-this-trace behavior still happens |
 
-Each point carries plotly's scalar fields for that trace type (`curveNumber`, `pointNumber`, `pointIndex`, `x`, `y`, `z`, `text`, `label`, `value`, `lat`, `lon`, ...) plus `customdata` (as a plain list, also when it was a numpy array), `bbox` and `pointNumbers` when present. `input.<id>_<event>()` raises a silent exception until the event has fired once, so check `is_set()` when the output should show something before that.
+Each point carries plotly's scalar fields for that trace type (`curveNumber`, `pointNumber`, `pointIndex`, `x`, `y`, `z`, `text`, `label`, `value`, `lat`, `lon`, ...) plus `customdata` (as a plain list, also when it was a numpy array), `bbox` and `pointNumbers` when present. On a 2-D trace such as a heatmap `pointNumber` is the cell's `[row, column]`. `input.<id>_<event>()` raises a silent exception until the event has fired once, so check `is_set()` when the output should show something before that.
 
 #### Dense traces
 
@@ -322,7 +322,7 @@ The value is never silently cut: `points` is a full list or `None`, and `point_c
 
 `click` and `hover` carry one point per trace under the pointer, so the cap matters for `selected`; hover is also debounced (100 ms), so a pointer sweeping across a dense trace sends one event when it rests, not one per point.
 
-For anything else, `post_script` runs once, after the first figure is drawn, with `{plot_id}` replaced by the graph div's id. Re-renders go through `Plotly.react` into the same graph div, so handlers attached either way stay attached and are never stacked.
+For anything else, `post_script` runs once, after the first figure is drawn, with `{plot_id}` replaced by the graph div's id. A script that throws is logged to the browser console and the chart carries on: events, theming and held updates do not depend on it. Re-renders go through `Plotly.react` into the same graph div, so handlers attached either way stay attached and are never stacked.
 
 ```python
 ANNOTATION_TO_INPUT = """
@@ -371,7 +371,7 @@ async def _highlight():
 - `add_traces(id, traces, indices=None)`: whole new traces, each a graph object (`go.Scatter(y=[1, 2])`) or a dict (`{"y": [1], "type": "bar"}`); `indices` says where they land in the trace order, appended without it.
 - `delete_traces(id, indices)`: removes the traces at `indices`; the rest renumber, as a Python list does on `del`.
 
-The values go through plotly's encoder, so numpy arrays, pandas columns and datetimes work. The id is namespaced inside a module, like the output. An update reaches the figure that is drawn at that moment; one sent while the output has no figure (its first render is still running, it sits in a hidden tab, it shows an error or was emptied by `None`) is held and applied, in order, right after the output's next draw. A re-render replaces the figure, updates included, with what the render function returns: the server stays the source of truth, and a figure that should keep its streamed points across a re-render builds them in from server-side state.
+The values go through plotly's encoder, so numpy arrays, pandas columns and datetimes work. The id is namespaced inside a module, like the output. An update reaches the figure that is drawn at that moment; one sent while the output has no figure (its first render is still running, it sits in a hidden tab, it shows an error or was emptied by `None`) is held and applied, in order, right after the output's next draw. Consecutive held `extend_traces` calls with the same traces, attributes and `max_points` are merged into one as they arrive, and so are consecutive `prepend_traces` calls, cut to `max_points` as they go: a stream into a chart in a closed tab costs one redraw when the tab opens and, with a cap, holds no more points than the chart will keep. A re-render replaces the figure, updates included, with what the render function returns: the server stays the source of truth, and a figure that should keep its streamed points across a re-render builds them in from server-side state.
 
 A runnable version of the streaming pattern, with a pause switch and a window slider, is `examples/streaming_app.py`.
 
@@ -388,7 +388,7 @@ 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, 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.
+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 `Cache-Control: no-cache` to a browser that asked for an encoding still being compressed, so its next visit revalidates and swaps in the compressed body rather than keeping the raw one for a year.
 
 `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.
 

{shiny_plotly-0.4.0 → shiny_plotly-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "shiny-plotly"
-version = "0.4.0"
+version = "0.4.1"
 description = "Render plotly figures in Shiny for Python with plain plotly.js, without the shinywidgets layer."
 readme = "README.md"
 requires-python = ">=3.10"

{shiny_plotly-0.4.0 → shiny_plotly-0.4.1}/src/shiny_plotly/_render.py

@@ -16,6 +16,7 @@ from shiny.ui.fill import as_fill_item, as_fillable_container
 from ._deps import plotly_js, shiny_plotly_js
 from ._html import DEFAULT_CONFIG, Figure, as_fig_dict, fill_in_margins
 from ._serve import enable_compressed_plotly_js
+from ._validate import as_positive_int
 
 __all__ = ("DEFAULT_MAX_EVENT_POINTS", "EVENTS", "output_plotly", "render_plotly")
 
@@ -127,11 +128,7 @@ def template_key(template_json: str) -> str:
 
 
 def normalize_max_event_points(value: int | None) -> int | None:
-    if value is None:
-        return None
-    if isinstance(value, bool) or not isinstance(value, int) or value < 1:
-        raise ValueError(f"max_event_points must be a positive int or None, got {value!r}")
-    return value
+    return None if value is None else as_positive_int(value, "max_event_points")
 
 
 def output_plotly(id: str, *, width: str | None = None, height: str | None = None) -> Tag:

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

@@ -10,7 +10,8 @@ Importing ``shiny_plotly`` wraps ``shiny.App.__init__``, so every app built afte
 route for the bundle's exact path in front of Shiny's mount, and a background thread starts
 compressing the bundle once per process. Both happen while the app is being built, before it
 can serve anything, so the first request of the process is already served here; until the
-compression has finished the route serves the raw file with the same cache headers. An app
+compression has finished the route serves the raw file, marked for revalidation rather than
+immutable when the client asked for an encoding that is still on its way. An app
 built before the import can still ask for the route with :func:`enable_compressed_plotly_js`,
 and each session enables it for its own app, so it is there either way.
 """
@@ -44,6 +45,10 @@ __all__ = (
 
 ROUTE_NAME = "shiny-plotly-bundle"
 CACHE_CONTROL = "public, max-age=31536000, immutable"
+# For a body that is not yet the one this client will get: the raw file, served while the
+# encoding it asked for is still being compressed. Stored, but revalidated on every use,
+# so the next visit swaps it for the compressed body instead of keeping it for a year.
+PROVISIONAL_CACHE_CONTROL = "no-cache"
 MEDIA_TYPE = "text/javascript; charset=utf-8"
 
 logger = logging.getLogger(__name__)
@@ -72,6 +77,8 @@ class CompressedBundle:
             f"{stat.st_size}-{stat.st_mtime_ns}".encode(), usedforsecurity=False
         ).hexdigest()[:16]
         self.encodings: dict[str, bytes] = {}
+        # Every encoding the compression will produce, in the order it produces them.
+        self.produces: tuple[str, ...] = ("br", "gzip") if brotli is not None else ("gzip",)
         self._ready = threading.Event()
         self._started = False
         self._lock = threading.Lock()
@@ -86,6 +93,11 @@ class CompressedBundle:
     def wait(self, timeout: float | None = None) -> bool:
         return self._ready.wait(timeout)
 
+    @property
+    def ready(self) -> bool:
+        """Whether compression has finished, every encoding it will produce in place."""
+        return self._ready.is_set()
+
     def etag(self, encoding: str | None) -> str:
         return f'"{self.etag_base}"' if encoding is None else f'"{self.etag_base}-{encoding}"'
 
@@ -132,17 +144,19 @@ 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.
+    and ``q=0.000``, wherever it stands among the entry's ``;``-separated parameters.
+    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
+    for param in params.split(";"):
+        key, _, value = param.partition("=")
+        if key.strip().lower() != "q":
+            continue
+        try:
+            return float(value) == 0
+        except ValueError:
+            return False
+    return False
 
 
 def accepted_encodings(accept_encoding: str | None) -> Iterator[str]:
@@ -150,16 +164,34 @@ def accepted_encodings(accept_encoding: str | None) -> Iterator[str]:
     if not accept_encoding:
         return
     offered: set[str] = set()
+    refused: set[str] = set()
     for part in accept_encoding.split(","):
         token, _, params = part.partition(";")
-        if refuses(params):
-            continue
-        offered.add(token.strip().lower())
+        (refused if refuses(params) else offered).add(token.strip().lower())
+    # "*" stands for every encoding the header does not name (RFC 9110, 12.5.3), so a
+    # named refusal holds against it, and a named acceptance holds against "*;q=0".
+    wildcard = "*" in offered
     for encoding in ("br", "gzip"):
-        if encoding in offered or "*" in offered:
+        if encoding in offered or (wildcard and encoding not in refused):
             yield encoding
 
 
+def etag_matches(if_none_match: str, etag: str) -> bool:
+    """
+    Whether an ``If-None-Match`` header names ``etag``, compared as RFC 9110 requires.
+
+    The comparison is weak (13.1.2): ``W/"x"`` matches ``"x"``, since a proxy may weaken a
+    tag it passes on. ``*`` matches any current representation, which this route always has.
+    """
+    for candidate in if_none_match.split(","):
+        tag = candidate.strip()
+        if tag == "*":
+            return True
+        if tag.removeprefix("W/") == etag:
+            return True
+    return False
+
+
 def response_for(
     bundle: CompressedBundle,
     *,
@@ -167,10 +199,19 @@ def response_for(
     if_none_match: str | None,
     method: str = "GET",
 ) -> Response:
-    encoding = next((e for e in accepted_encodings(accept_encoding) if e in bundle.encodings), None)
+    accepted = list(accepted_encodings(accept_encoding))
+    encoding = next((e for e in accepted if e in bundle.encodings), None)
+    # The encoding this client gets once compression is done. Until then it may be served
+    # the raw file instead, which must not be the body it caches for a year.
+    eventual = next((e for e in accepted if e in bundle.produces), None)
+    final = bundle.ready or encoding == eventual
     etag = bundle.etag(encoding)
-    headers = {"Cache-Control": CACHE_CONTROL, "Vary": "Accept-Encoding", "ETag": etag}
-    if if_none_match is not None and etag in [t.strip() for t in if_none_match.split(",")]:
+    headers = {
+        "Cache-Control": CACHE_CONTROL if final else PROVISIONAL_CACHE_CONTROL,
+        "Vary": "Accept-Encoding",
+        "ETag": etag,
+    }
+    if if_none_match is not None and etag_matches(if_none_match, etag):
         return Response(status_code=304, headers=headers)
     if encoding is None:
         # Streams the file from disk; HEAD is detected from the request scope.

{shiny_plotly-0.4.0 → shiny_plotly-0.4.1}/src/shiny_plotly/_update.py

@@ -8,9 +8,10 @@ dashboard wants for a new point every second. They ride on Shiny's custom messag
 are applied by the browser helper to the graph div of the named output. One sent while
 the output has no figure drawn (its first render is still running, it sits in a hidden
 tab, it shows an error or was emptied by ``None``) is held and applied, in order, right
-after the output's next draw. A re-render replaces the figure, updates included, with
-what the render function returns. All of these are coroutines: await them from an
-``async def`` effect.
+after the output's next draw; consecutive held extends (or prepends) to the same traces,
+attributes and ``max_points`` are merged into one as they arrive. A re-render replaces
+the figure, updates included, with what the render function returns. All of these are
+coroutines: await them from an ``async def`` effect.
 """
 
 from __future__ import annotations
@@ -21,6 +22,8 @@ from typing import Any
 from plotly.io.json import to_json_plotly
 from shiny.session import Session, require_active_session
 
+from ._validate import as_int, as_positive_int
+
 __all__ = (
     "add_traces",
     "delete_traces",
@@ -40,20 +43,23 @@ Trace = Mapping[str, Any] | Any
 
 
 def _indices(indices: Indices) -> list[int] | None:
+    """Trace indices as a list of Python ints; numpy integers and arrays are taken too."""
     if indices is None:
         return None
-    if isinstance(indices, int):
-        return [indices]
-    return list(indices)
+    try:
+        return [as_int(indices)]
+    except TypeError:
+        pass
+    try:
+        return [as_int(index) for index in indices]  # type: ignore[union-attr]
+    except TypeError:
+        raise ValueError(f"indices must be an integer or integers, got {indices!r}") from None
 
 
-def _check_max_points(max_points: int | None) -> None:
-    # bool is excluded by name: it is an int in Python but serializes to a JSON true,
-    # which plotly.js reads as non-numeric and quietly treats as no cap at all.
-    if max_points is not None and (
-        isinstance(max_points, bool) or not isinstance(max_points, int) or max_points < 1
-    ):
-        raise ValueError(f"max_points must be a positive integer, got {max_points!r}")
+def _max_points(max_points: int | None) -> int | None:
+    # A JSON true, which a Python bool would become, reads to plotly.js as non-numeric and
+    # quietly means no cap at all; as_positive_int refuses it here instead.
+    return None if max_points is None else as_positive_int(max_points, "max_points")
 
 
 def _trace_json(trace: Trace) -> Any:
@@ -97,8 +103,7 @@ async def extend_traces(
     The update is sent to the session's client; outside a session it fails. Use it
     from a reactive effect, for instance one driven by ``reactive.invalidate_later``.
     """
-    _check_max_points(max_points)
-    await _send(id, "extendTraces", [data, _indices(indices), max_points], session)
+    await _send(id, "extendTraces", [data, _indices(indices), _max_points(max_points)], session)
 
 
 async def prepend_traces(
@@ -116,8 +121,7 @@ async def prepend_traces(
     ones, and ``max_points`` drops the newest points past that many instead of the
     oldest. Same ``data`` and ``indices`` shapes.
     """
-    _check_max_points(max_points)
-    await _send(id, "prependTraces", [data, _indices(indices), max_points], session)
+    await _send(id, "prependTraces", [data, _indices(indices), _max_points(max_points)], session)
 
 
 async def add_traces(

shiny_plotly-0.4.1/src/shiny_plotly/_validate.py

@@ -0,0 +1,31 @@
+"""Argument checks shared by the renderer and the in-place updates."""
+
+from __future__ import annotations
+
+import operator
+from typing import Any
+
+
+def as_int(value: Any) -> int:
+    """
+    ``value`` as a Python int, for anything integer-like: ``int`` and numpy's integers.
+
+    Raises TypeError for anything else. ``bool`` is refused by name: it is an int in Python
+    but serializes to a JSON ``true``, which plotly.js does not read as a number (numpy's
+    bool is no integer to begin with). A float, even a whole one, is refused as well, the
+    way ``range()`` and list indexing refuse it.
+    """
+    if isinstance(value, bool):
+        raise TypeError(f"expected an integer, got {value!r}")
+    return operator.index(value)
+
+
+def as_positive_int(value: Any, name: str) -> int:
+    """``value`` as a Python int of at least 1; ValueError naming ``name`` otherwise."""
+    try:
+        number = as_int(value)
+    except TypeError:
+        number = 0
+    if number < 1:
+        raise ValueError(f"{name} must be a positive integer, got {value!r}")
+    return number

{shiny_plotly-0.4.0 → shiny_plotly-0.4.1}/src/shiny_plotly/www/shiny-plotly.js

@@ -154,7 +154,8 @@
   // --- events to inputs ---------------------------------------------------------------
   // What plotly hands an event handler holds the full trace and axis objects, circular and
   // large; what travels is each point's scalar fields plus the few objects worth having
-  // (bbox, pointNumbers, customdata), the same cut Dash makes. Typed arrays, which is how
+  // (bbox, pointNumbers, customdata, and a pointNumber that is a [row, column] pair on a
+  // 2-D trace such as a heatmap), the same cut Dash makes. Typed arrays, which is how
   // plotly holds decoded bdata, become plain arrays so they serialize as lists.
 
   function plain(value) {
@@ -171,10 +172,10 @@
     }
     if (point.bbox) out.bbox = point.bbox;
     if (point.pointNumbers) out.pointNumbers = point.pointNumbers;
-    var trace = gd._fullData && gd._fullData[point.curveNumber];
-    if (trace && trace.customdata != null && point.pointNumber !== undefined) {
-      out.customdata = plain(trace.customdata[point.pointNumber]);
-    }
+    if (Array.isArray(point.pointNumber)) out.pointNumber = point.pointNumber.slice();
+    // Plotly puts the point's customdata on the point itself, looked up the way the trace
+    // type addresses its points; a trace without customdata leaves it undefined.
+    if (point.customdata !== undefined) out.customdata = plain(point.customdata);
     return out;
   }
 
@@ -288,10 +289,16 @@
     return gd;
   }
 
+  // The figure is drawn by the time the script runs, so a script that throws is reported
+  // and the chart carries on: held updates, theming and events do not depend on it.
   function runPostScript(gd, script) {
     if (!script) return;
-    /* eslint-disable-next-line no-new-func */
-    new Function(script.replace(/\{plot_id\}/g, gd.id))();
+    try {
+      /* eslint-disable-next-line no-new-func */
+      new Function(script.replace(/\{plot_id\}/g, gd.id))();
+    } catch (err) {
+      console.error("shiny-plotly: post_script of '" + gd.id + "' failed:", err);
+    }
   }
 
   function draw(el, value) {
@@ -342,9 +349,62 @@
   // tab, an output showing an error or emptied by a None) is held on the output element and
   // applied, in order, right after its next draw. One for an id with no output on the page
   // is dropped with a warning.
+  //
+  // A stream into an output in a hidden tab would otherwise queue one update per tick, each
+  // a redraw on reveal, so a held extend or prepend is folded into the one held just before
+  // it when both name the same traces, attributes and cap: their points are joined and cut
+  // to the cap, which is exactly what the two calls would have left on the traces.
+
+  // Per-trace arrays for every attribute, one per index; anything else (a scalar, a typed
+  // array spelled as bdata) is applied as sent.
+  function perTraceArrays(data) {
+    var keys = Object.keys(data);
+    if (keys.length === 0) return null;
+    var count = null;
+    for (var i = 0; i < keys.length; i++) {
+      var column = data[keys[i]];
+      if (!Array.isArray(column) || !column.every(Array.isArray)) return null;
+      if (count !== null && column.length !== count) return null;
+      count = column.length;
+    }
+    return keys.sort();
+  }
+
+  function mergeable(held, next) {
+    if (held.method !== next.method) return false;
+    if (next.method !== "extendTraces" && next.method !== "prependTraces") return false;
+    var a = held.args, b = next.args;
+    if (JSON.stringify(a[1]) !== JSON.stringify(b[1])) return false;
+    if (a[2] !== b[2] || (a[2] !== null && typeof a[2] !== "number")) return false;
+    var keys = perTraceArrays(a[0]);
+    return keys !== null && JSON.stringify(keys) === JSON.stringify(perTraceArrays(b[0]));
+  }
+
+  // Folds next into held: extend appends and keeps the last maxPoints, prepend puts the
+  // newer points in front and keeps the first maxPoints, as Plotly does to the trace.
+  function merge(held, next) {
+    var cap = held.args[2];
+    var extend = held.method === "extendTraces";
+    Object.keys(held.args[0]).forEach(function (key) {
+      var older = held.args[0][key], newer = next.args[0][key];
+      held.args[0][key] = older.map(function (points, i) {
+        var joined = extend ? points.concat(newer[i]) : newer[i].concat(points);
+        if (cap === null || joined.length <= cap) return joined;
+        return extend ? joined.slice(joined.length - cap) : joined.slice(0, cap);
+      });
+    });
+  }
+
+  function hold(el, update) {
+    var queue = el._shinyPlotlyPending || (el._shinyPlotlyPending = []);
+    var held = { method: update.method, args: JSON.parse(update.args) };
+    var last = queue[queue.length - 1];
+    if (last && mergeable(last, held)) merge(last, held);
+    else queue.push(held);
+  }
 
   function applyUpdate(gd, update) {
-    var args = JSON.parse(update.args);
+    var args = update.args;
     if (update.method === "extendTraces" || update.method === "prependTraces") {
       // Both want an array of indices and no maxPoints rather than null.
       if (args[1] === null) args[1] = gd.data.map(function (_, i) { return i; });
@@ -369,10 +429,10 @@
     }
     var gd = graphDiv(el);
     if (gd && gd._shinyPlotlyDrawn) {
-      applyUpdate(gd, update);
+      applyUpdate(gd, { method: update.method, args: JSON.parse(update.args) });
       return;
     }
-    (el._shinyPlotlyPending || (el._shinyPlotlyPending = [])).push(update);
+    hold(el, update);
   }
 
   function register() {

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

@@ -2,6 +2,7 @@
 
 import asyncio
 import json
+from collections.abc import Awaitable, Callable
 from typing import Any
 
 import numpy as np
@@ -128,6 +129,7 @@ def make_events_app() -> App:
         output_plotly("sel", height="300px", width="500px"),
         output_plotly("dense", height="300px", width="500px"),
         output_plotly("leg", height="300px", width="500px"),
+        output_plotly("heat", height="300px", width="500px"),
         ui.output_text("click_out"),
         ui.output_text("click_count"),
         ui.output_text("hover_out"),
@@ -137,6 +139,7 @@ def make_events_app() -> App:
         ui.output_text("legendclick_out"),
         ui.output_text("legenddbl_out"),
         ui.output_text("dbl_out"),
+        ui.output_text("heat_out"),
         events_mod_ui("m"),
     )
 
@@ -166,6 +169,14 @@ def make_events_app() -> App:
                 [go.Scatter(y=[1, 2], name="alpha"), go.Scatter(y=[2, 1], name="beta")]
             )
 
+        @render_plotly(events="click")
+        def heat():
+            # A cell is addressed by [row, column], and its customdata is itself a list:
+            # 3-D numpy customdata, which travels as bdata.
+            return go.Figure(
+                go.Heatmap(z=[[1, 2], [3, 4]], customdata=np.arange(8).reshape(2, 2, 2))
+            )
+
         @reactive.effect
         @reactive.event(input.fig_click)
         def _count():
@@ -209,6 +220,10 @@ def make_events_app() -> App:
         def dbl_out():
             return as_text(input.leg_doubleclick()) if input.leg_doubleclick.is_set() else "-"
 
+        @render.text
+        def heat_out():
+            return as_text(input.heat_click()) if input.heat_click.is_set() else "-"
+
         events_mod_server("m")
 
     return App(app_ui, server)
@@ -518,3 +533,112 @@ def make_scoped_theme_app() -> App:
             return bars(3)
 
     return App(app_ui, server)
+
+
+def make_post_script_app() -> App:
+    """A chart whose post_script throws, with every feature that runs after it switched on."""
+    app_ui = ui.page_fluid(
+        ui.input_action_button("grow", "grow"),
+        output_plotly("fig", height="300px", width="500px"),
+        ui.output_text("click_out"),
+    )
+
+    def server(input: Inputs, output: Outputs, session: Session):
+        @render_plotly(
+            post_script="throw new Error('post_script failed');", events="click", theme="auto"
+        )
+        def fig():
+            return bars(3)
+
+        @reactive.effect
+        @reactive.event(input.grow)
+        async def _grow():
+            await extend_traces("fig", {"x": [["x3"]], "y": [[4]]}, 0)
+
+        @render.text
+        def click_out():
+            return as_text(input.fig_click()) if input.fig_click.is_set() else "-"
+
+    return App(app_ui, server)
+
+
+def burst_steps() -> list[Callable[[str], Awaitable[None]]]:
+    """
+    Every kind of held update, each a call taking the output id.
+
+    Runs of extends and prepends that can merge, broken up by what must not merge with
+    them: a relayout, a restyle, a change of max_points, other data keys, other indices.
+    """
+    steps: list[Callable[[str], Awaitable[None]]] = []
+    for i in range(20):
+        steps.append(
+            lambda id, i=i: extend_traces(id, {"x": [[f"e{i}"]], "y": [[i]]}, 0, max_points=10)
+        )
+    # Each run below differs from the one before it in one thing only.
+    for i in range(6):  # the cap
+        steps.append(
+            lambda id, i=i: extend_traces(id, {"x": [[f"f{i}"]], "y": [[100 + i]]}, 0, max_points=4)
+        )
+    for i in range(3):  # the attributes
+        steps.append(lambda id, i=i: extend_traces(id, {"y": [[200 + i]]}, 0, max_points=4))
+    steps.append(lambda id: relayout(id, {"title.text": "mid"}))
+    for i in range(8):
+        steps.append(lambda id, i=i: extend_traces(id, {"y": [[i], [-i]]}, [1, 2]))
+    for i in range(4):  # the indices
+        steps.append(lambda id, i=i: extend_traces(id, {"y": [[10 + i], [-10 - i]]}, [2, 1]))
+    for i in range(10):
+        steps.append(
+            lambda id, i=i: prepend_traces(id, {"y": [[-100 - i, -200 - i]]}, 1, max_points=15)
+        )
+    steps.append(lambda id: restyle(id, {"opacity": [0.5]}, [2]))
+    for i in range(3):
+        steps.append(lambda id, i=i: prepend_traces(id, {"y": [[i]]}, [2]))
+    return steps
+
+
+def make_held_app() -> App:
+    """One chart drawn, one in a hidden tab, and a button sending both the same burst."""
+    app_ui = ui.page_fluid(
+        ui.input_action_button("burst", "burst"),
+        ui.output_text("sent"),
+        output_plotly("shown", height="200px"),
+        ui.navset_tab(
+            ui.nav_panel("Empty", "nothing here"),
+            ui.nav_panel("Held", output_plotly("held", height="200px")),
+            id="tab",
+        ),
+    )
+
+    def figure() -> go.Figure:
+        return go.Figure(
+            [
+                go.Scatter(x=["a", "b"], y=[1, 2]),
+                go.Scatter(y=[5, 6, 7]),
+                go.Scatter(y=[8]),
+            ]
+        )
+
+    def server(input: Inputs, output: Outputs, session: Session):
+        @render_plotly
+        def shown():
+            return figure()
+
+        @render_plotly
+        def held():
+            return figure()
+
+        done = reactive.value(0)
+
+        @reactive.effect
+        @reactive.event(input.burst)
+        async def _burst():
+            for step in burst_steps():
+                await step("shown")
+                await step("held")
+            done.set(done() + 1)
+
+        @render.text
+        def sent():
+            return f"sent {done()}"
+
+    return App(app_ui, server)

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

@@ -17,10 +17,12 @@ from .apps import (
     make_app,
     make_dark_app,
     make_events_app,
+    make_held_app,
     make_hidden_app,
     make_lazy_app,
     make_live_app,
     make_own_mode_app,
+    make_post_script_app,
     make_scoped_theme_app,
     make_theme_app,
 )
@@ -48,6 +50,8 @@ def server_url() -> Iterator[str]:
             Mount("/scoped", app=make_scoped_theme_app()),
             Mount("/own-mode", app=make_own_mode_app()),
             Mount("/hidden", app=make_hidden_app()),
+            Mount("/post-script", app=make_post_script_app()),
+            Mount("/held", app=make_held_app()),
             Mount("/stream", app=load_example("streaming_app.py")),
             Mount("/demo", app=load_example("shinylive/app.py")),
             Mount("/", app=make_app()),

{shiny_plotly-0.4.0 → shiny_plotly-0.4.1}/tests/browser/test_events.py

@@ -17,6 +17,7 @@ def app(page: Page, server_url: str, errors: list[str]) -> Iterator[Page]:
     expect(page.locator(f"#fig {SVG}").first).to_be_visible()
     expect(page.locator(f"#sel {SVG}").first).to_be_visible()
     expect(page.locator(f"#leg {SVG}").first).to_be_visible()
+    expect(page.locator(f"#heat {SVG}").first).to_be_visible()
     expect(page.locator(f"#m-fig {SVG}").first).to_be_visible()
     expect(page.locator("#click_out")).to_have_text("-")
     yield page
@@ -51,6 +52,24 @@ def test_click_hands_the_point_to_the_input_with_plain_customdata(app: Page):
     assert not {"data", "fullData", "xaxis", "yaxis"} & point.keys(), "no circular plotly objects"
 
 
+def test_a_heatmap_click_hands_back_the_cell_address_and_its_customdata(app: Page):
+    """A cell's pointNumber is [row, column]; its customdata is looked up by both."""
+    drag_area = app.locator("#heat .nsewdrag")
+    drag_area.scroll_into_view_if_needed()
+    box = drag_area.bounding_box()
+    assert box is not None
+    # The top left cell: row 1 (rows count up from the bottom), column 0.
+    app.mouse.click(box["x"] + box["width"] * 0.25, box["y"] + box["height"] * 0.25)
+
+    wait_for_change(app, "heat_out", "-")
+    event = received(app, "heat_out")
+    assert isinstance(event, dict)
+    point = event["points"][0]
+    assert point["z"] == 3
+    assert point["pointNumber"] == [1, 0]
+    assert point["customdata"] == [4, 5], "the cell's own customdata, as a plain list"
+
+
 def test_clicking_the_same_point_twice_fires_twice(app: Page):
     bar(app, "fig", 0).click(force=True)
     expect(app.locator("#click_count")).to_have_text("1")

{shiny_plotly-0.4.0 → shiny_plotly-0.4.1}/tests/browser/test_update.py

@@ -200,3 +200,64 @@ def test_a_fixed_height_output_on_a_plain_page_keeps_the_graph_inside_it(app: Pa
     assert output["height"] == 200
     assert graph["height"] == 200
     assert graph["width"] == 300
+
+
+def test_a_throwing_post_script_leaves_updates_theming_and_events_working(
+    page: Page, server_url: str, errors: list[str]
+):
+    """The script's error is reported; everything the chart does after its draw still runs."""
+    page.goto(server_url + "/post-script/")
+    expect(page.locator(f"#fig {SVG}").first).to_be_visible()
+
+    page.click("#grow")
+    wait_for(page, trace_y("fig", 0), [1, 2, 3, 4])
+
+    font = f"{gd('fig')}._fullLayout.font.color"
+    light = value(page, font)
+    page.evaluate("() => document.documentElement.setAttribute('data-bs-theme', 'dark')")
+    page.wait_for_function(f"() => {font} !== {json.dumps(light)}")
+
+    page.locator("#fig .bars .point").first.click(force=True)
+    expect(page.locator("#click_out")).not_to_have_text("-")
+
+    assert len(errors) == 1 and "post_script failed" in errors[0], errors
+
+
+HELD_STATE = """
+(() => {
+  const g = document.getElementById("%s-plotly");
+  return {
+    data: g.data.map((t) => ({x: t.x ? Array.from(t.x) : null, y: Array.from(t.y),
+                              opacity: t.opacity === undefined ? null : t.opacity})),
+    title: (g.layout.title || {}).text,
+  };
+})()
+"""
+
+
+def test_updates_held_for_a_hidden_output_are_merged_and_land_as_if_applied_one_by_one(
+    page: Page, server_url: str, errors: list[str]
+):
+    """A hidden output folds each run of extends or prepends into one, to the same result."""
+    page.goto(server_url + "/held/")
+    expect(page.locator(f"#shown {SVG}").first).to_be_visible()
+
+    page.click("#burst")
+    expect(page.locator("#sent")).to_have_text("sent 1")
+
+    # 57 extends and prepends in seven runs, plus a relayout and a restyle: nine.
+    assert value(page, "document.getElementById('held')._shinyPlotlyPending.length") == 9
+    # Held points are cut to the cap as they merge, so a stream held for an hour keeps a
+    # window of points, not an hour of them.
+    first_run = "document.getElementById('held')._shinyPlotlyPending[0].args[0]"
+    assert value(page, f"{first_run}.y[0].length") == 10
+
+    page.get_by_role("tab", name="Held").click()
+    expect(page.locator(f"#held {SVG}").first).to_be_visible()
+    wait_for(page, "document.getElementById('held')._shinyPlotlyPending", None)
+
+    applied_one_by_one = value(page, HELD_STATE % "shown")
+    assert isinstance(applied_one_by_one, dict)
+    assert value(page, HELD_STATE % "held") == applied_one_by_one
+    assert applied_one_by_one["title"] == "mid"
+    assert errors == []

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

@@ -278,17 +278,85 @@ def test_under_pyodide_the_route_is_skipped_and_the_app_still_renders(monkeypatc
     assert _serve.ROUTE_NAME not in names
 
 
-def test_bundle_before_compression_has_finished_is_served_raw_and_cacheable():
-    """The route never waits for the background compression; it serves what it has."""
+def test_bundle_before_compression_has_finished_is_served_raw_and_revalidated():
+    """
+    The route never waits for the background compression; it serves what it has, but a
+    client that will be offered a compressed encoding must not keep the raw file for a year.
+    """
     pending = _serve.CompressedBundle(_serve.bundle().path)
 
     resp = _serve.response_for(pending, accept_encoding="gzip, br", if_none_match=None)
 
     assert resp.status_code == 200
     assert "content-encoding" not in resp.headers
+    assert resp.headers["cache-control"] == "no-cache"
+    assert resp.headers["etag"] == pending.etag(None)
+
+
+def test_a_client_revalidating_the_early_raw_file_gets_the_compressed_one_once_ready(tmp_path):
+    bundle = stub_bundle(tmp_path)
+    early = _serve.response_for(bundle, accept_encoding="br, gzip", if_none_match=None)
+
+    bundle.start()
+    assert bundle.wait(timeout=30)
+    later = _serve.response_for(
+        bundle, accept_encoding="br, gzip", if_none_match=early.headers["etag"]
+    )
+
+    assert later.status_code == 200, "the raw ETag no longer matches: the body is new"
+    assert later.headers["content-encoding"] == "br"
+    assert later.headers["cache-control"] == "public, max-age=31536000, immutable"
+
+
+def test_raw_is_final_for_a_client_that_takes_no_encoding_even_before_compression():
+    pending = _serve.CompressedBundle(_serve.bundle().path)
+
+    resp = _serve.response_for(pending, accept_encoding="identity", if_none_match=None)
+
     assert resp.headers["cache-control"] == "public, max-age=31536000, immutable"
 
 
+def test_the_encoding_served_mid_compression_is_final_when_it_is_the_one_preferred(tmp_path):
+    """brotli is produced first; a client preferring it need not wait for gzip too."""
+    bundle = stub_bundle(tmp_path)
+    bundle.encodings["br"] = brotli.compress(bundle.path.read_bytes())
+
+    preferred = _serve.response_for(bundle, accept_encoding="gzip, br", if_none_match=None)
+    gzip_only = _serve.response_for(bundle, accept_encoding="gzip", if_none_match=None)
+
+    assert preferred.headers["content-encoding"] == "br"
+    assert preferred.headers["cache-control"] == "public, max-age=31536000, immutable"
+    assert "content-encoding" not in gzip_only.headers
+    assert gzip_only.headers["cache-control"] == "no-cache"
+
+
+@pytest.mark.parametrize(
+    "if_none_match",
+    ["*", "W/{etag}", '"other", {etag}', '"other",W/{etag}', " {etag} "],
+)
+def test_revalidation_matches_the_way_rfc_9110_compares_tags(client, if_none_match):
+    """If-None-Match compares weakly, and ``*`` matches any current representation."""
+    etag = client.get(BUNDLE_URL, headers={"Accept-Encoding": "gzip"}).headers["etag"]
+
+    resp = client.get(
+        BUNDLE_URL,
+        headers={"Accept-Encoding": "gzip", "If-None-Match": if_none_match.format(etag=etag)},
+    )
+
+    assert resp.status_code == 304
+    assert resp.headers["etag"] == etag
+
+
+@pytest.mark.parametrize("if_none_match", ['"other"', 'W/"other"', ""])
+def test_revalidation_with_a_tag_that_does_not_match_gets_the_body(client, if_none_match):
+    resp = client.get(
+        BUNDLE_URL, headers={"Accept-Encoding": "gzip", "If-None-Match": if_none_match}
+    )
+
+    assert resp.status_code == 200
+    assert resp.content == RAW
+
+
 def test_gzip_body_is_the_bundle():
     bundle = _serve.bundle()
     assert bundle.wait(timeout=30)
@@ -309,6 +377,11 @@ def test_gzip_body_is_the_bundle():
         ("gzip, br;q=0.0", ["gzip"]),
         ("gzip, br;q=0.000", ["gzip"]),
         ("*;q=0", []),
+        ("gzip;q=0, *", ["br"]),
+        ("*, gzip;q=0", ["br"]),
+        ("br;q=0, *;q=1", ["gzip"]),
+        ("*;q=0, gzip", ["gzip"]),
+        ("br;level=5;q=0, gzip", ["gzip"]),
         ("identity", []),
         ("deflate, zstd", []),
         ("br;q=none-of-that", ["br"]),

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

@@ -140,6 +140,17 @@ def test_max_event_points_must_be_a_positive_int_or_none(bad):
             return bar()
 
 
+def test_max_event_points_takes_a_numpy_integer_as_a_python_int():
+    np = pytest.importorskip("numpy")
+
+    @render_plotly(max_event_points=np.int64(500))
+    def sales():
+        return bar()
+
+    assert sales.max_event_points == 500
+    assert type(sales.max_event_points) is int
+
+
 def test_theme_auto_is_the_plotly_light_dark_pair():
     @render_plotly(theme="auto")
     def sales():

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

@@ -64,13 +64,16 @@ def make_app() -> App:
             await prepend_traces("fig", {"y": [[0]]}, indices=0, max_points=4)
             await update("fig", restyle={"marker.color": "red"}, relayout={"title.text": "u"})
             await update("fig", restyle={"opacity": [0.5]}, indices=[0])
+            # What a dataframe or an event hands back: numpy integers, not Python ints.
+            await extend_traces("fig", {"y": [[5]]}, indices=np.int64(0), max_points=np.int32(3))
+            await restyle("fig", {"opacity": [1]}, indices=np.array([0]))
 
         mod_server("m")
 
     return App(app_ui, server)
 
 
-MESSAGE_COUNT = 12
+MESSAGE_COUNT = 14
 
 
 def custom_messages(client: TestClient) -> list[dict]:
@@ -149,8 +152,15 @@ def test_update_sends_restyle_and_relayout_in_one_call(messages):
     assert json.loads(restyle_only["args"]) == [{"opacity": [0.5]}, {}, [0]]
 
 
+def test_numpy_integers_are_taken_as_indices_and_max_points(messages):
+    extend, restyle_np = messages[11], messages[12]
+
+    assert json.loads(extend["args"]) == [{"y": [[5]]}, [0], 3]
+    assert json.loads(restyle_np["args"]) == [{"opacity": [1]}, [0]]
+
+
 def test_ids_are_namespaced_inside_a_module(messages):
-    msg = messages[11]
+    msg = messages[13]
 
     assert msg["id"] == "m-fig"
     assert json.loads(msg["args"]) == [{"title.text": "from the module"}]
@@ -169,6 +179,25 @@ def test_prepend_traces_max_points_must_be_a_positive_integer(bad):
         run(prepend_traces("fig", {"y": [[1]]}, max_points=bad))
 
 
+@pytest.mark.parametrize("bad", [0.5, "0", True, None])
+def test_indices_must_be_integers(bad):
+    """Caught here, where the call is, rather than as a plotly.js error in the browser."""
+    with pytest.raises(ValueError, match="indices"):
+        run(restyle("fig", {"opacity": 1}, indices=[0, bad]))
+    with pytest.raises(ValueError, match="indices"):
+        run(delete_traces("fig", bad if bad is not None else 1.5))  # type: ignore[arg-type]
+
+
+def test_numpy_non_integers_are_refused_like_their_python_counterparts():
+    np = pytest.importorskip("numpy")
+    with pytest.raises(ValueError, match="max_points"):
+        run(extend_traces("fig", {"y": [[1]]}, max_points=np.float64(3)))
+    with pytest.raises(ValueError, match="max_points"):
+        run(extend_traces("fig", {"y": [[1]]}, max_points=np.bool_(True)))
+    with pytest.raises(ValueError, match="indices"):
+        run(restyle("fig", {"opacity": 1}, indices=np.array([0.5])))
+
+
 def test_add_traces_requires_at_least_one_trace():
     with pytest.raises(ValueError, match="trace"):
         run(add_traces("fig", []))