| """Shared helpers for the t3_analytical template modules (GC 8890B, HPLC 1260, HS 8697, DR6000, FT/IR-4700, 5910 Ri). |
| |
| Everything here is read-only access to public-data libraries under ``assets/reactions/``. Library files that are not |
| in the ``{"templates": [...]}`` layout (the shared ``spectral_library`` tables) are read directly; their provenance |
| block uses the same SHA-256 helper as :mod:`scripts.template_library`. |
| """ |
| from __future__ import annotations |
|
|
| import json |
| import math |
| from functools import lru_cache |
| from typing import Any |
|
|
| from scripts.template_library import ROOT, library_sha256 |
|
|
| SPECTRAL = "assets/reactions/spectral_library" |
| COMPOUNDS_REL = SPECTRAL + "/compounds.json" |
| SUBSTANCES_REL = "assets/reactions/substances.json" |
|
|
|
|
| @lru_cache(maxsize=None) |
| def load_json(rel_path: str) -> Any: |
| path = (ROOT / rel_path).resolve() |
| if ROOT not in path.parents: |
| raise ValueError(f"library path escapes the project root: {rel_path}") |
| return json.loads(path.read_text(encoding="utf-8")) |
|
|
|
|
| def compounds() -> dict[str, dict[str, Any]]: |
| return load_json(COMPOUNDS_REL)["compounds"] |
|
|
|
|
| def resolve_compound_id(identifier: Any) -> str | None: |
| """spectral_library compound id for ``identifier``. |
| |
| Accepts a spectral_library id directly, or a ``substances.json`` id (reaction-ledger species) when the same id |
| exists in the spectral library (acetic_acid, ethanol, ethyl_acetate, water, carbon_dioxide, hydrogen_peroxide). |
| """ |
| if not isinstance(identifier, str) or not identifier: |
| return None |
| return identifier if identifier in compounds() else None |
|
|
|
|
| def finite(value: Any) -> bool: |
| if isinstance(value, bool) or not isinstance(value, (int, float)): |
| return False |
| try: |
| return math.isfinite(value) |
| except (OverflowError, ValueError): |
| return False |
|
|
|
|
| def sha256_map(*rel_paths: str) -> dict[str, str]: |
| return {rel: library_sha256(rel) for rel in rel_paths} |
|
|
|
|
| def number(unit: str, minimum: float | None = None, maximum: float | None = None) -> dict[str, Any]: |
| 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 schema |
|
|
|
|
| def obj(properties: dict[str, Any], required: list[str] | None = None) -> dict[str, Any]: |
| return {"type": "object", "properties": properties, |
| "required": list(properties) if required is None else required, "additionalProperties": False} |
|
|
|
|
| def nullable(schema: dict[str, Any]) -> dict[str, Any]: |
| return {"anyOf": [schema, {"type": "null"}]} |
|
|
|
|
| TEXT = {"type": "string"} |
| TEXT_LIST = {"type": "array", "items": {"type": "string"}} |
| SHA_MAP = {"type": "object", "additionalProperties": {"type": "string"}} |
|
|
|
|
| def provenance_schema() -> dict[str, Any]: |
| """Fields every template-backed result carries.""" |
| return {"template_source": TEXT_LIST, "library_sha256": SHA_MAP, "evidence": TEXT, |
| "synthetic": {"type": "boolean", "const": False}, "synthetic_parts": TEXT_LIST, "limitations": TEXT_LIST} |
|
|
|
|
| def provenance(rel_paths: list[str], evidence: str, synthetic_parts: list[str], limitations: list[str]) -> dict[str, Any]: |
| return {"template_source": list(rel_paths), "library_sha256": sha256_map(*rel_paths), "evidence": evidence, |
| "synthetic": False, "synthetic_parts": list(synthetic_parts), "limitations": list(limitations)} |
|
|
|
|
| def template_read_capability(cls_name: str, example_id: str, output_schema: dict[str, Any], component_ids: list[str], |
| description: str) -> dict[str, Any]: |
| """Runtime-metadata entry for an agent-visible ``template.read`` reference query.""" |
| return {"input_schema": obj({"substance_id": {"type": "string", "description": description}}), |
| "output_schema": output_schema, "example_arguments": [{"substance_id": example_id}], |
| "state_ids": [], "component_ids": component_ids, "preconditions": [], |
| "scene_required": False, "availability": "implemented", "kind": "query", |
| "invocation": cls_name + ".invoke(instance_id=..., capability_id='template.read', arguments={'substance_id': ...}, request_id=...)", |
| "errors": ["UNKNOWN_INSTANCE", "INVALID_ARGUMENT", "REQUEST_CONFLICT"], |
| "rejection_side_effects": "none", |
| "measurement_cache_semantics": "Public reference lookup; does not read or change the loaded sample, state revision or scene."} |
|
|
|
|
| |
|
|
| def interp(x: float, xs: list[float], ys: list[float]) -> float | None: |
| """Linear interpolation on an ascending grid; None outside [xs[0], xs[-1]] (no extrapolation).""" |
| if not xs or x < xs[0] or x > xs[-1]: |
| return None |
| lo, hi = 0, len(xs) - 1 |
| while hi - lo > 1: |
| mid = (lo + hi) // 2 |
| if xs[mid] <= x: |
| lo = mid |
| else: |
| hi = mid |
| if xs[hi] == xs[lo]: |
| return ys[lo] |
| return ys[lo] + (ys[hi] - ys[lo]) * (x - xs[lo]) / (xs[hi] - xs[lo]) |
|
|
|
|
| def detect_peaks(time_s: list[float], signal: list[float], relative_threshold: float = 1e-3) -> list[dict[str, Any]]: |
| """Unlabeled peak table from a sampled trace. |
| |
| Local maxima above ``relative_threshold`` x the largest value; boundaries walk down to the neighbouring valley |
| or baseline; trapezoid area between boundaries; apex refined by a three-point parabola; width at half height by |
| linear interpolation (None when the half-height crossing lies outside the sampled trace). |
| """ |
| n = len(signal) |
| if n < 3 or max(signal) <= 0: |
| return [] |
| threshold = max(signal) * relative_threshold |
| peaks = [] |
| for i in range(1, n - 1): |
| c = signal[i] |
| if c < threshold or not (c > signal[i - 1] and c >= signal[i + 1]): |
| continue |
| left = i |
| while left > 0 and signal[left - 1] < signal[left]: |
| left -= 1 |
| right = i |
| while right < n - 1 and signal[right + 1] < signal[right]: |
| right += 1 |
| area = sum((signal[j] + signal[j + 1]) * (time_s[j + 1] - time_s[j]) / 2 for j in range(left, right)) |
| denom = signal[i - 1] - 2 * c + signal[i + 1] |
| offset = 0.5 * (signal[i - 1] - signal[i + 1]) / denom if denom < 0 else 0.0 |
| step = (time_s[i + 1] - time_s[i - 1]) / 2 |
| apex = time_s[i] + offset * step |
| half = c / 2 |
| lo, hi = i, i |
| while lo > 0 and signal[lo] > half: |
| lo -= 1 |
| while hi < n - 1 and signal[hi] > half: |
| hi += 1 |
| width = None |
| if signal[lo] <= half < signal[lo + 1] and signal[hi] <= half < signal[hi - 1]: |
| t_lo = time_s[lo] + (half - signal[lo]) / (signal[lo + 1] - signal[lo]) * (time_s[lo + 1] - time_s[lo]) |
| t_hi = time_s[hi - 1] + (signal[hi - 1] - half) / (signal[hi - 1] - signal[hi]) * (time_s[hi] - time_s[hi - 1]) |
| width = t_hi - t_lo |
| peaks.append({"apex": apex, "area": area, "height": c, "width": width}) |
| return peaks |
|
|
|
|
| |
|
|
| UV_REL = SPECTRAL + "/uv_vis.json" |
| |
| L_PER_MOL_CM_TO_M2_PER_MOL = 0.1 |
|
|
|
|
| @lru_cache(maxsize=None) |
| def uv_curve(compound_id: str) -> dict[str, Any] | None: |
| """First NIST UV/Vis curve of a spectral_library compound as SI arrays (ascending wavelength), or None.""" |
| entry = load_json(UV_REL)["compounds"].get(compound_id) or {} |
| spectra = entry.get("spectra") or [] |
| if not spectra: |
| return None |
| spectrum = spectra[0] |
| pairs = sorted(zip(spectrum["wavelength_nm"], spectrum["y"])) |
| wavelengths, eps = [], [] |
| for nm, log_eps in pairs: |
| if wavelengths and nm * 1e-9 <= wavelengths[-1]: |
| continue |
| wavelengths.append(nm * 1e-9) |
| eps.append(10.0 ** log_eps * L_PER_MOL_CM_TO_M2_PER_MOL) |
| return {"compound_id": compound_id, "wavelength_m": wavelengths, "epsilon_m2_mol": eps, |
| "title": spectrum.get("title"), "nist_index": spectrum.get("nist_index"), "origin": spectrum.get("origin"), |
| "y_units_original": spectrum.get("y_units"), "source": spectrum.get("source"), "evidence": spectrum.get("evidence")} |
|
|
|
|
| def uv_epsilon(compound_id: str, wavelength_m: float) -> float | None: |
| curve = uv_curve(compound_id) |
| return None if curve is None else interp(wavelength_m, curve["wavelength_m"], curve["epsilon_m2_mol"]) |
|
|
