quantized-lab 0.9.0__tar.gz → 0.11.0__tar.gz

{quantized_lab-0.9.0 → quantized_lab-0.11.0}/.gitignore

@@ -16,6 +16,13 @@ node_modules/
 frontend/dist/
 *.tsbuildinfo
 
+# ── Playwright E2E (GUI_INTERACTION_PLAN #15) ──────────────────────────
+frontend/test-results/
+frontend/playwright-report/
+frontend/e2e/test-results/
+frontend/e2e/playwright-report/
+frontend/blob-report/
+
 # ── Tauri / desktop ───────────────────────────────────────────────────
 src-tauri/target/
 

{quantized_lab-0.9.0 → quantized_lab-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantized-lab
-Version: 0.9.0
+Version: 0.11.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

{quantized_lab-0.9.0 → quantized_lab-0.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "quantized-lab"
-version = "0.9.0"
+version = "0.11.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"

{quantized_lab-0.9.0 → quantized_lab-0.11.0}/src/quantized/__init__.py

@@ -7,5 +7,5 @@ Layered, enforced architecture (see CLAUDE.md):
 
 from __future__ import annotations
 
-__version__ = "0.9.0"
+__version__ = "0.11.0"
 __all__ = ["__version__"]

{quantized_lab-0.9.0 → quantized_lab-0.11.0}/src/quantized/app.py

@@ -25,12 +25,14 @@ from quantized.routes import (
     calc,
     corrections,
     crystallography,
+    database,
     diffusion,
     electrical,
     electrochemistry,
     export,
     export_facets,
     export_figures,
+    export_figures_aux,
     export_page,
     fitting,
     fitting_bumps,
@@ -146,6 +148,7 @@ def create_app() -> FastAPI:
     application.include_router(import_template.router)
     application.include_router(plot.router)
     application.include_router(corrections.router)
+    application.include_router(database.router)
     application.include_router(fitting.router)
     application.include_router(fitting_bumps.router)
     application.include_router(jobs_api.router)
@@ -156,6 +159,7 @@ def create_app() -> FastAPI:
     application.include_router(reference.router)
     application.include_router(export.router)
     application.include_router(export_figures.router)
+    application.include_router(export_figures_aux.router)
     application.include_router(export_facets.router)
     application.include_router(export_page.router)
     application.include_router(report_export.router)

{quantized_lab-0.9.0 → quantized_lab-0.11.0}/src/quantized/calc/figure.py

@@ -27,12 +27,12 @@ from quantized.calc.figure_labels import safe_mathtext_label  # noqa: E402
 from quantized.calc.figure_overrides import _apply_overrides, _validate_overrides  # noqa: E402
 from quantized.calc.figure_scale import apply_axis_scale, resolve_axis_scale  # noqa: E402
 from quantized.calc.figure_styles import FigureStyle, figure_style  # noqa: E402
-from quantized.calc.figure_ticks import apply_tick_formats  # noqa: E402
+from quantized.calc.figure_ticks import apply_tick_formats, apply_tick_steps  # noqa: E402
 
 __all__ = ["draw_series_axes", "render_figure", "style_rc"]
 
 _FORMATS = ("pdf", "svg", "png", "tiff")
-_LINESTYLE = {"solid": "-", "dashed": "--", "dotted": ":"}
+_LINESTYLE = {"solid": "-", "dashed": "--", "dotted": ":", "none": "none"}
 # Fixed fill translucency for MAIN #13 (fill under/between curves) — matches
 # the screen side's `uplotFill.ts` FILL_ALPHA_PCT (25%) so an exported figure
 # reads the same as its on-screen counterpart.
@@ -177,6 +177,8 @@ def draw_series_axes(
     series_styles: Sequence[Mapping[str, Any] | None] | None = None,
     x_fmt: Mapping[str, Any] | None = None,
     y_fmt: Mapping[str, Any] | None = None,
+    x_step: float | None = None,
+    y_step: float | None = None,
 ) -> list[Any]:
     """Plot ``series`` into an EXISTING Axes: lines, scales, labels, spines,
     legend, grid, and the per-figure override sweep (:func:`_apply_overrides`).
@@ -221,8 +223,11 @@ def draw_series_axes(
         (line,) = ax.plot(xv, yv, label=label, **kw)
         _apply_fill(ax, xv, yv, series, i, spec, line.get_color())
         artists.append(line)
-    apply_axis_scale(ax, "x", resolve_axis_scale(x_scale, x_log))
-    apply_axis_scale(ax, "y", resolve_axis_scale(y_scale, y_log))
+    resolved_x_scale = resolve_axis_scale(x_scale, x_log)
+    resolved_y_scale = resolve_axis_scale(y_scale, y_log)
+    apply_axis_scale(ax, "x", resolved_x_scale)
+    apply_axis_scale(ax, "y", resolved_y_scale)
+    apply_tick_steps(ax, x_step, y_step, resolved_x_scale, resolved_y_scale)
     apply_tick_formats(ax, x_fmt, y_fmt)
     if title:
         ax.set_title(title)
@@ -242,9 +247,10 @@ def draw_series_axes(
             loc=st.legend_location,
         )
     if st.grid_alpha > 0:
-        ax.grid(True, alpha=st.grid_alpha)
+        ax.grid(True, which="major", alpha=st.grid_alpha)
+        ax.grid(True, which="minor", alpha=st.grid_alpha * 0.4)
     else:
-        ax.grid(False)
+        ax.grid(False, which="both")
     _apply_overrides(fig, ax, st, ov, n_series=len(series))
     return artists
 
@@ -270,6 +276,13 @@ def _render_impl(
     collect_map: bool = False,
     x_fmt: Mapping[str, Any] | None = None,
     y_fmt: Mapping[str, Any] | None = None,
+    x_step: float | None = None,
+    y_step: float | None = None,
+    y2_mask: Sequence[bool] | None = None,
+    y2_label: str = "",
+    y2_scale: str | None = None,
+    y2_fmt: Mapping[str, Any] | None = None,
+    y2_step: float | None = None,
 ) -> bytes | dict[str, Any]:
     """Render ``series`` (each ``(label, y)``) against ``x`` to image bytes.
 
@@ -295,7 +308,17 @@ def _render_impl(
     (MAIN #12) select linear/log/reciprocal; ``x_log``/``y_log`` are the
     back-compat boolean fallback (see :func:`draw_series_axes`'s doc).
     ``x_fmt``/``y_fmt`` (MAIN #24) are the tick-label number format -- see
-    :func:`draw_series_axes`'s doc.
+    :func:`draw_series_axes`'s doc. ``y2_mask`` (parallel to ``series``,
+    ``True`` marks a channel drawn on a secondary/right Y axis) dispatches to
+    :func:`quantized.calc.figure_y2.render_with_secondary_axis` -- a real
+    ``Axes.twinx()`` -- instead of ``draw_series_axes``'s single axes;
+    ``None``/all-``False`` (the default) is today's single-axis behaviour,
+    byte-identical. ``y2_label``/``y2_scale``/``y2_fmt``/``y2_step`` mirror
+    their primary-axis counterparts but apply only to the secondary axis;
+    a fixed secondary range rides ``overrides["y2_lim"]`` (see
+    ``figure_y2.render_with_secondary_axis``'s doc). Not compatible with
+    ``x_breaks`` (raises ``ValueError``) -- a broken figure has several
+    axes already and gains no coherent secondary-axis meaning.
     """
     if fmt not in _FORMATS:
         raise ValueError(f"fmt must be one of {_FORMATS}")
@@ -307,11 +330,16 @@ def _render_impl(
     title = safe_mathtext_label(title)
     x_label = safe_mathtext_label(x_label)
     y_label = safe_mathtext_label(y_label)
+    y2_label = safe_mathtext_label(y2_label)
     series = [(safe_mathtext_label(label), y) for label, y in series]
     st = figure_style(style)
     ov = dict(overrides or {})
     _validate_overrides(ov)
     resolved_dpi = int(dpi) if dpi is not None else int(st.dpi)
+    y2_mask_list = list(y2_mask) if y2_mask is not None else [False] * len(series)
+    if len(y2_mask_list) != len(series):
+        raise ValueError("y2_mask must have the same length as series")
+    has_y2 = any(y2_mask_list)
 
     # rc_context scopes typography to this render (see style_rc). (matplotlib's
     # RcParams Literal-key type is impractical with the dynamic font.<generic>
@@ -321,6 +349,8 @@ def _render_impl(
 
     xv: NDArray[np.float64] = np.asarray(x, dtype=float)
     x_breaks = ov.get("x_breaks")
+    if has_y2 and x_breaks:
+        raise ValueError("y2_keys is not supported together with x_breaks")
     with matplotlib.rc_context(rc):  # type: ignore[arg-type]
         # Manual axis breaks (gap #21): a distinct, twinned-panel rendering
         # path — not compatible with the hit-map collector (collect_map is
@@ -352,27 +382,47 @@ def _render_impl(
                 series_styles=series_styles,
                 x_fmt=x_fmt,
                 y_fmt=y_fmt,
+                x_step=x_step,
+                y_step=y_step,
             )
         fig, ax = plt.subplots(figsize=figsize)
         try:
-            artists = draw_series_axes(
-                fig,
-                ax,
-                xv,
-                series,
-                st=st,
-                ov=ov,
-                x_log=x_log,
-                y_log=y_log,
-                x_scale=x_scale,
-                y_scale=y_scale,
-                title=title,
-                x_label=x_label,
-                y_label=y_label,
-                series_styles=series_styles,
-                x_fmt=x_fmt,
-                y_fmt=y_fmt,
-            )
+            if has_y2:
+                # Lazy import: mirrors figure_break's own lazy import above —
+                # keeps this module's own top-level import list light, and
+                # the twinx orchestration out of the 500-line ceiling here.
+                from quantized.calc.figure_y2 import render_with_secondary_axis
+
+                artists = render_with_secondary_axis(
+                    fig, ax, xv, series, series_styles, y2_mask_list,
+                    st=st, ov=ov, x_log=x_log, y_log=y_log,
+                    x_scale=x_scale, y_scale=y_scale,
+                    title=title, x_label=x_label, y_label=y_label,
+                    x_fmt=x_fmt, y_fmt=y_fmt, x_step=x_step, y_step=y_step,
+                    y2_label=y2_label, y2_scale=y2_scale,
+                    y2_fmt=y2_fmt, y2_step=y2_step,
+                )
+            else:
+                artists = draw_series_axes(
+                    fig,
+                    ax,
+                    xv,
+                    series,
+                    st=st,
+                    ov=ov,
+                    x_log=x_log,
+                    y_log=y_log,
+                    x_scale=x_scale,
+                    y_scale=y_scale,
+                    title=title,
+                    x_label=x_label,
+                    y_label=y_label,
+                    series_styles=series_styles,
+                    x_fmt=x_fmt,
+                    y_fmt=y_fmt,
+                    x_step=x_step,
+                    y_step=y_step,
+                )
             if not ov.get("margins"):
                 fig.tight_layout()
             if collect_map:

{quantized_lab-0.9.0 → quantized_lab-0.11.0}/src/quantized/calc/figure_break.py

@@ -40,7 +40,7 @@ from numpy.typing import ArrayLike, NDArray  # noqa: E402
 
 from quantized.calc.figure import _plot_kwargs  # noqa: E402
 from quantized.calc.figure_scale import apply_axis_scale, resolve_axis_scale  # noqa: E402
-from quantized.calc.figure_ticks import apply_tick_formats  # noqa: E402
+from quantized.calc.figure_ticks import apply_tick_formats, apply_tick_steps  # noqa: E402
 
 __all__ = ["render_breaks_impl"]
 
@@ -65,6 +65,8 @@ def render_breaks_impl(
     series_styles: Sequence[Mapping[str, Any] | None] | None,
     x_fmt: Mapping[str, Any] | None = None,
     y_fmt: Mapping[str, Any] | None = None,
+    x_step: float | None = None,
+    y_step: float | None = None,
 ) -> bytes:
     """Render ``series`` against ``x`` with the x-axis elided over each
     ``[lo, hi]`` pair in ``breaks`` (already sorted/validated non-overlapping
@@ -100,8 +102,11 @@ def render_breaks_impl(
                 ax.plot(x, np.asarray(y, dtype=float), label=label, **kw)
             lo, hi = bounds[i]
             ax.set_xlim(lo, hi)
-            apply_axis_scale(ax, "x", resolve_axis_scale(x_scale, x_log))
-            apply_axis_scale(ax, "y", resolve_axis_scale(y_scale, y_log))
+            resolved_x_scale = resolve_axis_scale(x_scale, x_log)
+            resolved_y_scale = resolve_axis_scale(y_scale, y_log)
+            apply_axis_scale(ax, "x", resolved_x_scale)
+            apply_axis_scale(ax, "y", resolved_y_scale)
+            apply_tick_steps(ax, x_step, y_step, resolved_x_scale, resolved_y_scale)
             apply_tick_formats(ax, x_fmt, y_fmt)
             if i == 0:
                 handles, labels_out = ax.get_legend_handles_labels()
@@ -113,7 +118,8 @@ def render_breaks_impl(
             if not st.box_on:
                 ax.spines["top"].set_visible(False)
             if st.grid_alpha > 0:
-                ax.grid(True, alpha=st.grid_alpha)
+                ax.grid(True, which="major", alpha=st.grid_alpha)
+                ax.grid(True, which="minor", alpha=st.grid_alpha * 0.4)
 
         # Diagonal break glyphs (matplotlib's standard broken-axis recipe):
         # short strokes angled across each seam, on both the outgoing panel's

{quantized_lab-0.9.0 → quantized_lab-0.11.0}/src/quantized/calc/figure_categorical.py

@@ -28,6 +28,44 @@ __all__ = ["render_categorical_figure"]
 _FORMATS = ("pdf", "svg", "png", "tiff")
 
 
+def _draw_categorical_bars(
+    ax: Any,
+    groups: list[str],
+    series: list[str],
+    vals: Any,
+    errs: Any | None,
+    stacked: bool,
+) -> None:
+    """Draw one grouped/stacked bar panel into `ax` — shared by the flat
+    single-panel path below and `figure_facets.render_categorical_facets_figure`
+    (GUI_INTERACTION #12 slice 4b), so a faceted panel matches the flat
+    export exactly. Caller applies title/axis-labels/spines/legend/grid —
+    this function only draws the bars + category ticks + zero baseline."""
+    n_groups, n_series = len(groups), len(series)
+    x = np.arange(n_groups, dtype=float)
+    if stacked:
+        bottom = np.zeros(n_groups)
+        for si in range(n_series):
+            yerr = errs[:, si] if errs is not None and si == n_series - 1 else None
+            ax.bar(
+                x, vals[:, si], 0.68, bottom=bottom, yerr=yerr, capsize=3,
+                label=series[si],
+            )
+            bottom = bottom + np.nan_to_num(vals[:, si])
+    else:
+        width = 0.8 / n_series
+        for si in range(n_series):
+            offset = (si - (n_series - 1) / 2) * width
+            yerr = errs[:, si] if errs is not None else None
+            ax.bar(
+                x + offset, vals[:, si], width * 0.85, yerr=yerr, capsize=3,
+                label=series[si],
+            )
+    ax.set_xticks(x)
+    ax.set_xticklabels(groups)
+    ax.axhline(0, color="0.3", linewidth=0.8)  # baseline, visible for mixed-sign data
+
+
 def _to_matrix(
     values: list[list[float]], n_groups: int, n_series: int, name: str
 ) -> np.ndarray:
@@ -111,28 +149,7 @@ def render_categorical_figure(
     with matplotlib.rc_context(rc):  # type: ignore[arg-type]
         fig, ax = plt.subplots(figsize=figsize)
         try:
-            x = np.arange(n_groups, dtype=float)
-            if stacked:
-                bottom = np.zeros(n_groups)
-                for si in range(n_series):
-                    yerr = errs[:, si] if errs is not None and si == n_series - 1 else None
-                    ax.bar(
-                        x, vals[:, si], 0.68, bottom=bottom, yerr=yerr, capsize=3,
-                        label=series[si],
-                    )
-                    bottom = bottom + np.nan_to_num(vals[:, si])
-            else:
-                width = 0.8 / n_series
-                for si in range(n_series):
-                    offset = (si - (n_series - 1) / 2) * width
-                    yerr = errs[:, si] if errs is not None else None
-                    ax.bar(
-                        x + offset, vals[:, si], width * 0.85, yerr=yerr, capsize=3,
-                        label=series[si],
-                    )
-            ax.set_xticks(x)
-            ax.set_xticklabels(groups)
-            ax.axhline(0, color="0.3", linewidth=0.8)  # baseline, visible for mixed-sign data
+            _draw_categorical_bars(ax, groups, series, vals, errs, stacked)
             if title:
                 ax.set_title(title)
             if x_label: