shiny-plotly 0.4.2__tar.gz → 0.4.3__tar.gz

{shiny_plotly-0.4.2 → shiny_plotly-0.4.3}/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.3](https://github.com/rvben/shiny-plotly/compare/v0.4.2...v0.4.3) - 2026-09-25
+
+### Fixed
+
+- `extend_traces` and `prepend_traces` work on traces built from numpy arrays or pandas columns with plotly 6. plotly 6 sends those arrays in binary form, which `Plotly.extendTraces` refuses ("cannot extend missing or non-array attribute"), so the update failed in the browser and the chart stopped updating. The new points now land as their own values, even ones the original array's type could not hold, such as 300 or 0.5 added to `np.arange(3)`. This covers held updates and 2-D arrays such as a heatmap's `z`.
+- `extend_traces` and `prepend_traces` are typed to take numpy arrays as the per-trace values (`{"y": [np.array([...])]}`), which they always accepted at runtime.
+
 ## [0.4.2](https://github.com/rvben/shiny-plotly/compare/v0.4.1...v0.4.2) - 2026-09-25
 
 ### Fixed

{shiny_plotly-0.4.2 → shiny_plotly-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: shiny-plotly
-Version: 0.4.2
+Version: 0.4.3
 Summary: Render plotly figures in Shiny for Python with plain plotly.js, without the shinywidgets layer.
 Project-URL: Homepage, https://github.com/rvben/shiny-plotly
 Project-URL: Repository, https://github.com/rvben/shiny-plotly

{shiny_plotly-0.4.2 → shiny_plotly-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "shiny-plotly"
-version = "0.4.2"
+version = "0.4.3"
 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.2 → shiny_plotly-0.4.3}/src/shiny_plotly/_update.py

@@ -85,7 +85,7 @@ async def _send(id: str, method: str, args: Sequence[Any], session: Session | No
 
 async def extend_traces(
     id: str,
-    data: Mapping[str, Sequence[Sequence[Any]]],
+    data: Mapping[str, Sequence[Any]],
     indices: Indices = None,
     *,
     max_points: int | None = None,
@@ -108,7 +108,7 @@ async def extend_traces(
 
 async def prepend_traces(
     id: str,
-    data: Mapping[str, Sequence[Sequence[Any]]],
+    data: Mapping[str, Sequence[Any]],
     indices: Indices = None,
     *,
     max_points: int | None = None,

{shiny_plotly-0.4.2 → shiny_plotly-0.4.3}/src/shiny_plotly/www/shiny-plotly.js

@@ -403,12 +403,69 @@
     else queue.push(held);
   }
 
+  // plotly 6 sends a figure's numpy arrays as binary, {dtype, bdata[, shape]}, which
+  // plotly.js keeps on the trace as sent and draws from a typed array.
+  var TYPED_ARRAYS = {
+    i1: Int8Array, u1: Uint8Array, u1c: Uint8ClampedArray, i2: Int16Array, u2: Uint16Array,
+    i4: Int32Array, u4: Uint32Array, f4: Float32Array, f8: Float64Array
+  };
+
+  function isBinary(value) {
+    return value !== null && typeof value === "object" && typeof value.bdata === "string" &&
+      TYPED_ARRAYS.hasOwnProperty(value.dtype);
+  }
+
+  // The values of a 1-D binary array as a typed array, of a 2-D one as rows of them; null
+  // for more dimensions, which no update extends.
+  function decodeBinary(spec) {
+    var shape = spec.shape ? String(spec.shape).split(",").map(Number) : [];
+    if (shape.length > 2) return null;
+    var bytes = window.atob(spec.bdata);
+    var buffer = new Uint8Array(bytes.length);
+    for (var i = 0; i < bytes.length; i++) buffer[i] = bytes.charCodeAt(i);
+    var flat = new TYPED_ARRAYS[spec.dtype](buffer.buffer);
+    if (shape.length < 2) return flat;
+    var rows = [];
+    for (var r = 0; r < shape[0]; r++) rows.push(flat.subarray(r * shape[1], (r + 1) * shape[1]));
+    return rows;
+  }
+
+  // An array of values, or of rows of values, as plain arrays, whatever form it came in;
+  // anything else as it is.
+  function plainArray(value) {
+    var decoded = isBinary(value) ? decodeBinary(value) : value;
+    if (decoded === null) return value;
+    if (ArrayBuffer.isView(decoded)) return Array.prototype.slice.call(decoded);
+    if (Array.isArray(decoded)) {
+      return decoded.map(function (v) { return ArrayBuffer.isView(v) ? plainArray(v) : v; });
+    }
+    return decoded;
+  }
+
+  // extendTraces and prependTraces join plain arrays to plain arrays and a typed array only
+  // to one of its own type, so a trace built from numpy (an int8 np.arange, say) could take
+  // no new points at all. The attributes an extend or prepend reaches become plain arrays
+  // of their values first, as if the figure had been built from lists; a plain array holds
+  // a 300 or a 0.5 where an int8 array would wrap or truncate them.
+  function plainTargets(gd, data, indices) {
+    Object.keys(data).forEach(function (key) {
+      var path = key.split(".");
+      indices.forEach(function (index) {
+        var node = gd.data[index < 0 ? gd.data.length + index : index];
+        for (var i = 0; node && i < path.length - 1; i++) node = node[path[i]];
+        var last = path[path.length - 1];
+        if (node && node[last] !== undefined) node[last] = plainArray(node[last]);
+      });
+    });
+  }
+
   function applyUpdate(gd, update) {
     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; });
       if (args[2] === null) args.length = 2;
+      plainTargets(gd, args[0], args[1]);
     }
     return window.Plotly[update.method].apply(window.Plotly, [gd].concat(args));
   }

{shiny_plotly-0.4.2 → shiny_plotly-0.4.3}/tests/browser/apps.py

@@ -642,3 +642,108 @@ def make_held_app() -> App:
             return f"sent {done()}"
 
     return App(app_ui, server)
+
+
+def make_arrays_app() -> App:
+    """
+    Figures built from numpy, which plotly 6 sends as binary, updated in place.
+
+    Each button extends or prepends one output, with plain lists and with numpy arrays of
+    other dtypes than the figure's: the int8 a small ``np.arange`` travels as must take a
+    300 and a 0.5, and no update may reach the figure in any other form than its values.
+    """
+    app_ui = ui.page_fluid(
+        ui.input_action_button("extend_plain", "extend plain"),
+        ui.input_action_button("extend_capped", "extend capped"),
+        ui.input_action_button("prepend", "prepend"),
+        ui.input_action_button("extend_numpy", "extend numpy"),
+        ui.input_action_button("replace", "replace"),
+        ui.input_action_button("burst", "burst"),
+        ui.input_action_button("add_row", "add row"),
+        ui.output_text("bursts"),
+        output_plotly("ints", height="200px", width="400px"),
+        output_plotly("floats", height="200px", width="400px"),
+        output_plotly("two", height="200px", width="400px"),
+        output_plotly("grid", height="200px", width="400px"),
+        ui.navset_tab(
+            ui.nav_panel("Empty", "nothing here"),
+            ui.nav_panel("Held", output_plotly("held", height="200px", width="400px")),
+            id="tab",
+        ),
+    )
+
+    def server(input: Inputs, output: Outputs, session: Session):
+        @render_plotly
+        def ints():
+            return go.Figure(go.Scatter(x=np.arange(3), y=np.arange(3)))
+
+        @render_plotly
+        def floats():
+            return go.Figure(go.Scatter(x=np.linspace(0, 1, 3), y=np.array([0.5, 1.5, 2.5])))
+
+        @render_plotly
+        def two():
+            return go.Figure([go.Scatter(y=np.arange(3)), go.Scatter(y=[5, 6])])
+
+        @render_plotly
+        def held():
+            return go.Figure(go.Scatter(y=np.arange(3)))
+
+        @render_plotly
+        def grid():
+            # A 2-D array travels as one binary block with its shape.
+            return go.Figure(go.Heatmap(z=np.arange(4).reshape(2, 2)))
+
+        @reactive.effect
+        @reactive.event(input.add_row)
+        async def _add_row():
+            await extend_traces("grid", {"z": [[[40, 50.5]]]})
+
+        @reactive.effect
+        @reactive.event(input.extend_plain)
+        async def _extend_plain():
+            await extend_traces("ints", {"x": [[3, 4]], "y": [[300, 0.5]]})
+
+        @reactive.effect
+        @reactive.event(input.extend_capped)
+        async def _extend_capped():
+            await extend_traces("floats", {"x": [[2]], "y": [[3.5]]}, max_points=3)
+
+        @reactive.effect
+        @reactive.event(input.prepend)
+        async def _prepend():
+            await prepend_traces("two", {"y": [[-1], [4]]}, max_points=3)
+
+        @reactive.effect
+        @reactive.event(input.extend_numpy)
+        async def _extend_numpy():
+            await extend_traces(
+                "ints",
+                {
+                    "x": [np.array([5, 6, 7], dtype=np.uint8)],
+                    "y": [np.array([2**40, -1, 7], dtype=np.int64)],
+                },
+            )
+            await extend_traces("floats", {"y": [np.array([0.25], dtype=np.float32)]})
+
+        @reactive.effect
+        @reactive.event(input.replace)
+        async def _replace():
+            await restyle("floats", {"y": [np.array([9.5, 10.5])]})
+            await add_traces("two", go.Scatter(y=np.array([-3, 3], dtype=np.int16)))
+            await update("two", restyle={"marker.size": [np.array([11.0, 12.0])]}, indices=[1])
+
+        sent = reactive.value(0)
+
+        @reactive.effect
+        @reactive.event(input.burst)
+        async def _burst():
+            for i in range(5):
+                await extend_traces("held", {"y": [np.array([10.0 * i + 0.5])]}, max_points=6)
+            sent.set(sent() + 1)
+
+        @render.text
+        def bursts():
+            return f"bursts {sent()}"
+
+    return App(app_ui, server)

{shiny_plotly-0.4.2 → shiny_plotly-0.4.3}/tests/browser/conftest.py

@@ -15,6 +15,7 @@ from starlette.routing import Mount
 
 from .apps import (
     make_app,
+    make_arrays_app,
     make_dark_app,
     make_events_app,
     make_held_app,
@@ -52,6 +53,7 @@ def server_url() -> Iterator[str]:
             Mount("/hidden", app=make_hidden_app()),
             Mount("/post-script", app=make_post_script_app()),
             Mount("/held", app=make_held_app()),
+            Mount("/arrays", app=make_arrays_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.3/tests/browser/test_arrays.py

@@ -0,0 +1,92 @@
+"""In-place updates to figures built from numpy arrays, which plotly 6 sends as binary."""
+
+import json
+from collections.abc import Iterator
+
+import pytest
+from playwright.sync_api import Page, expect
+
+pytestmark = pytest.mark.browser
+
+SVG = "svg.main-svg"
+
+
+@pytest.fixture
+def app(page: Page, server_url: str, errors: list[str]) -> Iterator[Page]:
+    page.goto(server_url + "/arrays/")
+    for output_id in ("ints", "floats", "two", "grid"):
+        expect(page.locator(f"#{output_id} {SVG}").first).to_be_visible()
+    yield page
+    assert errors == []
+
+
+def drawn(output_id: str, index: int, attribute: str) -> str:
+    """The values plotly draws for one attribute of one trace, as a plain list."""
+    trace = f"document.getElementById('{output_id}-plotly')._fullData[{index}]"
+    return f"Array.from({trace}.{attribute})"
+
+
+def wait_for(page: Page, expression: str, expected: object) -> None:
+    want = json.dumps(json.dumps(expected, separators=(",", ":")))
+    page.wait_for_function(f"() => JSON.stringify({expression}) === {want}")
+
+
+def points(page: Page, output_id: str, index: int) -> int:
+    return page.locator(f"#{output_id} .scatterlayer .trace").nth(index).locator(".point").count()
+
+
+def test_a_trace_built_from_numpy_takes_points_of_any_value(app: Page):
+    """np.arange(3) travels as int8; a 300 and a 0.5 must still land as themselves."""
+    app.click("#extend_plain")
+
+    wait_for(app, drawn("ints", 0, "y"), [0, 1, 2, 300, 0.5])
+    assert app.evaluate(f"() => {drawn('ints', 0, 'x')}") == [0, 1, 2, 3, 4]
+    assert points(app, "ints", 0) == 5, "the drawing follows the data"
+
+
+def test_extending_a_numpy_trace_keeps_the_rolling_window(app: Page):
+    app.click("#extend_capped")
+
+    wait_for(app, drawn("floats", 0, "y"), [1.5, 2.5, 3.5])
+    assert app.evaluate(f"() => {drawn('floats', 0, 'x')}") == [0.5, 1, 2]
+
+
+def test_prepending_reaches_numpy_and_list_traces_alike(app: Page):
+    app.click("#prepend")
+
+    wait_for(app, drawn("two", 0, "y"), [-1, 0, 1])
+    wait_for(app, drawn("two", 1, "y"), [4, 5, 6])
+
+
+def test_numpy_points_of_any_dtype_land_as_their_values(app: Page):
+    """uint8, an int64 past int32 and a float32, into int8 and float64 traces."""
+    app.click("#extend_numpy")
+
+    wait_for(app, drawn("ints", 0, "y"), [0, 1, 2, 2**40, -1, 7])
+    assert app.evaluate(f"() => {drawn('ints', 0, 'x')}") == [0, 1, 2, 5, 6, 7]
+    wait_for(app, drawn("floats", 0, "y"), [0.5, 1.5, 2.5, 0.25])
+
+
+def test_numpy_arrays_in_restyle_add_traces_and_update_land_as_their_values(app: Page):
+    app.click("#replace")
+
+    wait_for(app, drawn("floats", 0, "y"), [9.5, 10.5])
+    wait_for(app, drawn("two", 2, "y"), [-3, 3])
+    wait_for(app, drawn("two", 1, "marker.size"), [11, 12])
+
+
+def test_updates_held_for_a_hidden_numpy_figure_apply_once_it_is_drawn(app: Page):
+    app.click("#burst")
+    expect(app.locator("#bursts")).to_have_text("bursts 1")
+
+    app.get_by_role("tab", name="Held").click()
+    expect(app.locator(f"#held {SVG}").first).to_be_visible()
+
+    wait_for(app, drawn("held", 0, "y"), [2, 0.5, 10.5, 20.5, 30.5, 40.5])
+
+
+def test_a_heatmap_built_from_a_2d_array_takes_a_new_row(app: Page):
+    app.click("#add_row")
+
+    rows = "document.getElementById('grid-plotly')._fullData[0].z.map((r) => Array.from(r))"
+    wait_for(app, rows, [[0, 1], [2, 3], [40, 50.5]])