HyperTools 2.0: modernized toolbox, interactive backend, soft clustering, comprehensive visual verification

[jeremymanning]

HyperTools 2.0: modernized toolbox with interactive backend, soft clustering, and comprehensive visual verification

This PR modernizes hypertools end-to-end while preserving the public API, integrating the best ideas from the earlier refactor attempt (jeremymanning/hypertools dev branch + backend experiments) into the current, tested codebase. Full design rationale: notes/hypertools_2.0_roadmap.md.

Highlights

Interactive plotly backend with visual parity (backend='auto' | 'matplotlib' | 'plotly')

• matplotlib remains the default renderer everywhere; backend='auto' (the default) switches to plotly only on Google Colab and Kaggle. Existing local/CI workflows see zero change.
• The two backends produce visually matched output: identical colors, line/marker styles and sizes (pt→px calibrated), format strings (markers + dash styles), the signature wireframe cube / square frame, hidden axes, and matched camera angles. Evidence: 22 side-by-side montages in docs/images/v2.0-parity/ — matplotlib left, plotly right, same call.
• Animations on both backends (sliding window + camera spin with play/pause controls on plotly).

Mixture-model ("soft") clustering + robust coloring

• hyp.cluster(x, cluster='GaussianMixture' | 'BayesianGaussianMixture' | 'LatentDirichletAllocation' | 'NMF') returns (n_samples, n_components) membership proportions (rows sum to 1). Hard clustering unchanged.
• hyp.plot(x, cluster='GaussianMixture', ...) colors observations by proportion-weighted blends of component colors.
• hue accepts categorical labels, continuous values, or any 2D matrix via the new mat2colors.

Multicolored lines

• Continuous or matrix-valued hue + a line format string colors each trajectory continuously along its length on both backends (matplotlib Line3DCollection/LineCollection; plotly per-point line colors in 3D, segment traces in 2D).

Nested-list input with multilevel styling

• hyp.plot([[a, b], [c]]) colors datasets by outermost group; deeper nesting renders thinner + fainter. Text corpora keep existing behavior.

hyp.apply_model: the stack/unstack core

• Datasets are stacked, the model fits once across all of them, and results unstack to the input structure — what makes embeddings/labels comparable across datasets. Model specs: registry name / dict with params / sklearn-style instance / pipeline list. mode='auto'|fit_transform|fit_predict|predict_proba, return_model=True for held-out reuse, stack=False for per-dataset fits. Explicit whitelist registry (no eval).

Retired legacy arguments (long-deprecated)

• plot(group=...) → hue; plot(model=/model_params=) → reduce; reduce(model=/model_params=/normalize=/align=); align(method=/normalize=/ndims=) and the ambiguous align=True (now a clear ValueError with a migration hint); cluster(ndims=). Saved geos from hypertools 0.x still load — retired kwargs are translated (group→hue) or dropped with a warning on replay.

Bug fixes

• importing hypertools updates matplotlib rcParams #259 fixed: plotting no longer mutates global matplotlib rcParams (verified by before/after diff; regression-tested).
• Problem with creating multiple hypertools figures in a for loop #264 fixed: plots in loops no longer repeat the first plot — root cause was the memoize cache, whose str()-keys truncated numpy arrays so new data collided with stale entries. Cache removed; regression test reproduces the reported loop scenario.
• Plotting animations in Jupyter does not seem to be compatible with current Numpy (version 2 or greater) #265 fixed: animate=True under numpy≥2 — regression test reproduces the exact array from the issue report; also fixed the Colab/ipympl backend crash (matplotlib ≥3.9 raises ValueError, not ImportError, for broken module:// backends) and a broken-Tcl/Tk fallback.
• Long-standing is_line() bug: '' in Line2D.markers made it return False for every format string, silently disabling hypertools' smooth line interpolation on modern matplotlib. Fixed (with linestyle-aware parsing), restoring the intended rendering; per-point labels are now re-mapped onto interpolated trajectories.
• Fixed redundant format_data/PPCA pass per plot.

Performance, packaging, docs

• import hypertools: 5.1s → 1.4s (lazy umap/seaborn/scipy.interpolate).
• PEP 621 pyproject.toml (2.0.0.dev0, Python 3.10–3.13); setup.py/requirements.txt/MANIFEST.in/.travis.yml removed; extras [interactive], [dev]; CI matrix 3 OS × py3.10–3.13 with bumped actions + screenshot artifacts; readthedocs on py3.11; external hdbscan → sklearn's built-in; unmaintained pca-magic dropped.
• Docs updated throughout: README "What's new in 2.0"; 5 new gallery examples (interactive backend, mixture models, multicolored lines, nested lists, apply_model) — full sphinx site + gallery builds cleanly; apply_model added to the API reference; docstrings updated for all changed signatures.

Evidence: every function verified on both backends

• Test suite: 185 passing (was 136) — all real calls, no mocks. Includes regression tests reproducing importing hypertools updates matplotlib rcParams #259/Problem with creating multiple hypertools figures in a for loop #264/Plotting animations in Jupyter does not seem to be compatible with current Numpy (version 2 or greater) #265 from the issue reports.
• Visual verification matrix: 75/75 cases pass — every public function (plot, reduce, align, normalize, cluster, analyze, describe, format_data, load, apply_model, text input) across use cases on both backends: line/marker/dash styles, hue variants, clustering (hard + mixture), nested lists, multicolored lines, missing data, animations. Regenerate: python scripts/generate_verification_screenshots.py.
• Backend parity matrix: 22/22 montages — identical calls rendered side by side (matplotlib | plotly). Regenerate: python scripts/generate_parity_screenshots.py.
• Dev notebook executed end-to-end, 0 errors: dev/hypertools_2.0_dev_executed.ipynb.

Sample parity montages (matplotlib | plotly — same call)

case	montage
trajectories
multicolored line
mixture blending
dashed lines
nested multilevel

Breaking changes

• Python ≥3.10; dependency floors raised (numpy≥2, pandas≥2.2, sklearn≥1.4, matplotlib≥3.8).
• Retired arguments listed above raise TypeError/ValueError with migration hints (old saved geos are translated on replay).
• The buggy result cache is gone (recompute instead of risking wrong cached results).

---

⚠️ Do not merge without @jeremymanning's explicit sign-off.

🤖 Generated with Claude Code

[jeremymanning]

All review items addressed ✅

Every item from the review is now implemented, tested, and screenshotted (PR body updated with full details). Summary of what changed since the initial submission:

1. Backend visual parity

The plotly renderer was rewritten to reproduce the matplotlib output exactly: same wireframe cube / square framing, hidden axes, matched camera (elev/azim), pt→px-calibrated line widths and marker sizes, full format-string support (marker symbols + dash styles), and identical palette assignment. Evidence: 22 side-by-side montages (matplotlib left | plotly right, same call) in docs/images/v2.0-parity/ (manifest).

Multicolored line, same call on both backends:

2. Complete feature screenshot coverage

The verification matrix grew from 44 → 75 cases, all passing (manifest): clustering (hard + all four mixture models), multilevel/nested lists, multicolored lines (new feature — continuous per-segment coloring along trajectories, both backends), matrix/continuous/categorical hue, marker + line styles, animations, apply_model, and every other public function — each on both backends.

3. Formerly deferred items — all now in this PR

• hyp.apply_model (stack → fit once → unstack core): registry/dict/instance/pipeline model specs, return_model for held-out reuse, stack=False for per-dataset fits; 12 dedicated tests; gallery example + API reference entry.
• Sphinx gallery: 5 new examples (interactive backend, mixture models, multicolored lines, nested lists, apply_model); full docs site + gallery build cleanly.
• Animation bugs: Problem with creating multiple hypertools figures in a for loop #264 (loops repeating the first plot — memoize root cause) and Plotting animations in Jupyter does not seem to be compatible with current Numpy (version 2 or greater) #265 (numpy≥2 animations — exact repro from the issue) are fixed with regression tests, alongside importing hypertools updates matplotlib rcParams #259 (rcParams mutation).
• Deprecated kwargs retired: group, model/model_params, align(method=)/align=True, cluster(ndims=), reduce(normalize=/align=) — with clear migration errors, and old saved geos still replay (retired args translated with a warning).

Bonus fix found while restoring parity

is_line() had returned False for every format string on modern matplotlib ('' in Line2D.markers is a substring of everything), silently disabling hypertools' smooth line interpolation. Fixed — line plots are smooth again on both backends.

Final numbers: 185 tests passing · 75/75 verification cases · 22/22 parity montages · dev notebook executes with 0 errors · docs build clean · CI matrix green.

🤖 Generated with Claude Code

[jeremymanning]

Round-2 review items addressed ✅

1. Mixture demos now show true multi-class membership

All mixture-model demos (examples, screenshots, parity montages, dev notebook) use overlapping clusters (1.5 sd apart), so points in the overlap regions have genuinely mixed memberships and render with blended, intermediate colors. A new test asserts that a substantial fraction of points have soft (< 0.9 max-proportion) assignments.

2. Axis sizing/ratio and title placement now match

• Title: centered, black, 12pt on both backends (plotly previously rendered it off-center, blue-gray, oversized).
• 3D: plotly now uses matplotlib's default 4:4:3 box aspect and a matched camera distance, so the cube's shape and on-canvas size agree.
• 2D: the frame fills the canvas exactly like matplotlib (no forced square).
• Default canvas is 640×480 on both (matplotlib's default figsize).

All 22 parity montages regenerated: docs/images/v2.0-parity/.

3. Animation works and exports to gif / animated png / mp4 — both backends

hyp.plot(..., animate=..., save_path='file.gif' | '.png' | '.mp4') — the extension picks the format. matplotlib uses Pillow (gif/APNG) or ffmpeg (video); the plotly backend renders every frame via kaleido and assembles them (play/pause controls are excluded from exports). 7 new tests save real files and verify multi-frame output. Committed samples (INDEX):

matplotlib	plotly

The dev notebook now displays animations inline (to_jshtml for matplotlib; interactive frames for plotly) and demonstrates gif export — re-executed end-to-end with 0 errors.

4. Sphinx gallery renders plotly output (including animation)

docs/conf.py now uses the plotly sphinx-gallery scraper, so plotly figures produced by examples render into the gallery (verified in the rebuilt HTML: the interactive-backend page shows the plotly figure). A new animate_plotly example demonstrates plotly animation + export, with an animated GIF thumbnail wired into the existing post-build thumbnail mechanism.

Bonus: dataset-download hardening (found via a CI failure during this round)

One macOS CI job failed because Google Drive rate-limited a dataset download and returned an HTML error page with a 200 status, which load() cached as the dataset — poisoning every subsequent text-data test on that runner. load() now validates downloads (rejects HTML error pages), retries with backoff when rate-limited, and heals corrupt caches instead of leaving a poisoned file behind — regression-tested against the real failure mode. CI additionally shares one cross-OS cache of the example datasets so 24 concurrent jobs no longer hammer the download host every run.

Updated numbers: 193 tests passing · 75/75 verification cases · 22/22 parity montages · 4 committed animation exports · docs + gallery build clean · CI green.

🤖 Generated with Claude Code

[jeremymanning]

Round-3 review items — all 10 addressed ✅

1. SVG export: static AND animated, both backends

save_path='plot.svg' works everywhere. Animated exports produce a single self-contained SMIL-animated vector SVG (frames switched via discrete <animate>, looping, no JavaScript). Verified in a real browser: scrubbing the SVG timeline with setCurrentTime() in headless Chrome renders different frames on both backends. 4 new tests.

2. plotly window animation now rotates

animate=True on the plotly backend rotates the camera while the window advances, exactly like matplotlib. Re-exported sample:

3. Titles match

plotly titles are centered over the plot area (xref='paper'), black, 12pt, with a matplotlib-matched font stack. Parity montages regenerated (22/22): docs/images/v2.0-parity/.

4. Multi-panel figures verified

hyp.plot(..., ax=<subplot>) composes into user figure grids (3D + 2D panels mixed); when embedding, hypertools respects the caller's color cycle. Tested + screenshotted.

5. Hyperalignment n_iter

hyp.align(data, align='hyper', n_iter=10) — the common template is iteratively re-estimated (default 10; also settable via the dict form). Found and fixed two latent bugs in the same block: the dict form silently returned None, and a leftover method reference raised NameError.

6. Classic readthedocs figure reconstructed

hyp.plot(weights, align='hyper', animate=True, zoom=2.5) reproduces the hyperaligned-weights animation:

Getting this right exposed a real bug: Axes3D.dist was removed in matplotlib ≥3.8, so animation zoom had been silently doing nothing — now implemented via set_box_aspect(zoom=...) with the exact legacy scale mapping.

7. Modern sphinx theme

Docs now use pydata-sphinx-theme (numpy/pandas-style), full site + gallery compile verified; screenshots committed to docs/images/v2.0-theme/. Also fixed a docs-build hang: nbsphinx was re-executing every gallery notebook (nbsphinx_execute='never'; tutorials ship pre-executed).

8. Shapes zoo datasets

hyp.load('bunny' | 'cube' | 'dragon' | 'sphere' | 'teapot' | 'vase' | 'biplane' | 'datasaurus') — registered with their Dropbox sources (direct-URL download support; tolerant unpickler for the dill/legacy-pandas formats these were saved in; dill added as a dependency). All verified via real downloads. ⚠️ egyption_mask is intentionally excluded: the source file (locally and at the Dropbox link) is an empty (0, 3) array — flagging for you to re-export it.

9. No re-download copy leak

Verified + regression-tested: repeated hyp.load() calls leave the cache byte-identical (no duplicate files, no re-download, mtime unchanged).

10. Modern demos

• Gallery: plot_shapes_zoo (2×2 multi-panel point clouds) and plot_datasaurus (identical stats, different shapes).
• Tutorial notebooks (executed, 0 errors, in the docs toctree): Visualizing Hugging Face text embeddings — sentence-transformers + HF ag_news, category coloring, GaussianMixture soft clustering, UMAP, animated spin export; Modern scikit-learn models and dynamical systems — HDBSCAN, mixture blending, and a Lorenz-attractor multicolored-line animation.

Updated numbers: 202 tests passing · 75/75 verification cases · 22/22 parity montages · 5 committed animation exports · full docs + gallery build clean on the new theme · CI green.

🤖 Generated with Claude Code

[jeremymanning]

Round-4.5: the weights animation is solved, plus the requested animation & API fixes ✅

The story-trajectories mystery — full diagnosis

The classic readthedocs animation could not be reproduced by any plot(align=...) call because it was never produced by one. Working from the 2020 pieman_trajectory_demo notebook (hypertools 0.6.2 + timecorr), the actual pipeline is:

gaussian temporal smoothing (var=300)
  → hyp.align(...) applied REPEATEDLY (n_iter=20, SRM)
  → smooth again
  → UMAP
  → animate

Two things still had to be fixed/understood to make that work on modern dependencies:

1. align('SRM', n_iter=...) now re-fits SRM on each pass's aligned output (matching the notebook's loop). Inter-subject correlation plateaus at ~0.87 — the data's shared-signal ceiling (the vendored SRM is byte-identical to v0.6.2, so this matches era behavior).

2. UMAP's n_neighbors sets the whole character of the embedding. The modern default (15) keeps neighborhoods within-subject and disperses the aligned data into a hairball; very large values (150+) over-globalize and flatten the trajectory into a near-straight line. n_neighbors=36 (with min_dist=0.1) is the sweet spot: same-timepoint rows across the 36 subjects rope together into one tight bundle while preserving the dramatic looping bend of the classic reference.

   I verified this is a pure neighborhood-size effect, not a dependency-version artifact: the modern SRM alignment is byte-identical to v0.6.2 (SRM(features=min(shape[0])), re-fit per pass), and fitting the era umap-learn 0.4.6 on the same aligned data also produces a hairball at its default n_neighbors=15. So the look is recovered by neighborhood tuning on current dependencies rather than by pinning old ones.

The animation is the classic sliding-window style (animate=True) in a fixed space: the data are scaled once from the full dataset before animating, so the axis limits never depend on which window is visible — the comet travels along the loop inside a stationary cube while the camera makes one slow rotation (900 frames @30fps). I verified the fixed-view property programmatically: axis limits are identical across all frames while the visible fragment's extent slides along the trajectory. The full recipe is scripted in scripts/generate_weights_trajectory.py:

Along the way, repeated hyperalignment got a real fix too: procrustes' optimal scaling is < 1 under noise, so repeated passes shrank the data geometrically (eventually crashing). Per-pass rescaling keeps norms stable through n_iter=50.

Single-call soft clustering (requested syntax)

geo = hyp.plot(embeddings, '.', markersize=2, reduce='UMAP',
               cluster={'model': GaussianMixture, 'n_clusters': 10})

works verbatim: the cluster dict accepts top-level n_clusters and model classes (in both cluster() and plot()), and colors flow from the mixture proportions automatically as exact per-point blends. The Wikipedia tutorial now uses this one-liner (10s, 1 rotation, small dots):

Conversation demo on the new animate='serial' mode

Windows are now 3-sentence windows within each utterance, so utterances are truly disconnected trajectories; speaker colors repeat (one color per speaker); rotations=1; no frame clipping (border-verified):

30fps smooth/slow animation standard

All animations render at frame_rate=30 and gifs convert at fps=30 with no downsampling (the earlier choppiness came from fps-6/12 conversions). plotly's animation frame density is raised to 30 effective fps (cap 600). Regenerated at the new standard: shapes morph (3,510-frame mp4 + 30fps preview below), lorenz + HF spin tutorials (900 frames / 30s each), matplotlib evidence gifs (450 frames).

(One honest caveat: the two plotly evidence gifs kept their previous renders — kaleido makes 450-frame plotly exports impractically slow; everything user-facing uses the new standard.)

206 tests passing · all four tutorial notebooks re-executed with 0 errors · CI green.

🤖 Generated with Claude Code

[jeremymanning]

Round 5: streaming data (#101), streaming tutorial, and the ContextLab docs theme ✅

Streaming data — closes the oldest open feature request (#101, 2017)

Streams are now a first-class data type, exactly as specified in the issue thread: no streaming flag — hyp.plot() infers it from the structure of the input. Python iterators/generators and Hugging Face streaming datasets both work:

from datasets import load_dataset
ds = load_dataset('scikit-learn/iris', split='train', streaming=True)
geo = hyp.plot(ds, '.')          # streams straight in, nothing materialized

Semantics (matching the issue design + review guidance):

• stream_init (default 10,000): the initial samples used to estimate the normalization/reduction parameters. Those fitted models are then applied to every subsequent sample, which is added to the plot dynamically — verified by test: IncrementalPCA.n_samples_seen_ == stream_init after a full stream, and the stored model's transform() exactly reproduces the plotted trajectory.
• stream_chunk (default 100): how many samples are fetched per update; each chunk renders as one live redraw / one saved animation frame, so it sets the animation's temporal resolution.
• stream_max (default None): streaming continues until the stream ends, stream_max is hit, or the user hits Ctrl-C. Infinite streams render continually, and any save_path animation is finalized whenever streaming stops — including on interrupt (tested with a generator that raises KeyboardInterrupt mid-stream: the gif is finalized and the geometry returned).
• stream_window (optional): comet-style display of only the most recent samples for long/infinite streams; everything consumed is still retained on the returned geometry (geo.data, geo.xform_data, geo.stream_info).

Guardrails: reduction models must support transform() (IncrementalPCA default, PCA, UMAP; TSNE raises with a clear message); align/cluster raise for streams (a stream is a single dataset; streaming clustering is future work). Dict rows (the HF case) contribute their numeric fields in insertion order; .select_columns(...) gives exact control.

14 real tests (tests/test_streaming.py) — real generators, a real infinite stream, a real interrupt, and a real load_dataset(..., streaming=True) network stream; no mocks.

New executed tutorial (docs/tutorials/streaming_data.ipynb) with two streamed animations:

Docs theme: Furo with the ContextLab look

Ported from ContextLab/scheduler per review: stock Furo plus the lab's brand — Nunito Sans, lowercase 300-weight headings with 0.6 px letter-spacing, green #007030 (light) / #4CAF50 (dark). Screenshot-verified across index/API/tutorial pages:

220 tests passing (213 fast set + 7 animation-export) · streaming tutorial executed with 0 errors · docs build clean.

🤖 Generated with Claude Code

[jeremymanning]

Round 6: gallery pages render everything, dual-backend audit, notebooks-on-click, universal loader ✅

Gallery pages now display their outputs (including animations)

chemtrails.html (and 9 other pages) showed code with no output. Two independent root causes, both fixed:

1. sphinx-gallery only executed examples named plot_* — chemtrails/animate*/precog/explore/save_*/analyze were never run. All 39 examples now execute at build time, and matplotlib animations render as embedded HTML5 video (matplotlib_animations=(True,'mp4') + sphinxcontrib.video; the animation examples now expose ani = ani_geo.line_ani, which also documents how to grab the animation object).
2. nbsphinx was hijacking the pages: sphinx-gallery writes a downloadable .ipynb next to each generated .rst, and nbsphinx rendered the unexecuted notebook instead of the gallery page. Gallery notebooks are now excluded from the document build (downloads unaffected).

The chemtrails page with its playable 30s animation (screenshot):

Clicking a gallery example gets you a runnable notebook

Every example page opens with an Open in Colab badge (branch-aware link to the example's committed notebook) next to the .ipynb download — visible in the screenshot above, injected across all 40 pages by post_build.py. If you'd prefer gallery thumbnails to jump straight to Colab instead of the example page, that's a one-line change to the click handler — say the word.

Every example verified on BOTH backends

New audit harness (scripts/audit_gallery_backends.py) runs all 39 examples under matplotlib and plotly in subprocesses: 78/78 pass (full report, side-by-side spot-check). Two things fell out of it:

• A real, years-latent data-corruption bug: per-dataset format lists (['-','--']) routed each dataset through interp_array_list (plural), silently replacing 2D arrays with lists of per-row interpolations. It was unreachable for years because is_line() always returned False before its round-2 fix. Fixed (interp_array) with a regression test; this is what was crashing plot_procrustes and plot_missing_data.
• Plotly parity gaps closed: chemtrails/precog/bullettime now draw low-opacity trail traces on plotly window animations, tail_duration sets the plotly window length, and zoom moves the camera (mirroring the matplotlib zoom semantics) — none were previously forwarded to the plotly renderer. explore maps to plotly's native hover labels. (save_movie under plotly passes but takes ~32 min — kaleido renders all 600 mp4 frames; noted in the report.)

Universal loader (hyp.load + DataGeometry)

Strings (and lists of strings) resolve in the requested order: built-in dataset → local file (npy/npz/csv/tsv/txt/json/parquet/mat/pickle) → Hugging Face dataset (streaming=True feeds straight into hyp.plot) → Google Drive URL or bare file id → Dropbox URL/shared-link path → any URL with or without https://. Raw text still flows to the text-embedding pipeline (whitespace is the discriminator). All verified with real network fetches — including the legacy Drive-hosted files, Dropbox dl=0 links, and schemeless URLs. Also fixed df2mat for pandas≥2 (bool get_dummies produced object arrays that crashed mixed-dtype DataFrame plotting).

239 tests passing (232 fast set + 7 animation-export) · 78/78 dual-backend example runs · docs build clean with all examples executed (9m39s) · CI green.

🤖 Generated with Claude Code

[jeremymanning]

Round 6.5: animation pacing standard, streaming stability, legends, gallery UX ✅

One animation standard, both backends: 30 fps · 30 s · 1 rotation per 30 s

"Plotly is much too fast" had three stacked causes, each now fixed and regression-tested:

1. Library defaults — frame_rate 50→30, rotations 2→1, and plotly now generates exactly frame_rate × duration frames like matplotlib (its 600-frame cap is gone). A parity test asserts both backends produce identical 900 frames @ ~33 ms at defaults.
2. Saved geos smuggled in old pacing — gallery examples call geo.plot(...) on pickled example data whose stored kwargs carry their era's defaults (frame_rate=50, rotations=2), silently overriding current defaults. DataGeometry.plot no longer replays pacing kwargs from saved files (explicit overrides still win).
3. Docs rendering — plotly's sphinx-gallery renderer pushed every animation frame through kaleido for one static png (a 900-frame figure took ~57 min and would embed tens-of-MB pages). The docs path now writes a frame-stripped png + an interactive html with embedded frames capped at 150, each displayed proportionally longer — duration and rotation speed unchanged, pages ~0.1 MB.

All gallery animation mp4s re-rendered at the standard (verified 900 frames @ 30 fps via ffprobe), and the plotly evidence gifs re-exported at correct pacing.

Streaming: view is rock-stable, out-of-range samples clamp to the box

The data→box transform is frozen from the initial samples (the center+scale affine is captured once); every future sample passes through that exact transform, and anything outside the box is clamped to the closest point on its surface. Axis limits never change once set. Verified: zero vanishing ink across the re-rendered tutorial animation (previously drawn pixels never move), plus regression tests for exact drawn-position stability and box-surface clamping:

Legends: right of the plot, vertically centered (both backends)

matplotlib | plotly:

Gallery: thumbnails click through to notebooks, correct aspect

Thumbnail clicks were genuinely dead (sphinx-gallery ≥ 0.17 no longer wraps the image in a link, and the old fix-up JS targeted markup that no longer exists). Thumbnails now open the example's notebook on Colab; the title text under each thumbnail opens the example page with the rendered output. The animated thumbnails were also being squashed into squares from 4:3 sources — all seven are regenerated letterboxed at the correct aspect from the new 30 fps videos:

API docs

hyp.load's docstring documents the full resolution chain (builtin → local file → Hugging Face incl. streaming → Drive → Dropbox → URL, lists supported), and DataGeometry.plot/transform now document automatic string-source loading — both regenerate into the API reference.

(CI hardening: a kaleido subprocess wedged for 6 hours on one Windows runner before hitting the Actions timeout -- pytest-timeout now caps every test at 20 minutes so a hung native call fails fast instead of burning a runner.)

237 tests passing · gallery animations verified at 900 frames / 30 fps · streaming tutorial re-executed with 0 errors.

🤖 Generated with Claude Code