anyplotlib 0.7.0__tar.gz → 0.7.2__tar.gz

{anyplotlib-0.7.0 → anyplotlib-0.7.2}/CHANGELOG.rst

@@ -10,6 +10,46 @@ Fragment files in ``upcoming_changes/`` are assembled into this file by
 
 .. towncrier release notes start
 
+0.7.2 (2026-08-03)
+==================
+
+Bug Fixes
+---------
+
+- ``Plot2D.set_overlay_mask`` now works in TILE mode. The renderer sizes the mask
+  against ``base_width || image_width`` -- the tile overview grid -- but tile mode
+  sets ``image_width`` to the full native frame, so the shape check accepted only
+  the one shape the renderer silently discards (``maskCache = null``, no error) and
+  rejected the one that actually renders. On a 4096x4096 tiled plot neither a
+  1024x1024 nor a 4096x4096 mask could be drawn: the first raised ``ValueError``,
+  the second encoded 22.4 MB the renderer dropped. Both shapes are now accepted and
+  a full-resolution mask is reduced to the overview grid with a block ANY -- never
+  a subsample, so an object a few pixels across cannot vanish into a skipped
+  sample.
+
+
+0.7.1 (2026-08-02)
+==================
+
+Bug Fixes
+---------
+
+- Fixed ``save_html`` / ``to_html`` / ``figure_state`` dropping image pixels
+  under the Electron binary transport: the snapshot kept the ``"\x00bin:"``
+  change-tokens whose bytes only ever ride the live PLOTBIN channel, so an
+  overlay added with :meth:`~anyplotlib.Plot2D.add_layer` did not render in the
+  exported document. (`#52 <https://github.com/CSSFrancis/anyplotlib/pull/52>`_)
+
+
+Documentation
+-------------
+
+- Fixed the documentation build failing on
+  :class:`~anyplotlib.keys.KeyOverlay`, whose ``id`` and ``name`` were described
+  both in the class docstring and by the properties themselves — a duplicate
+  object description, which the build treats as an error. (`#53 <https://github.com/CSSFrancis/anyplotlib/pull/53>`_)
+
+
 0.7.0 (2026-07-31)
 ==================
 

{anyplotlib-0.7.0 → anyplotlib-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anyplotlib
-Version: 0.7.0
+Version: 0.7.2
 Summary: A plotting library using python, javascript and anywidget for performant in browser plotting.
 Project-URL: Homepage, https://cssfrancis.github.io/anyplotlib/
 Project-URL: Repository, https://github.com/CSSFrancis/anyplotlib

{anyplotlib-0.7.0 → anyplotlib-0.7.2}/anyplotlib/figure/_figure.py

@@ -300,7 +300,7 @@ class Figure(anywidget.AnyWidget, _EventMixin):
         self._push(pid)
         self._push_layout()
 
-    def _push(self, panel_id: str) -> None:
+    def _push(self, panel_id: str, *, resolve_pixels: bool = False) -> None:
         """Serialise one panel and write to its trait.
 
         Inside a :meth:`batch` block, pushes are coalesced: each panel is
@@ -309,6 +309,14 @@ class Figure(anywidget.AnyWidget, _EventMixin):
         many per-frame pushes of a linked-view update (set_data + set_title +
         widget moves on the same panel) into one serialise/transfer per panel
         — the dominant cost over a Pyodide comm boundary.
+
+        Parameters
+        ----------
+        resolve_pixels : bool, optional
+            Force pixel change-tokens to be materialised to inline base64 even
+            when the binary transport is live.  Set by :meth:`_sync_for_export`
+            because a snapshot has no PLOTBIN channel to carry the bytes; see
+            the token discussion below.
         """
         plot = self._plots_map.get(panel_id)
         if plot is None:
@@ -329,7 +337,15 @@ class Figure(anywidget.AnyWidget, _EventMixin):
         # save_html / Jupyter figure with no binary channel — materialise the
         # real base64 inline so the pixels actually travel. ``_binary_wire``
         # matches the producer's gate (``Plot2D._encode_pixels``).
-        if geom_keys and not _binary_wire() and hasattr(plot, "resolve_pixel_tokens"):
+        #
+        # ``resolve_pixels`` overrides that gate for an EXPORT. A snapshot is by
+        # definition off-wire: whatever PLOTBIN would have delivered never
+        # arrives, so a token left in the state is a dangling reference and the
+        # pixels are simply lost. The gate reads a process-global env var, which
+        # is on in a host app even while THIS push is serialising a snapshot —
+        # so the export has to say so explicitly.
+        if (geom_keys and (resolve_pixels or not _binary_wire())
+                and hasattr(plot, "resolve_pixel_tokens")):
             plot.resolve_pixel_tokens(state)
         if geom_keys and self.has_trait(gname):
             # Split heavy geometry into its own channel.  Detect change by
@@ -814,9 +830,17 @@ class Figure(anywidget.AnyWidget, _EventMixin):
         Called from ``_repr_utils._widget_state``, the one chokepoint every
         export path goes through.  The live Jupyter path deliberately keeps
         using targeted pushes and does not pay this cost.
+
+        The re-push passes ``resolve_pixels=True``: this rewrites the panel
+        traits, and under a live binary transport an ordinary push leaves pixel
+        change-tokens in place for PLOTBIN to fill in.  A snapshot has no
+        PLOTBIN, so those tokens would be dangling — and because the re-push
+        rewrites ``panel_<id>_json`` unconditionally it would also undo any
+        materialisation the caller did beforehand.  An export always ships real
+        pixels.
         """
         for panel_id in list(self._plots_map):
-            self._push(panel_id)
+            self._push(panel_id, resolve_pixels=True)
 
     def _push_panel_fields(self, panel_id: str, fields: dict) -> None:
         """Apply a small set of changed *fields* to a panel, then push once.

{anyplotlib-0.7.0 → anyplotlib-0.7.2}/anyplotlib/keys.py

@@ -37,14 +37,6 @@ class KeyOverlay:
         key = plot.add_key(ipf_triangle, corner="bottom-right")
         key.set(size=0.3, bgcolor="none")
         key.visible = False          # plain attribute assignment also pushes
-
-    Attributes
-    ----------
-    id : str
-        Short unique identifier.
-    name : str
-        Caller-supplied name, or the id when none was given.  Use it with
-        :meth:`~anyplotlib.Plot2D.get_key`.
     """
 
     #: Fields that live on the light view channel.  The image itself does NOT
@@ -68,10 +60,15 @@ class KeyOverlay:
 
     @property
     def id(self) -> str:
+        """Short unique identifier."""
         return self._id
 
     @property
     def name(self) -> str:
+        """Caller-supplied name, or the id when none was given.
+
+        Use it with :meth:`~anyplotlib.Plot2D.get_key`.
+        """
         return self._name
 
     # ── attribute access ──────────────────────────────────────────────

{anyplotlib-0.7.0 → anyplotlib-0.7.2}/anyplotlib/plot2d/_plot2d.py

@@ -45,6 +45,40 @@ def _binary_transport_active() -> bool:
     return os.environ.get("APL_BINARY_TRANSPORT") == "1"
 
 
+def _reduce_mask_any(mask, out_h: int, out_w: int):
+    """Reduce a boolean *mask* to ``(out_h, out_w)`` with a block ANY.
+
+    A block of the source is True in the output if ANY of its pixels is. For a
+    mask that is the only defensible reduction: it marks *where objects are*,
+    and an object smaller than one output block must not vanish because the
+    sampled pixel happened to miss it.
+
+    The tail rows/columns that do not divide evenly are folded into the last
+    block rather than cropped, so an object at the right or bottom edge is kept.
+    """
+    import numpy as _np
+
+    src_h, src_w = mask.shape
+    if (src_h, src_w) == (out_h, out_w):
+        return mask
+    ys = max(1, src_h // out_h)
+    xs = max(1, src_w // out_w)
+    keep_h, keep_w = (src_h // ys) * ys, (src_w // xs) * xs
+    small = mask[:keep_h, :keep_w].reshape(
+        keep_h // ys, ys, keep_w // xs, xs).any(axis=(1, 3))
+    out = _np.zeros((out_h, out_w), bool)
+    sh, sw = min(out_h, small.shape[0]), min(out_w, small.shape[1])
+    out[:sh, :sw] = small[:sh, :sw]
+    # Fold any cropped tail into the final block so edge objects survive.
+    if keep_h < src_h and sh > 0:
+        out[sh - 1, :sw] |= mask[keep_h:, :keep_w].reshape(
+            1, src_h - keep_h, keep_w // xs, xs).any(axis=(1, 3))[0, :sw]
+    if keep_w < src_w and sw > 0:
+        out[:sh, sw - 1] |= mask[:keep_h, keep_w:].reshape(
+            keep_h // ys, ys, 1, src_w - keep_w).any(axis=(1, 3))[:sh, 0]
+    return out
+
+
 class Plot2D(_BasePlot, _PanelMixin, _MarkerMixin):
     """2-D image plot panel.
 
@@ -1115,6 +1149,13 @@ class Plot2D(_BasePlot, _PanelMixin, _MarkerMixin):
             Boolean array aligned to the image data.  ``True`` / non-zero
             pixels are filled with *color* at transparency *alpha*.
             Pass ``None`` to clear the overlay.
+
+            In TILE mode pass the mask at the FULL image resolution: the
+            renderer composites the mask against the OVERVIEW texture, so it
+            is reduced to the base grid here.  A mask already at the base grid
+            is accepted unchanged.  (Both are accepted because neither is
+            wrong; what was wrong was accepting only the full-resolution one
+            and then shipping bytes the renderer silently discards.)
         color : str, optional
             CSS hex colour for the overlay, e.g. ``"#ff4444"``.  Default red.
             Must be in ``#RRGGBB`` format.
@@ -1137,14 +1178,32 @@ class Plot2D(_BasePlot, _PanelMixin, _MarkerMixin):
             self._state["overlay_mask_alpha"] = alpha
         else:
             arr = np.asarray(mask)
-            if arr.shape != (self._state["image_height"], self._state["image_width"]):
-                raise ValueError(
-                    f"mask shape {arr.shape} does not match image "
-                    f"({self._state['image_height']} x {self._state['image_width']})"
-                )
+            ih, iw = self._state["image_height"], self._state["image_width"]
+            bh = int(self._state.get("base_height") or 0)
+            bw = int(self._state.get("base_width") or 0)
+            # THE TILE-MODE SHAPE TRAP. The renderer sizes the mask against
+            # `base_width || image_width` -- the OVERVIEW grid -- but tile mode
+            # sets image_width/height to the FULL native frame. So validating
+            # only against the image shape rejected the one shape that renders
+            # and accepted the one the renderer drops on the floor
+            # (`mBytes.length===iw*ih` else `maskCache=null`, silently). Both
+            # shapes are legal here; the overview is what actually ships.
+            tiled = bw > 0 and bh > 0 and (bh, bw) != (ih, iw)
+            if arr.shape != (ih, iw) and not (tiled and arr.shape == (bh, bw)):
+                want = f"({ih} x {iw})"
+                if tiled:
+                    want += f" or the tile overview ({bh} x {bw})"
+                raise ValueError(f"mask shape {arr.shape} does not match image {want}")
             # For origin='lower' the image data was flipped; flip mask to match.
             if self._origin == "lower":
                 arr = np.flipud(arr)
+            if tiled and arr.shape == (ih, iw):
+                # Block ANY, never a subsample: a mask marks objects that are
+                # often only a few pixels across, and striding a 4096² mask
+                # down to 1024² drops three quarters of them at random. ANY
+                # keeps every object visible at the cost of fattening it, which
+                # is the right trade for an overlay you are looking at.
+                arr = _reduce_mask_any(np.asarray(arr, dtype=bool), bh, bw)
             # Convert to uint8: True/non-zero → 255, False/zero → 0
             u8 = (np.asarray(arr, dtype=bool).view(np.uint8) * 255).astype(np.uint8)
             self._state["overlay_mask_b64"]   = base64.b64encode(u8.tobytes()).decode("ascii")

anyplotlib-0.7.2/anyplotlib/tests/test_embed/test_export_pixel_tokens.py

@@ -0,0 +1,174 @@
+"""
+Snapshots must carry real pixels, never a dangling binary change-token.
+
+Under the Electron binary transport (``APL_BINARY_TRANSPORT=1``) a panel's
+image bytes do not travel in the state at all: ``Plot2D._encode_pixels`` writes
+a ``"\\x00bin:<adler>"`` change-token and the real bytes ride a PLOTBIN frame
+emitted by ``_electron._route_change``.  That split is right for a live wire and
+wrong for a snapshot — ``save_html`` / ``to_html`` / ``figure_state`` produce a
+document with no PLOTBIN behind it, so a token left in the state resolves to
+nothing and the pixels are simply lost.
+
+``Figure._sync_for_export`` therefore re-pushes with ``resolve_pixels=True``.
+It has to say so explicitly because the transport gate is a process-global env
+var, which is on in a host app even while that push is serialising a snapshot.
+
+Regression: the re-push (added for widget-position capture) rewrote
+``panel_<id>_json`` unconditionally with unresolved tokens, which both lost the
+pixels and undid any materialisation a caller had done beforehand.  An overlay
+LAYER was the visible casualty — ``_layerBytes`` in figure_esm.js bails on a
+token (``b64.charCodeAt(0) === 0``), so the layer silently did not draw while
+the base image, which is plain base64, still did.
+"""
+from __future__ import annotations
+
+import json
+
+import numpy as np
+import pytest
+
+import anyplotlib as apl
+from anyplotlib.embed import figure_state
+
+
+TOKEN = "\x00bin:"
+
+
+@pytest.fixture
+def binary_wire(monkeypatch):
+    """Turn on the same env gate the Electron host sets."""
+    monkeypatch.setenv("APL_BINARY_TRANSPORT", "1")
+
+
+def _fig_with_layer():
+    """A base image + one overlay layer, both on the token path.
+
+    ``imshow`` encodes the base BEFORE the plot is attached to its Figure, so
+    ``_encode_pixels`` finds no ``_raw_pixels`` side-table and falls back to
+    base64 for it; ``add_layer`` runs after the attach and does produce a token.
+    One ``set_data`` puts the base on the token path too — the state a live host
+    is actually in once anything has redrawn.  (That asymmetry is why the
+    regression looked so odd in the wild: the base image still rendered and only
+    the overlay vanished.)
+    """
+    img = np.linspace(0, 1, 32 * 32, dtype=np.float32).reshape(32, 32)
+    fig, ax = apl.subplots(1, 1, figsize=(300, 300))
+    plot = ax.imshow(img, cmap="gray")
+    plot.add_layer(img, cmap="magma", alpha=0.5)
+    plot.set_data(img)
+    return fig, plot
+
+
+def _panel(state, plot):
+    return json.loads(state[f"panel_{plot._id}_json"])
+
+
+def _geom(state, plot):
+    return json.loads(state[f"panel_{plot._id}_geom"])
+
+
+def _is_b64(value):
+    return isinstance(value, str) and value != "" and not value.startswith(TOKEN)
+
+
+class TestSnapshotResolvesPixelTokens:
+    def test_producer_really_emits_tokens(self, binary_wire):
+        """Guard the premise: without this, the tests below prove nothing."""
+        fig, plot = _fig_with_layer()
+        state = plot.to_state_dict()
+        assert state["image_b64"].startswith(TOKEN)
+        assert state["layers"][0]["image_b64"].startswith(TOKEN)
+
+    def test_base_image_is_inline_base64(self, binary_wire):
+        fig, plot = _fig_with_layer()
+        assert _is_b64(_geom(figure_state(fig), plot)["image_b64"])
+
+    def test_layer_pixels_are_inline_base64(self, binary_wire):
+        """The nested copy is the one figure_esm.js `_layerBytes` reads."""
+        fig, plot = _fig_with_layer()
+        layer = _panel(figure_state(fig), plot)["layers"][0]
+        assert _is_b64(layer["image_b64"])
+
+    def test_layer_geom_key_is_inline_base64(self, binary_wire):
+        fig, plot = _fig_with_layer()
+        geom = _geom(figure_state(fig), plot)
+        assert _is_b64(geom[f"layer_{plot._state['layers'][0]['id']}_b64"])
+
+    def test_no_token_survives_anywhere_in_the_snapshot(self, binary_wire):
+        fig, plot = _fig_with_layer()
+        blob = json.dumps(figure_state(fig))
+        # json.dumps escapes NUL as \\u0000.
+        assert "\\u0000bin:" not in blob
+
+    def test_caller_materialisation_is_not_undone(self, binary_wire):
+        """A host that resolves the traits itself before exporting keeps them.
+
+        ``_sync_for_export`` rewrites ``panel_<id>_json`` unconditionally, so an
+        unresolved re-push would clobber the caller's work — the exact shape of
+        the reported regression.
+        """
+        fig, plot = _fig_with_layer()
+        state = plot.to_state_dict()
+        plot.resolve_pixel_tokens(state)
+        resolved = state["layers"][0]["image_b64"]
+        setattr(fig, f"panel_{plot._id}_json", json.dumps(state))
+
+        after = _panel(figure_state(fig), plot)["layers"][0]["image_b64"]
+        assert after == resolved
+
+    def test_multi_layer_all_resolved(self, binary_wire):
+        img = np.linspace(0, 1, 16 * 16, dtype=np.float32).reshape(16, 16)
+        fig, ax = apl.subplots(1, 1, figsize=(300, 300))
+        plot = ax.imshow(img, cmap="gray")
+        for cmap in ("magma", "cividis", "plasma"):
+            plot.add_layer(img, cmap=cmap, alpha=0.4)
+        layers = _panel(figure_state(fig), plot)["layers"]
+        assert len(layers) == 3
+        assert all(_is_b64(ly["image_b64"]) for ly in layers)
+
+    def test_widget_positions_still_reconciled(self, binary_wire):
+        """The pixel fix must not cost the reason _sync_for_export exists."""
+        fig, plot = _fig_with_layer()
+        widget = plot.add_widget("rectangle", x=2, y=2, w=4, h=4)
+        widget.set(x=21, y=23)
+        got = _panel(figure_state(fig), plot)["overlay_widgets"][0]
+        assert got["x"] == 21 and got["y"] == 23
+
+
+class TestLiveWireStillUsesTokens:
+    """The live path must keep its token/PLOTBIN split — that is the whole
+    point of the binary transport, and resolving there would push megabytes of
+    base64 through the comm on every scrub frame."""
+
+    def test_ordinary_push_keeps_the_token(self, binary_wire):
+        fig, plot = _fig_with_layer()
+        fig._push(plot._id)
+        geom = json.loads(getattr(fig, f"panel_{plot._id}_geom"))
+        assert geom["image_b64"].startswith(TOKEN)
+        layer_key = f"layer_{plot._state['layers'][0]['id']}_b64"
+        assert geom[layer_key].startswith(TOKEN)
+
+    def test_set_data_keeps_the_token(self, binary_wire):
+        fig, plot = _fig_with_layer()
+        plot.set_data(np.zeros((32, 32), dtype=np.float32))
+        geom = json.loads(getattr(fig, f"panel_{plot._id}_geom"))
+        assert geom["image_b64"].startswith(TOKEN)
+
+    def test_push_after_export_returns_to_tokens(self, binary_wire):
+        """An export must not leave the live wire on the base64 path."""
+        fig, plot = _fig_with_layer()
+        figure_state(fig)
+        plot.set_data(np.ones((32, 32), dtype=np.float32))
+        geom = json.loads(getattr(fig, f"panel_{plot._id}_geom"))
+        assert geom["image_b64"].startswith(TOKEN)
+
+
+class TestNoBinaryTransport:
+    """With no binary wire the state was always inline base64; keep it so."""
+
+    def test_snapshot_is_inline_base64(self, monkeypatch):
+        monkeypatch.delenv("APL_BINARY_TRANSPORT", raising=False)
+        fig, plot = _fig_with_layer()
+        layer = _panel(figure_state(fig), plot)["layers"][0]
+        assert _is_b64(layer["image_b64"])
+        assert _is_b64(_geom(figure_state(fig), plot)["image_b64"])

{anyplotlib-0.7.0 → anyplotlib-0.7.2}/anyplotlib/tests/test_plot2d/test_imshow.py

@@ -575,6 +575,60 @@ class TestImshowOverlayMask:
         with pytest.raises(ValueError, match="mask shape"):
             plot.set_overlay_mask(bad_mask)
 
+    def test_overlay_mask_in_TILE_mode_ships_the_overview_size(self):
+        """The mask must be sized for what the RENDERER checks.
+
+        The renderer sizes the mask against ``base_width || image_width`` — the
+        OVERVIEW grid — and on a mismatch sets ``maskCache=null``: no error, no
+        overlay, nothing in the log. Tile mode sets ``image_width`` to the FULL
+        native frame, so validating a mask only against the image shape both
+        rejected the one shape that renders and accepted the one the renderer
+        drops. A caller that did the reduction itself got a ValueError; one that
+        did not got 22 MB of bytes silently discarded.
+
+        Either shape in, overview-sized bytes out.
+        """
+        import base64
+
+        plot = apl.subplots(1, 1)[1].imshow(
+            np.zeros((2048, 2048), np.uint8), tile="auto")
+        st = plot._state
+        bw, bh = st.get("base_width"), st.get("base_height")
+        assert bw and bh and (bw, bh) != (st["image_width"], st["image_height"]), \
+            "this test needs a genuinely tiled plot with a smaller base grid"
+
+        for shape in [(st["image_height"], st["image_width"]), (bh, bw)]:
+            mask = np.zeros(shape, bool)
+            mask[::5, ::5] = True
+            plot.set_overlay_mask(mask)
+            sent = base64.b64decode(st["overlay_mask_b64"])
+            assert len(sent) == bw * bh, (
+                f"a {shape} mask shipped {len(sent)} bytes; the renderer "
+                f"expects {bw * bh} and drops anything else silently")
+            assert any(sent), "the reduction emptied the mask"
+
+    def test_overlay_mask_reduction_is_block_ANY_not_a_subsample(self):
+        """A single-pixel object 4 blocks in must survive the reduction.
+
+        Objects here are often a few pixels across; a strided sample of a 2048²
+        mask at 512² keeps one pixel in sixteen and drops them at random.
+        """
+        import base64
+
+        plot = apl.subplots(1, 1)[1].imshow(
+            np.zeros((2048, 2048), np.uint8), tile="auto")
+        st = plot._state
+        bw, bh = st["base_width"], st["base_height"]
+        mask = np.zeros((st["image_height"], st["image_width"]), bool)
+        # Deliberately NOT on a block boundary — a subsample would miss it.
+        mask[537, 921] = True
+        plot.set_overlay_mask(mask)
+        sent = np.frombuffer(base64.b64decode(st["overlay_mask_b64"]), np.uint8)
+        # Bytes are 0/255, so COUNT the lit ones rather than summing them.
+        assert np.count_nonzero(sent.reshape(bh, bw)) == 1, (
+            "the single lit pixel did not survive the reduction — this is a "
+            "subsample, not a block ANY")
+
     def test_set_overlay_mask_alpha_boundary(self):
         plot = _img(n=16)
         mask = np.zeros((16, 16), dtype=bool)

{anyplotlib-0.7.0 → anyplotlib-0.7.2}/docs/_root/index.html

@@ -4,12 +4,12 @@
     <meta charset="utf-8" />
     <title>anyplotlib – redirecting…</title>
     <!-- Redirect to the latest dev docs. -->
-    <meta http-equiv="refresh" content="0; url=v0.7.0/" />
-    <link rel="canonical" href="v0.7.0/" />
+    <meta http-equiv="refresh" content="0; url=v0.7.2/" />
+    <link rel="canonical" href="v0.7.2/" />
   </head>
   <body>
     <p>
-      Redirecting to <a href="v0.7.0/">v0.7.0 documentation</a>…
+      Redirecting to <a href="v0.7.2/">v0.7.2 documentation</a>…
     </p>
   </body>
 </html>

{anyplotlib-0.7.0 → anyplotlib-0.7.2}/docs/_root/switcher.json

@@ -4,6 +4,16 @@
     "version": "dev",
     "url": "https://cssfrancis.github.io/anyplotlib/dev/"
   },
+  {
+    "name": "v0.7.2 (stable)",
+    "version": "v0.7.2",
+    "url": "https://cssfrancis.github.io/anyplotlib/v0.7.2/"
+  },
+  {
+    "name": "v0.7.1 (stable)",
+    "version": "v0.7.1",
+    "url": "https://cssfrancis.github.io/anyplotlib/v0.7.1/"
+  },
   {
     "name": "v0.7.0 (stable)",
     "version": "v0.7.0",

{anyplotlib-0.7.0 → anyplotlib-0.7.2}/docs/conf.py

@@ -17,7 +17,7 @@ from _sg_html_scraper import ViewerScraper  # noqa: E402
 project = "anyplotlib"
 copyright = "2026, anyplotlib contributors"
 author = "anyplotlib contributors"
-release = "0.7.0"
+release = "0.7.2"
 
 # When built in CI the workflow sets DOCS_VERSION to the tag name (e.g.
 # "v0.1.0") or "dev".  Fall back to "dev" for local builds.

{anyplotlib-0.7.0 → anyplotlib-0.7.2}/pyproject.toml

@@ -13,7 +13,7 @@ exclude = [
 
 [project]
 name = "anyplotlib"
-version = "0.7.0"
+version = "0.7.2"
 description = "A plotting library using python, javascript and anywidget for performant in browser plotting."
 readme = "README.md"
 license = { text = "MIT" }