quantized-lab 0.26.1__tar.gz → 0.28.0__tar.gz

quantized_lab-0.28.0/PKG-INFO

@@ -0,0 +1,198 @@
+Metadata-Version: 2.5
+Name: quantized-lab
+Version: 0.28.0
+Summary: Plot, analyze, and publish lab data - magnetometry, XRD, reflectometry - with OriginPro file interop, golden-verified analysis, and reproducible pipelines.
+Project-URL: Homepage, https://github.com/pquarterman17/quantized
+Project-URL: Documentation, https://github.com/pquarterman17/quantized/wiki
+Project-URL: Repository, https://github.com/pquarterman17/quantized
+Project-URL: Releases, https://github.com/pquarterman17/quantized/releases
+Project-URL: Issues, https://github.com/pquarterman17/quantized/issues
+Author: Paige Quarterman
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.139.0
+Requires-Dist: h5py>=3.10
+Requires-Dist: matplotlib>=3.11.0
+Requires-Dist: numpy>=1.26
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: periodictable>=1.7
+Requires-Dist: platformdirs>=4.10.0
+Requires-Dist: pydantic>=2.7
+Requires-Dist: python-multipart>=0.0.32
+Requires-Dist: scipy>=1.11
+Requires-Dist: uvicorn[standard]>=0.51.0
+Provides-Extra: bumps
+Requires-Dist: bumps>=1.0; extra == 'bumps'
+Provides-Extra: client
+Requires-Dist: httpx>=0.27; extra == 'client'
+Provides-Extra: desktop
+Requires-Dist: pywebview>=5.1; extra == 'desktop'
+Provides-Extra: office
+Requires-Dist: python-docx>=1.1; extra == 'office'
+Requires-Dist: python-pptx>=1.0; extra == 'office'
+Provides-Extra: origin-com
+Requires-Dist: pywin32; (sys_platform == 'win32') and extra == 'origin-com'
+Provides-Extra: stats
+Requires-Dist: lifelines>=0.27; extra == 'stats'
+Requires-Dist: statsmodels>=0.14; extra == 'stats'
+Description-Content-Type: text/markdown
+
+# quantized
+
+<p align="center">
+  <!-- Absolute URL, not a repo-relative path: this README is also the PyPI
+       long_description (pyproject `readme`), and PyPI cannot resolve
+       repo-relative images. -->
+  <img src="https://raw.githubusercontent.com/pquarterman17/quantized/main/assets/branding/quantized-app-icon.png" alt="Quantized logo" width="180">
+</p>
+
+**Plot, analyze, and publish lab data — magnetometry, X-ray/neutron
+diffraction & reflectometry, transport — in one fast, reproducible app.**
+
+A clean-architecture Python (FastAPI) + React application, born as a port
+of the `quantized_matlab` scientific toolbox and grown into a full
+OriginPro-class daily driver. Backend math is **golden-verified** against
+the MATLAB original; the GUI is a ground-up revamp.
+
+> **Install:** `pip install quantized-lab` → run `qz`
+> (the PyPI name is `quantized-lab`; the package you import and the
+> commands you run are plain `quantized` / `qz`)
+
+## What it does
+
+**Import instrument data** — Quantum Design VSM/PPMS/MPMS, Lake Shore VSM,
+PANalytical XRDML (1-D scans *and* 2-D reciprocal-space maps with Q-space),
+Rigaku, NCNR reflectometry/PNR, refl1d, SIMS, generic CSV/Excel — with
+content sniffing for ambiguous extensions, drag-drop, paste, guided import
+wizard, and one-click re-import when the source file changes.
+
+**Read and write OriginPro files** — native, clean-room `.opj`/`.opju`
+readers recover workbooks, figures (with styles, legends, annotations),
+and notes; the `.opj` writer produces projects real Origin loads; plus
+Origin-ASCII + `.ogs` scripts, `.otp` template import, and an optional
+Windows COM "Send to Origin" bridge.
+
+**Explore interactively** — an Origin-style pointer tool (drag, resize,
+and pin plot text; draggable legends), multi-window MDI with linked
+zoom/cursor groups, a ctrl-click panel builder (side-by-side / grid /
+overlay with automatic dual-Y by unit family), linked row selection and
+masking across every view, worksheet with formulas and filters, and
+app-wide **undo/redo**.
+
+**Analyze with domain depth** — 29+ fit models plus a no-eval custom
+equation builder, AICc model scanning, global/batch/ODR fits, an optional
+[bumps](https://github.com/bumps/bumps) engine with DREAM posterior
+sampling; a Peak Analyzer wizard; baselines from ALS to Shirley to
+interactive anchor points; Parratt reflectivity; RSM strain analysis;
+Williamson-Hall, FFT film thickness, and reflectivity-FFT reductions;
+hysteresis, relaxation, and a full statistics suite.
+
+**Publish** — every plot window is a durable **figure document**: save,
+reopen, rename, and duplicate figures without losing errors, secondary
+axes, styles, or annotations. **Publication Preview** edits that same
+document at output size — tweak fonts, ticks, margins, axis breaks, and
+annotations in a live WYSIWYG preview (drag the legend, right-click any
+element), then Apply as one undoable change or Cancel cleanly. Export is
+vector PDF/SVG (server-rendered matplotlib) that matches the screen:
+rich-text labels (µ₀H, Å⁻¹, χ″…), journal size presets
+(APS/Nature/thesis…), per-series styles, fills, color-mapped scatter,
+and a multi-panel figure composer for Fig. 1(a)–(d)-style pages.
+
+**Stay reproducible** — every correction is a replayable pipeline step
+with a recalculation DAG, a macro recorder emits runnable scripts,
+workspaces save to a single `.dwk` file, and everything is scriptable
+through the HTTP API and a plugin system.
+
+**DiraCulator** — the built-in materials calculators (units, X-ray/neutron,
+crystallography, SLD, semiconductors, superconductors, magnetism, optics,
+vacuum, and more) also launch standalone: `diraculator` (or
+`qz --calc`), with its own Start Menu entry in the Windows installer.
+
+## Scope
+
+Magnetometry / XRD / reflectometry / lab-data analysis. Electron-microscopy
+tooling (EELS/EDS, imaging) is **out of scope** and lives in the separate
+`fermiviewer` project.
+
+## Run it
+
+| Method | Command | Notes |
+|--------|---------|-------|
+| pipx (recommended) | `pipx install quantized-lab && qz` | isolated env, `qz` on PATH, no dev tools needed |
+| uv tool | `uv tool install quantized-lab && qz` | same idea, via `uv` |
+| pip | `pip install quantized-lab && qz` | into whatever env is active |
+| Native installer | download from [Releases](https://github.com/pquarterman17/quantized/releases) | Windows `.exe` (NSIS, auto-updates), macOS `.dmg` (Apple silicon only — no Intel/x86-64 build), Linux `.deb` — no Python required |
+| From source | see below | for development |
+
+Once installed, `qz` serves the app at `http://127.0.0.1:8000` and opens a
+browser tab. An empty library shows a **"Drop files here, or use ⊞ to import
+/ ✚ for a demo"** hint — click **✚** for an instant synthetic dataset, so a
+fresh install has something to plot within seconds.
+
+**From source — double-click a launcher** (builds the UI + installs deps on
+first run, then opens the app in your browser):
+
+- **Windows:** double-click `run.cmd`
+- **macOS:** double-click `run.command` (first time: right-click → Open)
+
+**Or one command** (after `uv` + Node.js are installed):
+
+```bash
+# first time only: build the UI bundle the app serves
+cd frontend && npm install && npm run build && cd ..
+
+uv run qz                 # serve on :8000 and open a browser tab
+uv run qz --port 9000     # different port
+uv run qz --no-browser    # headless (don't open a tab; never auto-exits)
+uv run qz --desktop       # native window (needs: pip install quantized-lab[desktop])
+uv run qz --dev           # contributor mode: Vite HMR + reloading backend
+uv run diraculator        # the materials calculators, standalone
+```
+
+The default mode behaves like an app: closing the last browser tab shuts
+the server down (a page refresh doesn't). Set `QZ_AUTO_SHUTDOWN=0` to opt
+out, use `--no-browser` for a persistent/headless server, or stop any mode
+with **Ctrl+C** in its window. A busy port falls back to a free one
+automatically, so the app and a standalone DiraCulator coexist.
+
+Building your own wheel/sdist? Build the frontend **first** —
+`cd frontend && npm ci && npm run build` — before `uv build`, or the wheel
+ships without a UI.
+
+## Documentation
+
+- **[Wiki](https://github.com/pquarterman17/quantized/wiki)** — installation,
+  getting started, feature guides, Origin interop
+- **[Releases](https://github.com/pquarterman17/quantized/releases)** —
+  installers + changelogs
+- [`CHANGELOG.md`](https://github.com/pquarterman17/quantized/blob/main/CHANGELOG.md)
+  — plain-language changes per release, Keep a Changelog format
+- [`RELEASE.md`](https://github.com/pquarterman17/quantized/blob/main/RELEASE.md)
+  — how releases are built and published
+- In-app: **⌘K** command palette, **Help ▸ Keyboard shortcuts**, and
+  **Help ▸ Text formatting** for the rich-text label syntax
+
+## Architecture (for contributors)
+
+Pure `io/` + `calc/` libraries (data in → results out, no web imports),
+thin FastAPI `routes/`, a 500-line per-module ceiling, ~400-line React
+component ceiling, and **golden tests** that freeze MATLAB outputs as the
+parity oracle — enforced by tests, not convention. See
+[`CLAUDE.md`](https://github.com/pquarterman17/quantized/blob/main/CLAUDE.md)
+for the rules and
+[`CONTRIBUTING.md`](https://github.com/pquarterman17/quantized/blob/main/CONTRIBUTING.md)
+for the gate and the flake-fix evidence standard.
+
+```bash
+uv sync --group dev                    # backend deps
+uv run python tools/gate.py            # the whole gate, one command (~8 min)
+
+# what it runs, if you want to run a step by hand:
+uv run pytest -n auto        # backend tests (+ `-m golden` for MATLAB parity)
+uv run ruff check src tests tools && uv run mypy src
+cd frontend && npm test && npm run build
+```
+
+License: Apache-2.0.

quantized_lab-0.28.0/pyproject.toml

@@ -0,0 +1,178 @@
+[project]
+name = "quantized-lab"
+version = "0.28.0"
+description = "Plot, analyze, and publish lab data - magnetometry, XRD, reflectometry - with OriginPro file interop, golden-verified analysis, and reproducible pipelines."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "Apache-2.0"
+authors = [{ name = "Paige Quarterman" }]
+dependencies = [
+    "fastapi>=0.139.0",
+    "uvicorn[standard]>=0.51.0",
+    "numpy>=1.26",
+    "scipy>=1.11",
+    "pydantic>=2.7",
+    "openpyxl>=3.1",
+    "h5py>=3.10",
+    "python-multipart>=0.0.32",
+    "matplotlib>=3.11.0",
+    "periodictable>=1.7",
+    "platformdirs>=4.10.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/pquarterman17/quantized"
+Documentation = "https://github.com/pquarterman17/quantized/wiki"
+Repository = "https://github.com/pquarterman17/quantized"
+Releases = "https://github.com/pquarterman17/quantized/releases"
+Issues = "https://github.com/pquarterman17/quantized/issues"
+
+[project.scripts]
+qz = "quantized.cli:main"
+quantized = "quantized.cli:main"
+diraculator = "quantized.cli:main_calc"
+
+[project.optional-dependencies]
+# Word/PowerPoint report export (#37). MIT-licensed, pure-python. Optional so
+# the core install stays lean — io/report_export.py guards these imports and
+# LaTeX/HTML export always work; `pip install quantized[office]` enables .docx/.pptx.
+office = [
+    "python-docx>=1.1",
+    "python-pptx>=1.0",
+]
+# COM "Send to Origin" (item 25) — Windows-only optional, behind QZ_ORIGIN_COM=1
+# (architecture guard #10: never a hard dependency, never a CI requirement).
+# io/origin_com.py imports win32com lazily and guards its absence; the
+# cross-platform fallback (Origin-ASCII / .ogs, always available) is
+# io/origin.py. `pip install quantized[origin-com]` adds the live COM path.
+origin-com = [
+    "pywin32; sys_platform == 'win32'",
+]
+# `qz --desktop` native window (PORT_PLAN #3): pure-Python pywebview shell for
+# dev/daily use; the Tauri shell (src-tauri/) stays the packaged path (W8).
+# BSD-3 licensed. server_launch.py guards the import — without this extra,
+# `qz --desktop` prints an install hint and every other mode works normally.
+desktop = [
+    "pywebview>=5.1",
+]
+# Advanced statistics: GLM, survival analysis, Cox PH (gap #30). BSD-3 / MIT
+# licensed. Optional so core install stays lean — calc/stats_glm.py and
+# calc/stats_survival.py guard these imports; ROC is pure numpy and always
+# available. `pip install quantized[stats]` enables GLM/survival methods.
+stats = [
+    "statsmodels>=0.14",
+    "lifelines>=0.27",
+]
+# Optional bumps fit engine (GOTO #10). BSD-3 licensed. calc/fit_bumps.py
+# guards the import — the MATLAB-parity fitter (calc/fitting.py, golden-locked)
+# stays the default engine everywhere; bumps adds amoeba/lm/de/dream as an
+# ADDITIONAL engine. `pip install quantized[bumps]` enables it.
+bumps = [
+    "bumps>=1.0",
+]
+# quantized.client (scripting/API slice 1) — a network client for an
+# ALREADY-RUNNING `qz` server, distinct from the in-process `quantized.api`.
+# BSD-licensed. client.py guards the import; `pip install quantized[client]`
+# enables `QuantizedClient`. Already a dev dependency (TestClient), so this
+# adds no new package to CI, only a new extras group.
+client = [
+    "httpx>=0.27",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+    "httpx>=0.27",
+    "ruff>=0.15.21",
+    "mypy>=2.2.0",
+    # exercise the optional office exporters (#37) in CI
+    "python-docx>=1.1",
+    "python-pptx>=1.0",
+    # exercise the optional stats methods (GLM/survival/Cox) in CI
+    "statsmodels>=0.14",
+    "lifelines>=0.27",
+    # exercise the optional bumps fit engine (GOTO #10) in CI
+    "bumps>=1.0",
+    "pytest-xdist>=3.8.0",
+]
+# Desktop packaging only — used by the release workflow to freeze the server
+# into a self-contained sidecar (tools/bundle/qz-server.spec). Never a runtime
+# dependency; CI installs it with `uv sync --group bundle`.
+bundle = [
+    "pyinstaller>=6.10",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+# Hatchling's default sdist has no include/exclude list, so it sweeps in the
+# whole repo (frontend/node_modules alone is 5000+ files) — scope it to just
+# what a build needs: the package sources (including src/quantized/web/, the
+# gitignored Vite build output, and src/quantized/samples/, the bundled demo
+# dataset — both walked from disk, not from git, so they're picked up when
+# present) plus top-level metadata. Build the SPA BEFORE `uv build` / `python
+# -m build` (`cd frontend && npm ci && npm run build`) or the wheel ships
+# without a UI (qz still runs — see cli.py's "UI not built" warning).
+[tool.hatch.build.targets.sdist]
+include = ["src/quantized", "README.md", "LICENSE", "NOTICE"]
+# Hatchling force-includes LICENSE*/README*-named files project-wide by
+# default (a footgun here: every vendored npm package under
+# frontend/node_modules ships its own LICENSE + README.md) — exclude wins
+# over that default, so this is required even with the include list above.
+exclude = ["frontend/**"]
+# The Vite SPA output (src/quantized/web/**) is gitignored, so hatchling's
+# VCS-aware sdist drops it even though it's under the `include` path above.
+# `uv build`/`python -m build` build the WHEEL FROM THIS SDIST, so if the SPA
+# is missing here it's missing from the wheel too (the wheel target's own
+# artifacts= can't re-add what the sdist never carried). Force-include it in
+# BOTH targets. (Regression fixed 2026-07-08: v0.5.0's wheel shipped UI-less.)
+artifacts = ["src/quantized/web/**"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/quantized"]
+# `packages` alone only reliably ships src/quantized/web/ when hatchling
+# builds directly against a live git checkout; building the wheel FROM an
+# sdist (what `uv build`/`python -m build` do by default, and what the
+# publish workflow does) drops it, since that step can't see this repo's
+# .git and treats the gitignored build output as excluded. `artifacts` is
+# hatchling's explicit "include this even though it looks ignored" escape
+# hatch — force it so the SPA ships in both the direct-build and
+# build-from-sdist paths.
+artifacts = ["src/quantized/web/**"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.ruff.lint.per-file-ignores]
+# Miller indices are conventionally named h, k, l — `l` is unavoidable and clear
+# in crystallographic context (E741 "ambiguous variable name").
+"src/quantized/calc/crystallography.py" = ["E741"]
+"src/quantized/calc/miller_bravais.py" = ["E741"]
+"src/quantized/calc/plane_spacings.py" = ["E741"]
+"src/quantized/routes/crystallography.py" = ["E741"]
+"tests/test_crystallography.py" = ["E741"]
+"tests/test_calc_planespacings.py" = ["E741"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+
+[[tool.mypy.overrides]]
+# Third-party libs without bundled type stubs — skeleton-safe.
+module = ["scipy.*", "uvicorn.*", "openpyxl.*", "h5py.*", "periodictable.*", "docx.*", "pptx.*", "mpl_toolkits.*", "win32com.*", "statsmodels.*", "lifelines.*", "pandas.*", "webview.*", "bumps.*"]
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+addopts = "--strict-markers"
+markers = [
+    "golden: compares output against frozen quantized_matlab reference values",
+    "realdata: needs the local-only instrument corpus (auto-skips when absent)",
+    "perf: wall-time regression tripwires with generous ceilings (not benchmarks)",
+    "perfguard: R7 bounded large-map regression guard, run in a dedicated non-blocking CI job",
+]

quantized_lab-0.28.0/src/quantized/__init__.py

@@ -0,0 +1,11 @@
+"""quantized — Python backend for the quantized toolbox port.
+
+Layered, enforced architecture (see CLAUDE.md):
+  - ``datastruct`` + ``io`` + ``calc`` are pure libraries (no web imports).
+  - ``routes`` are thin FastAPI adapters.
+"""
+
+from __future__ import annotations
+
+__version__ = "0.28.0"
+__all__ = ["__version__"]

quantized_lab-0.28.0/src/quantized/api.py

@@ -0,0 +1,257 @@
+"""``quantized`` headless public API — drive the analysis engine from code.
+
+ORIGIN_GAP_PLAN #9. Everything the app does to your data is a pure function you
+can call from a script, notebook, or CI job — no GUI, no server, cross-platform.
+This is the differentiator Origin structurally can't match: *analysis is code*.
+
+This module is the **blessed, stable surface**. Names here are frozen — a
+rename or removal breaks ``tests/test_public_api.py`` on purpose. The
+underlying modules (``quantized.calc.*`` / ``quantized.io.*``) may reorganize;
+import from here to stay insulated.
+
+Example — load a scan, integrate a peak, build a report, render it::
+
+    import numpy as np
+    import quantized.api as qz
+
+    data = qz.load("scan.xy")                     # any registered format -> DataStruct
+    x, y = data.time, data.column(0)
+
+    result = qz.integrate_peaks(x, y, [(28.0, 32.0)])   # net area / centroid / FWHM
+    fit = qz.fit_single_peak(x, y, 28.0, 32.0, seed_center=30.0, model="Gaussian")
+
+    report = qz.from_stats_table(
+        [{"region": "111", **result["peaks"][0]}], title="Peak integration"
+    )
+    open("report.html", "w").write(qz.to_html(report.to_dict()))
+    pdf = qz.render_figure(x, [("intensity", y)], fmt="pdf")   # publication vector
+
+Note: importing this module pulls in matplotlib (for the render helpers), so it
+is heavier than ``import quantized``; the FastAPI server never imports it.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+# ── Data contract + file loading ──────────────────────────────────────────
+from quantized.calc.backgrounds import (
+    anchor_baseline,
+    footprint_correction,
+    shirley_background,
+    xrd_low_angle_background,
+)
+from quantized.calc.baseline import (
+    baseline_als,
+    baseline_modpoly,
+    baseline_rolling_ball,
+    estimate_background,
+    fit_region_background,
+)
+
+# ── Corrections ────────────────────────────────────────────────────────────
+from quantized.calc.corrections import apply_corrections
+
+# ── Publication rendering (matplotlib) ─────────────────────────────────────
+from quantized.calc.figure import render_figure
+from quantized.calc.figure_map import render_map_figure
+from quantized.calc.figure_statplots import render_statplot_figure
+
+# ── Curve & peak fitting ───────────────────────────────────────────────────
+from quantized.calc.fitting import curve_fit
+from quantized.calc.peak_batch import batch_integrate_peaks
+from quantized.calc.peak_fit import fit_single_peak
+from quantized.calc.peak_integrate import integrate_peaks
+from quantized.calc.peak_multifit import fit_multi_peak
+from quantized.calc.peaks import find_peaks_robust
+
+# ── Reporting ──────────────────────────────────────────────────────────────
+from quantized.calc.report import (
+    ReportSheet,
+    figure_block,
+    params_block,
+    section,
+    source_ref,
+    table_block,
+    text_block,
+    validate_report,
+)
+from quantized.calc.report_emit import (
+    from_anova,
+    from_batch_integrate,
+    from_curve_fit,
+    from_integrate,
+    from_stats_table,
+)
+from quantized.calc.report_emit_peaks import from_multipeak_fit
+
+# ── Statistical plots ──────────────────────────────────────────────────────
+from quantized.calc.statplots import (
+    box_stats,
+    grouped_box_stats,
+    histogram,
+    qq_plot,
+    violin_kde,
+)
+
+# ── Statistics ─────────────────────────────────────────────────────────────
+from quantized.calc.stats import (
+    anova1,
+    descriptive_stats,
+    lin_regress,
+    pca_analysis,
+    t_test,
+)
+from quantized.calc.stats_anova2 import anova2, dunnett_test, tukey_hsd
+from quantized.calc.stats_anova_ext import anova2_unbalanced, repeated_measures_anova
+from quantized.calc.stats_dist import fit_distribution, required_n, t_test_power
+from quantized.calc.stats_multivar import (
+    correlation_matrix,
+    multiple_regression,
+    partial_correlation,
+    stepwise_regression,
+)
+from quantized.calc.stats_tests import (
+    anderson_darling,
+    friedman,
+    kruskal_wallis,
+    ks_normal,
+    ks_two_sample,
+    levene,
+    mann_whitney,
+    recommend_test,
+    shapiro_wilk,
+    sign_test,
+    wilcoxon_signed_rank,
+)
+from quantized.datastruct import DataStruct
+from quantized.heavy_import import heavy_imports
+from quantized.io.registry import import_auto as load
+from quantized.io.report_export import figure_target, format_value_error, to_html, to_latex
+from quantized.io.report_export import render_report as _render_report_io
+
+
+def render_report(
+    report: Mapping[str, Any],
+    fmt: str,
+    *,
+    render_figures: bool = False,
+    warnings: list[str] | None = None,
+) -> tuple[bytes, str, bool]:
+    """Render ``report`` to ``fmt`` (see ``io.report_export.render_report``).
+
+    ``render_figures=True`` additionally renders every figure block's
+    ``spec`` first, through the SAME exporter ``/api/export/figure`` and the
+    server's own report route use (``routes.report_figures``) — so a report
+    built and rendered entirely from a script embeds real figures too, not
+    just the placeholder text ``io.report_export.render_report`` alone can
+    produce for a spec-bearing block (PRIMARY_SOFTWARE_AUDIT_PLAN P3.6 review,
+    finding 10: the pure ``io``/``calc`` layers may never import ``routes``,
+    so spec rendering lives there — this wrapper is ``api.py``'s own bridge to
+    it, paid for only by scripts that ask for it; the plan note on that
+    finding documents why the deeper move — a calc-level ``render_figure_spec``
+    shared by the route and this wrapper — is future work, not done here).
+    Default ``False`` keeps this byte-identical to the plain export.
+    """
+    figures = None
+    if render_figures:
+        # Local import: quantized.routes pulls in fastapi/pydantic, a cost
+        # this module's own docstring already promises to defer (matplotlib
+        # there, the web stack here) -- paid only by a caller that asks. Goes
+        # through heavy_imports like every other lazy quantized.* import
+        # (BUG-032 guard).
+        with heavy_imports("quantized.routes.report_figures"):
+            from quantized.routes.report_figures import render_report_figures
+
+        figures = render_report_figures(dict(report), figure_target(fmt))
+    return _render_report_io(report, fmt, figures=figures, warnings=warnings)
+
+
+__all__ = [
+    # data + I/O
+    "DataStruct",
+    "load",
+    # fitting
+    "curve_fit",
+    "fit_single_peak",
+    "fit_multi_peak",
+    "find_peaks_robust",
+    "integrate_peaks",
+    "batch_integrate_peaks",
+    # baseline
+    "estimate_background",
+    "fit_region_background",
+    "baseline_als",
+    "baseline_modpoly",
+    "baseline_rolling_ball",
+    # backgrounds (GOTO #2/#3/#7 — new beyond MATLAB parity)
+    "anchor_baseline",
+    "shirley_background",
+    "xrd_low_angle_background",
+    "footprint_correction",
+    # corrections
+    "apply_corrections",
+    # statistics — core
+    "descriptive_stats",
+    "lin_regress",
+    "t_test",
+    "anova1",
+    "pca_analysis",
+    # statistics — multivariate
+    "multiple_regression",
+    "correlation_matrix",
+    "partial_correlation",
+    "stepwise_regression",
+    # statistics — designed experiments
+    "anova2",
+    "anova2_unbalanced",
+    "repeated_measures_anova",
+    "tukey_hsd",
+    "dunnett_test",
+    # statistics — nonparametric + assumptions
+    "mann_whitney",
+    "wilcoxon_signed_rank",
+    "kruskal_wallis",
+    "friedman",
+    "sign_test",
+    "shapiro_wilk",
+    "anderson_darling",
+    "levene",
+    "ks_normal",
+    "ks_two_sample",
+    "recommend_test",
+    # statistics — distributions + power
+    "fit_distribution",
+    "t_test_power",
+    "required_n",
+    # statistical plots
+    "box_stats",
+    "grouped_box_stats",
+    "violin_kde",
+    "qq_plot",
+    "histogram",
+    # reporting
+    "ReportSheet",
+    "section",
+    "text_block",
+    "table_block",
+    "params_block",
+    "figure_block",
+    "source_ref",
+    "validate_report",
+    "from_curve_fit",
+    "from_multipeak_fit",
+    "from_anova",
+    "from_stats_table",
+    "from_integrate",
+    "from_batch_integrate",
+    # export / rendering
+    "render_figure",
+    "render_map_figure",
+    "render_statplot_figure",
+    "render_report",
+    "to_latex",
+    "to_html",
+    "format_value_error",
+]