plotpress 0.24.0__tar.gz → 0.25.0__tar.gz

{plotpress-0.24.0 → plotpress-0.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotpress
-Version: 0.24.0
+Version: 0.25.0
 Summary: A fast, figure-centric plotting library with a matplotlib-like API, no global state, and one figure exportable to SVG, PNG, PDF, interactive HTML, or Vega/Vega-Lite.
 Author: plotpress contributors
 License: MIT
@@ -58,11 +58,15 @@ Dynamic: license-file
 
 # plotpress
 
-A **fast, dependency-light** plotting library that renders one figure to
-**SVG, PNG, PDF, Vega/Vega-Lite, and self-contained interactive HTML** — the
-HTML carrying a full pan/zoom, point-picking, and annotation toolbar —
-through a **matplotlib-shaped** API. **No global state**, **no compiled
-extension**, so it installs everywhere `pip` runs.
+**Scientific plots you can explore, share, and reuse.**
+
+A **fast, dependency-light** plotting library for scientific computing, with
+a **matplotlib-shaped** API and **no compiled extension** — install it
+anywhere Python does, from notebooks to CI pipelines to offline environments.
+It renders one figure to **SVG, PNG, PDF, Vega/Vega-Lite, and self-contained
+interactive HTML** — the HTML carrying a full pan/zoom, point-picking, and
+annotation toolbar. **No global state**, either — a `Figure` owns its own
+axes and its own `Style`.
 
 ```python
 import plotpress
@@ -86,9 +90,9 @@ genuinely shareable: the plotted data and the toolbar's own JS are both
 inlined into that one file, so anyone can open and interact with it with
 nothing installed on their end — no Python, no plotpress, no internet
 connection, just a browser. Email it, drop it in a chat, put it on a USB
-stick — it still works. PyPI/GitHub READMEs can't run the page's own script,
-so the three GIFs below stand in for it; open one yourself (or click through
-to the
+stick — it still works. Send someone a file, not a service they have to
+install. PyPI/GitHub READMEs can't run the page's own script, so the four
+GIFs below stand in for it; open one yourself (or click through to the
 [real-applications gallery](https://jrvannucci.github.io/plotpress/auto_applications/index.html),
 embedded exactly this way) and it's fully live.
 
@@ -106,7 +110,16 @@ point it's pinned to:
 
 ![Dropping an annotation on a bar chart and dragging its label away from the point it's pinned to](https://raw.githubusercontent.com/jrvannucci/plotpress/main/assets/readme_annotation.gif)
 
-## One figure, several outputs
+**At scale**, every gesture above still works the same way on a figure with
+hundreds of axes — zoom from the full grid into a handful of panels, pan,
+pick a value, remove it, pick again and drag its label, pan to a distant
+group, annotate, then back Home (the figure is
+[`docs/examples/grouping/plot_13_full_scale_demo.py`](https://jrvannucci.github.io/plotpress/auto_examples/grouping/plot_13_full_scale_demo.html) —
+500 `pcolormesh` panels, 250 groups, each with its own colorbar):
+
+![Zooming from a 500-panel figure into a handful of panels, panning, picking a value, removing and re-picking it, dragging its label, panning to a distant group, annotating, then Home](https://raw.githubusercontent.com/jrvannucci/plotpress/main/assets/readme_scale_demo.gif)
+
+## One figure. Many destinations.
 
 The same `Figure` built once from the matplotlib-shaped API renders to every
 format below — no separate figure per output, no plugin to install:
@@ -125,19 +138,22 @@ the core         Pillow)        svglib +       inlined --      real pixel-   str
 
 `fig.save(path, ...)` dispatches on the file extension for the first four;
 `fig.to_vega()` / `fig.to_vega_lite()` return a JSON specification as a plain
-`dict` for a separate Vega/Vega-Lite runtime to render, rather than a
-rendered artifact — useful for handing a figure to an existing Vega-based
-dashboard or notebook instead of embedding plotpress's own SVG/JS. See the
+`dict` for a separate Vega/Vega-Lite runtime to render — a bridge from
+scientific Python to web-native visualization, for handing a figure to an
+existing Vega-based dashboard or notebook without rebuilding the plot from
+scratch. See the
 [architecture docs](https://jrvannucci.github.io/plotpress/user_guide/architecture.html)
 for exactly how much of the rendering pipeline each of these six actually
 shares, and where a format gets its own dedicated path instead.
 
 ## Reading a figure back out of HTML
 
-The interactive HTML above isn't a one-way trip: it embeds the plotted data
-and the figure's own layout as JSON alongside the SVG, so a later process —
-with none of the Python objects that built it still around — can read a
-figure back out and rebuild it:
+A plot doesn't have to be a dead image. The interactive HTML above isn't a
+one-way trip: it embeds the plotted data and the figure's own layout as JSON
+alongside the SVG, so a later process — with none of the Python objects that
+built it still around — can read a figure back out and rebuild it. The
+figure becomes a portable representation of the data it displays, not just a
+picture of it:
 
 ```
 a saved .html (Figure.save(path, interactive=True))
@@ -182,6 +198,73 @@ layout still available under `ds.attrs["layout"]` for
 [data round-trip example](https://jrvannucci.github.io/plotpress/auto_examples/data_roundtrip/index.html)
 for both paths worked through end to end.
 
+## What makes it different
+
+1. **No `pyplot`, no globals.** There is no "current figure/axes" and no global
+   `rcParams`. A `Figure` owns its axes and its own `Style`; two figures never
+   share mutable state. `plotpress.subplots()` returns `(fig, axes)` just like
+   `plt.subplots()` — but touches no global state.
+2. **matplotlib-*shaped* API** so moving code either direction is mostly
+   mechanical: `Figure`/`Axes`, `plot`, `scatter`, `pcolormesh`,
+   `set_xlabel/ylabel/title`, `set_xlim/ylim`, `grid`, `legend`, `colorbar`. It
+   is shaped, not drop-in — there's no `pyplot` state machine and not every
+   matplotlib keyword is present; treat the gallery as the compatibility surface.
+3. **SVG-first + built for speed.** Output is vector SVG; only mesh/image layers
+   are rasterized (as a single embedded `<image>`, not thousands of rects). Each
+   series is one `<path>`. It's **pure Python + NumPy** — vectorized coordinate
+   formatting, min/max-decimated huge lines — with **no compiled extension**, so
+   it installs everywhere pip does.
+
+## Scientific visualization, end to end
+
+plotpress is designed around the way scientific figures actually get used:
+
+```
+Explore ──► Analyze ──► Visualize ──► Share ──► Publish ──► Archive ──► Reuse
+   ▲                                                                       │
+   └───────────────────────────────────────────────────────────────────────┘
+```
+
+- **Explore** — interact with a measurement, simulation, image, or spectrum
+  while building an experiment or analysis (pan/zoom, point-picking).
+- **Analyze** — the same figure workflow for signal processing, statistics,
+  and multidimensional data.
+- **Visualize** — build and style the figure: plot, arrange subplots, apply
+  colormaps and normalization.
+- **Share** — hand an interactive HTML figure to a collaborator — no server,
+  nothing to install on their end.
+- **Publish** — export a publication figure as SVG/PNG/PDF, or publish a
+  self-contained HTML figure that carries its own data.
+- **Archive** — keep the figure and its plotted data together in one
+  portable file.
+- **Reuse** — load the figure back with `plotpress.load_data()`, recover the
+  data, and analyze or replot it — the cycle starts again from Explore.
+
+## Made for real scientific workloads
+
+plotpress isn't just a handful of basic plotting primitives — it covers the
+kinds of figures scientists actually build. See
+[Supported plot types](#supported-plot-types) below for the full method
+list; the categories:
+
+- **Signal processing** — power spectral density, cross-spectral density,
+  coherence, spectrograms, autocorrelation, cross-correlation, and
+  magnitude/angle/phase spectra (pure-NumPy Welch estimators).
+- **2-D and gridded data** — images, meshes (including curvilinear grids),
+  contours, vector fields, and logarithmic/power/symlog normalization for
+  large scientific fields.
+- **Statistical visualization** — histograms, 2-D histograms, box plots,
+  violin plots, ECDFs, KDEs, event rasters, error bars, and hexbins.
+- **Complex figures** — subplot grids, shared axes, colorbars (including one
+  shared across several axes), secondary axes, inset axes, grouped panels,
+  figure-level titles/labels, and mixed layouts.
+- **Animation** — animated lines and meshes with frame sliders, exportable
+  as self-contained looping GIFs.
+- **Large figures** — built to keep object and output-node counts under
+  control, so a very large multi-panel figure stays practical; see the "At
+  scale" GIF above (500 `pcolormesh` panels, 250 groups, each with its own
+  colorbar).
+
 ## What it is for
 
 plotpress is **not a matplotlib replacement**, and it does not try to match
@@ -189,13 +272,15 @@ matplotlib's twenty years of breadth (no geographic projections or triangulated
 grids, one font-metric family, no 3-D, and its polar axes project onto the 2-D
 core rather than a dedicated pipeline — see [Supported plot types](#supported-plot-types)
 below). It aims at a narrower, underserved spot: plotting where matplotlib's
-install footprint or global state gets in the way.
+install footprint or global state gets in the way — scientific software
+doesn't always run on a developer laptop.
 
 **Reach for plotpress when you want to:**
 
-- **Ship plots from a constrained runtime** — locked-down servers, minimal
-  containers, Pyodide/WASM, or CI — where a pure-Python + NumPy install with no
-  build toolchain and no per-platform wheels matters.
+- **Ship plots from a constrained runtime** — locked-down networks, offline
+  systems, minimal containers, Pyodide/WASM, CI, or shared computing
+  environments — where a pure-Python + NumPy install with no build toolchain
+  and no per-platform wheels matters.
 - **Embed in web apps or notebooks** as SVG or self-contained interactive HTML
   whose JS makes no external requests (works under strict CSPs like Jupyter).
 - **Write library or server code** that should never touch a global "current
@@ -213,23 +298,6 @@ with one figure per method, and
 grouped by field, each explaining the axis, scale and colour choices the data
 forces. Every application figure is embedded live, with the interactive toolbar.
 
-## What makes it different
-
-1. **No `pyplot`, no globals.** There is no "current figure/axes" and no global
-   `rcParams`. A `Figure` owns its axes and its own `Style`; two figures never
-   share mutable state. `plotpress.subplots()` returns `(fig, axes)` just like
-   `plt.subplots()` — but touches no global state.
-2. **matplotlib-*shaped* API** so moving code either direction is mostly
-   mechanical: `Figure`/`Axes`, `plot`, `scatter`, `pcolormesh`,
-   `set_xlabel/ylabel/title`, `set_xlim/ylim`, `grid`, `legend`, `colorbar`. It
-   is shaped, not drop-in — there's no `pyplot` state machine and not every
-   matplotlib keyword is present; treat the gallery as the compatibility surface.
-3. **SVG-first + built for speed.** Output is vector SVG; only mesh/image layers
-   are rasterized (as a single embedded `<image>`, not thousands of rects). Each
-   series is one `<path>`. It's **pure Python + NumPy** — vectorized coordinate
-   formatting, min/max-decimated huge lines — with **no compiled extension**, so
-   it installs everywhere pip does.
-
 ## Install
 
 ```bash
@@ -298,11 +366,12 @@ grouped into Axes, Point Picking, Annotate, and File menus:
 - **Save**/**Save As** — persist pan/zoom, every pin/annotation, and every
   toggle above to a new (or the same) self-contained HTML file.
 
-`fig.to_html()`/`fig.save(..., interactive=True)` accept `pick_precision`
-(decimal places embedded per value) and `pick_max_mesh_cells`/
-`pick_max_points` (a hard cap on how much of each mesh/series is embedded for
-picking, per artist) to bound the interactive payload for mesh- or
-point-heavy figures.
+`fig.to_html()`/`fig.save(..., interactive=True)` also accept `extra_js` — a
+raw JS string inlined as its own `<script>`, for adding a custom tool to the
+same toolbar menu — plus `pick_precision` (decimal places embedded per
+value) and `pick_max_mesh_cells`/`pick_max_points` (a hard cap on how much of
+each mesh/series is embedded for picking, per artist) to bound the
+interactive payload for mesh- or point-heavy figures.
 
 Per axes: `ax.set_pickable(False)` excludes that axes from Point Picking
 (Axis Span/Zoom/Annotation still work everywhere), and

{plotpress-0.24.0 → plotpress-0.25.0}/README.md

@@ -1,10 +1,14 @@
 # plotpress
 
-A **fast, dependency-light** plotting library that renders one figure to
-**SVG, PNG, PDF, Vega/Vega-Lite, and self-contained interactive HTML** — the
-HTML carrying a full pan/zoom, point-picking, and annotation toolbar —
-through a **matplotlib-shaped** API. **No global state**, **no compiled
-extension**, so it installs everywhere `pip` runs.
+**Scientific plots you can explore, share, and reuse.**
+
+A **fast, dependency-light** plotting library for scientific computing, with
+a **matplotlib-shaped** API and **no compiled extension** — install it
+anywhere Python does, from notebooks to CI pipelines to offline environments.
+It renders one figure to **SVG, PNG, PDF, Vega/Vega-Lite, and self-contained
+interactive HTML** — the HTML carrying a full pan/zoom, point-picking, and
+annotation toolbar. **No global state**, either — a `Figure` owns its own
+axes and its own `Style`.
 
 ```python
 import plotpress
@@ -28,9 +32,9 @@ genuinely shareable: the plotted data and the toolbar's own JS are both
 inlined into that one file, so anyone can open and interact with it with
 nothing installed on their end — no Python, no plotpress, no internet
 connection, just a browser. Email it, drop it in a chat, put it on a USB
-stick — it still works. PyPI/GitHub READMEs can't run the page's own script,
-so the three GIFs below stand in for it; open one yourself (or click through
-to the
+stick — it still works. Send someone a file, not a service they have to
+install. PyPI/GitHub READMEs can't run the page's own script, so the four
+GIFs below stand in for it; open one yourself (or click through to the
 [real-applications gallery](https://jrvannucci.github.io/plotpress/auto_applications/index.html),
 embedded exactly this way) and it's fully live.
 
@@ -48,7 +52,16 @@ point it's pinned to:
 
 ![Dropping an annotation on a bar chart and dragging its label away from the point it's pinned to](https://raw.githubusercontent.com/jrvannucci/plotpress/main/assets/readme_annotation.gif)
 
-## One figure, several outputs
+**At scale**, every gesture above still works the same way on a figure with
+hundreds of axes — zoom from the full grid into a handful of panels, pan,
+pick a value, remove it, pick again and drag its label, pan to a distant
+group, annotate, then back Home (the figure is
+[`docs/examples/grouping/plot_13_full_scale_demo.py`](https://jrvannucci.github.io/plotpress/auto_examples/grouping/plot_13_full_scale_demo.html) —
+500 `pcolormesh` panels, 250 groups, each with its own colorbar):
+
+![Zooming from a 500-panel figure into a handful of panels, panning, picking a value, removing and re-picking it, dragging its label, panning to a distant group, annotating, then Home](https://raw.githubusercontent.com/jrvannucci/plotpress/main/assets/readme_scale_demo.gif)
+
+## One figure. Many destinations.
 
 The same `Figure` built once from the matplotlib-shaped API renders to every
 format below — no separate figure per output, no plugin to install:
@@ -67,19 +80,22 @@ the core         Pillow)        svglib +       inlined --      real pixel-   str
 
 `fig.save(path, ...)` dispatches on the file extension for the first four;
 `fig.to_vega()` / `fig.to_vega_lite()` return a JSON specification as a plain
-`dict` for a separate Vega/Vega-Lite runtime to render, rather than a
-rendered artifact — useful for handing a figure to an existing Vega-based
-dashboard or notebook instead of embedding plotpress's own SVG/JS. See the
+`dict` for a separate Vega/Vega-Lite runtime to render — a bridge from
+scientific Python to web-native visualization, for handing a figure to an
+existing Vega-based dashboard or notebook without rebuilding the plot from
+scratch. See the
 [architecture docs](https://jrvannucci.github.io/plotpress/user_guide/architecture.html)
 for exactly how much of the rendering pipeline each of these six actually
 shares, and where a format gets its own dedicated path instead.
 
 ## Reading a figure back out of HTML
 
-The interactive HTML above isn't a one-way trip: it embeds the plotted data
-and the figure's own layout as JSON alongside the SVG, so a later process —
-with none of the Python objects that built it still around — can read a
-figure back out and rebuild it:
+A plot doesn't have to be a dead image. The interactive HTML above isn't a
+one-way trip: it embeds the plotted data and the figure's own layout as JSON
+alongside the SVG, so a later process — with none of the Python objects that
+built it still around — can read a figure back out and rebuild it. The
+figure becomes a portable representation of the data it displays, not just a
+picture of it:
 
 ```
 a saved .html (Figure.save(path, interactive=True))
@@ -124,6 +140,73 @@ layout still available under `ds.attrs["layout"]` for
 [data round-trip example](https://jrvannucci.github.io/plotpress/auto_examples/data_roundtrip/index.html)
 for both paths worked through end to end.
 
+## What makes it different
+
+1. **No `pyplot`, no globals.** There is no "current figure/axes" and no global
+   `rcParams`. A `Figure` owns its axes and its own `Style`; two figures never
+   share mutable state. `plotpress.subplots()` returns `(fig, axes)` just like
+   `plt.subplots()` — but touches no global state.
+2. **matplotlib-*shaped* API** so moving code either direction is mostly
+   mechanical: `Figure`/`Axes`, `plot`, `scatter`, `pcolormesh`,
+   `set_xlabel/ylabel/title`, `set_xlim/ylim`, `grid`, `legend`, `colorbar`. It
+   is shaped, not drop-in — there's no `pyplot` state machine and not every
+   matplotlib keyword is present; treat the gallery as the compatibility surface.
+3. **SVG-first + built for speed.** Output is vector SVG; only mesh/image layers
+   are rasterized (as a single embedded `<image>`, not thousands of rects). Each
+   series is one `<path>`. It's **pure Python + NumPy** — vectorized coordinate
+   formatting, min/max-decimated huge lines — with **no compiled extension**, so
+   it installs everywhere pip does.
+
+## Scientific visualization, end to end
+
+plotpress is designed around the way scientific figures actually get used:
+
+```
+Explore ──► Analyze ──► Visualize ──► Share ──► Publish ──► Archive ──► Reuse
+   ▲                                                                       │
+   └───────────────────────────────────────────────────────────────────────┘
+```
+
+- **Explore** — interact with a measurement, simulation, image, or spectrum
+  while building an experiment or analysis (pan/zoom, point-picking).
+- **Analyze** — the same figure workflow for signal processing, statistics,
+  and multidimensional data.
+- **Visualize** — build and style the figure: plot, arrange subplots, apply
+  colormaps and normalization.
+- **Share** — hand an interactive HTML figure to a collaborator — no server,
+  nothing to install on their end.
+- **Publish** — export a publication figure as SVG/PNG/PDF, or publish a
+  self-contained HTML figure that carries its own data.
+- **Archive** — keep the figure and its plotted data together in one
+  portable file.
+- **Reuse** — load the figure back with `plotpress.load_data()`, recover the
+  data, and analyze or replot it — the cycle starts again from Explore.
+
+## Made for real scientific workloads
+
+plotpress isn't just a handful of basic plotting primitives — it covers the
+kinds of figures scientists actually build. See
+[Supported plot types](#supported-plot-types) below for the full method
+list; the categories:
+
+- **Signal processing** — power spectral density, cross-spectral density,
+  coherence, spectrograms, autocorrelation, cross-correlation, and
+  magnitude/angle/phase spectra (pure-NumPy Welch estimators).
+- **2-D and gridded data** — images, meshes (including curvilinear grids),
+  contours, vector fields, and logarithmic/power/symlog normalization for
+  large scientific fields.
+- **Statistical visualization** — histograms, 2-D histograms, box plots,
+  violin plots, ECDFs, KDEs, event rasters, error bars, and hexbins.
+- **Complex figures** — subplot grids, shared axes, colorbars (including one
+  shared across several axes), secondary axes, inset axes, grouped panels,
+  figure-level titles/labels, and mixed layouts.
+- **Animation** — animated lines and meshes with frame sliders, exportable
+  as self-contained looping GIFs.
+- **Large figures** — built to keep object and output-node counts under
+  control, so a very large multi-panel figure stays practical; see the "At
+  scale" GIF above (500 `pcolormesh` panels, 250 groups, each with its own
+  colorbar).
+
 ## What it is for
 
 plotpress is **not a matplotlib replacement**, and it does not try to match
@@ -131,13 +214,15 @@ matplotlib's twenty years of breadth (no geographic projections or triangulated
 grids, one font-metric family, no 3-D, and its polar axes project onto the 2-D
 core rather than a dedicated pipeline — see [Supported plot types](#supported-plot-types)
 below). It aims at a narrower, underserved spot: plotting where matplotlib's
-install footprint or global state gets in the way.
+install footprint or global state gets in the way — scientific software
+doesn't always run on a developer laptop.
 
 **Reach for plotpress when you want to:**
 
-- **Ship plots from a constrained runtime** — locked-down servers, minimal
-  containers, Pyodide/WASM, or CI — where a pure-Python + NumPy install with no
-  build toolchain and no per-platform wheels matters.
+- **Ship plots from a constrained runtime** — locked-down networks, offline
+  systems, minimal containers, Pyodide/WASM, CI, or shared computing
+  environments — where a pure-Python + NumPy install with no build toolchain
+  and no per-platform wheels matters.
 - **Embed in web apps or notebooks** as SVG or self-contained interactive HTML
   whose JS makes no external requests (works under strict CSPs like Jupyter).
 - **Write library or server code** that should never touch a global "current
@@ -155,23 +240,6 @@ with one figure per method, and
 grouped by field, each explaining the axis, scale and colour choices the data
 forces. Every application figure is embedded live, with the interactive toolbar.
 
-## What makes it different
-
-1. **No `pyplot`, no globals.** There is no "current figure/axes" and no global
-   `rcParams`. A `Figure` owns its axes and its own `Style`; two figures never
-   share mutable state. `plotpress.subplots()` returns `(fig, axes)` just like
-   `plt.subplots()` — but touches no global state.
-2. **matplotlib-*shaped* API** so moving code either direction is mostly
-   mechanical: `Figure`/`Axes`, `plot`, `scatter`, `pcolormesh`,
-   `set_xlabel/ylabel/title`, `set_xlim/ylim`, `grid`, `legend`, `colorbar`. It
-   is shaped, not drop-in — there's no `pyplot` state machine and not every
-   matplotlib keyword is present; treat the gallery as the compatibility surface.
-3. **SVG-first + built for speed.** Output is vector SVG; only mesh/image layers
-   are rasterized (as a single embedded `<image>`, not thousands of rects). Each
-   series is one `<path>`. It's **pure Python + NumPy** — vectorized coordinate
-   formatting, min/max-decimated huge lines — with **no compiled extension**, so
-   it installs everywhere pip does.
-
 ## Install
 
 ```bash
@@ -240,11 +308,12 @@ grouped into Axes, Point Picking, Annotate, and File menus:
 - **Save**/**Save As** — persist pan/zoom, every pin/annotation, and every
   toggle above to a new (or the same) self-contained HTML file.
 
-`fig.to_html()`/`fig.save(..., interactive=True)` accept `pick_precision`
-(decimal places embedded per value) and `pick_max_mesh_cells`/
-`pick_max_points` (a hard cap on how much of each mesh/series is embedded for
-picking, per artist) to bound the interactive payload for mesh- or
-point-heavy figures.
+`fig.to_html()`/`fig.save(..., interactive=True)` also accept `extra_js` — a
+raw JS string inlined as its own `<script>`, for adding a custom tool to the
+same toolbar menu — plus `pick_precision` (decimal places embedded per
+value) and `pick_max_mesh_cells`/`pick_max_points` (a hard cap on how much of
+each mesh/series is embedded for picking, per artist) to bound the
+interactive payload for mesh- or point-heavy figures.
 
 Per axes: `ax.set_pickable(False)` excludes that axes from Point Picking
 (Axis Span/Zoom/Annotation still work everywhere), and

plotpress-0.25.0/plotpress/_version.py

@@ -0,0 +1 @@
+__version__ = "0.25.0"

{plotpress-0.24.0 → plotpress-0.25.0}/plotpress/figure.py

@@ -728,14 +728,23 @@ class Figure:
             # rows in a column-band (say) still needs a top-margin band for
             # its top-facing title even though most of its own axes are in
             # rows 1+, same as one spanning a single row would.
+            # max(), not +=: every group touching a given outer edge shares
+            # that same margin band (they're side by side along it, not
+            # stacked), so the band only has to be tall/wide enough for the
+            # single largest title reaching it -- not the sum of every
+            # group's own extent. A grid with many groups along one edge
+            # (e.g. one group per column, all title_position="top") used to
+            # accumulate every one of their extents into one ever-growing
+            # top margin, producing a band of blank space scaling with the
+            # number of columns instead of a fixed, correctly-sized one.
             if pos == "top" and r0 == 0:
-                group_top_px += extent
+                group_top_px = max(group_top_px, extent)
             elif pos == "bottom" and r1 == nrows - 1:
-                group_bottom_px += extent
+                group_bottom_px = max(group_bottom_px, extent)
             elif pos == "left" and c0 == 0:
-                group_left_px += extent
+                group_left_px = max(group_left_px, extent)
             elif pos == "right" and c1 == ncols - 1:
-                group_right_px += extent
+                group_right_px = max(group_right_px, extent)
             if r0 > 0:
                 row_needs_hspace[r0 - 1] = True
             if r1 < nrows - 1:
@@ -1302,7 +1311,21 @@ class Figure:
                                      # falls back to its fixed width/height
                                      # attributes instead, undoing the scaling
         svg_style = (
-            "#plotpress-svg{cursor:default;box-shadow:0 1px 6px rgba(0,0,0,.2)}" if standalone
+            # flex-shrink:0 -- the SVG is a direct flex child of body (below)
+            # with no wrapper div (that only exists for a plot_frames()/
+            # pcolormesh_frames() figure's docked sliders, see above). Without
+            # it, a figure wider than the viewport -- unremarkable at ordinary
+            # sizes, real once the figure is genuinely large (hundreds of
+            # axes) -- got shrunk by the flex container's default
+            # flex-shrink:1 to fit the viewport's *width* only, since a
+            # replaced element's flex-basis shrinks independently per axis
+            # with no aspect-ratio preservation: the SVG's height stayed at
+            # its full, unscaled attribute value while its width compressed,
+            # rendering every element non-uniformly squashed rather than
+            # simply centered with the page free to scroll to see the rest,
+            # which is what happens with this set.
+            "#plotpress-svg{cursor:default;box-shadow:0 1px 6px rgba(0,0,0,.2);"
+            "flex-shrink:0}" if standalone
             else "#plotpress-svg{cursor:default;display:block;width:100%;height:auto}"
         )
         # A plot_frames()/pcolormesh_frames() figure wraps the SVG in a div

{plotpress-0.24.0 → plotpress-0.25.0}/plotpress/vega.py

@@ -67,7 +67,7 @@ from .artists import (
     Bars, ErrorBar, Line2D, Pie, QuadMesh, ScatterCollection, Stem, Text,
     Annotation, _VECTOR_CELL_LIMIT,
 )
-from .colors import Normalize, to_hex
+from .colors import Normalize, colorbar_ticks, to_hex
 from .png import png_data_uri
 from .primitives import artist_to_prims
 from .primitives import pie_center_radius, pie_label_positions
@@ -119,7 +119,10 @@ def figure_to_vega(fig, mesh_data: bool = False) -> dict:
     groups = []
     legend_axes = []
     for i, ax in enumerate(fig.axes):
-        if ax._is_colorbar or not ax._visible:
+        if not ax._visible:
+            continue
+        if ax._is_colorbar:
+            groups.append(_colorbar_to_group(ax, i, W, H, fig.style))
             continue
         groups.append(_axes_to_group(ax, i, W, H, size_scale, fig.style, mesh_data))
         if ax._show_legend:
@@ -208,6 +211,69 @@ def _axis_def(orient, scale_name, label, grid, custom_ticks, custom_labels, scal
     return axis
 
 
+def _colorbar_to_group(ax, i, W, H, st):
+    """A colorbar axes as its own Vega group: a gradient ``image`` mark (the
+    same 256x1-LUT-as-a-stretched-image technique svg.py's own
+    ``_render_colorbar`` uses) plus tick ``rule``/``text`` marks along its
+    right edge.
+
+    Not routed through ``_axes_to_group``/``artist_to_prims`` -- a colorbar
+    has no data-space x/y scale to encode marks against (its own
+    ``_resolved_limits()`` is meaningless placeholder 0..1), just a fixed
+    pixel rect and a ``Normalize`` to read tick positions from -- closer to
+    a `Text`/`Image` figure decoration than a real axes.
+    """
+    alloc = _pixel_rect(ax, W, H)
+    xlim, ylim = ax._resolved_limits()
+    px_left, px_top, px_w, px_h = _effective_rect(ax, *alloc, xlim, ylim)
+    src = ax._cbar_source
+    lut = src.lut
+    grad = np.flipud(lut).reshape(-1, 1, 3)  # top = vmax, matches svg.py
+    alpha = np.full((grad.shape[0], 1, 1), 255, np.uint8)
+    rgba = np.concatenate([grad, alpha], axis=2)
+    marks = [{
+        "type": "image",
+        "encode": {"enter": {
+            "x": {"value": round(float(px_left), 2)},
+            "y": {"value": round(float(px_top), 2)},
+            "width": {"value": round(float(px_w), 2)},
+            "height": {"value": round(float(px_h), 2)},
+            "url": {"value": png_data_uri(rgba)},
+            "smooth": {"value": False}, "aspect": {"value": False},
+        }},
+    }]
+    _, fracs, tlabels = colorbar_ticks(src.norm)
+    for frac, lab in zip(fracs, tlabels):
+        y = px_top + (1 - frac) * px_h
+        marks.append({
+            "type": "rule",
+            "encode": {"enter": {
+                "x": {"value": round(float(px_left + px_w), 2)}, "y": {"value": round(float(y), 2)},
+                "x2": {"value": round(float(px_left + px_w + st.tick_size), 2)}, "y2": {"value": round(float(y), 2)},
+                "stroke": {"value": _color(st.spine_color)},
+                "strokeWidth": {"value": float(st.tick_width)},
+            }},
+        })
+        marks.append({
+            "type": "text",
+            "encode": {"enter": {
+                "x": {"value": round(float(px_left + px_w + st.tick_size + 2), 2)},
+                "y": {"value": round(float(y + st.tick_label_size * 0.35), 2)},
+                "text": {"value": str(lab)},
+                "fontSize": {"value": float(st.tick_label_size)},
+                "fill": {"value": _color(st.text_color)},
+            }},
+        })
+    return {
+        "type": "group", "name": f"axes{i}",
+        "encode": {"enter": {
+            "x": {"value": 0}, "y": {"value": 0},
+            "width": {"value": round(float(W), 2)}, "height": {"value": round(float(H), 2)},
+        }},
+        "marks": marks,
+    }
+
+
 def _axes_to_group(ax, i, W, H, size_scale, st, mesh_data=False):
     alloc = _pixel_rect(ax, W, H)
     (xmin, xmax), (ymin, ymax) = ax._resolved_limits()