anyplotlib 0.10.0__tar.gz → 0.10.1__tar.gz

{anyplotlib-0.10.0 → anyplotlib-0.10.1}/AGENTS.md

@@ -115,7 +115,7 @@ grep -nE '^\s*(function|const|let) [A-Za-z_]' anyplotlib/figure_esm.js
 ```
 
 and reconcile against the two numbered tables (the section map near the top and
-the 2-D function table). Both were last verified at 12,407 lines.
+the 2-D function table). Both were last verified at 12,438 lines.
 
 Changelog entries: add a fragment file to `upcoming_changes/` (e.g.
 `123.new_feature.rst`) — towncrier assembles `CHANGELOG.rst` at release time.

{anyplotlib-0.10.0 → anyplotlib-0.10.1}/CHANGELOG.rst

@@ -10,6 +10,21 @@ Fragment files in ``upcoming_changes/`` are assembled into this file by
 
 .. towncrier release notes start
 
+0.10.1 (2026-09-17)
+===================
+
+New Features
+------------
+
+- A page embedding a figure in an iframe can post ``{type: 'anyplotlib_host', savesPng: true}`` to say it saves exported PNGs itself; the figure's "Save PNG…" then only sends the image to the host, without the in-figure "Save image as…" preview or the "Save as… (choose folder)" entry. (`#78 <https://github.com/CSSFrancis/anyplotlib/pull/78>`_)
+
+
+Bug Fixes
+---------
+
+- Zooming or panning a coordinate axis no longer blanks an :meth:`~anyplotlib.plotxy.PlotXY.add_raster` image, and every marker drawn after it, until the next update from Python. (`#76 <https://github.com/CSSFrancis/anyplotlib/pull/76>`_)
+
+
 0.10.0 (2026-09-14)
 ===================
 

{anyplotlib-0.10.0 → anyplotlib-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: anyplotlib
-Version: 0.10.0
+Version: 0.10.1
 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.10.0 → anyplotlib-0.10.1}/anyplotlib/FIGURE_ESM.md

@@ -73,32 +73,34 @@ Rule 5 – Text never clips.  Optional gutters earn real layout space:
 | 3D event handlers `_attachEvents3d` | 6661 |
 | **1D drawing**: `draw1d` | 6885 |
 | `_drawLine` (1D series + markers) | 7038 |
-| `drawOverlay1d` / `drawMarkers1d` | 7331 / 7415 |
-| Marker hit-test `_markerHitTest2d` | 7682 |
+| `drawOverlay1d` / `_rasterBitmap` / `drawMarkers1d` | 7331 / 7419 / 7436 |
+| Marker hit-test `_markerHitTest2d` | 7700 |
 
 > **`raster` marker (1D/PlotXY)** — `drawMarkers1d` has a `type==='raster'`
 > branch that blits a single RGBA image across data-coord `extent` (the fast
 > path for dense `PlotXY.pcolormesh` heatmaps). The image bytes ride the geom
 > channel as `st.raster_geom[id]` (Python `Plot1D._GEOM_KEYS`), so view-only
-> redraws never re-transmit them; the decoded `OffscreenCanvas` is cached on
-> the marker set (`ms._rasterBmp`/`_rasterKey`). The shared `clip_path` block
-> clips it to a curved sector.
-| Panel event dispatch `_attachPanelEvents` | 7939 |
-| 2D events `_attachEvents2d` | 8025 |
-| 1D events `_attachEvents1d` | 8411 |
-| 2D widget drag `_ovHitTest2d` / `_doDrag2d` | 8686 / 8965 |
-| **Brush strokes**: `_brushLiveBegin` / `_brushCommit` / `_brushErase` / `_brushPaintAt` | 8878 / 8892 / 8921 / 8956 |
-| 1D widget drag `_canvasXToFrac1d` … / snapping `_snapVal` | 9090 / 9163 |
-| Shared-axis propagation `_getShareGroups` | 9234 |
-| Figure resize `_applyFigResizeDOM` | 9298 |
-| **Bar chart**: `_barGeom` / `drawBar` / `_attachEventsBar` | 9492 / 9555 / 9931 |
-| Generic redraw `_redrawPanel` | 10121 |
-| **PNG export**: `_compositeCanvas` / `exportCanvas` / `exportPNG` | 10284 / 10480 / 10539 |
-| Native-resolution render `_withNativeSize` | 10260 |
-| **Export UI**: `_toast` / `_downloadCanvas` / `_openMenu` | 10573 / 10682 / 10861 |
-| Export registry `registerExportAction` | 10738 |
-| **Embedding API**: `createLocalModel` / `mount` | 11252 / 11308 |
-| **Navigated embed**: `decodeBlocks` / `mountNavigated` | 11563 / 11950 |
+> redraws never re-transmit them. The decoded `OffscreenCanvas` is cached per
+> panel by `_rasterBitmap` (keyed by the marker set's id, re-decoded when the
+> bytes or the shape change) — never on the marker set, which is state the
+> wheel and pan handlers serialise back. The shared `clip_path` block clips it
+> to a curved sector.
+| Panel event dispatch `_attachPanelEvents` | 7957 |
+| 2D events `_attachEvents2d` | 8043 |
+| 1D events `_attachEvents1d` | 8429 |
+| 2D widget drag `_ovHitTest2d` / `_doDrag2d` | 8704 / 8983 |
+| **Brush strokes**: `_brushLiveBegin` / `_brushCommit` / `_brushErase` / `_brushPaintAt` | 8896 / 8910 / 8939 / 8974 |
+| 1D widget drag `_canvasXToFrac1d` … / snapping `_snapVal` | 9108 / 9181 |
+| Shared-axis propagation `_getShareGroups` | 9252 |
+| Figure resize `_applyFigResizeDOM` | 9316 |
+| **Bar chart**: `_barGeom` / `drawBar` / `_attachEventsBar` | 9510 / 9573 / 9949 |
+| Generic redraw `_redrawPanel` | 10139 |
+| **PNG export**: `_compositeCanvas` / `exportCanvas` / `exportPNG` | 10302 / 10498 / 10557 |
+| Native-resolution render `_withNativeSize` | 10278 |
+| **Export UI**: `_toast` / `_downloadCanvas` / `_openMenu` | 10591 / 10713 / 10892 |
+| Export registry `registerExportAction` | 10769 |
+| **Embedding API**: `createLocalModel` / `mount` | 11283 / 11339 |
+| **Navigated embed**: `decodeBlocks` / `mountNavigated` | 11594 / 11981 |
 
 > **`brush` widget (2-D)** — the one widget whose drag is *modal*, and the one
 > that must NOT write the model per tick. `_ovHitTest2d` takes an extra `mods`
@@ -660,13 +662,13 @@ exportCanvas(same opts) → {canvas, width, height}   // synchronous, throws
 
 | Function | Line | Purpose |
 |----------|------|---------|
-| `_cssScale` | 10156 | inverse of `_applyScale`'s `transform:scale()` |
-| `_panelBox` | 10167 | the element whose rect bounds one panel |
-| `_neutralizeView` / `_restoreView` | 10176 / 10201 | transient whole-extent view |
-| `_nativeGeom` / `_nativeGuard` | 10216 / 10235 | native size + why-not message |
-| `_withNativeSize` | 10260 | resize → redraw → run → restore |
-| `_compositeCanvas` | 10284 | the compositor (`_drawEl` / `_drawPanel` …) |
-| `exportCanvas` / `exportPNG` | 10480 / 10539 | orchestrator / data-URL wrapper |
+| `_cssScale` | 10174 | inverse of `_applyScale`'s `transform:scale()` |
+| `_panelBox` | 10185 | the element whose rect bounds one panel |
+| `_neutralizeView` / `_restoreView` | 10194 / 10219 | transient whole-extent view |
+| `_nativeGeom` / `_nativeGuard` | 10234 / 10253 | native size + why-not message |
+| `_withNativeSize` | 10278 | resize → redraw → run → restore |
+| `_compositeCanvas` | 10302 | the compositor (`_drawEl` / `_drawPanel` …) |
+| `exportCanvas` / `exportPNG` | 10498 / 10557 | orchestrator / data-URL wrapper |
 
 **The whole pipeline is ONE synchronous task** — theme swap, view reset, native
 resize, composite, restore — so the browser never paints an intermediate state
@@ -762,13 +764,14 @@ leaders that cross into the panel included. Pinned by
 
 | Function | Line | Purpose |
 |----------|------|---------|
-| `_toast` | 10573 | transient bottom-centre message |
-| `_copyCanvas` | 10608 | clipboard write + feature detection |
-| `_showPngPreview` | 10632 | framed-document download fallback |
-| `_downloadCanvas` | 10682 | `<a download>` or the preview |
-| `registerExportAction` | 10738 | downstream extension point |
-| `_menuRows` / `_openMenu` | 10792 / 10861 | menu model / DOM |
-| `_panelAtPoint` | 10973 | hit test (insets first — they sit on top) |
+| `_toast` | 10591 | transient bottom-centre message |
+| `_copyCanvas` | 10626 | clipboard write + feature detection |
+| `_showPngPreview` | 10650 | framed-document download fallback |
+| `_hostSavesPng` / `_canPickFile` | 10702 / 10708 | the parent saves PNGs itself / a system Save dialog exists |
+| `_downloadCanvas` | 10713 | `<a download>`, the preview, or the host |
+| `registerExportAction` | 10769 | downstream extension point |
+| `_menuRows` / `_openMenu` | 10823 / 10892 | menu model / DOM |
+| `_panelAtPoint` | 11004 | hit test (insets first — they sit on top) |
 
 - **An `exportBtn` badge (⤓, beside the help badge) opens the same menu on an
   ordinary left click.** It is a `role="button"` with `tabIndex=0` and
@@ -810,9 +813,15 @@ leaders that cross into the panel included. Pinned by
   `save_html` page opened directly is top-level) from the unreliable one (VS
   Code webviews, `_repr_html_` iframes, nbconvert output). When framed, the
   result is posted to the parent under the existing
-  `anyplotlib_export_png_result` message AND shown as an in-figure preview whose
-  caption points at the browser's own "Save image as…", which needs no
-  permission and is never blocked.
+  `anyplotlib_export_png_result` message (`requestId: null`, plus `filename`)
+  AND shown as an in-figure preview whose caption points at the browser's own
+  "Save image as…", which needs no permission and is never blocked.
+- **Host saves** (`_hostSavesPng`): a parent that posts
+  `{type:'anyplotlib_host', savesPng:true}` sets `globalThis.__aplHostSavesPng`
+  (the page template's listener, parent frame only). Framed saves then post the
+  image WITHOUT the preview, and `_canPickFile()` is false, so the *Save as…*
+  row disappears — the host's own Save dialog chooses the folder, and an app
+  webview may have no "Save image as…" menu for the preview to point at.
 - **Clipboard**: gated on `isSecureContext && navigator.clipboard &&
   ClipboardItem && clipboard.write`. The Blob is built SYNCHRONOUSLY from the
   data URL (not via the async `toBlob` callback) so the write stays inside the
@@ -829,6 +838,7 @@ Test hooks: `__apl_menuItems`, `__apl_toastText`, `__apl_menuTheme`,
 Tests: `tests/test_embed/test_export_png.py` (the pre-existing contract),
 `test_export_sources.py` (panelId / source / theme / CSS scale),
 `test_export_menu.py` (menu, clipboard, download, registry),
+`test_host_saves_png.py` (the host announcement and the framed save),
 `test_savefig.py` (the Python entry point + view reconciliation).
 
 The standalone HTML template (`_repr_utils.build_standalone_html`) captures
@@ -838,11 +848,14 @@ render()'s api into `_aplRenderApi`, **also assigns it to `window._aplRenderApi`
 `{type:'anyplotlib_export_png', requestId, opts}` → `exportPNG(opts)` → replies
 `{type:'anyplotlib_export_png_result', requestId, dataUrl, width, height}` (or
 `{…, error}`) to `event.source` (targetOrigin `'*'`). `opts` is forwarded
-verbatim, so the new fields work over that channel too.
+verbatim, so the new fields work over that channel too. A second listener takes
+`{type:'anyplotlib_host', savesPng}` from `window.parent` only and records it
+in `globalThis.__aplHostSavesPng` (read by `_hostSavesPng`). Both live in
+`PNG_HARVEST_LISTENER`, which the navigated embed installs too.
 
 ---
 
-## Navigated-embed runtime (line 11333 to the end of the file)
+## Navigated-embed runtime (line 11346 to the end of the file)
 
 Everything below `mount()` is module scope, outside `render()`'s closure: pure
 functions over decoded data plus one entry point that wires them to a mounted
@@ -852,16 +865,16 @@ bindings, let it dispatch", rather than a hand-written program per result kind.
 
 | Function | Line | Purpose |
 |----------|------|---------|
-| `decodeBlocks` | 11563 | one base64 `fetch` → one ArrayBuffer → a typed-array view per manifest entry |
-| `dense` | 11589 | `at` / `gather` / `reduce` over a block whose leading axes are the nav axes |
-| `ragged` | 11654 | the same three, over a row-pointer block (`offsets` + one array per column) |
-| `maskFromWidget` | 11737 | rectangle / circle / annulus widget dict → `Uint8Array` (carries `width`/`height`) |
-| `rasterDisks` | 11777 | splat `{x, y, intensity}` rows as filled disks — the base image of a vectors panel |
-| `robustLevels` / `toU8` | 11806 / 11847 | the percentile window and the 8-bit code map, one implementation |
-| `panelAxis` | 11925 | a 1-D panel's decoded x axis (`_1dXArr`, else `x_axis_b64`) |
-| `installTouchShim` / `reportEmbedHeight` | 11862 / 11881 | page chrome: touch → mouse, `postMessage({aplEmbedHeight})` |
-| `encodeBase64` / `typedArrayBytes` | 11901 / 11909 | a 3-D cloud's geometry channel is base64, not the binary side table |
-| `mountNavigated` | 11950 | mount + bind + dispatch; resolves to the mount handle plus `dispatch`/`index`/`blocks` |
+| `decodeBlocks` | 11594 | one base64 `fetch` → one ArrayBuffer → a typed-array view per manifest entry |
+| `dense` | 11620 | `at` / `gather` / `reduce` over a block whose leading axes are the nav axes |
+| `ragged` | 11685 | the same three, over a row-pointer block (`offsets` + one array per column) |
+| `maskFromWidget` | 11768 | rectangle / circle / annulus widget dict → `Uint8Array` (carries `width`/`height`) |
+| `rasterDisks` | 11808 | splat `{x, y, intensity}` rows as filled disks — the base image of a vectors panel |
+| `robustLevels` / `toU8` | 11837 / 11878 | the percentile window and the 8-bit code map, one implementation |
+| `panelAxis` | 11956 | a 1-D panel's decoded x axis (`_1dXArr`, else `x_axis_b64`) |
+| `installTouchShim` / `reportEmbedHeight` | 11893 / 11912 | page chrome: touch → mouse, `postMessage({aplEmbedHeight})` |
+| `encodeBase64` / `typedArrayBytes` | 11932 / 11940 | a 3-D cloud's geometry channel is base64, not the binary side table |
+| `mountNavigated` | 11981 | mount + bind + dispatch; resolves to the mount handle plus `dispatch`/`index`/`blocks` |
 
 `mountNavigated(el, page, opts)` is **async** — the blob decode is a `fetch` of
 a `data:` URL — so a host `await`s it.  `page` is `{state, blocks, bindings,

{anyplotlib-0.10.0 → anyplotlib-0.10.1}/anyplotlib/_repr_utils.py

@@ -330,9 +330,10 @@ window.addEventListener('message', (e) => {{
 
 
 # A host page (or the SpyDE report harvester) asks an embedded figure for a
-# composite PNG over postMessage.  Both the standalone page and the navigated
-# embed install this listener; each assigns ``globalThis.__aplExportPNG`` once
-# its figure is mounted, which is also what makes "not ready yet" answerable.
+# composite PNG over postMessage, and can announce that it saves exported PNGs
+# itself.  Both the standalone page and the navigated embed install these
+# listeners; each assigns ``globalThis.__aplExportPNG`` once its figure is
+# mounted, which is also what makes "not ready yet" answerable.
 PNG_HARVEST_LISTENER = '''\
 // ── PNG export protocol ──────────────────────────────────────────────────────
 // A parent page (or the SpyDE report harvester) asks this frame over
@@ -370,6 +371,20 @@ window.addEventListener('message', (e) => {
     reply({ error: String(err && err.message || err) });
   }
 });
+
+// A host that saves exported PNGs itself (a desktop app with its own Save
+// dialog) announces it once:
+//   → { type: 'anyplotlib_host', savesPng: true }
+// after which the export menu's "Save PNG…" only posts the image to it
+//   ← { type: 'anyplotlib_export_png_result', requestId: null,
+//       dataUrl, width, height, filename }
+// instead of also showing the in-figure "Save image as…" preview. Only the
+// parent frame may say so.
+window.addEventListener('message', (e) => {
+  if (!e.data || e.data.type !== 'anyplotlib_host') return;
+  if (e.source !== window.parent || window.parent === window) return;
+  globalThis.__aplHostSavesPng = e.data.savesPng === true;
+});
 '''
 
 

{anyplotlib-0.10.0 → anyplotlib-0.10.1}/anyplotlib/figure_esm.js

@@ -7412,6 +7412,27 @@ fn fs(in : VsOut) -> @location(0) vec4<f32> {
     ctx.beginPath();ctx.arc(x,y,5,0,Math.PI*2);ctx.fill();ctx.stroke();ctx.restore();
   }
 
+  // The decoded image of raster marker set `id`, re-decoded only when its bytes
+  // or its shape change (the same bytes can be 1×4 or 2×2), or null if they
+  // cannot be decoded. Kept in a per-panel map rather than on the marker set
+  // itself, which is serialised state.
+  function _rasterBitmap(p, id, b64, width, height){
+    if(!p._rasterCache) p._rasterCache=new Map();
+    const cached=p._rasterCache.get(id);
+    if(cached && cached.b64===b64 && cached.width===width && cached.height===height)
+      return cached.bitmap;
+    let bitmap=null;
+    try{
+      const bin=atob(b64);
+      const bytes=new Uint8ClampedArray(bin.length);
+      for(let i=0;i<bin.length;i++) bytes[i]=bin.charCodeAt(i);
+      bitmap=new OffscreenCanvas(width,height);
+      bitmap.getContext('2d').putImageData(new ImageData(bytes, width, height),0,0);
+    }catch(_){ bitmap=null; }
+    p._rasterCache.set(id, {b64, width, height, bitmap});
+    return bitmap;
+  }
+
   function drawMarkers1d(p, hoverState) {
     const st=p.state; if(!st) return;
     const {pw,ph,mkCtx} = p;
@@ -7424,6 +7445,10 @@ fn fs(in : VsOut) -> @location(0) vec4<f32> {
     if (st.y_range && st.y_range.length === 2) { dMin = st.y_range[0]; dMax = st.y_range[1]; }
     mkCtx.clearRect(0,0,pw,ph);
     const sets=st.markers||[];
+    if(p._rasterCache){
+      const live=new Set(sets.map(set=>set.id));
+      for(const id of [...p._rasterCache.keys()]) if(!live.has(id)) p._rasterCache.delete(id);
+    }
     if(!sets.length) return;
     const hsi = hoverState ? hoverState.si : -1;
 
@@ -7567,33 +7592,26 @@ fn fs(in : VsOut) -> @location(0) vec4<f32> {
       } else if(type==='raster'){
         // A single RGBA image stretched across data-coord `extent`. Heavy bytes
         // ride the geom channel (st.raster_geom[id]); fall back to inline. The
-        // decoded OffscreenCanvas is cached on the set so view-only redraws blit
-        // without re-decoding. The clip block above already scoped any sector.
+        // clip block above already scoped any sector.
         const rg = (st.raster_geom && st.raster_geom[ms.id]) || ms;
         const b64 = rg.image_b64 || '';
         const iw = rg.image_width|0, ih = rg.image_height|0;
         if(b64 && iw>0 && ih>0){
-          if(ms._rasterKey!==b64 || !ms._rasterBmp){
-            try{
-              const bin=atob(b64);
-              const bytes=new Uint8ClampedArray(bin.length);
-              for(let i=0;i<bin.length;i++) bytes[i]=bin.charCodeAt(i);
-              const imgData=new ImageData(bytes, iw, ih);
-              const oc=new OffscreenCanvas(iw,ih);
-              oc.getContext('2d').putImageData(imgData,0,0);
-              ms._rasterBmp=oc; ms._rasterKey=b64;
-            }catch(_){ ms._rasterBmp=null; }
-          }
+          // The decoded image is cached on the PANEL, not on `ms`: `ms` is part
+          // of the state a view write-back serialises, and a decoded canvas
+          // serialises to `{}`, which would then pass for a cached image and
+          // make drawImage throw — blanking the panel on every zoom.
+          const decoded=_rasterBitmap(p, ms.id, b64, iw, ih);
           const ext=ms.extent||[0,1,0,1];
           const [ax2,ay2]= tfm==='data' ? _offToCanvas([ext[0],ext[2]]) : _tc2d(ext[0],ext[2]);
           const [bx2,by2]= tfm==='data' ? _offToCanvas([ext[1],ext[3]]) : _tc2d(ext[1],ext[3]);
-          if(ms._rasterBmp){
+          if(decoded){
             mkCtx.save();
             // Nearest-neighbour by default (crisp cells); smoothing bilinearly
             // interpolates for a smooth heat field (ms.smooth === true).
             mkCtx.imageSmoothingEnabled = ms.smooth === true;
             if(ms.smooth === true) mkCtx.imageSmoothingQuality = 'high';
-            mkCtx.drawImage(ms._rasterBmp, 0,0,iw,ih,
+            mkCtx.drawImage(decoded, 0,0,iw,ih,
               Math.min(ax2,bx2), Math.min(ay2,by2),
               Math.abs(bx2-ax2), Math.abs(by2-ay2));
             mkCtx.restore();
@@ -10671,11 +10689,24 @@ fn fs(in : VsOut) -> @location(0) vec4<f32> {
   //   usePicker → showSaveFilePicker, a real system dialog (Chromium, secure
   //               context, user gesture) — costs a Chrome permission prompt
   //   otherwise → <a download>, straight to the downloads folder, no prompt
-  //   framed    → an in-figure preview, since a sandboxed frame makes a.click()
-  //               a SILENT no-op with nothing to feature detect
+  //   framed    → the image is posted to the parent, plus an in-figure preview,
+  //               since a sandboxed frame makes a.click() a SILENT no-op with
+  //               nothing to feature detect
+  //   framed, host saves → posted to the parent only: the host has its own
+  //               Save dialog (a desktop app), so the preview's "right-click →
+  //               Save image as…" would be wrong — an app webview may have no
+  //               such menu at all
+
+  // Set by the page template when the parent announces
+  // {type:'anyplotlib_host', savesPng:true} (see PNG_HARVEST_LISTENER).
+  function _hostSavesPng() {
+    return window.self !== window.top && globalThis.__aplHostSavesPng === true;
+  }
+
   // Is a system Save dialog available at all? Chromium only, secure context.
+  // A host that saves already asks where to put the file.
   function _canPickFile() {
-    return !!(window.isSecureContext
+    return !_hostSavesPng() && !!(window.isSecureContext
               && typeof window.showSaveFilePicker === 'function');
   }
 
@@ -10718,7 +10749,7 @@ fn fs(in : VsOut) -> @location(0) vec4<f32> {
           type: 'anyplotlib_export_png_result', requestId: null,
           dataUrl, width: canvas.width, height: canvas.height, filename }, '*');
       } catch (_) {}
-      _showPngPreview(dataUrl, filename);
+      if (!_hostSavesPng()) _showPngPreview(dataUrl, filename);
       return;
     }
     const url = URL.createObjectURL(blob);

anyplotlib-0.10.1/anyplotlib/tests/test_embed/test_host_saves_png.py

@@ -0,0 +1,114 @@
+"""
+A framed figure's "Save PNG…" when the host page saves PNGs itself.
+
+In a frame, "Save PNG…" cannot download (a sandboxed frame makes ``a.click()``
+a silent no-op), so it posts the image to the parent and shows an in-figure
+preview whose caption points at the browser's "Save image as…". A host with its
+own Save dialog — a desktop app, whose webview may have no such menu —
+announces ``{type: 'anyplotlib_host', savesPng: true}``; the figure then only
+posts the image, and drops the "Save as… (choose folder)" row, since the
+host's dialog already chooses the folder.
+"""
+from __future__ import annotations
+
+import pathlib
+import tempfile
+from html import escape
+
+import numpy as np
+import pytest
+
+import anyplotlib as apl
+from anyplotlib._repr_utils import build_standalone_html
+
+_PARENT_PAGE = """<!DOCTYPE html>
+<html><head><meta charset="utf-8"/><style>html,body{margin:0;padding:0;}</style></head>
+<body>
+<iframe id="fig" srcdoc="__SRCDOC__" width="360" height="280" style="border:none;"></iframe>
+<script>
+window._saved = [];
+window.addEventListener('message', (e) => {
+  if (e.data && e.data.type === 'anyplotlib_export_png_result' && e.data.requestId === null) {
+    window._saved.push({filename: e.data.filename, dataUrl: e.data.dataUrl});
+  }
+});
+window._announceHost = () => document.getElementById('fig').contentWindow.postMessage(
+  {type: 'anyplotlib_host', savesPng: true}, '*');
+</script>
+</body></html>
+"""
+
+_MENU_ROWS = """() => Array.from(document.querySelectorAll('[data-apl-menu] *'))
+  .filter((element) => element.children.length === 0)
+  .map((element) => element.textContent)"""
+
+_OPEN_MENU = """() => document.querySelector(
+  '[aria-label="Copy or save this figure"]').click()"""
+
+_CLICK_SAVE_PNG = """() => Array.from(document.querySelectorAll('[data-apl-menu] *'))
+  .find((element) => element.textContent === 'Save PNG…').click()"""
+
+_PREVIEW_SHOWN = "() => document.body.innerText.includes('Save image as')"
+
+
+@pytest.fixture
+def framed_figure(_pw_browser):
+    """Open a parent page holding a figure in an iframe; yield ``(page, frame)``."""
+    fig, ax = apl.subplots(1, 1, figsize=(320, 240))
+    ax.imshow(np.random.default_rng(3).random((16, 16)).astype(np.float32))
+    parent = _PARENT_PAGE.replace(
+        "__SRCDOC__", escape(build_standalone_html(fig, resizable=False), quote=True))
+    with tempfile.NamedTemporaryFile(
+            suffix=".html", mode="w", encoding="utf-8", delete=False) as handle:
+        handle.write(parent)
+        path = pathlib.Path(handle.name)
+    page = _pw_browser.new_page()
+    try:
+        page.goto(path.as_uri())
+        frame = next(frame for frame in page.frames if frame.parent_frame is not None)
+        frame.wait_for_function(
+            "() => typeof globalThis.__aplExportPNG === 'function'", timeout=15_000)
+        yield page, frame
+    finally:
+        page.close()
+        path.unlink(missing_ok=True)
+
+
+def _save_png(page, frame):
+    """Open the export menu, click "Save PNG…"; return the menu's rows."""
+    frame.evaluate(_OPEN_MENU)
+    rows = frame.evaluate(_MENU_ROWS)
+    frame.evaluate(_CLICK_SAVE_PNG)
+    page.wait_for_function("() => window._saved.length > 0", timeout=5_000)
+    frame.wait_for_timeout(100)
+    return rows
+
+
+class TestHostSavesPng:
+    def test_without_a_host_the_frame_shows_the_preview(self, framed_figure):
+        page, frame = framed_figure
+        _save_png(page, frame)
+        saved = page.evaluate("() => window._saved")
+        assert saved[0]["dataUrl"].startswith("data:image/png;base64,")
+        assert saved[0]["filename"].endswith(".png")
+        assert frame.evaluate(_PREVIEW_SHOWN)
+
+    def test_a_host_that_saves_gets_the_image_and_no_preview(self, framed_figure):
+        page, frame = framed_figure
+        page.evaluate("() => window._announceHost()")
+        frame.wait_for_function("() => globalThis.__aplHostSavesPng === true")
+        rows = _save_png(page, frame)
+        saved = page.evaluate("() => window._saved")
+        assert len(saved) == 1 and saved[0]["dataUrl"].startswith("data:image/png;base64,")
+        assert not frame.evaluate(_PREVIEW_SHOWN)
+        # The host's own dialog chooses the folder.
+        assert not any("choose folder" in (row or "") for row in rows), rows
+
+    def test_only_the_parent_can_announce_itself(self, framed_figure):
+        page, frame = framed_figure
+        frame.evaluate(
+            "() => window.postMessage({type: 'anyplotlib_host', savesPng: true}, '*')")
+        frame.wait_for_timeout(100)
+        assert frame.evaluate("() => globalThis.__aplHostSavesPng") is None
+        _save_png(page, frame)
+        assert frame.evaluate(_PREVIEW_SHOWN)

anyplotlib-0.10.1/anyplotlib/tests/test_plotxy/test_raster_zoom.py

@@ -0,0 +1,109 @@
+"""
+A raster on a coordinate axis survives the view write-back a zoom makes, and
+its decoded image is rebuilt whenever its bytes or its shape change.
+
+The wheel handler writes the panel's view state back through the model, and
+the model's change listener redraws the panel from that state after a round
+trip through JSON. The decoded raster must not live in that state: a decoded
+canvas serialises to ``{}``, which then passed for a cached image, made
+``drawImage`` throw, and left the raster — and every marker drawn after it —
+blank until the next push from Python.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+import anyplotlib as apl
+
+GRID_PAD = 8  # gridDiv padding: the canvas's offset from the page origin
+
+RED = (255, 0, 0, 255)
+GREEN = (0, 255, 0, 255)
+
+# Where the red and the green pixels are, across every 2-D canvas.
+_COLOUR_EXTENTS = """() => {
+  const found = {red: {count: 0, minX: Infinity, maxX: -Infinity},
+                 green: {count: 0, minX: Infinity, maxX: -Infinity}}
+  for (const canvas of document.querySelectorAll('canvas')) {
+    const context = canvas.getContext('2d')
+    if (!context || !canvas.width || !canvas.height) continue
+    const data = context.getImageData(0, 0, canvas.width, canvas.height).data
+    for (let i = 0; i < data.length; i += 4) {
+      if (data[i + 3] < 128) continue
+      const red = data[i], green = data[i + 1], blue = data[i + 2]
+      const colour = red > 150 && green < 80 && blue < 80 ? found.red
+        : green > 150 && red < 80 && blue < 80 ? found.green : null
+      if (!colour) continue
+      const x = (i / 4) % canvas.width
+      colour.count++
+      colour.minX = Math.min(colour.minX, x)
+      colour.maxX = Math.max(colour.maxX, x)
+    }
+  }
+  return found
+}"""
+
+_TWO_FRAMES = "() => new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r)))"
+
+
+def _coordinate_axis():
+    fig, ax = apl.subplots(1, 1, figsize=(300, 300))
+    return fig, ax.axes2d(xlim=(0.0, 1.0), ylim=(0.0, 1.0), aspect="equal")
+
+
+def _wheel_zoom(page):
+    page.mouse.move(GRID_PAD + 150, GRID_PAD + 130)
+    for _ in range(3):
+        page.mouse.wheel(0, -240)
+        page.wait_for_timeout(50)
+    page.evaluate(_TWO_FRAMES)
+    page.wait_for_timeout(100)
+
+
+class TestRasterSurvivesZoom:
+    def test_a_wheel_zoom_keeps_the_raster_and_the_markers_after_it(self, interact_page):
+        fig, coordinates = _coordinate_axis()
+        coordinates.add_raster(np.tile(np.array(RED, np.uint8), (8, 8, 1)),
+                               extent=(0.0, 1.0, 0.0, 1.0))
+        # Drawn after the raster, so a raster that throws takes it down too.
+        coordinates.scatter([0.5], [0.5], s=10, c="#00ff00", edgecolors="#00ff00")
+        page = interact_page(fig)
+        before = page.evaluate(_COLOUR_EXTENTS)
+        assert before["red"]["count"] > 1000, f"the raster was not drawn to begin with: {before}"
+        assert before["green"]["count"] > 20, f"the marker was not drawn to begin with: {before}"
+
+        _wheel_zoom(page)
+
+        after = page.evaluate(_COLOUR_EXTENTS)
+        assert after["red"]["count"] > 1000, f"zooming blanked the raster: {before} -> {after}"
+        assert after["green"]["count"] > 20, f"zooming blanked the marker: {before} -> {after}"
+
+
+class TestRasterRedecodes:
+    def test_the_same_bytes_in_a_new_shape_are_decoded_again(self, interact_page):
+        # Two red pixels then two green ones: as 2×2 the red row sits above the
+        # green one; as 4×1 the red half sits left of the green half.
+        fig, coordinates = _coordinate_axis()
+        square = np.array([[RED, RED], [GREEN, GREEN]], dtype=np.uint8)
+        coordinates.add_raster(square, extent=(0.0, 1.0, 0.0, 1.0))
+        page = interact_page(fig)
+        stacked = page.evaluate(_COLOUR_EXTENTS)
+        assert stacked["red"]["maxX"] > stacked["green"]["minX"] + 50, \
+            f"the 2x2 raster should put red above green: {stacked}"
+
+        page.evaluate("""(panelId) => {
+          const name = 'panel_' + panelId + '_geom'
+          const geom = JSON.parse(window._aplModel.get(name))
+          for (const id in geom.raster_geom) {
+            geom.raster_geom[id].image_width = 4
+            geom.raster_geom[id].image_height = 1
+          }
+          window._aplModel.set(name, JSON.stringify(geom))
+        }""", coordinates._id)
+        page.evaluate(_TWO_FRAMES)
+
+        side_by_side = page.evaluate(_COLOUR_EXTENTS)
+        assert side_by_side["red"]["count"] > 1000 and side_by_side["green"]["count"] > 1000, \
+            f"the 4x1 raster lost a colour: {side_by_side}"
+        assert side_by_side["red"]["maxX"] <= side_by_side["green"]["minX"] + 2, \
+            f"the 4x1 raster was drawn from the stale 2x2 image: {side_by_side}"

{anyplotlib-0.10.0 → anyplotlib-0.10.1}/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.10.0/" />
-    <link rel="canonical" href="v0.10.0/" />
+    <meta http-equiv="refresh" content="0; url=v0.10.1/" />
+    <link rel="canonical" href="v0.10.1/" />
   </head>
   <body>
     <p>
-      Redirecting to <a href="v0.10.0/">v0.10.0 documentation</a>…
+      Redirecting to <a href="v0.10.1/">v0.10.1 documentation</a>…
     </p>
   </body>
 </html>

{anyplotlib-0.10.0 → anyplotlib-0.10.1}/docs/_root/switcher.json

@@ -4,6 +4,11 @@
     "version": "dev",
     "url": "https://cssfrancis.github.io/anyplotlib/dev/"
   },
+  {
+    "name": "v0.10.1 (stable)",
+    "version": "v0.10.1",
+    "url": "https://cssfrancis.github.io/anyplotlib/v0.10.1/"
+  },
   {
     "name": "v0.10.0 (stable)",
     "version": "v0.10.0",

{anyplotlib-0.10.0 → anyplotlib-0.10.1}/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.10.0"
+release = "0.10.1"
 
 # 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.