quantized-lab 0.8.0__py3-none-any.whl

quantized/routes/crystallography.py

@@ -0,0 +1,80 @@
+"""Thin crystallography route. Wraps ``calc.crystallography`` (pure formulas).
+
+Computes interplanar d-spacing from lattice parameters + Miller indices, and the
+unit-cell volume + theoretical density (from a chemical formula + Z); the math
+lives in calc, this only validates + serializes.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from quantized.calc.crystallography import cell_volume, d_spacing, theoretical_density
+from quantized.calc.formula import formula_mass
+
+router = APIRouter(prefix="/api/crystallography", tags=["crystallography"])
+
+
+class DSpacingRequest(BaseModel):
+    system: str
+    a: float
+    b: float = 0.0
+    c: float = 0.0
+    alpha: float = 90.0
+    beta: float = 90.0
+    gamma: float = 90.0
+    h: int
+    k: int
+    l: int  # noqa: E741 — Miller index, the conventional name
+
+
+@router.post("/dspacing")
+def dspacing(req: DSpacingRequest) -> dict[str, Any]:
+    """Interplanar d-spacing for (h,k,l) in the given crystal system."""
+    try:
+        return d_spacing(
+            req.system,
+            req.a,
+            req.b,
+            req.c,
+            req.h,
+            req.k,
+            req.l,
+            alpha=req.alpha,
+            beta=req.beta,
+            gamma=req.gamma,
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+class CellRequest(BaseModel):
+    a: float
+    b: float = 0.0  # ≤ 0 → defaults to a (cubic / rhombohedral)
+    c: float = 0.0  # ≤ 0 → defaults to a
+    alpha: float = 90.0
+    beta: float = 90.0
+    gamma: float = 90.0
+    formula: str = ""  # optional — enables molar mass + theoretical density
+    z: int = 1  # formula units per cell
+
+
+@router.post("/cell")
+def cell(req: CellRequest) -> dict[str, Any]:
+    """Unit-cell volume (ų) and, when a formula is given, molar mass + density."""
+    try:
+        a = req.a
+        b = req.b if req.b > 0 else a
+        c = req.c if req.c > 0 else a
+        volume = cell_volume(a, b, c, req.alpha, req.beta, req.gamma)
+        out: dict[str, Any] = {"volume": volume}
+        if req.formula.strip():
+            mass = formula_mass(req.formula)
+            out["molar_mass"] = mass
+            out["density"] = theoretical_density(mass, req.z, volume)
+        return out
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc

quantized/routes/diffusion.py

@@ -0,0 +1,58 @@
+"""Thin diffusion routes. Wraps ``calc.diffusion`` (pure formulas): Arrhenius
+diffusion coefficient / diffusion length / Fick's first-law flux. Validate ->
+call the pure fn -> serialize.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from quantized.calc import diffusion
+
+router = APIRouter(prefix="/api/diffusion", tags=["diffusion"])
+
+
+class ArrheniusRequest(BaseModel):
+    d0: float  # pre-exponential factor (cm²/s)
+    ea: float  # activation energy (eV)
+    t: float  # temperature (K)
+
+
+class DiffusionLengthRequest(BaseModel):
+    d: float  # diffusion coefficient (cm²/s)
+    t: float  # time (s)
+
+
+class FickFluxRequest(BaseModel):
+    d: float  # diffusion coefficient (cm²/s)
+    dc: float  # concentration difference (cm⁻³)
+    dx: float  # distance (cm)
+
+
+def _call(fn: Callable[..., dict[str, Any]], *args: Any, **kwargs: Any) -> dict[str, Any]:
+    try:
+        return fn(*args, **kwargs)
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post("/arrhenius")
+def arrhenius(req: ArrheniusRequest) -> dict[str, Any]:
+    """D = D0·exp(-Ea/(kB·T)) (cm²/s)."""
+    return _call(diffusion.arrhenius, req.d0, req.ea, req.t)
+
+
+@router.post("/diffusion-length")
+def diffusion_length(req: DiffusionLengthRequest) -> dict[str, Any]:
+    """L = √(D·t) (cm)."""
+    return _call(diffusion.diffusion_length, req.d, req.t)
+
+
+@router.post("/fick-flux")
+def fick_flux(req: FickFluxRequest) -> dict[str, Any]:
+    """J = -D·ΔC/Δx (atoms/(cm²·s))."""
+    return _call(diffusion.fick_flux, req.d, req.dc, req.dx)

quantized/routes/electrical.py

@@ -0,0 +1,101 @@
+"""Thin electrical-transport routes. Wraps ``calc.electrical`` (pure formulas):
+resistivity / sheet resistance / conductivity / mobility / current density /
+Hall effect / Wiedemann-Franz. Validate -> call the pure fn -> serialize.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from quantized.calc import electrical
+
+router = APIRouter(prefix="/api/electrical", tags=["electrical"])
+
+
+class ResistivityRequest(BaseModel):
+    rs: float
+    t: float  # thickness (cm)
+
+
+class SheetResistanceRequest(BaseModel):
+    rho: float
+    t: float
+
+
+class ConductivityRequest(BaseModel):
+    rho: float
+
+
+class MobilityRequest(BaseModel):
+    rho: float
+    n: float
+
+
+class CurrentDensityRequest(BaseModel):
+    i: float
+    area: float
+
+
+class HallRequest(BaseModel):
+    v_h: float
+    i: float
+    b: float
+    t: float  # thickness (cm)
+
+
+class WiedemannFranzRequest(BaseModel):
+    temperature: float | list[float]
+    resistivity: float | list[float]
+
+
+def _call(fn: Callable[..., dict[str, Any]], *args: Any, **kwargs: Any) -> dict[str, Any]:
+    try:
+        return fn(*args, **kwargs)
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post("/resistivity")
+def resistivity(req: ResistivityRequest) -> dict[str, Any]:
+    """ρ = R_s·t (Ω·cm)."""
+    return _call(electrical.resistivity, req.rs, req.t)
+
+
+@router.post("/sheet-resistance")
+def sheet_resistance(req: SheetResistanceRequest) -> dict[str, Any]:
+    """R_s = ρ/t (Ω/sq)."""
+    return _call(electrical.sheet_resistance, req.rho, req.t)
+
+
+@router.post("/conductivity")
+def conductivity(req: ConductivityRequest) -> dict[str, Any]:
+    """σ = 1/ρ (S/cm)."""
+    return _call(electrical.conductivity, req.rho)
+
+
+@router.post("/mobility")
+def mobility(req: MobilityRequest) -> dict[str, Any]:
+    """μ = 1/(q·n·ρ) (cm²/V·s)."""
+    return _call(electrical.mobility, req.rho, req.n)
+
+
+@router.post("/current-density")
+def current_density(req: CurrentDensityRequest) -> dict[str, Any]:
+    """J = I/A (A/cm²)."""
+    return _call(electrical.current_density, req.i, req.area)
+
+
+@router.post("/hall")
+def hall(req: HallRequest) -> dict[str, Any]:
+    """Single-point Hall: R_H, carrier density, carrier type."""
+    return _call(electrical.hall_single_point, req.v_h, req.i, req.b, req.t)
+
+
+@router.post("/wiedemann-franz")
+def wiedemann_franz(req: WiedemannFranzRequest) -> dict[str, Any]:
+    """κ_e = L₀·T/ρ (W/(cm·K))."""
+    return _call(electrical.wiedemann_franz, req.temperature, req.resistivity)

quantized/routes/electrochemistry.py

@@ -0,0 +1,83 @@
+"""Thin electrochemistry routes. Wraps ``calc.electrochemistry`` (pure
+formulas): Nernst potential / Butler-Volmer / Tafel slope / ohmic (iR) drop /
+double-layer capacitance. Validate -> call the pure fn -> serialize.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from quantized.calc import electrochemistry
+
+router = APIRouter(prefix="/api/electrochemistry", tags=["electrochemistry"])
+
+
+class NernstRequest(BaseModel):
+    e0: float
+    n: float
+    q: float
+    t: float = 298.15
+
+
+class ButlerVolmerRequest(BaseModel):
+    j0: float
+    eta: float
+    alpha: float = 0.5
+    t: float = 298.15
+
+
+class TafelRequest(BaseModel):
+    alpha: float
+    t: float = 298.15
+
+
+class OhmicDropRequest(BaseModel):
+    i: float
+    r: float
+
+
+class DoubleLayerRequest(BaseModel):
+    epsilon: float
+    d: float  # nm
+    area: float  # cm^2
+
+
+def _call(fn: Callable[..., dict[str, Any]], *args: Any, **kwargs: Any) -> dict[str, Any]:
+    try:
+        return fn(*args, **kwargs)
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.post("/nernst")
+def nernst(req: NernstRequest) -> dict[str, Any]:
+    """E = E⁰ − (R·T)/(n·F)·ln(Q) (V)."""
+    return _call(electrochemistry.nernst_potential, req.e0, req.n, req.q, t=req.t)
+
+
+@router.post("/butler-volmer")
+def butler_volmer(req: ButlerVolmerRequest) -> dict[str, Any]:
+    """j = j₀·[exp(αFη/RT) − exp(−(1−α)Fη/RT)] (A/cm²)."""
+    return _call(electrochemistry.butler_volmer, req.j0, req.eta, alpha=req.alpha, t=req.t)
+
+
+@router.post("/tafel-slope")
+def tafel_slope(req: TafelRequest) -> dict[str, Any]:
+    """b = 2.303·R·T/(α·F) (V/decade)."""
+    return _call(electrochemistry.tafel_slope, req.alpha, t=req.t)
+
+
+@router.post("/ohmic-drop")
+def ohmic_drop(req: OhmicDropRequest) -> dict[str, Any]:
+    """V_IR = I·R (V)."""
+    return _call(electrochemistry.ohmic_drop, req.i, req.r)
+
+
+@router.post("/double-layer-capacitance")
+def double_layer_capacitance(req: DoubleLayerRequest) -> dict[str, Any]:
+    """C = ε₀·ε_r·A/d (F)."""
+    return _call(electrochemistry.double_layer_capacitance, req.epsilon, req.d, req.area)

quantized/routes/export.py

@@ -0,0 +1,280 @@
+"""Thin export routes: DataStruct -> downloadable file (data formats).
+
+Wraps data exporters: ``io.xrd_csv`` (pure in-memory text), ``io.hdf5``
+(writes a binary file; staged in temp dir), and ``io.origin`` (LabTalk scripts
+for Origin). No formatting logic here — writers own it. Figure rendering is
+in ``routes.export_figures``. Filenames are sanitized before the
+Content-Disposition header.
+"""
+
+from __future__ import annotations
+
+import tempfile
+import zipfile
+from datetime import UTC, datetime
+from io import BytesIO
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Response
+from pydantic import BaseModel
+
+from quantized.datastruct import DataStruct
+from quantized.io.consolidated import consolidate_csv
+from quantized.io.hdf5 import write_hdf5
+from quantized.io.origin import GraphSpec, format_origin_project_script, format_origin_script
+from quantized.io.origin_com import com_available, send_to_origin
+from quantized.io.origin_project.writer import opj_bytes
+from quantized.io.xrd_csv import format_xrd_csv
+from quantized.routes._export_common import _attachment, _safe_name
+
+router = APIRouter(prefix="/api/export", tags=["export"])
+
+
+class XrdCsvRequest(BaseModel):
+    dataset: dict[str, Any]
+    fmt: str = "standard"
+    intensity: str = "both"
+    include_metadata: bool = True
+    filename: str = "export.csv"
+
+
+class Hdf5Request(BaseModel):
+    dataset: dict[str, Any]
+    corrected: dict[str, Any] | None = None
+    corrections: dict[str, float] | None = None
+    filename: str = "export.h5"
+
+
+@router.post("/xrd-csv")
+def export_xrd_csv(req: XrdCsvRequest) -> Response:
+    """XRD data -> CSV (standard) or Origin ASCII text, as a file download."""
+    try:
+        ds = DataStruct.from_dict(req.dataset)
+        text = format_xrd_csv(
+            ds,
+            fmt=req.fmt,
+            intensity=req.intensity,
+            include_metadata=req.include_metadata,
+        )
+    except (ValueError, KeyError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return Response(
+        content=text,
+        media_type="text/csv",
+        headers=_attachment(_safe_name(req.filename, ".csv")),
+    )
+
+
+@router.post("/hdf5")
+def export_hdf5(req: Hdf5Request) -> Response:
+    """DataStruct (+ optional corrected/corrections) -> self-describing HDF5."""
+    try:
+        ds = DataStruct.from_dict(req.dataset)
+        corr = DataStruct.from_dict(req.corrected) if req.corrected else None
+        with tempfile.TemporaryDirectory() as tmp:
+            out = Path(tmp) / "export.h5"
+            write_hdf5(ds, out, corr_data=corr, corrections=req.corrections)
+            payload = out.read_bytes()
+    except ImportError as exc:  # h5py absent (declared runtime dep, but be safe)
+        raise HTTPException(
+            status_code=501, detail="HDF5 export requires h5py"
+        ) from exc
+    except (ValueError, KeyError, IndexError, FileNotFoundError, FileExistsError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return Response(
+        content=payload,
+        media_type="application/x-hdf5",
+        headers=_attachment(_safe_name(req.filename, ".h5")),
+    )
+
+
+class OriginGraphSpec(BaseModel):
+    """Current plot-state snapshot for the ``.ogs`` GRAPH block (item 26) —
+    wire model for ``io.origin.GraphSpec``. Indices are 0-based value-channel
+    positions (same as ``PlotState``): ``y_keys=None`` means "all channels"."""
+
+    y_keys: list[int] | None = None
+    x_key: int | None = None
+    x_log: bool = False
+    y_log: bool = False
+    x_lim: tuple[float, float] | None = None
+    y_lim: tuple[float, float] | None = None
+    y2_keys: list[int] = []
+
+
+class OriginRequest(BaseModel):
+    dataset: dict[str, Any]
+    filename: str = "export"
+    log_x: bool = False
+    log_y: bool = False
+    make_graph: bool = True
+    graph: OriginGraphSpec | None = None
+
+
+class ConsolidatedItem(BaseModel):
+    dataset: dict[str, Any]
+    name: str = ""
+
+
+class OpjRequest(BaseModel):
+    datasets: list[ConsolidatedItem]
+    filename: str = "project"
+
+
+class OriginComRequest(BaseModel):
+    datasets: list[ConsolidatedItem]
+
+
+class ConsolidatedRequest(BaseModel):
+    datasets: list[ConsolidatedItem]
+    fmt: str = "standard"
+    filename: str = "consolidated.csv"
+
+
+@router.post("/origin")
+def export_origin(req: OriginRequest) -> Response:
+    """DataStruct -> a ZIP of an Origin LabTalk ``.ogs`` script + its CSV."""
+    stem = _safe_name(req.filename, "")
+    csv_name = f"{stem}_data.csv"
+    created = datetime.now(UTC).strftime("%Y-%m-%d %H:%M:%S")
+    graph_spec = None
+    if req.graph is not None:
+        g = req.graph
+        graph_spec = GraphSpec(
+            y_keys=tuple(g.y_keys) if g.y_keys is not None else None,
+            x_key=g.x_key,
+            x_log=g.x_log,
+            y_log=g.y_log,
+            x_lim=g.x_lim,
+            y_lim=g.y_lim,
+            y2_keys=tuple(g.y2_keys),
+        )
+    try:
+        ds = DataStruct.from_dict(req.dataset)
+        csv_text, ogs_text = format_origin_script(
+            ds,
+            csv_name=csv_name,
+            book_name=stem,
+            sheet_name=stem,
+            log_x=req.log_x,
+            log_y=req.log_y,
+            make_graph=req.make_graph,
+            created=created,
+            graph=graph_spec,
+        )
+    except (ValueError, KeyError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+    buf = BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        zf.writestr(f"{stem}.ogs", ogs_text)
+        zf.writestr(csv_name, csv_text)
+    return Response(
+        content=buf.getvalue(),
+        media_type="application/zip",
+        headers=_attachment(_safe_name(stem, ".zip")),
+    )
+
+
+@router.post("/consolidated")
+def export_consolidated(req: ConsolidatedRequest) -> Response:
+    """Multiple datasets -> one role-based CSV (per-dataset Q + value blocks)."""
+    try:
+        items = [(DataStruct.from_dict(it.dataset), it.name) for it in req.datasets]
+        text = consolidate_csv(items, fmt=req.fmt)
+    except (ValueError, KeyError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return Response(
+        content=text,
+        media_type="text/csv",
+        headers=_attachment(_safe_name(req.filename, ".csv")),
+    )
+
+
+@router.post("/opj")
+def export_opj(req: OpjRequest) -> Response:
+    """DataStructs -> a native Origin ``.opj`` project (readable by ANY Origin
+    version — Origin ≥2023 dropped writing .opj but still opens it)."""
+    try:
+        books = []
+        for item in req.datasets:
+            ds = DataStruct.from_dict(item.dataset)
+            if item.name and "origin_book" not in ds.metadata:
+                meta = dict(ds.metadata)
+                meta["origin_book"] = item.name
+                ds = DataStruct(
+                    time=ds.time,
+                    values=ds.values,
+                    labels=ds.labels,
+                    units=ds.units,
+                    metadata=meta,
+                )
+            books.append(ds)
+        payload = opj_bytes(books)
+    except (ValueError, KeyError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    stem = _safe_name(req.filename, "")
+    return Response(
+        content=payload,
+        media_type="application/octet-stream",
+        headers=_attachment(f"{stem}.opj"),
+    )
+
+
+@router.post("/origin-project")
+def export_origin_project(req: OpjRequest) -> Response:
+    """DataStructs -> a ZIP holding one LabTalk ``.ogs`` + one CSV per book."""
+    created = datetime.now(UTC).strftime("%Y-%m-%d %H:%M:%S")
+    try:
+        items = [(DataStruct.from_dict(i.dataset), i.name) for i in req.datasets]
+        csvs, ogs_text = format_origin_project_script(items, created=created)
+    except (ValueError, KeyError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    stem = _safe_name(req.filename, "")
+    buf = BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        zf.writestr(f"{stem}.ogs", ogs_text)
+        for csv_name, csv_text in csvs:
+            zf.writestr(csv_name, csv_text)
+    return Response(
+        content=buf.getvalue(),
+        media_type="application/zip",
+        headers=_attachment(_safe_name(stem, ".zip")),
+    )
+
+
+@router.get("/origin-com/status")
+def origin_com_status() -> dict[str, bool]:
+    """Whether COM "Send to Origin" (item 25) is usable right now: Windows +
+    pywin32 + ``QZ_ORIGIN_COM=1`` + (unverified here) a running OriginPro
+    instance. The UI uses this to show/hide the action; everywhere it is
+    False, use ``/origin`` or ``/origin-project`` instead."""
+    return {"available": com_available()}
+
+
+@router.post("/origin-com")
+def export_origin_com(req: OriginComRequest) -> dict[str, Any]:
+    """DataStructs -> new workbooks in a RUNNING Origin instance via COM
+    (item 25, Windows-only optional). 409 when COM is unavailable or Origin
+    rejects the push — use ``/origin`` or ``/origin-project`` instead."""
+    if not req.datasets:
+        raise HTTPException(status_code=422, detail="datasets must be non-empty")
+    if not com_available():
+        raise HTTPException(
+            status_code=409,
+            detail=(
+                "Origin COM is unavailable on this machine (needs Windows, "
+                "pywin32, QZ_ORIGIN_COM=1, and a running OriginPro instance). "
+                "Use POST /api/export/origin or /api/export/origin-project instead."
+            ),
+        )
+    try:
+        items = [DataStruct.from_dict(i.dataset) for i in req.datasets]
+        book_names = [i.name for i in req.datasets]
+        result = send_to_origin(items, book_names=book_names)
+    except (ValueError, KeyError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    except RuntimeError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+    return result

quantized/routes/export_facets.py

@@ -0,0 +1,83 @@
+"""Faceted (small-multiples) figure export route (ORIGIN_GAP_PLAN #21).
+
+Split into its own router file (rather than joining `routes/export_figures.py`)
+purely to keep that file under the 500-line god-module ceiling — it was
+already at 421 lines before this endpoint. Wraps `calc.figure_facets`.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Response
+from pydantic import BaseModel
+
+from quantized.routes._export_common import (
+    _DPI_MAX,
+    _DPI_MIN,
+    _FIGURE_MIME,
+    _attachment,
+    _safe_name,
+)
+
+router = APIRouter(prefix="/api/export", tags=["export"])
+
+
+class FacetSeries(BaseModel):
+    label: str
+    y: list[float]
+
+
+class FacetPanel(BaseModel):
+    label: str
+    x: list[float]
+    series: list[FacetSeries]
+
+
+class FacetsFigureRequest(BaseModel):
+    panels: list[FacetPanel]  # one per facet-column level (frontend lib/facet.facetPayloads)
+    x_log: bool = False
+    y_log: bool = False
+    fmt: str = "pdf"
+    style: str = "default"
+    title: str = ""
+    x_label: str = ""
+    y_label: str = ""
+    dpi: int = 200
+    width_in: float | None = None
+    height_in: float | None = None
+    filename: str = "facets"
+
+
+@router.post("/facets-figure")
+def export_facets_figure(req: FacetsFigureRequest) -> Response:
+    """Render a small-multiples (faceted) figure (gap #21): one panel per
+    facet-column level, sharing scales, tiled into a grid (PDF/SVG/PNG/TIFF)."""
+    if req.fmt not in _FIGURE_MIME:
+        raise HTTPException(
+            status_code=422, detail=f"fmt must be one of {sorted(_FIGURE_MIME)}"
+        )
+    dpi = max(_DPI_MIN, min(_DPI_MAX, req.dpi))
+    from quantized.calc.figure_facets import render_facets_figure  # lazy: matplotlib is heavy
+
+    try:
+        panels: list[dict[str, Any]] = [
+            {
+                "label": p.label,
+                "x": p.x,
+                "series": [{"label": s.label, "y": s.y} for s in p.series],
+            }
+            for p in req.panels
+        ]
+        img = render_facets_figure(
+            panels, x_log=req.x_log, y_log=req.y_log, fmt=req.fmt, style=req.style,
+            title=req.title, x_label=req.x_label, y_label=req.y_label, dpi=dpi,
+            width_in=req.width_in, height_in=req.height_in,
+        )
+    except (ValueError, KeyError, IndexError, TypeError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return Response(
+        content=img,
+        media_type=_FIGURE_MIME[req.fmt],
+        headers=_attachment(_safe_name(req.filename, f".{req.fmt}")),
+    )