quantized-lab 0.8.0__py3-none-any.whl

quantized/routes/import_wizard.py

@@ -0,0 +1,150 @@
+"""Thin routes for the interactive import wizard (ORIGIN_GAP_PLAN #40).
+
+The browser sends raw file text; these adapters guess/preview/parse it under
+adjustable :class:`~quantized.io.import_preview.ImportSettings` and return the
+wizard's preview table or the imported ``DataStruct``. All logic lives in
+``io.import_preview``.
+
+The ``/filters`` routes are CRUD over saved :class:`~quantized.io.import_filters.
+ImportFilter` records (name + glob + settings), persisted server-side so the
+registry (``io.registry.resolve_parser``) can consult them headlessly, not just
+from this wizard. All logic lives in ``io.import_filters``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from quantized.io.import_filters import (
+    ImportFilter,
+    delete_filter,
+    load_filters,
+    match_filter,
+    save_filter,
+)
+from quantized.io.import_preview import (
+    ImportSettings,
+    guess_settings,
+    parse_import,
+    preview_import,
+)
+from quantized.routes._payload import datastruct_payload
+
+router = APIRouter(prefix="/api/import", tags=["import"])
+
+
+class GuessRequest(BaseModel):
+    text: str
+
+
+@router.post("/guess")
+def guess_route(req: GuessRequest) -> dict[str, Any]:
+    """Best-effort starting settings for a pasted/uploaded file's text."""
+    try:
+        return guess_settings(req.text).to_dict()
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+class PreviewRequest(BaseModel):
+    text: str
+    settings: dict[str, Any] | None = None  # None -> auto-guess
+    max_rows: int = 20
+
+
+@router.post("/preview")
+def preview_route(req: PreviewRequest) -> dict[str, Any]:
+    """Parse the first rows under the given settings for the wizard to render."""
+    try:
+        settings = (
+            guess_settings(req.text) if req.settings is None
+            else ImportSettings.from_dict(req.settings)
+        )
+        return preview_import(req.text, settings, max_rows=max(1, min(200, req.max_rows)))
+    except (ValueError, IndexError, TypeError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+class ParseRequest(BaseModel):
+    text: str
+    settings: dict[str, Any]
+
+
+@router.post("/parse")
+def parse_route(req: ParseRequest) -> dict[str, Any]:
+    """Import the full text under confirmed settings into a DataStruct."""
+    try:
+        ds = parse_import(req.text, ImportSettings.from_dict(req.settings))
+    except (ValueError, IndexError, TypeError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return datastruct_payload(ds)
+
+
+# ── Saved import filters (gap #40 persistence) ───────────────────────────────
+
+
+@router.get("/filters")
+def list_filters_route() -> list[dict[str, Any]]:
+    """All saved import filters, most-recently-saved information included."""
+    return [f.to_dict() for f in load_filters()]
+
+
+class SaveFilterRequest(BaseModel):
+    name: str
+    glob: str
+    settings: dict[str, Any]
+
+
+@router.post("/filters")
+def save_filter_route(req: SaveFilterRequest) -> dict[str, Any]:
+    """Save (upsert by name) a filter binding a glob to import settings."""
+    try:
+        filt = ImportFilter(
+            name=req.name, glob=req.glob, settings=ImportSettings.from_dict(req.settings)
+        )
+        saved = save_filter(filt)
+    except (ValueError, TypeError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return saved.to_dict()
+
+
+@router.delete("/filters/{name}")
+def delete_filter_route(name: str) -> dict[str, str]:
+    """Delete the saved filter named ``name``."""
+    if not delete_filter(name):
+        raise HTTPException(status_code=404, detail=f"no saved filter named '{name}'")
+    return {"deleted": name}
+
+
+class ImportWithFilterRequest(BaseModel):
+    text: str
+    filename: str | None = None  # match the best saved filter for this name
+    filter_name: str | None = None  # or use one specific saved filter by name
+
+
+@router.post("/filters/parse")
+def parse_with_filter_route(req: ImportWithFilterRequest) -> dict[str, Any]:
+    """Import ``text`` under a saved filter — by name, or the best glob match
+    for ``filename`` — so a returning file imports with zero dialogs."""
+    if req.filter_name is not None:
+        filt = next((f for f in load_filters() if f.name == req.filter_name), None)
+        if filt is None:
+            raise HTTPException(
+                status_code=404, detail=f"no saved filter named '{req.filter_name}'"
+            )
+    elif req.filename is not None:
+        filt = match_filter(req.filename)
+        if filt is None:
+            raise HTTPException(
+                status_code=404, detail=f"no saved filter matches '{req.filename}'"
+            )
+    else:
+        raise HTTPException(status_code=422, detail="filename or filter_name is required")
+    try:
+        ds = parse_import(req.text, filt.settings)
+    except (ValueError, IndexError, TypeError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return datastruct_payload(ds)

quantized/routes/jobs_api.py

@@ -0,0 +1,59 @@
+"""Poll-model background-job routes (GOTO #9): status / result / cancel / list.
+
+Thin adapters over ``quantized.jobs``. There is deliberately NO generic
+submit endpoint — jobs are submitted internally by other routes (e.g.
+``POST /api/fitting/bumps`` with ``engine='dream'``), never from
+client-supplied code. The SPA GET-polls ``/api/jobs/{id}`` (~1 s) only
+while a job is live; no WebSocket.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+
+from quantized.jobs import jobs
+from quantized.routes._payload import to_jsonable
+
+router = APIRouter(prefix="/api/jobs", tags=["jobs"])
+
+
+@router.get("")
+def list_jobs() -> dict[str, Any]:
+    """Snapshots of every registered job (results omitted — poll /result)."""
+    return {"jobs": jobs.list()}
+
+
+@router.get("/{job_id}")
+def job_status(job_id: str) -> dict[str, Any]:
+    """Poll one job: status / progress / message (+ error when failed)."""
+    job = jobs.get(job_id)
+    if job is None:
+        raise HTTPException(status_code=404, detail=f"unknown job id: {job_id}")
+    return job.snapshot()
+
+
+@router.get("/{job_id}/result")
+def job_result(job_id: str) -> dict[str, Any]:
+    """The completed job's result. 409 until the job reaches ``done``."""
+    job = jobs.get(job_id)
+    if job is None:
+        raise HTTPException(status_code=404, detail=f"unknown job id: {job_id}")
+    snap = job.snapshot(include_result=True)
+    if snap["status"] == "error":
+        raise HTTPException(status_code=422, detail=f"job failed: {snap.get('error', '')}")
+    if snap["status"] != "done":
+        raise HTTPException(
+            status_code=409, detail=f"job not finished (status: {snap['status']})"
+        )
+    return {"id": job_id, "status": "done", "result": to_jsonable(snap["result"])}
+
+
+@router.post("/{job_id}/cancel")
+def job_cancel(job_id: str) -> dict[str, Any]:
+    """Request cooperative cancellation; returns the (possibly updated) snapshot."""
+    job = jobs.cancel(job_id)
+    if job is None:
+        raise HTTPException(status_code=404, detail=f"unknown job id: {job_id}")
+    return job.snapshot()

quantized/routes/magnetic.py

@@ -0,0 +1,135 @@
+"""Thin magnetic-calculator routes. Wraps ``calc.magnetic`` (pure formulas):
+moment conversion / magnetization / demagnetizing factors / Curie-Weiss /
+Langevin / domain wall. 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 magnetic
+
+router = APIRouter(prefix="/api/magnetic", tags=["magnetic"])
+
+
+class MomentConvertRequest(BaseModel):
+    value: float
+    unit: str = "emu"
+    volume: float | None = None
+    atoms: float | None = None
+
+
+class BohrMagnetonRequest(BaseModel):
+    moment: float
+    unit: str = "emu"
+
+
+class MagnetizationRequest(BaseModel):
+    moment: float
+    volume: float
+
+
+class MomentPerAtomRequest(BaseModel):
+    total_moment: float
+    volume: float
+    atom_density: float
+
+
+class DemagRequest(BaseModel):
+    shape: str  # GUI dropdown label (e.g. "Sphere", "Thin film (in-plane)")
+
+
+class CurieWeissRequest(BaseModel):
+    C: float
+    theta: float
+
+
+class CurieWeissFitRequest(BaseModel):
+    temperature: list[float]
+    susceptibility: list[float]
+    fit_range: tuple[float, float] | None = None
+
+
+class LangevinRequest(BaseModel):
+    mu: float
+    field_oe: float
+    temperature: float
+
+
+class DomainWallRequest(BaseModel):
+    exchange_a: float
+    anisotropy_k: 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("/moment-convert")
+def moment_convert(req: MomentConvertRequest) -> dict[str, Any]:
+    """Convert a moment to emu / A·m² / µ_B (+ magnetization, µ_B/atom)."""
+    return _call(
+        magnetic.moment_convert, req.value, req.unit, volume=req.volume, atoms=req.atoms
+    )
+
+
+@router.post("/bohr-magneton")
+def bohr_magneton(req: BohrMagnetonRequest) -> dict[str, Any]:
+    """Moment → number of Bohr magnetons."""
+    return _call(magnetic.bohr_magneton_convert, req.moment, req.unit)
+
+
+@router.post("/magnetization")
+def magnetization(req: MagnetizationRequest) -> dict[str, Any]:
+    """M = m/V (emu/cm³, A/m, kA/m)."""
+    return _call(magnetic.magnetization, req.moment, req.volume)
+
+
+@router.post("/moment-per-atom")
+def moment_per_atom(req: MomentPerAtomRequest) -> dict[str, Any]:
+    """Per-atom moment in Bohr magnetons."""
+    return _call(
+        magnetic.moment_per_atom, req.total_moment, req.volume, req.atom_density
+    )
+
+
+@router.post("/demag")
+def demag(req: DemagRequest) -> dict[str, Any]:
+    """Demagnetizing factors Nz, Nxy, 4πNz from a geometry label."""
+    return _call(magnetic.demag_named, req.shape)
+
+
+@router.post("/curie-weiss")
+def curie_weiss(req: CurieWeissRequest) -> dict[str, Any]:
+    """µ_eff and order type from Curie constant C and Weiss temperature θ."""
+    return _call(magnetic.curie_weiss_moment, req.C, req.theta)
+
+
+@router.post("/curie-weiss-fit")
+def curie_weiss_fit(req: CurieWeissFitRequest) -> dict[str, Any]:
+    """Curie-Weiss fit of 1/χ vs T → θ_CW, C, µ_eff, R²."""
+    return _call(
+        magnetic.curie_weiss_fit,
+        req.temperature,
+        req.susceptibility,
+        fit_range=req.fit_range,
+    )
+
+
+@router.post("/langevin")
+def langevin(req: LangevinRequest) -> dict[str, Any]:
+    """Langevin L(x) = coth(x) − 1/x for a superparamagnet."""
+    return _call(magnetic.langevin, req.mu, req.field_oe, req.temperature)
+
+
+@router.post("/domain-wall")
+def domain_wall(req: DomainWallRequest) -> dict[str, Any]:
+    """Domain-wall width δ = π√(A/K) and energy E = 4√(AK)."""
+    return _call(magnetic.domain_wall, req.exchange_a, req.anisotropy_k)

quantized/routes/magnetometry.py

@@ -0,0 +1,133 @@
+"""Thin magnetometry routes. Wraps ``calc.magnetometry`` (golden vs MATLAB):
+hysteresis-loop analysis, high-T background subtraction, sample-aware unit
+conversion. Validate -> call the pure fn -> serialize; no analysis here.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from quantized.calc.magnetometry import (
+    convert_mag_units,
+    hysteresis_analysis,
+    subtract_hysteresis_background,
+    subtract_mag_background,
+)
+from quantized.routes._payload import to_jsonable
+
+router = APIRouter(prefix="/api/magnetometry", tags=["magnetometry"])
+
+
+class HysteresisRequest(BaseModel):
+    h: list[float]
+    m: list[float]
+    saturation_fraction: float = 0.8
+    pre_smooth: int = 0
+    virgin_detect: bool = True
+
+
+class SubtractBgRequest(BaseModel):
+    temperature: list[float]
+    moment: list[float]
+    fit_range: tuple[float, float] | None = None
+    auto_fraction: float = 0.1
+
+
+class HysteresisBgRequest(BaseModel):
+    h: list[float]
+    m: list[float]
+    hi_fraction: float = 0.7
+    min_points: int = 4
+
+
+class ConvertUnitsRequest(BaseModel):
+    x: list[float]
+    y: list[float]
+    from_field: str = "Oe"
+    to_field: str = "Oe"
+    from_moment: str = "emu"
+    to_moment: str = "emu"
+    sample_mass: float = 0.0
+    sample_volume: float = 0.0
+
+
+@router.post("/hysteresis")
+def hysteresis(req: HysteresisRequest) -> dict[str, Any]:
+    """Analyze an M-H loop -> Hc / Mr / Ms / squareness / loop area / SFD."""
+    try:
+        result = hysteresis_analysis(
+            req.h,
+            req.m,
+            saturation_fraction=req.saturation_fraction,
+            pre_smooth=req.pre_smooth,
+            virgin_detect=req.virgin_detect,
+        )
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return to_jsonable(result)  # type: ignore[no-any-return]
+
+
+@router.post("/subtract-background")
+def subtract_background(req: SubtractBgRequest) -> dict[str, Any]:
+    """Subtract a linear high-T background from M(T)."""
+    try:
+        corrected, slope, intercept = subtract_mag_background(
+            req.temperature,
+            req.moment,
+            fit_range=req.fit_range,
+            auto_fraction=req.auto_fraction,
+        )
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return {
+        "corrected": to_jsonable(corrected),
+        "slope": to_jsonable(slope),
+        "intercept": to_jsonable(intercept),
+    }
+
+
+@router.post("/subtract-hysteresis-background")
+def subtract_hysteresis_bg(req: HysteresisBgRequest) -> dict[str, Any]:
+    """Remove a linear dia/paramagnetic background from an M-H loop and centre it
+    vertically (per-tail slope + saturation-midpoint offset, so no vertical shift
+    remains)."""
+    try:
+        corrected, slope, offset = subtract_hysteresis_background(
+            req.h, req.m, hi_fraction=req.hi_fraction, min_points=req.min_points
+        )
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return {
+        "corrected": to_jsonable(corrected),
+        "slope": to_jsonable(slope),
+        "offset": to_jsonable(offset),
+    }
+
+
+@router.post("/convert-units")
+def convert_units(req: ConvertUnitsRequest) -> dict[str, Any]:
+    """Convert field (x) + moment (y) units (sample-aware)."""
+    try:
+        x_out, y_out, x_unit, y_unit, warning = convert_mag_units(
+            req.x,
+            req.y,
+            from_field=req.from_field,
+            to_field=req.to_field,
+            from_moment=req.from_moment,
+            to_moment=req.to_moment,
+            sample_mass=req.sample_mass,
+            sample_volume=req.sample_volume,
+        )
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return {
+        "x": to_jsonable(np.asarray(x_out, dtype=float)),
+        "y": to_jsonable(np.asarray(y_out, dtype=float)),
+        "x_unit": x_unit,
+        "y_unit": y_unit,
+        "warning": warning,
+    }

quantized/routes/optics.py

@@ -0,0 +1,98 @@
+"""Thin optics routes. Wraps ``calc.optics`` (pure formulas): Fresnel
+coefficients / critical angle / Brewster angle / penetration depth / skin depth
+/ refractive-index <-> dielectric conversion. Validate -> call 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 optics
+
+router = APIRouter(prefix="/api/optics", tags=["optics"])
+
+
+class FresnelRequest(BaseModel):
+    n1: float
+    n2: float
+    theta: float  # angle of incidence (deg)
+
+
+class AngleRequest(BaseModel):
+    n1: float
+    n2: float
+
+
+class PenetrationDepthRequest(BaseModel):
+    n: float
+    k: float
+    wavelength: float
+
+
+class SkinDepthRequest(BaseModel):
+    rho: float  # resistivity (Ohm*m, SI)
+    f: float  # frequency (Hz)
+
+
+class RefractiveToDielectricRequest(BaseModel):
+    n: float
+    k: float = 0.0
+
+
+class DielectricToRefractiveRequest(BaseModel):
+    eps1: float
+    eps2: float = 0.0
+
+
+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("/fresnel")
+def fresnel(req: FresnelRequest) -> dict[str, Any]:
+    """Rs, Rp, Ts, Tp at an interface."""
+    return _call(optics.fresnel_coefficients, req.n1, req.n2, req.theta)
+
+
+@router.post("/critical-angle")
+def critical_angle(req: AngleRequest) -> dict[str, Any]:
+    """θ_c = arcsin(n₂/n₁) (deg); NaN if n₂ >= n₁."""
+    return _call(optics.critical_angle, req.n1, req.n2)
+
+
+@router.post("/brewster-angle")
+def brewster_angle(req: AngleRequest) -> dict[str, Any]:
+    """θ_B = arctan(n₂/n₁) (deg)."""
+    return _call(optics.brewster_angle, req.n1, req.n2)
+
+
+@router.post("/penetration-depth")
+def penetration_depth(req: PenetrationDepthRequest) -> dict[str, Any]:
+    """δ = λ/(4πk) (same unit as λ)."""
+    return _call(optics.penetration_depth, req.n, req.k, req.wavelength)
+
+
+@router.post("/skin-depth")
+def skin_depth(req: SkinDepthRequest) -> dict[str, Any]:
+    """δ = √(2ρ/(ωμ₀)) (m)."""
+    return _call(optics.skin_depth, req.rho, req.f)
+
+
+@router.post("/refractive-to-dielectric")
+def refractive_to_dielectric(req: RefractiveToDielectricRequest) -> dict[str, Any]:
+    """ε₁ = n²−k², ε₂ = 2nk."""
+    return _call(optics.refractive_to_dielectric, req.n, req.k)
+
+
+@router.post("/dielectric-to-refractive")
+def dielectric_to_refractive(req: DielectricToRefractiveRequest) -> dict[str, Any]:
+    """n, k from (ε₁, ε₂) via the physical square root."""
+    return _call(optics.dielectric_to_refractive, req.eps1, req.eps2)