scripts/basic40_templates/magritek_spinsolve80.py

"""Template-backed samples for the Magritek Spinsolve 80 runtime (CHEM-068).

Library: ``assets/reactions/magritek_spinsolve80_nmr_library/templates.json`` (built from the shared
``spectral_library/nmr.json``: HMDB experimental 1H/13C peak lists via PubChem). A trusted host registers a
sample by composition (library ids + amounts in mol); this module turns the reference peak lists into the
runtime's existing damped-sinusoid signal list at the Spinsolve field, so the unchanged acquisition, FID,
DFT spectrum and ``nmr.integrate`` paths measure it. Two agent queries are added:

* ``template.read``               public reference lookup (no information about the loaded tube);
* ``nmr.read_template_spectrum``  the acquired spectrum of a template-backed tube on a ppm axis, with provenance.

Field transform: chemical shifts are field independent (ppm); measured multiplet line offsets are kept in Hz
(first-order J pattern), so ``nu = (delta_centroid - delta_ref) * nu0 + offset_hz`` at nu0 = 80 MHz (1H) or
nu0 * Xi(13C) (13C). Line shape, linewidth, receiver scale and the carrier reference are assumptions.
"""
from __future__ import annotations

import copy
import math
from typing import Any

try:  # scripts/ on sys.path (tier runtime import style)
    from template_library import get_template, index_by_id, library_sha256, load_library, provenance
except ImportError:  # project root on sys.path
    from scripts.template_library import get_template, index_by_id, library_sha256, load_library, provenance

TEMPLATE_REL = "assets/reactions/magritek_spinsolve80_nmr_library/templates.json"
PROTON_FREQUENCY_HZ = 80e6                 # workbook "1H 80 MHz" (documented, nominal)
XI_13C = 0.25145020                        # IUPAC 2001 frequency ratio Xi(13C, TMS) (Harris et al., Pure Appl. Chem. 73, 1795)
CARBON_FREQUENCY_HZ = PROTON_FREQUENCY_HZ * XI_13C
OBSERVE_FREQUENCY_HZ = {"1H": PROTON_FREQUENCY_HZ, "13C": CARBON_FREQUENCY_HZ}
REFERENCE_SHIFT_PPM = {"1H": 6.0, "13C": 110.0}   # assumption: carrier placed mid shift window (0-12 / 0-220 ppm)
LINEWIDTH_HZ = 1.0                                 # assumption: Lorentzian FWHM of every line
T2_S = 1.0 / (math.pi * LINEWIDTH_HZ)
AMPLITUDE_PER_MOL = 1.0e4                          # assumption: arbitrary receiver scale per mol of observed nuclei
MAX_COMPONENTS = 8
MAX_AMOUNT_MOL = 1.0
SOLVENT_KEYS = ("CDCl3", "D2O", "CD3OD", "DMSO-d6", "CCl4", "C6D6", "CD2Cl2", "D2O_5pct_DMSO")
TEMPLATE_CAPABILITIES = ("template.read", "nmr.read_template_spectrum")

SYNTHETIC_PARTS = [
    "Lorentzian line shape with assumed 1 Hz FWHM (T2* = 1/(pi*FWHM)), noise-free averaged FID",
    "receiver amplitude scale (1e4 per mol of observed nuclei) and carrier reference shift (1H 6 ppm, 13C 110 ppm)",
    "13C lines are the 1H-decoupled reference singlets; 13C intensities follow source peak heights (not quantitative)",
]
LIMITATIONS = [
    "Chemical shifts and multiplet line offsets come from HMDB experimental peak lists (via PubChem) at the source field; line offsets in Hz are kept as a first-order J pattern at 80 MHz, so strong-coupling (second-order) effects of the benchtop field are not recomputed.",
    "Source lists give shifts to 0.01 ppm: line offsets carry +/- 0.5e-2 ppm x source MHz quantisation (0.45 Hz at 90 MHz, 3 Hz at 600 MHz).",
    "Proton counts per multiplet are derived from source peak heights constrained to whole RDKit symmetry-equivalent H groups; heights are not areas, so crowded multiplets can be misassigned by one group (per-molecule totals are exact).",
    "No solvent, lock, residual-solvent, water or reference (TMS/DSS) signals, no relaxation weighting, NOE, exchange broadening, concentration or temperature shifts; solvent choice only selects which reference spectrum is used.",
    "13C observe frequency is derived from the nominal 80 MHz 1H frequency and IUPAC Xi(13C); the instrument's actual 13C carrier is not documented.",
]


def _finite(value: Any) -> bool:
    return type(value) in (int, float) and math.isfinite(value)


def library() -> dict[str, Any]:
    return load_library(TEMPLATE_REL)


def record(substance_id: str) -> dict[str, Any] | None:
    return get_template(TEMPLATE_REL, substance_id) if isinstance(substance_id, str) else None


def substance_ids() -> list[str]:
    return sorted(index_by_id(TEMPLATE_REL))


def select_spectrum(rec: dict[str, Any], nucleus: str, solvent: str | None = None) -> tuple[dict[str, Any] | None, bool]:
    """Reference spectrum for ``nucleus``: first in library order, or the first in ``solvent`` when available."""
    spectra = rec["nuclei"].get(nucleus) or []
    if not spectra:
        return None, False
    if solvent is not None:
        for spectrum in spectra:
            if spectrum["solvent_key"] == solvent:
                return spectrum, True
        return spectra[0], False
    return spectra[0], True


def reference_lines(rec: dict[str, Any], nucleus: str, solvent: str | None = None) -> tuple[list[dict[str, Any]], dict[str, Any] | None, bool]:
    """Lines at the Spinsolve field for one molecule (amount 1 mol): shift_ppm, offset from reference, weight (nuclei)."""
    spectrum, solvent_match = select_spectrum(rec, nucleus, solvent)
    if spectrum is None:
        return [], None, solvent_match
    nu0 = OBSERVE_FREQUENCY_HZ[nucleus] / 1e6
    lines = []
    if nucleus == "1H":
        for index, multiplet in enumerate(spectrum["multiplets"]):
            heights = sum(line["height"] for line in multiplet["lines"])
            j_known = spectrum["j_pattern"] == "measured_line_offsets" and all(line["offset_hz"] is not None for line in multiplet["lines"])
            if not j_known or heights <= 0:
                lines.append({"group": index, "center_ppm": multiplet["center_ppm"], "group_nuclei": float(multiplet["n_h"]),
                              "shift_ppm": multiplet["center_ppm"], "weight": float(multiplet["n_h"]), "j_from_source": False})
                continue
            for line in multiplet["lines"]:
                lines.append({"group": index, "center_ppm": multiplet["center_ppm"], "group_nuclei": float(multiplet["n_h"]),
                              "shift_ppm": multiplet["center_ppm"] + line["offset_hz"] / nu0,
                              "weight": float(multiplet["n_h"]) * line["height"] / heights, "j_from_source": True})
    else:
        heights = sum(line["height"] for line in spectrum["lines"])
        for index, line in enumerate(spectrum["lines"]):
            weight = rec["c_count"] * line["height"] / heights if heights > 0 else 0.0
            lines.append({"group": index, "center_ppm": line["ppm"], "group_nuclei": weight, "shift_ppm": line["ppm"],
                          "weight": weight, "j_from_source": False})
    for line in lines:
        line["frequency_offset_hz"] = (line["shift_ppm"] - REFERENCE_SHIFT_PPM[nucleus]) * nu0
    return lines, spectrum, solvent_match


def validate_composition(composition: Any, solvent: Any) -> list[dict[str, Any]]:
    if solvent is not None and solvent not in SOLVENT_KEYS:
        raise ValueError("Unknown solvent key")
    if not isinstance(composition, list) or not 1 <= len(composition) <= MAX_COMPONENTS:
        raise ValueError("Composition must list 1..8 components")
    seen, clean = set(), []
    for item in composition:
        if not isinstance(item, dict) or set(item) != {"substance_id", "amount_mol"}:
            raise ValueError("Each component needs exactly substance_id and amount_mol")
        sid, amount = item["substance_id"], item["amount_mol"]
        if record(sid) is None or sid in seen:
            raise ValueError("Unknown or duplicate template substance_id")
        if not _finite(amount) or not 0 < amount <= MAX_AMOUNT_MOL:
            raise ValueError("amount_mol must be finite, > 0 and <= 1 mol")
        seen.add(sid)
        clean.append({"substance_id": sid, "amount_mol": float(amount)})
    return clean


def build_sample(composition: Any, solvent: Any = None) -> tuple[dict[str, list[dict[str, float]]], dict[str, Any]]:
    """Runtime signal lists ({"1H": [...], "13C": [...]}) plus host-private provenance for one tube."""
    clean = validate_composition(composition, solvent)
    signals: dict[str, list[dict[str, float]]] = {"1H": [], "13C": []}
    used = []
    for item in clean:
        rec = record(item["substance_id"])
        entry = {"substance_id": rec["substance_id"], "amount_mol": item["amount_mol"], "spectra": {}}
        for nucleus in ("1H", "13C"):
            lines, spectrum, solvent_match = reference_lines(rec, nucleus, solvent)
            if spectrum is None:
                entry["spectra"][nucleus] = None
                continue
            for line in lines:
                amplitude = AMPLITUDE_PER_MOL * item["amount_mol"] * line["weight"]
                if amplitude > 0:
                    signals[nucleus].append({"frequency_offset_hz": line["frequency_offset_hz"], "amplitude": amplitude, "t2_s": T2_S})
            entry["spectra"][nucleus] = {"hmdb_spectrum_id": spectrum["hmdb_spectrum_id"], "solvent_key": spectrum["solvent_key"],
                                         "solvent_match": solvent_match, "source_frequency_hz": spectrum["source_frequency_hz"],
                                         "j_pattern": spectrum.get("j_pattern"), "n_lines": len(lines)}
        used.append(entry)
    for nucleus in signals:
        signals[nucleus].sort(key=lambda p: p["frequency_offset_hz"])
    mismatched = sum(1 for e in used for s in e["spectra"].values() if s is not None and not s["solvent_match"])
    prov = {"composition": used, "solvent": solvent, "solvent_mismatches": mismatched,
            "template_source": TEMPLATE_REL, "library_sha256": library_sha256(TEMPLATE_REL)}
    return signals, prov


# ---------------------------------------------------------------- agent-facing capability metadata
def _num(unit, minimum=None, maximum=None, nullable=False):
    schema: dict[str, Any] = {"type": "number", "x-unit": unit}
    if minimum is not None:
        schema["minimum"] = minimum
    if maximum is not None:
        schema["maximum"] = maximum
    return {"anyOf": [schema, {"type": "null"}]} if nullable else schema


def _obj(properties, required=None):
    return {"type": "object", "properties": properties, "required": list(properties) if required is None else required, "additionalProperties": False}


_TEXT = {"type": "string", "minLength": 1, "maxLength": 128}
_STR = {"type": "string", "minLength": 1}
_NTEXT = {"anyOf": [{"type": "string"}, {"type": "null"}]}
_NUCLEUS = {"type": "string", "enum": ["1H", "13C"]}
_TEXTS = {"type": "array", "items": {"type": "string"}}
_LINE = _obj({"shift_ppm": _num("ppm"), "frequency_offset_hz": _num("Hz"), "relative_nuclei": _num("1", 0)})
_GROUP = _obj({"center_ppm": _num("ppm"), "n_nuclei": _num("1", 0), "lines": {"type": "array", "items": _LINE}})
_STATUS = {"type": "string", "enum": ["idle", "running", "completed", "stopped"]}
_POINT = _obj({"chemical_shift_ppm": _num("ppm"), "frequency_offset_hz": _num("Hz"), "amplitude": _num("1", 0)})

TEMPLATE_READ_INPUT = _obj({"substance_id": _TEXT, "nucleus": _NUCLEUS, "solvent": {"anyOf": [{"type": "string", "enum": list(SOLVENT_KEYS)}, {"type": "null"}]}},
                           required=["substance_id", "nucleus"])
TEMPLATE_READ_OUTPUT = _obj({
    "substance_id": _TEXT, "name": _TEXT, "cas": _NTEXT, "shared_ids": {"type": "object", "additionalProperties": {"type": "string"}},
    "nucleus": _NUCLEUS, "solvent": _NTEXT, "available_solvents": _TEXTS, "source_frequency_hz": _num("Hz", nullable=True),
    "observe_frequency_hz": _num("Hz"), "reference_shift_ppm": _num("ppm"), "groups": {"type": "array", "items": _GROUP},
    "proton_count_rule": {"anyOf": [{"type": "string"}, {"type": "null"}]}, "template_source": _STR,
    "template_record_source": _STR, "spectrum_source": _STR, "evidence": _STR, "library_sha256": _STR,
    "synthetic": {"type": "boolean", "const": False}, "limitations": _TEXTS})
SPECTRUM_INPUT = _obj({})
SPECTRUM_OUTPUT = _obj({
    "samples": {"type": "array", "maxItems": 512, "items": _POINT}, "nucleus": {"anyOf": [_NUCLEUS, {"type": "null"}]},
    "observe_frequency_hz": _num("Hz", nullable=True), "reference_shift_ppm": _num("ppm", nullable=True), "status": _STATUS,
    "completed_scans": {"type": "integer", "minimum": 0, "maximum": 4096, "x-unit": "1"}, "template_source": _STR,
    "library_sha256": _STR, "evidence": _STR, "synthetic": {"type": "boolean", "const": False},
    "synthetic_parts": _TEXTS, "limitations": _TEXTS})


def capability_metadata() -> dict[str, dict[str, Any]]:
    """Agent-visible descriptions of the added queries (merged into Session.describe)."""
    common = {"visibility": "agent", "availability": "implemented", "component_ids": ["control_panel"],
              "implementation": {"process": "implemented", "scene": "not_applicable", "robot": "absent", "hardware": "absent", "host": "implemented"},
              "binding": {"backend": "process", "artifact_id": "template_module", "entrypoint": "MagritekSpinsolve80Session.invoke"},
              "state_effects": [], "model_effects": {"mode": "none", "binding_ids": [], "description_zh": "纯查询，无几何变化。"},
              "source_ids": ["template_library"]}
    return {
        "template.read": {**common, "kind": "query", "function_zh": "按物质id读取公开参考核磁模板（80 MHz下的化学位移、多重峰线位与核数），不透露当前样品身份。",
                          "input_schema": TEMPLATE_READ_INPUT, "output_schema": TEMPLATE_READ_OUTPUT, "observes": [],
                          "example_arguments": {"substance_id": "ethyl_acetate", "nucleus": "1H"},
                          "errors": ["INVALID_ARGUMENT", "UNKNOWN_REFERENCE", "PRECONDITION_FAILED"]},
        "nmr.read_template_spectrum": {**common, "kind": "query", "function_zh": "读取模板样品已采集谱的ppm横轴与来源信息；不推进时间、不暴露样品组成。",
                                       "input_schema": SPECTRUM_INPUT, "output_schema": SPECTRUM_OUTPUT,
                                       "observes": ["measurement.spectrum", "method.nucleus", "acquisition.status", "acquisition.completed_scans"],
                                       "example_arguments": {}, "errors": ["INVALID_ARGUMENT", "PRECONDITION_FAILED"]},
    }


def _matches_input(cap: str, args: Any) -> bool:
    if not isinstance(args, dict):
        return False
    if cap == "nmr.read_template_spectrum":
        return args == {}
    allowed = {"substance_id", "nucleus", "solvent"}
    if not {"substance_id", "nucleus"} <= set(args) <= allowed:
        return False
    sid, nucleus, solvent = args["substance_id"], args["nucleus"], args.get("solvent")
    return (isinstance(sid, str) and 1 <= len(sid) <= 128 and nucleus in ("1H", "13C")
            and (solvent is None or solvent in SOLVENT_KEYS))


def public_reference(substance_id: str, nucleus: str, solvent: str | None = None) -> dict[str, Any] | None:
    rec = record(substance_id)
    if rec is None:
        return None
    lines, spectrum, _ = reference_lines(rec, nucleus, solvent)
    if spectrum is None:
        return {}
    groups: list[dict[str, Any]] = []
    for line in lines:
        if not groups or groups[-1]["_group"] != line["group"]:
            groups.append({"_group": line["group"], "center_ppm": line["center_ppm"], "n_nuclei": line["group_nuclei"], "lines": []})
        groups[-1]["lines"].append({"shift_ppm": line["shift_ppm"], "frequency_offset_hz": line["frequency_offset_hz"], "relative_nuclei": line["weight"]})
    for group in groups:
        del group["_group"]
    rule = spectrum["proton_count_rule"]["status"] if nucleus == "1H" else None
    prov = provenance(TEMPLATE_REL, rec)
    return {"substance_id": rec["substance_id"], "name": rec["name"], "cas": rec.get("cas"), "shared_ids": copy.deepcopy(rec.get("shared_ids", {})),
            "nucleus": nucleus, "solvent": spectrum["solvent_key"], "available_solvents": sorted({s["solvent_key"] for s in rec["nuclei"][nucleus]}),
            "source_frequency_hz": spectrum["source_frequency_hz"], "observe_frequency_hz": OBSERVE_FREQUENCY_HZ[nucleus],
            "reference_shift_ppm": REFERENCE_SHIFT_PPM[nucleus], "groups": groups, "proton_count_rule": rule,
            "template_source": prov["template_source"], "template_record_source": prov["template_record_source"],
            "spectrum_source": spectrum["source_url"], "evidence": prov["evidence"], "library_sha256": prov["library_sha256"],
            "synthetic": False, "limitations": list(LIMITATIONS)}


def spectrum_on_ppm_axis(inst: dict[str, Any], completed_scans: int) -> dict[str, Any]:
    nucleus = (inst.get("method") or {}).get("nucleus")
    points = []
    if nucleus is not None:
        nu0 = OBSERVE_FREQUENCY_HZ[nucleus] / 1e6
        for p in inst["spectrum"]:
            points.append({"chemical_shift_ppm": REFERENCE_SHIFT_PPM[nucleus] + p["frequency_offset_hz"] / nu0,
                           "frequency_offset_hz": p["frequency_offset_hz"], "amplitude": p["amplitude"]})
    return {"samples": points, "nucleus": nucleus, "observe_frequency_hz": OBSERVE_FREQUENCY_HZ.get(nucleus),
            "reference_shift_ppm": REFERENCE_SHIFT_PPM.get(nucleus), "status": inst["status"], "completed_scans": completed_scans,
            "template_source": TEMPLATE_REL, "library_sha256": library_sha256(TEMPLATE_REL),
            "evidence": "measured_literature shifts and J-line offsets (HMDB via PubChem); derived proton counts; assumed line shape",
            "synthetic": False, "synthetic_parts": list(SYNTHETIC_PARTS), "limitations": list(LIMITATIONS)}


def session_query(session, host, instance_id: str, inst: dict[str, Any], cap: str, args: Any, request_id: str) -> dict[str, Any]:
    """Dispatch of the added agent queries; read-only, never advances time or touches the scene."""
    if not _matches_input(cap, args):
        return session._error(instance_id, "INVALID_ARGUMENT", request_id)
    if cap == "template.read":
        result = public_reference(args["substance_id"], args["nucleus"], args.get("solvent"))
        if result is None:
            return session._error(instance_id, "UNKNOWN_REFERENCE", request_id)
        if not result:
            return session._error(instance_id, "PRECONDITION_FAILED", request_id)
        return session._envelope(instance_id, request_id, result=result)
    tube = inst["sample_id"]
    if tube is None or tube not in inst.get("template_samples", {}):
        return session._error(instance_id, "PRECONDITION_FAILED", request_id)
    return session._envelope(instance_id, request_id, result=spectrum_on_ppm_axis(inst, inst["completed_scans"]))


def register_template_sample(host, instance_id: str, sample_id: str, composition: Any, *, solvent: str | None = None) -> None:
    """Trusted-host registration of a tube whose signals come from the NMR template library."""
    with host._lock:
        if instance_id not in host._instances or not isinstance(sample_id, str) or not 1 <= len(sample_id) <= 128:
            raise ValueError("Invalid instance or sample identifier")
        signals, prov = build_sample(composition, solvent)
        inst = host._instances[instance_id]
        if sample_id in inst["samples"] or len(inst["samples"]) >= 64 or inst["running"]:
            raise ValueError("Sample registration unavailable")
        if any(not (math.isfinite(p["frequency_offset_hz"]) and math.isfinite(p["amplitude"])) for n in signals.values() for p in n):
            raise ValueError("Non-finite template signal")
        inst["samples"][sample_id] = signals
        inst.setdefault("template_samples", {})[sample_id] = prov
        inst["revision"] += 1


def template_sample_truth(host, instance_id: str) -> dict[str, Any]:
    """Trusted host / evaluator view of template-backed tubes (composition and reference spectra used)."""
    with host._lock:
        return copy.deepcopy(host._instances[instance_id].get("template_samples", {}))