diff --git "a/scripts/basic40_runtime_measure.py" "b/scripts/basic40_runtime_measure.py" new file mode 100644--- /dev/null +++ "b/scripts/basic40_runtime_measure.py" @@ -0,0 +1,4304 @@ +"""Append-only measurement runtimes. CHEM-001 uses synthetic PX224E-family behavior. + +The XPR204E catalogue target and the reused OHAUS geometry are distinct. The +filtered runtime is an engineering model, not either manufacturer's firmware. +Only the trusted host supplies supported pan force and advances the common clock. +Session filtering is an API boundary, not a Python or filesystem sandbox. +""" +import copy as _xpr_copy +import hashlib as _xpr_hashlib +import json as _xpr_json +import math as _xpr_math +import random as _xpr_random +import threading as _xpr_threading +from collections import deque as _xpr_deque +from decimal import Decimal as _xpr_Decimal, ROUND_HALF_UP as _xpr_ROUND_HALF_UP +from datetime import datetime as _xpr_datetime, timezone as _xpr_timezone +from pathlib import Path as _xpr_Path + +try: + from .balance_runtime import Balance as _XPRLegacyBalance +except ImportError: + from balance_runtime import Balance as _XPRLegacyBalance + +XPR204E_TYPE = "instrument.mt_xpr204e" +XPR204E_CAPACITY_KG = 0.220 +XPR204E_READABILITY_KG = 1e-7 +XPR204E_TARGET_SETTLING_S = 1.5 +XPR204E_DOOR_MAX_M = 0.109 +XPR204E_CALIBRATION_MIN_KG = 1e-12 # Numerical input envelope, not a vendor standard-mass specification. +XPR204E_FILTERS = { + "Low": {"time_constant_s": 0.25, "stability_divisions": 512}, + "Medium": {"time_constant_s": 1.0, "stability_divisions": 256}, + "High": {"time_constant_s": 4.0, "stability_divisions": 128}, +} +XPR204E_SCENE_KEYS = ( + "power.enabled", "balance.filter_level", "balance.display_unit", "balance.status", "balance.stable", + "balance.gross_kg", "balance.net_kg", "balance.tare_kg", "balance.calibrated", "balance.task_ready", + "balance.synthetic", "balance.stability_elapsed_s", "pan.installed", "environment.tilt_rad", "environment.vibration", + "door.left.opening_m", "door.right.opening_m", "door.top.opening_m", +) + + +def _xpr_number(value): + try: + return type(value) in (int, float) and _xpr_math.isfinite(value) + except (TypeError, OverflowError): + return False + + +def _xpr_num_schema(unit, minimum=None, maximum=None, nullable=False): + spec = {"type": "number", "x-unit": unit} + if minimum is not None: + spec["minimum"] = minimum + if maximum is not None: + spec["maximum"] = maximum + return {"anyOf": [spec, {"type": "null"}]} if nullable else spec + + +def _xpr_object(properties): + return {"type": "object", "properties": properties, "required": list(properties), "additionalProperties": False} + + +def _xpr_quantize(value): + step = _xpr_Decimal(str(XPR204E_READABILITY_KG)) + return float((_xpr_Decimal(str(value)) / step).quantize(_xpr_Decimal("1"), rounding=_xpr_ROUND_HALF_UP) * step) + + +class FilteredAnalyticalBalance(_XPRLegacyBalance): + """Trusted force-input core. Direct read() is a debugging interface. + + The manufacturer's Low/Medium/High ordering is documented in PX manual + section 5.3.3. All numeric tau/N values and the five-tau startup interval are + engineering assumptions for the specified white-contact-noise experiment. + N is a full peak-to-peak displayed range, NOT accuracy or repeatability. + The 1.5 s default holding window is the XPR catalogue target reused as a + simulation rule; it is not proof of a 1.5 s instrument response. + """ + def __init__(self, *, filter_level="Medium", settling_s=XPR204E_TARGET_SETTLING_S): + if not isinstance(filter_level, str) or filter_level not in XPR204E_FILTERS or not _xpr_number(settling_s) or not 0 < settling_s <= 60: + raise ValueError("Unknown filter or invalid finite settling interval") + super().__init__(XPR204E_CAPACITY_KG, XPR204E_READABILITY_KG, float(settling_s), True) + self.filter_level = filter_level + self.raw_force_N = 0.0 + self.filtered_force_N = None + self.sample_time_s = 0.0 + self.filter_age_s = 0.0 + self._stability_samples = _xpr_deque() + self._window_range_kg = None + + @classmethod + def for_model(cls, model): + if model == "XPR204E": + return cls() + if model == "PX224E": + return cls(settling_s=3.0) + raise ValueError("This filtered analytical family supports XPR204E and PX224E") + + def reset_stability(self, *, clear_filter=False): + self.stable = False + self.elapsed_s = 0.0 + self.last_environment_valid = False + self._stability_samples.clear() + self._window_range_kg = None + if clear_filter: + self.filtered_force_N = None + self.filter_age_s = 0.0 + + @property + def stability_band_kg(self): + return XPR204E_FILTERS[self.filter_level]["stability_divisions"] * self.readability_kg + + def set_power(self, enabled): + if type(enabled) is not bool: + raise ValueError("Power is boolean") + if self.powered != enabled: + self.powered = enabled + self.reset_stability(clear_filter=True) + + def set_filter(self, level): + if not isinstance(level, str) or level not in XPR204E_FILTERS: + raise ValueError("Unknown filter level") + if self.security_locked: + raise ValueError("Filter configuration is locked") + if level != self.filter_level: + self.filter_level = level + self.reset_stability(clear_filter=True) + + def update(self, pan_load_force_N, dt_s, *, door_fraction=0.0, tilt_rad=0.0, vibration=False): + if (not _xpr_number(pan_load_force_N) or not _xpr_number(dt_s) or dt_s < 0 + or not _xpr_number(door_fraction) or not 0 <= door_fraction <= 1 + or not _xpr_number(tilt_rad) or type(vibration) is not bool): + raise ValueError("Finite SI force/time/environment and boolean vibration required") + if dt_s == 0: + return self.read() + self.sample_time_s += dt_s + self.raw_force_N = float(pan_load_force_N) + self.door_fraction, self.tilt_rad = float(door_fraction), float(tilt_rad) + if self.filtered_force_N is None: + self.filtered_force_N = self.raw_force_N + else: + tau = XPR204E_FILTERS[self.filter_level]["time_constant_s"] + alpha = -_xpr_math.expm1(-dt_s / tau) + # Convex form avoids overflow when two finite forces have opposite signs. + self.filtered_force_N = (1 - alpha) * self.filtered_force_N + alpha * self.raw_force_N + self.filter_age_s += dt_s + self.gross_kg = self.filtered_force_N / self.g_cal + hardware = self.powered and self.pan_installed and self.pan_latched and self.transport_unlocked + environment = door_fraction <= 0.01 and abs(tilt_rad) <= _xpr_math.radians(0.2) and not vibration + # Raw force rejects overload immediately: smoothing must not conceal it. + # Near-zero negative noise is handled by the filtered lower bound, not + # by resetting on every negative raw sample. The N*d tolerance is an + # engineering assumption; displayed negative values are not clipped. + range_valid = self.raw_force_N / self.g_cal <= self.capacity_kg and -self.stability_band_kg <= self.gross_kg <= self.capacity_kg + valid = hardware and environment and range_valid + if not valid: + self.reset_stability() + return self.read() + displayed = _xpr_quantize(self.gross_kg) + samples = self._stability_samples + samples.append((self.sample_time_s, displayed)) + cutoff = self.sample_time_s - self.settling_s + # Retain a bracketing sample so the verified window is never too short. + while len(samples) > 1 and samples[1][0] <= cutoff + 1e-10: + samples.popleft() + self._window_range_kg = max(v for _, v in samples) - min(v for _, v in samples) + band = self.stability_band_kg + inside = self._window_range_kg <= band + 1e-15 + self.elapsed_s = min(self.settling_s, self.sample_time_s - samples[0][0]) if inside else 0.0 + warmed = self.filter_age_s + 1e-10 >= 5 * XPR204E_FILTERS[self.filter_level]["time_constant_s"] + self.last_environment_valid = True + self.stable = bool(inside and warmed and self.elapsed_s + 1e-10 >= self.settling_s) + return self.read() + + def read(self): + if not self.powered: + status = "OFF" + elif not self.pan_installed: + status = "PAN_REMOVED" + elif not self.pan_latched: + status = "PAN_UNLATCHED" + elif not self.transport_unlocked: + status = "TRANSPORT_LOCKED" + elif self.raw_force_N / self.g_cal > self.capacity_kg or self.gross_kg > self.capacity_kg: + status = "OVERLOAD" + elif self.gross_kg < -self.stability_band_kg: + status = "UNDERLOAD" + else: + status = "STABLE" if self.stable else "UNSTABLE" + observable = status in ("STABLE", "UNSTABLE") and self.filtered_force_N is not None + # Do not quantize unbounded overloads or invent a reading before acquisition. + net = _xpr_quantize(self.gross_kg - self.zero_kg - self.tare_kg) if observable else None + stable = status == "STABLE" + return {"status": status, "stable": stable, "net_kg": net, + "value": None if net is None else net * (1000 if self.unit == "g" else 1), + "unit": self.unit, "gross_kg": self.gross_kg, "tare_kg": self.tare_kg, + "calibrated": self.calibrated, "task_ready": stable and self.calibrated, + "synthetic": True, "filter_level": self.filter_level, "raw_force_N": self.raw_force_N, + "filtered_force_N": self.filtered_force_N, "stability_window_range_kg": self._window_range_kg} + + def press(self, key, hold_s=0.1): + if not _xpr_number(hold_s) or hold_s < 0: + raise ValueError("Finite nonnegative hold time required") + if key == "zero" and (hold_s >= 2 or not self.powered): + self.set_power(hold_s < 2) + return self.read() + return super().press(key, hold_s) + + def calibrate_span(self, known_mass_kg, measured_load_force_N): + """Validate trusted direct calibration inputs before changing any state.""" + if (not _xpr_number(known_mass_kg) or not XPR204E_CALIBRATION_MIN_KG <= known_mass_kg <= self.capacity_kg + or not _xpr_number(measured_load_force_N) or measured_load_force_N <= 0 + or self.filtered_force_N is None): + raise ValueError("Finite calibration mass/force within the numeric input envelope required") + gain = measured_load_force_N / known_mass_kg + if not _xpr_number(gain) or gain <= 0 or not _xpr_number(self.filtered_force_N / gain): + raise ValueError("Calibration would produce a non-finite numerical state") + super().calibrate_span(known_mass_kg, measured_load_force_N) + self.gross_kg = self.filtered_force_N / self.g_cal + self.reset_stability() + + def calibrate_known_mass(self, known_mass_kg): + if not _xpr_number(known_mass_kg) or not XPR204E_CALIBRATION_MIN_KG <= known_mass_kg <= self.capacity_kg: + raise ValueError("Known calibration mass is outside capacity") + if self.filtered_force_N is None or self.filtered_force_N <= 0: + raise ValueError("A positive stable calibration load is required") + self.calibrate_span(known_mass_kg, self.filtered_force_N) + + +def export_xpr204e_contract_metadata(): + """Contract authoring metadata only. No live sample force or private state.""" + def slot(unit, origin, schema, visibility="agent", route=None): + return {"unit": unit, "origin": origin, "visibility": visibility, + "access": "read_write" if route else "read_only", "value_schema": schema, + "write_via": route, "read_binding": "XPR204ESession.read(instance_id=..., state_ids=[state_id])", + "sampling": {"mode": "instant", "time_domain": "simulation", "window": None}, + "reference_conditions": None} + def route(cap, parameter, fixed=None): + return {"capability_id": cap, "parameter": parameter, "fixed_arguments": fixed or {}} + boolean = {"type": "boolean"} + statuses = {"type": "string", "enum": ["OFF", "PAN_REMOVED", "PAN_UNLATCHED", "TRANSPORT_LOCKED", "OVERLOAD", "UNDERLOAD", "UNSTABLE", "STABLE"]} + levels = {"type": "string", "enum": list(XPR204E_FILTERS)} + units = {"type": "string", "enum": ["kg", "g"]} + slots = { + "power.enabled": slot("1", "setpoint", boolean, route=route("power.set", "enabled")), + "balance.filter_level": slot("1", "setpoint", levels, route=route("balance.set_filter", "level")), + "balance.display_unit": slot("1", "setpoint", units, route=route("balance.set_display_unit", "unit")), + "balance.status": slot("1", "derived", statuses), + "balance.stable": slot("1", "derived", boolean), + "balance.gross_kg": slot("kg", "derived", _xpr_num_schema("kg", nullable=True)), + "balance.net_kg": slot("kg", "derived", _xpr_num_schema("kg", nullable=True)), + "balance.tare_kg": slot("kg", "derived", _xpr_num_schema("kg")), + "balance.calibrated": slot("1", "derived", boolean), + "balance.task_ready": slot("1", "derived", boolean), + "balance.synthetic": slot("1", "derived", {"type": "boolean", "const": True}), + "balance.raw_force_n": slot("N", "process_truth", _xpr_num_schema("N"), "debug"), + "balance.filtered_force_n": slot("N", "process_truth", _xpr_num_schema("N", nullable=True), "debug"), + "balance.gain_n_kg": slot("N/kg", "process_truth", _xpr_num_schema("N/kg", 0), "debug"), + "balance.zero_kg": slot("kg", "process_truth", _xpr_num_schema("kg"), "debug"), + "balance.stability_elapsed_s": slot("s", "derived", _xpr_num_schema("s", 0)), + "pan.installed": slot("1", "scene", boolean, route=route("scene.set_pan", "installed")), + "environment.tilt_rad": slot("rad", "scene", _xpr_num_schema("rad")), + "environment.vibration": slot("1", "scene", boolean), + } + for side in ("left", "right", "top"): + slots[f"door.{side}.opening_m"] = slot("m", "scene", _xpr_num_schema("m", 0, XPR204E_DOOR_MAX_M), + route=route("scene.set_door", "opening_m", {"side": side})) + reading = {"status": statuses, "stable": boolean, "gross_kg": _xpr_num_schema("kg", nullable=True), + "net_kg": _xpr_num_schema("kg", nullable=True), "synthetic": {"type": "boolean", "const": True}} + definitions = { + "power.set": ({"enabled": boolean}, {"enabled": boolean}, {"enabled": True}, "设置本机供电；电源变化清空滤波启动与稳定历史。", ["power.enabled", "balance.stable", "balance.status", "balance.stability_elapsed_s"], ["power.enabled"]), + "balance.set_filter": ({"level": levels}, {"level": levels}, {"level": "High"}, "选择三档合成低通模型，改变设置后重新暖机。", ["balance.filter_level", "balance.stable", "balance.status", "balance.stability_elapsed_s"], ["balance.filter_level"]), + "balance.tare": ({}, {"tare_kg": _xpr_num_schema("kg")}, {}, "稳定时去皮；以后显示净重，毛重用于超载判定。", ["balance.tare_kg", "balance.net_kg"], ["balance.tare_kg"]), + "balance.zero": ({}, {"zeroed": boolean}, {}, "稳定且在假设的整机量程2%零点捕获范围内归零，并清除去皮。", ["balance.zero_kg", "balance.tare_kg", "balance.net_kg"], ["balance.net_kg"]), + "balance.set_display_unit": ({"unit": units}, {"unit": units}, {"unit": "g"}, "选择面板单位标签；公共质量接口始终以kg输出。", ["balance.display_unit"], ["balance.display_unit"]), + "balance.calibrate_span": ({"known_mass_kg": _xpr_num_schema("kg", XPR204E_CALIBRATION_MIN_KG, XPR204E_CAPACITY_KG)}, {"calibrated": boolean, "synthetic": {"type": "boolean", "const": True}}, {"known_mass_kg": 0.1}, "以已知标准砝码和当前滤波载荷进行简化单点增益校准；非厂家自动校准过程。", ["balance.gain_n_kg", "balance.zero_kg", "balance.tare_kg", "balance.calibrated", "balance.gross_kg", "balance.net_kg", "balance.stable", "balance.status", "balance.stability_elapsed_s"], ["balance.calibrated", "balance.synthetic"]), + "balance.reading": ({}, reading, {}, "读取同版本的量化滤波毛重、净重和稳定状态，不推进时钟。", [], ["balance.status", "balance.stable", "balance.gross_kg", "balance.net_kg", "balance.synthetic"]), + "scene.set_door": ({"side": {"type": "string", "enum": ["left", "right", "top"]}, "opening_m": _xpr_num_schema("m", 0, XPR204E_DOOR_MAX_M)}, {"side": {"type": "string", "enum": ["left", "right", "top"]}, "opening_m": _xpr_num_schema("m")}, {"side": "left", "opening_m": 0.05}, "同步设置复用PX224E滑门的+Y平移；改变门位后重新稳定。", ["door.left.opening_m", "door.right.opening_m", "door.top.opening_m", "balance.stable", "balance.status", "balance.stability_elapsed_s"], ["door.left.opening_m", "door.right.opening_m", "door.top.opening_m"]), + "scene.set_pan": ({"installed": boolean}, {"installed": boolean}, {"installed": False}, "仅在断电卸载后切换秤盘装配槽；不模拟机器人拆装或自由体接触。", ["pan.installed", "balance.stable", "balance.status", "balance.stability_elapsed_s"], ["pan.installed"]), + } + caps = {} + for name, (inputs, outputs, example, description, effects, observes) in definitions.items(): + if name in ("power.set", "balance.set_filter"): + effects += ["balance.filtered_force_n", "balance.gross_kg", "balance.net_kg", "balance.task_ready"] + if name in ("balance.calibrate_span", "scene.set_door", "scene.set_pan"): + effects += ["balance.task_ready"] + if name == "scene.set_pan": + effects += ["balance.gross_kg", "balance.net_kg"] + caps[name] = {"availability": "implemented", "visibility": "agent", + "kind": "query" if name == "balance.reading" else "simulation" if name.startswith("scene.") else "device_command", + "description_zh": description, "input_schema": _xpr_object(inputs), "output_schema": _xpr_object(outputs), + "example_arguments": [example], "state_effects": [{"state_id": sid, "timing": "immediate", "description_zh": description} for sid in effects], + "observes": observes, "scene_backend_required": name.startswith("scene."), + "binding": f"basic40_runtime_measure.XPR204ESession.invoke(instance_id=..., capability_id='{name}', arguments=..., request_id=...)", + "completion_criterion_zh": "同步提交声明状态；读数稳定需等待宿主推进与随后观测。", + "preconditions_zh": ("稳定、供电、未锁定校准，且所选质量与滤波力能得到有限增益。" if name == "balance.calibrate_span" else + "稳定且供电。" if name in ("balance.tare", "balance.zero") else + "同步场景回调已注册。" if name.startswith("scene.") else "参数与声明范围匹配。")} + parameters = { + "capacity_kg": {"value": XPR204E_CAPACITY_KG, "unit": "kg", "evidence": "catalog", "source": "CHEM-001 XPR204E catalogue row; same as migrated PX224E"}, + "readability_kg": {"value": XPR204E_READABILITY_KG, "unit": "kg", "evidence": "catalog", "source": "CHEM-001 XPR204E catalogue row; same as migrated PX224E; not accuracy"}, + "target_repeatability_kg": {"value": 4e-8, "unit": "kg", "evidence": "catalog", "source": "XPR204E target only, not a fitted simulation noise parameter"}, + "target_settling_s": {"value": XPR204E_TARGET_SETTLING_S, "unit": "s", "evidence": "catalog", "source": "XPR204E catalogue target; does not guarantee simulated total response time"}, + "stability_hold_s": {"value": XPR204E_TARGET_SETTLING_S, "unit": "s", "evidence": "engineering_assumption", "source": "Reuse target value as synthetic rolling-window hold duration"}, + "legacy_px224e_hold_s": {"value": 3.0, "unit": "s", "evidence": "code_behavior", "source": "Unmodified scripts/balance_runtime.py Balance.for_model('PX224E')"}, + "filter_levels": {"value": _xpr_copy.deepcopy(XPR204E_FILTERS), "unit": "1", "evidence": "engineering_assumption", "source": "Only level names/order follow PX manual EN-27 section 5.3.3; tau and N are not provided by either manufacturer"}, + "underload_lower_bound_kg": {"value": {level: -setting["stability_divisions"] * XPR204E_READABILITY_KG for level, setting in XPR204E_FILTERS.items()}, "unit": "kg", "evidence": "engineering_assumption", "source": "Underload is filtered gross below -N*d; near-zero negative noise is displayed without clipping and does not reset stability merely because a raw sample is negative"}, + "manufacturer_underload_threshold_kg": {"value": None, "unit": "kg", "evidence": "unknown", "source": "No manufacturer lower detection threshold was supplied"}, + "startup_time_constants": {"value": 5.0, "unit": "1", "evidence": "engineering_assumption", "source": "Five-tau startup bounds residual of first noisy sample; not vendor firmware"}, + "zero_capture_fraction": {"value": 0.02, "unit": "1", "evidence": "engineering_assumption", "source": "Inherited legacy runtime capture rule"}, + "minimum_calibration_input_kg": {"value": XPR204E_CALIBRATION_MIN_KG, "unit": "kg", "evidence": "engineering_assumption", "source": "Numerical API envelope prevents effectively zero denominator; not a practical or manufacturer calibration mass"}, + "manufacturer_calibration_mass_kg": {"value": None, "unit": "kg", "evidence": "unknown", "source": "No manufacturer procedure or required calibration mass is implemented"}, + "calibration_error_kg": {"value": None, "unit": "kg", "evidence": "unknown", "source": "No measured calibration error or fault data supplied"}, + } + return {"asset_types": {XPR204E_TYPE: {"catalog_id": "CHEM-001", "model": "METTLER TOLEDO XPR204E target / PX224E geometry family", + "asset_version": "1.0.0", "state_slots": slots, "capabilities": caps, "parameters": parameters}}, + "scene_snapshot_keys": list(XPR204E_SCENE_KEYS), + "scene_snapshot_schema": _xpr_object({sid: slots[sid]["value_schema"] for sid in XPR204E_SCENE_KEYS}), + "trusted_scene_callback": "scene_adapter(instance_id, updates): each call receives the full typed scene snapshot; raw force, unquantized filter, gain and zero truth are excluded", + "host_capabilities": { + "sim.step": {"kind": "simulation", "visibility": "trusted_host_only", "binding": "XPR204ERuntime.step(dt_s, pan_load_forces_N=...)"}, + "host.set_environment": {"kind": "configuration", "visibility": "trusted_host_only", "binding": "XPR204ERuntime.set_environment(instance_id, tilt_rad=..., vibration=...)"}}, + "limitations": ["All reported measurement results are synthetic and quality=estimated.", + "N is full displayed peak-to-peak range, not manufacturer repeatability or accuracy.", + "High white-force noise requires coarse stability bands (Low 51.2mg, Medium 25.6mg, High 12.8mg).", + "Underload uses a synthetic filtered lower bound of -N*d so noisy empty-pan readings can settle; this is not a manufacturer underload specification.", + "AZT is not implemented; its 0.5d/1d/3d per-second drift settings are not stability thresholds.", + "No contact solver, supported-force aggregation, robot action, real balance driver or fault calibration.", + "No filesystem/process sandbox; deploy the trusted host separately from untrusted execution.", + "Deduplication is in-memory only and does not survive a restart."]} + + +class XPR204ERuntime: + """Trusted multi-instance host; only sessions should be exposed to agents.""" + def __init__(self, *, scene_adapter=None): + self.scene_adapter = scene_adapter + self.time_s = 0.0 + self._instances = {} + self._principals = {"__public_agent__": ("agent", None)} + self._requests = {} + self._logs = {"__public_agent__": []} + self._lock = _xpr_threading.RLock() + self._metadata = export_xpr204e_contract_metadata() + self._agent = XPR204ESession(self, "__public_agent__") + + def create_instance(self, instance_id, asset_type_id=XPR204E_TYPE): + with self._lock: + if not isinstance(instance_id, str) or not instance_id or instance_id in self._instances or asset_type_id != XPR204E_TYPE: + raise ValueError("Unique nonempty instance ID and declared asset type required") + inst = {"balance": FilteredAnalyticalBalance(), "doors": {side: 0.0 for side in ("left", "right", "top")}, + "vibration": False, "tilt_rad": 0.0, "revision": 0} + if self.scene_adapter: + self.scene_adapter(instance_id, self._scene(inst)) + self._instances[instance_id] = inst + + def register_principal(self, principal_id, *, visibility, instance_ids=None): + with self._lock: + if not isinstance(principal_id, str) or not principal_id or principal_id in self._principals or visibility not in ("agent", "debug", "evaluator"): + raise ValueError("Invalid or already registered host identity") + scope = None if instance_ids is None else frozenset(instance_ids) + if scope is not None and not scope <= self._instances.keys(): + raise ValueError("Unknown instance in identity scope") + self._principals[principal_id] = (visibility, scope) + self._logs[principal_id] = [] + + def session(self, principal_id): + if principal_id not in self._principals: + raise ValueError("Identity must be registered by trusted host") + return XPR204ESession(self, principal_id) + + def describe(self, **kwargs): + return self._agent.describe(**kwargs) + + def read(self, **kwargs): + return self._agent.read(**kwargs) + + def invoke(self, **kwargs): + return self._agent.invoke(**kwargs) + + def write(self, **kwargs): + return self._agent.write(**kwargs) + + def describe_host(self): + return _xpr_copy.deepcopy(self._metadata["host_capabilities"]) + + @staticmethod + def _values(inst): + b = inst["balance"] + r = b.read() + observable = r["status"] in ("STABLE", "UNSTABLE") and b.filtered_force_N is not None + values = {"power.enabled": b.powered, "balance.filter_level": b.filter_level, "balance.display_unit": b.unit, + "balance.status": r["status"], "balance.stable": r["stable"], + "balance.gross_kg": _xpr_quantize(b.gross_kg) if observable else None, + "balance.net_kg": r["net_kg"], "balance.tare_kg": _xpr_quantize(b.tare_kg), + "balance.calibrated": b.calibrated, "balance.task_ready": r["task_ready"], "balance.synthetic": True, + "balance.raw_force_n": b.raw_force_N, "balance.filtered_force_n": b.filtered_force_N, + "balance.gain_n_kg": b.g_cal, "balance.zero_kg": b.zero_kg, "balance.stability_elapsed_s": b.elapsed_s, + "pan.installed": b.pan_installed, "environment.tilt_rad": inst["tilt_rad"], "environment.vibration": inst["vibration"]} + values.update({f"door.{side}.opening_m": value for side, value in inst["doors"].items()}) + return values + + def debug_snapshot(self): + with self._lock: + return {"time_s": self.time_s, "instances": {key: {"revision": inst["revision"], "state": _xpr_copy.deepcopy(self._values(inst)), + "filter_history": list(inst["balance"]._stability_samples), "filter_age_s": inst["balance"].filter_age_s} + for key, inst in self._instances.items()}} + + def _scene(self, inst): + values = self._values(inst) + return {sid: values[sid] for sid in XPR204E_SCENE_KEYS} + + def set_environment(self, instance_id, *, tilt_rad=0.0, vibration=False): + if not _xpr_number(tilt_rad) or abs(tilt_rad) > _xpr_math.pi / 2 or type(vibration) is not bool: + raise ValueError("Finite tilt within +/-pi/2 and boolean vibration required") + with self._lock: + if instance_id not in self._instances: + raise ValueError("Unknown instance") + inst = self._instances[instance_id] + inst["tilt_rad"], inst["vibration"] = float(tilt_rad), vibration + inst["balance"].tilt_rad = float(tilt_rad) + inst["balance"].reset_stability() + inst["revision"] += 1 + + def step(self, dt_s, *, pan_load_forces_N=None): + """Force values are supported pan load (exclude pan weight), held for dt. + + This call advances every registered instance under one clock. Missing + values retain the preceding trusted force input. Numerical substeps are + at most 0.01 s; they do not create new independent contact-force samples. + A callback failure leaves process/time advanced and raises RuntimeError. + """ + if not _xpr_number(dt_s) or not 0 <= dt_s <= 60: + raise ValueError("Finite host interval within 0..60 s required") + forces = {} if pan_load_forces_N is None else pan_load_forces_N + if not isinstance(forces, dict) or any(not isinstance(key, str) or not _xpr_number(value) for key, value in forces.items()): + raise ValueError("Supported force mapping must contain finite SI values") + with self._lock: + if any(key not in self._instances for key in forces): + raise ValueError("Unknown force target") + if dt_s == 0: + return + n = max(1, int(_xpr_math.ceil(dt_s / 0.01))) + h = dt_s / n + for key, inst in self._instances.items(): + b = inst["balance"] + force = forces.get(key, b.raw_force_N) + door_fraction = max(inst["doors"].values()) / XPR204E_DOOR_MAX_M + for _ in range(n): + b.update(force, h, door_fraction=door_fraction, tilt_rad=inst["tilt_rad"], vibration=inst["vibration"]) + inst["revision"] += 1 + self.time_s += dt_s + if self.scene_adapter: + failed = [] + for key, inst in self._instances.items(): + try: + self.scene_adapter(key, self._scene(inst)) + except Exception: + failed.append(key) + if failed: + raise RuntimeError("Process and common clock advanced; scene synchronization failed") from None + + +class XPR204ESession: + """Uniform describe/read/invoke/write interface with host-assigned identity.""" + def __init__(self, host, principal_id): + self.__host, self.__principal = host, principal_id + + def _visible(self, slot): + return slot["visibility"] == "agent" or self.__host._principals[self.__principal][0] in ("debug", "evaluator") + + def _instance(self, instance_id): + if not isinstance(instance_id, str): + return None + _, scope = self.__host._principals[self.__principal] + return self.__host._instances.get(instance_id) if scope is None or instance_id in scope else None + + def _envelope(self, instance_id, request_id=None, *, result=None, observations=None, status="succeeded", error=None): + inst = self._instance(instance_id) + return {"protocol_version": "1.0.0", "instance_id": instance_id if isinstance(instance_id, str) else None, + "request_id": request_id if isinstance(request_id, str) else None, "operation_id": None, "status": status, + "state_revision": inst["revision"] if inst else None, "clock": {"domain": "simulation", "time_s": self.__host.time_s}, + "result": {} if result is None else _xpr_copy.deepcopy(result), "observations": {} if observations is None else _xpr_copy.deepcopy(observations), "error": error} + + def _error(self, instance_id, code, request_id=None, status="rejected"): + messages = {"UNKNOWN_INSTANCE": "Instance is unavailable in this session.", "UNKNOWN_CAPABILITY": "Capability is unavailable.", + "INVALID_ARGUMENT": "Arguments do not meet declared schema or limits.", "ACCESS_DENIED": "Request is outside session access policy.", + "PRECONDITION_FAILED": "Required operating state or configuration is unavailable.", + "REQUEST_CONFLICT": "Request ID already belongs to different arguments.", "UNSUPPORTED": "Execution is unavailable in this adapter.", + "DEVICE_ERROR": "Scene callback did not complete the command."} + return self._envelope(instance_id, request_id, status=status, error={"code": code, "message": messages[code], + "retryable": False, "side_effects": "unknown" if code == "DEVICE_ERROR" else "none", "progress": None}) + + def describe(self, *, asset_type_id=None, instance_id=None): + host = self.__host + with host._lock: + if (asset_type_id is None) == (instance_id is None): + return self._error(None, "INVALID_ARGUMENT") + if instance_id is not None and not self._instance(instance_id): + return self._error(instance_id, "UNKNOWN_INSTANCE") + if asset_type_id is not None and asset_type_id != XPR204E_TYPE: + return self._error(None, "INVALID_ARGUMENT") + _, scope = host._principals[self.__principal] + if scope is not None and not scope: + return self._error(instance_id, "ACCESS_DENIED") + spec = _xpr_copy.deepcopy(host._metadata["asset_types"][XPR204E_TYPE]) + spec["state_slots"] = {sid: value for sid, value in spec["state_slots"].items() if self._visible(value)} + for cap in spec["capabilities"].values(): + cap["state_effects"] = [effect for effect in cap["state_effects"] if effect["state_id"] in spec["state_slots"]] + cap["observes"] = [sid for sid in cap["observes"] if sid in spec["state_slots"]] + if cap["scene_backend_required"] and host.scene_adapter is None: + cap["availability"] = "unsupported" + return {"protocol_version": "1.0.0", "asset_type_id": XPR204E_TYPE, "instance_id": instance_id, + "adapter": "basic40_runtime_measure.XPR204ESession", **spec, + "limitations": _xpr_copy.deepcopy(host._metadata["limitations"])} + + def read(self, *, instance_id, state_ids=None): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if not inst: + return self._error(instance_id, "UNKNOWN_INSTANCE") + slots = host._metadata["asset_types"][XPR204E_TYPE]["state_slots"] + if state_ids is None: + state_ids = [sid for sid, value in slots.items() if self._visible(value)] + if not isinstance(state_ids, list) or any(not isinstance(sid, str) for sid in state_ids) or len(state_ids) != len(set(state_ids)): + return self._error(instance_id, "INVALID_ARGUMENT") + if any(sid not in slots or not self._visible(slots[sid]) for sid in state_ids): + return self._error(instance_id, "ACCESS_DENIED") + values = host._values(inst) + observations = {sid: {"value": values[sid], "unit": slots[sid]["unit"], + "quality": "unavailable" if values[sid] is None else "estimated" if slots[sid]["origin"] == "derived" else "valid", + "sample_time_s": host.time_s, "sample_window_s": None, + "reason": "No reading is available in the current acquisition, power, pan or range state." if values[sid] is None else None, + "synthetic": slots[sid]["origin"] == "derived"} for sid in state_ids} + return self._envelope(instance_id, observations=observations) + + def invoke(self, *, instance_id, capability_id, arguments, request_id): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if not inst: + return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) + if not isinstance(capability_id, str) or not isinstance(arguments, dict) or not isinstance(request_id, str) or not request_id or len(request_id) > 256: + return self._error(instance_id, "INVALID_ARGUMENT", request_id) + try: + digest = _xpr_hashlib.sha256(_xpr_json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False).encode()).hexdigest() + except (TypeError, ValueError, OverflowError): + return self._error(instance_id, "INVALID_ARGUMENT", request_id) + key = (self.__principal, instance_id, request_id) + if key in host._requests: + old_digest, response = host._requests[key] + return _xpr_copy.deepcopy(response) if digest == old_digest else self._error(instance_id, "REQUEST_CONFLICT", request_id) + response = self._checked(instance_id, inst, capability_id, arguments, request_id) + host._requests[key] = (digest, _xpr_copy.deepcopy(response)) + host._logs[self.__principal].append({"instance_id": instance_id, "capability_id": capability_id, "request_id": request_id, + "response": _xpr_copy.deepcopy(response)}) + return response + + def _checked(self, instance_id, inst, cap, args, request_id): + host = self.__host + fail = lambda code, status="rejected": self._error(instance_id, code, request_id, status) + spec = host._metadata["asset_types"][XPR204E_TYPE] + if cap not in spec["capabilities"]: + return fail("UNKNOWN_CAPABILITY") + if set(args) != set(spec["capabilities"][cap]["input_schema"]["properties"]): + return fail("INVALID_ARGUMENT") + if cap == "power.set" and type(args["enabled"]) is not bool: + return fail("INVALID_ARGUMENT") + if cap == "balance.set_filter" and (not isinstance(args["level"], str) or args["level"] not in XPR204E_FILTERS): + return fail("INVALID_ARGUMENT") + if cap == "balance.set_display_unit" and args["unit"] not in ("kg", "g"): + return fail("INVALID_ARGUMENT") + if cap == "balance.calibrate_span" and (not _xpr_number(args["known_mass_kg"]) or not XPR204E_CALIBRATION_MIN_KG <= args["known_mass_kg"] <= XPR204E_CAPACITY_KG): + return fail("INVALID_ARGUMENT") + if cap == "scene.set_door" and (args["side"] not in ("left", "right", "top") or not _xpr_number(args["opening_m"]) or not 0 <= args["opening_m"] <= XPR204E_DOOR_MAX_M): + return fail("INVALID_ARGUMENT") + if cap == "scene.set_pan" and type(args["installed"]) is not bool: + return fail("INVALID_ARGUMENT") + b = inst["balance"] + if cap in ("balance.tare", "balance.zero", "balance.calibrate_span") and (not b.powered or not b.stable): + return fail("PRECONDITION_FAILED") + if cap == "balance.zero" and abs(b.gross_kg) > 0.02 * b.capacity_kg: + return fail("PRECONDITION_FAILED") + if cap == "balance.calibrate_span" and (b.security_locked or b.filtered_force_N is None or b.filtered_force_N <= 0): + return fail("PRECONDITION_FAILED") + if cap == "balance.set_filter" and b.security_locked: + return fail("PRECONDITION_FAILED") + if cap == "scene.set_pan" and (b.powered or abs(b.raw_force_N / b.g_cal) > b.readability_kg): + return fail("PRECONDITION_FAILED") + if cap.startswith("scene.") and host.scene_adapter is None: + return fail("UNSUPPORTED", "unsupported") + if cap == "balance.reading": + values = host._values(inst) + return self._envelope(instance_id, request_id, result={"status": values["balance.status"], "stable": values["balance.stable"], + "gross_kg": values["balance.gross_kg"], "net_kg": values["balance.net_kg"], "synthetic": True}) + candidate = _xpr_copy.deepcopy(inst) + b = candidate["balance"] + if cap == "power.set": + b.set_power(args["enabled"]) + result = {"enabled": b.powered} + elif cap == "balance.set_filter": + b.set_filter(args["level"]) + result = {"level": b.filter_level} + elif cap == "balance.tare": + b.press("tare") + result = {"tare_kg": _xpr_quantize(b.tare_kg)} + elif cap == "balance.zero": + b.press("zero") + result = {"zeroed": True} + elif cap == "balance.set_display_unit": + b.unit = args["unit"] + result = {"unit": b.unit} + elif cap == "balance.calibrate_span": + try: + b.calibrate_known_mass(args["known_mass_kg"]) + except ValueError: + return fail("PRECONDITION_FAILED") + result = {"calibrated": True, "synthetic": True} + elif cap == "scene.set_door": + candidate["doors"][args["side"]] = float(args["opening_m"]) + b.door_fraction = max(candidate["doors"].values()) / XPR204E_DOOR_MAX_M + b.reset_stability() + result = {"side": args["side"], "opening_m": float(args["opening_m"])} + else: + b.pan_installed = b.pan_latched = args["installed"] + b.reset_stability() + result = {"installed": b.pan_installed} + if host.scene_adapter: + try: + host.scene_adapter(instance_id, host._scene(candidate)) + except Exception: + return fail("DEVICE_ERROR", "failed") + candidate["revision"] += 1 + host._instances[instance_id] = candidate + return self._envelope(instance_id, request_id, result=result) + + def write(self, *, instance_id, state_id, value, request_id): + host = self.__host + with host._lock: + if not self._instance(instance_id): + return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) + slots = host._metadata["asset_types"][XPR204E_TYPE]["state_slots"] + if not isinstance(state_id, str) or state_id not in slots or not self._visible(slots[state_id]) or not slots[state_id]["write_via"]: + return self._error(instance_id, "ACCESS_DENIED", request_id) + route = slots[state_id]["write_via"] + arguments = {**route["fixed_arguments"], route["parameter"]: value} + return self.invoke(instance_id=instance_id, capability_id=route["capability_id"], arguments=arguments, request_id=request_id) + + def logs(self): + with self.__host._lock: + return _xpr_copy.deepcopy(self.__host._logs[self.__principal]) + + +def xpr204e_filter_experiments(*, seeds=range(10), duration_s=60.0): + """Specified 100 Hz Gaussian-force test, including baseline and display error. + + These are fixed 100 g and empty-pan synthetic fixtures, not task/sample truth. + Results only characterize this uncorrelated-noise experiment, not arbitrary + contact noise. + """ + import platform + seeds = tuple(seeds) + trials, empty_pan_trials = [], [] + dt = 0.01 + for load, fixture_trials in ((0.1, trials), (0.0, empty_pan_trials)): + for level in XPR204E_FILTERS: + for sigma in (1e-6, 1e-4, 1e-3): + for seed in seeds: + rng = _xpr_random.Random(seed) + balance = FilteredAnalyticalBalance(filter_level=level) + balance.set_power(True) + first = None + stable_error = None + for index in range(1, int(duration_s / dt) + 1): + result = balance.update(load * 9.80665 + rng.gauss(0, sigma), dt) + if result["stable"]: + first = round(index * dt, 8) + stable_error = result["net_kg"] - load + break + fixture_trials.append({"level": level, "reference_load_kg": load, "sigma_force_N": sigma, "seed": seed, + "first_stable_s": first, "net_error_at_first_stable_kg": stable_error, + "filtered_peak_to_peak_at_stable_kg": balance._window_range_kg, + "result": "passed" if first is not None else "failed"}) + baseline = [] + for sigma in (1e-6, 1e-4, 1e-3): + rng = _xpr_random.Random(0) + balance = _XPRLegacyBalance.for_model("PX224E") + balance.press("zero") + first = None + for index in range(1, int(duration_s / dt) + 1): + if balance.update(0.1 * 9.80665 + rng.gauss(0, sigma), dt)["stable"]: + first = round(index * dt, 8) + break + baseline.append({"sigma_force_N": sigma, "first_stable_s": first, "duration_s": duration_s}) + return {"catalog_id": "CHEM-001", "recorded_at": _xpr_datetime.now(_xpr_timezone.utc).isoformat(), + "environment": {"python": platform.python_version(), "platform": platform.platform()}, + "method": "100 Hz independent Gaussian force noise on 0.1 kg and empty-pan synthetic fixtures; first STABLE within 60 s", + "synthetic": True, "noise_distribution": "independent Gaussian; zero mean", "dt_s": dt, + "duration_s": duration_s, "seed_values": list(seeds), "filter_parameters": _xpr_copy.deepcopy(XPR204E_FILTERS), + "numeric_filter_evidence": "engineering_assumption", "manufacturer_filter_numbers": None, + "manufacturer_level_evidence": "references/PX_manual.txt lines 1161-1168; section 5.3.3, EN-27", + "stability_hold_s": XPR204E_TARGET_SETTLING_S, "warmup": "5*tau from filter initialization", + "baseline_unmodified_px224e": baseline, "trials": trials, "empty_pan_trials": empty_pan_trials, + "result": "passed" if all(row["result"] == "passed" for row in trials + empty_pan_trials) else "failed", + "boundaries": "STABLE means a full filtered display window is within N divisions; coarse high-noise bands do not reproduce the XPR204E 0.04 mg typical repeatability. No correlated/bias/contact-solver noise, actual hardware, robot or process/filesystem isolation was validated."} + + +def write_xpr204e_runtime_reports(output_directory): + """Write only the caller-designated asset output directory; no global files.""" + import importlib.util + import io + import platform + import unittest + root = _xpr_Path(__file__).resolve().parents[1] + spec = importlib.util.spec_from_file_location("test_basic40_measure", root / "tests/test_basic40_measure.py") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + suite = unittest.defaultTestLoader.loadTestsFromTestCase(module.XPR204ERuntimeTests) + suite.addTests(unittest.defaultTestLoader.loadTestsFromTestCase(module.FilteredAnalyticalBalanceTests)) + stream = io.StringIO() + result = unittest.TextTestRunner(stream=stream, verbosity=2).run(suite) + report = {"catalog_id": "CHEM-001", "recorded_at": _xpr_datetime.now(_xpr_timezone.utc).isoformat(), + "environment": {"python": platform.python_version(), "platform": platform.platform()}, + "method": "unittest runtime inputs, state transitions, noise window, two instances, API truth filtering, request retry and scene callback failure", + "tests_run": result.testsRun, "failures": len(result.failures), "errors": len(result.errors), + "result": "passed" if result.wasSuccessful() else "failed", "output": stream.getvalue(), + "not_run": ["real_hardware", "robot_execution", "contact_solver", "process_filesystem_security_isolation"], + "scene_scope": "A recording callback checks synchronization, not evaluated Blender geometry."} + directory = _xpr_Path(output_directory) + directory.mkdir(parents=True, exist_ok=True) + for name, value in (("runtime_validation.json", report), ("filter_experiments.json", xpr204e_filter_experiments()), + ("runtime_metadata.json", export_xpr204e_contract_metadata())): + (directory / name).write_text(_xpr_json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report + + +# CHEM-103 append-only runtime: catalogue limits and synthetic command playback. +import copy as _gamry_copy +import hashlib as _gamry_hashlib +import json as _gamry_json +import math as _gamry_math +import threading as _gamry_threading +from fractions import Fraction as _gamry_Fraction + +GAMRY_REFERENCE620_TYPE = "instrument.gamry_reference620" +GAMRY_REFERENCE620_PORTS = ("working_electrode", "reference_electrode", "counter_electrode", "cell") +GAMRY_REFERENCE620_MIN_INTERVAL_S = 3.333e-6 +GAMRY_REFERENCE620_MAX_SAMPLES = 10000 # Runtime resource budget, not a vendor specification. + + +def _gamry_number(value): + try: + return type(value) in (int, float) and _gamry_math.isfinite(value) + except (TypeError, OverflowError): + return False + + +def _gamry_object(properties): + return {"type": "object", "properties": properties, "required": list(properties), "additionalProperties": False} + + +def _gamry_num(unit, minimum=None, maximum=None, nullable=False): + spec = {"type": "number", "x-unit": unit} + if minimum is not None: + spec["minimum"] = minimum + if maximum is not None: + spec["maximum"] = maximum + return {"anyOf": [spec, {"type": "null"}]} if nullable else spec + + +def export_gamry_reference620_contract_metadata(): + """Static contract metadata. No live samples or host identities are exported.""" + boolean = {"type": "boolean"} + synthetic = {"type": "boolean", "const": True} + nullable_id = {"anyOf": [{"type": "string", "minLength": 1}, {"type": "null"}]} + status_schema = {"type": "string", "enum": ["idle", "running", "completed", "stopped"]} + program_variants = [] + for mode, unit, limit in (("potential", "V", 11.0), ("current", "A", 0.6)): + program_variants.append(_gamry_object({"mode": {"type": "string", "const": mode}, + "sample_interval_s": _gamry_num("s", GAMRY_REFERENCE620_MIN_INTERVAL_S), + "values": {"type": "array", "items": _gamry_num(unit, -limit, limit), + "minItems": 1, "maxItems": GAMRY_REFERENCE620_MAX_SAMPLES}})) + program_schema = {"anyOf": program_variants} + sample_schema = _gamry_object({"time_s": _gamry_num("s", 0), "elapsed_s": _gamry_num("s", 0), + "commanded_potential_v": _gamry_num("V", -11, 11, True), + "commanded_current_a": _gamry_num("A", -0.6, 0.6, True), + "measured_potential_v": {"type": "null"}, "measured_current_a": {"type": "null"}, + "synthetic": synthetic}) + series_schema = {"type": "array", "items": sample_schema, "maxItems": GAMRY_REFERENCE620_MAX_SAMPLES} + slots = {} + def slot(sid, unit, origin, schema, description, route=None, visibility="agent", sampling="instant"): + slots[sid] = {"description_zh": description, "value_schema": schema, "unit": unit, + "origin": origin, "visibility": visibility, "access": "read_write" if route else "read_only", + "write_via": route, "reference_conditions": None, + "read_binding": "GamryReference620Session.read(instance_id=..., state_ids=[state_id])", + "sampling": {"mode": sampling, "time_domain": "simulation", "window": None}} + def route(capability_id, parameter, fixed_arguments=None): + return {"capability_id": capability_id, "parameter": parameter, "fixed_arguments": fixed_arguments or {}} + slot("power.enabled", "1", "setpoint", boolean, "供电逻辑状态；关电立即停止命令输出。", route("power.set", "enabled")) + for port in GAMRY_REFERENCE620_PORTS: + slot("slot." + port + ".connection_id", "1", "scene", nullable_id, + "宿主场景连接槽的逻辑引用；null表示未连接，不证明接触或机器人接线已完成。", + route("slot.set_connection", "connection_id", {"port_id": port})) + slot("waveform.program", "1", "setpoint", {"anyOf": program_variants + [{"type": "null"}]}, + "显式离散命令程序；电位与电流互斥；采样间隔须不小于表列最小时间基准。", + route("electrochem.configure_waveform", "program")) + slot("waveform.status", "1", "derived", status_schema, "离散播放状态，不代表真实样本实验完成。") + slot("waveform.running", "1", "derived", boolean, "是否等待宿主推进来播放剩余命令。") + slot("waveform.sample_count", "1", "derived", {"type": "integer", "minimum": 0, "maximum": GAMRY_REFERENCE620_MAX_SAMPLES, "x-unit": "1"}, "已播放命令点数。") + slot("waveform.elapsed_s", "s", "derived", _gamry_num("s", 0), "本次播放已推进的有效时间，完成后停在最后命令点。") + slot("output.commanded_potential_v", "V", "derived", _gamry_num("V", -11, 11, True), "当前合成电位命令；停止或使用电流模式时为null。") + slot("output.commanded_current_a", "A", "derived", _gamry_num("A", -0.6, 0.6, True), "当前合成电流命令；停止或使用电位模式时为null。") + slot("acquisition.series", "1", "derived", series_schema, "按时间排列的命令回放序列；两种实测通道均为null。", sampling="series") + slot("acquisition.synthetic", "1", "derived", synthetic, "本适配器产生的序列始终标记synthetic。") + for sid, unit, desc in (("measurement.potential_v", "V", "未接入真实电位传感器；无响应模型。"), + ("measurement.current_a", "A", "未接入真实电流传感器；无响应模型。"), + ("method.scan_rate_v_s", "V/s", "未配置连续扫描速率；本批仅显式离散程序。"), + ("method.frequency_hz", "Hz", "未配置EIS频率；EIS执行不支持。"), + ("method.amplitude_v", "V", "未配置EIS振幅；无虚构默认值。"), + ("method.ir_compensation_ohm", "ohm", "未提供iR补偿参数，保持未知。")): + slot(sid, unit, "sensor" if sid.startswith("measurement.") else "setpoint", {"type": "null"}, desc) + slot("scheduler.started_at_s", "s", "process_truth", _gamry_num("s", 0, nullable=True), + "宿主内部调度起点；仅debug/evaluator可见。", visibility="debug") + playback_effects = ["waveform.status", "waveform.running", "waveform.sample_count", "waveform.elapsed_s", + "output.commanded_potential_v", "output.commanded_current_a", "acquisition.series", "scheduler.started_at_s"] + stop_effects = ["waveform.status", "waveform.running", "output.commanded_potential_v", "output.commanded_current_a"] + connection_inputs = {"port_id": {"type": "string", "enum": list(GAMRY_REFERENCE620_PORTS)}, "connection_id": nullable_id} + series_result = {"samples": series_schema, "synthetic": synthetic, + "response_model": {"type": "null"}, "status": status_schema} + definitions = { + "power.set": ({"enabled": boolean}, {"enabled": boolean}, {"enabled": True}, + "设置逻辑电源；关电保留已播放序列并停止输出。", ["power.enabled"] + stop_effects, ["power.enabled"], "device_command", ["body"], "参数为布尔值。"), + "slot.set_connection": (connection_inputs, connection_inputs, {"port_id": "working_electrode", "connection_id": "electrode_we_01"}, + "登记或清除单个逻辑连接槽；不执行机械接线。", ["slot." + p + ".connection_id" for p in GAMRY_REFERENCE620_PORTS], + ["slot." + p + ".connection_id" for p in GAMRY_REFERENCE620_PORTS], "configuration", + [p + "_slot" for p in GAMRY_REFERENCE620_PORTS], "不得处于播放状态；连接引用为非空字符串或null。"), + "electrochem.configure_waveform": ({"program": program_schema}, {"program": program_schema}, + {"program": {"mode": "potential", "sample_interval_s": 0.01, "values": [-1.0, 0.0, 1.0]}}, + "配置显式离散电位或电流命令，清空上一轮序列；不推导扫描速率或样本响应。", + ["waveform.program"] + playback_effects, ["waveform.program"], "configuration", ["body"], + "不得处于播放状态；全部数值有限，电位±11V、电流±0.6A，间隔≥3.333e-6s。"), + "electrochem.start": ({}, {"status": status_schema, "synthetic": synthetic}, {}, + "开始等待宿主时钟播放离散程序；此调用不产生样点也不推进时间。", playback_effects, + ["waveform.status", "waveform.running"], "device_command", ["body"] + [p + "_slot" for p in GAMRY_REFERENCE620_PORTS], + "电源开启、四槽均已连接、程序已配置且当前未播放；整份计划的输出时间戳必须有限且逐点严格递增。"), + "electrochem.stop": ({}, {"status": status_schema, "synthetic": synthetic}, {}, + "停止尚未播放的命令，保留已播放序列；输出设为null。", stop_effects, + ["waveform.status", "waveform.running"], "device_command", ["body"], "实例可用；允许幂等停止。"), + "electrochem.read_series": ({}, series_result, {}, "只读合成命令序列；真实测量通道为null，不推进时间。", + [], ["acquisition.series", "acquisition.synthetic", "waveform.status"], "query", ["body"], "实例可用。"), + "electrochem.eis": ({}, {}, {}, "表中EIS范围保留为型号规格；本批不生成阻抗谱或虚构成功。", + [], [], "device_command", ["body"], "当前适配器不支持执行EIS。"), + } + caps = {} + for name, (inputs, outputs, example, description, effects, observes, kind, components, preconditions) in definitions.items(): + supported = name != "electrochem.eis" + caps[name] = {"availability": "implemented" if supported else "unsupported", "visibility": "agent", "kind": kind, + "description_zh": description, "input_schema": _gamry_object(inputs), "output_schema": _gamry_object(outputs), + "example_arguments": [example], "state_effects": [{"state_id": sid, "timing": "immediate", "description_zh": description} for sid in effects], + "observes": observes, "component_ids": components, "preconditions_zh": preconditions, + "binding": f"basic40_runtime_measure.GamryReference620Session.invoke(instance_id=..., capability_id='{name}', arguments=..., request_id=...)", + "completion_criterion_zh": "同步提交所列逻辑状态；播放完成须由宿主推进并读取completed状态。" if supported else "返回unsupported且无状态变化。", + "model_effects": {"mode": "none", "binding_ids": [], "description_zh": "仅逻辑槽位与离散电命令，不驱动几何或接触求解。"}, + "implementation": {"process": "implemented" if supported else "absent", "host": "implemented" if supported else "absent", "scene": "absent", "robot": "absent", "hardware": "absent"}, + "error_codes": ["UNKNOWN_INSTANCE", "UNKNOWN_CAPABILITY", "INVALID_ARGUMENT", "ACCESS_DENIED", "PRECONDITION_FAILED", "BUSY", "REQUEST_CONFLICT", "UNSUPPORTED"], + "retry": "same_request_id; in-memory only"} + parameters = { + "potential_limit_v": {"value": 11.0, "unit": "V", "evidence": "catalog", "note_zh": "参数与来源第108行，整机±11V命令限幅。"}, + "current_limit_a": {"value": 0.6, "unit": "A", "evidence": "catalog", "note_zh": "参数与来源第108行，±600mA换算SI；不是电极部件参数。"}, + "minimum_time_base_s": {"value": GAMRY_REFERENCE620_MIN_INTERVAL_S, "unit": "s", "evidence": "catalog", "note_zh": "表列3.333µs；映射为最小程序点间隔为工程假设。"}, + "eis_frequency_range_hz": {"value": [1e-5, 5e6], "unit": "Hz", "evidence": "catalog", "note_zh": "保留型号规格，未实现EIS执行。"}, + "maximum_program_samples": {"value": GAMRY_REFERENCE620_MAX_SAMPLES, "unit": "1", "evidence": "engineering_assumption", "note_zh": "本地资源预算，不是厂家最大点数。"}, + "cell_resistance_ohm": {"value": None, "unit": "ohm", "evidence": "unknown", "note_zh": "未提供真实电化学池参数。"}, + "electrode_area_m2": {"value": None, "unit": "m^2", "evidence": "unknown", "note_zh": "未提供电极几何或有效面积。"}, + "calibration_error_v": {"value": None, "unit": "V", "evidence": "unknown", "note_zh": "未提供校准或误差数据。"}, + } + return {"asset_types": {GAMRY_REFERENCE620_TYPE: {"catalog_id": "CHEM-103", "model": "Gamry Reference 620", "asset_version": "1.0.1", + "state_slots": slots, "capabilities": caps, "parameters": parameters}}, + "host_capabilities": {"sim.step": {"kind": "simulation", "visibility": "trusted_host_only", + "binding": "GamryReference620Runtime.step(dt_s)", "effects": playback_effects, + "semantics_zh": "显式推进所有实例共享时钟；输入数值的十进制表示转精确有理数进行累加和计划比较；正步进播放覆盖的计划点（包括起点），零步进不产生效果。输出仍为SI浮点数，完整计划须严格可分辨。"}}, + "limitations": ["All sequence data are synthetic command playback, not electrochemical measurements.", + "Measured potential/current and unprovided cell/method parameters remain null.", + "No EIS, Nernst, Coulomb, sample response, iR compensation, noise, calibration or hardware driver is implemented.", + "Sample playback and minimum-time-base interpretation are engineering assumptions, not vendor firmware emulation.", + "Clock inputs use their shortest decimal string as an exact rational; this numerical convention makes decimal step partitions consistent. Exposed timestamps remain floats; non-monotonic or indistinguishable complete schedules are rejected before start.", + "Slot references are logical only; compatibility, electrical contact and robot connection are not validated.", + "Session filtering is an API boundary only; this is not a Python/filesystem security sandbox.", + "Request deduplication lasts only for this in-memory host lifetime."]} + + +class GamryReference620Runtime: + """Trusted host for independent instances under an explicitly stepped clock.""" + def __init__(self): + self._time_fraction = _gamry_Fraction(0) + self._instances = {} + self._principals = {"__public_agent__": ("agent", None)} + self._logs = {"__public_agent__": []} + self._requests = {} + self._lock = _gamry_threading.RLock() + self._metadata = export_gamry_reference620_contract_metadata() + self._agent = GamryReference620Session(self, "__public_agent__") + + def create_instance(self, instance_id, asset_type_id=GAMRY_REFERENCE620_TYPE): + with self._lock: + if type(instance_id) is not str or not instance_id or instance_id in self._instances or asset_type_id != GAMRY_REFERENCE620_TYPE: + raise ValueError("A unique nonempty instance ID and the declared asset type are required") + self._instances[instance_id] = {"revision": 0, "enabled": False, + "connections": {p: None for p in GAMRY_REFERENCE620_PORTS}, "program": None, + "status": "idle", "running": False, "index": 0, "elapsed_s": 0.0, + "potential_v": None, "current_a": None, "samples": [], "started_at_s": None, + "started_at_fraction": None, "schedule": []} + + @property + def time_s(self): + """Public SI float view of the single authoritative rational host clock.""" + return float(self._time_fraction) + + def register_principal(self, principal_id, *, visibility, instance_ids=None): + with self._lock: + if type(principal_id) is not str or not principal_id or principal_id in self._principals or visibility not in ("agent", "debug", "evaluator"): + raise ValueError("Invalid or already registered host identity") + if instance_ids is not None and (type(instance_ids) not in (list, tuple, set, frozenset) or any(type(x) is not str for x in instance_ids)): + raise ValueError("Instance scope must be a collection of instance IDs") + scope = None if instance_ids is None else frozenset(instance_ids) + if scope is not None and not scope <= self._instances.keys(): + raise ValueError("Unknown instance in identity scope") + self._principals[principal_id] = (visibility, scope) + self._logs[principal_id] = [] + + def session(self, principal_id): + if type(principal_id) is not str or principal_id not in self._principals: + raise ValueError("Identity must be registered by the trusted host") + return GamryReference620Session(self, principal_id) + + def describe(self, **kwargs): + return self._agent.describe(**kwargs) + + def read(self, **kwargs): + return self._agent.read(**kwargs) + + def invoke(self, **kwargs): + return self._agent.invoke(**kwargs) + + def write(self, **kwargs): + return self._agent.write(**kwargs) + + def describe_host(self): + return _gamry_copy.deepcopy(self._metadata["host_capabilities"]) + + @staticmethod + def _values(inst): + values = {"power.enabled": inst["enabled"], "waveform.program": inst["program"], + "waveform.status": inst["status"], "waveform.running": inst["running"], + "waveform.sample_count": inst["index"], "waveform.elapsed_s": inst["elapsed_s"], + "output.commanded_potential_v": inst["potential_v"], "output.commanded_current_a": inst["current_a"], + "acquisition.series": inst["samples"], "acquisition.synthetic": True, + "measurement.potential_v": None, "measurement.current_a": None, + "method.scan_rate_v_s": None, "method.frequency_hz": None, + "method.amplitude_v": None, "method.ir_compensation_ohm": None, + "scheduler.started_at_s": inst["started_at_s"]} + values.update({"slot." + p + ".connection_id": value for p, value in inst["connections"].items()}) + return values + + def debug_snapshot(self): + with self._lock: + return {"time_s": self.time_s, "instances": {key: {"revision": inst["revision"], + "state": _gamry_copy.deepcopy(self._values(inst))} for key, inst in self._instances.items()}} + + def step(self, dt_s): + """Positive host steps emit scheduled command points, never sample chemistry. + + Inputs are interpreted by their shortest decimal representation, then + exact rational addition/comparison controls the host clock and schedule. + Each timestamp comes from the absolute start plus index*interval; chunk + boundaries do not set the sampling cadence. Zero is a pure no-op. The + first point is timestamped at the start but emitted only on a positive + host step. Completion de-energizes the command outputs and retains all + emitted samples. All registered instances share this host clock. + """ + if not _gamry_number(dt_s) or dt_s < 0: + raise ValueError("Finite nonnegative SI host interval required") + with self._lock: + target_fraction = self._time_fraction + _gamry_Fraction(str(dt_s)) + try: + target = float(target_fraction) + except OverflowError: + raise ValueError("Host clock exceeds representable range") from None + if not _gamry_number(target) or (dt_s > 0 and target <= self.time_s): + raise ValueError("Host clock interval exceeds representable precision or range") + if dt_s == 0: + return + candidates = _gamry_copy.deepcopy(self._instances) + for inst in candidates.values(): + if not inst["running"]: + continue + before = self._values(inst) + program = inst["program"] + duration = inst["schedule"][-1][1] + inst["elapsed_s"] = min(float(target_fraction - inst["started_at_fraction"]), duration) + while inst["index"] < len(program["values"]): + scheduled_fraction, offset = inst["schedule"][inst["index"]] + if scheduled_fraction > target_fraction: + break + timestamp = float(scheduled_fraction) + value = program["values"][inst["index"]] + potential = value if program["mode"] == "potential" else None + current = value if program["mode"] == "current" else None + inst["samples"].append({"time_s": timestamp, "elapsed_s": offset, + "commanded_potential_v": potential, "commanded_current_a": current, + "measured_potential_v": None, "measured_current_a": None, "synthetic": True}) + inst["potential_v"], inst["current_a"] = potential, current + inst["index"] += 1 + if inst["index"] == len(program["values"]): + inst["running"] = False + inst["status"] = "completed" + inst["potential_v"] = inst["current_a"] = None + if before != self._values(inst): + inst["revision"] += 1 + self._instances = candidates + self._time_fraction = target_fraction + + +class GamryReference620Session: + """Expose only this facade to agents; identities are assigned by the host.""" + def __init__(self, host, principal_id): + self.__host, self.__principal = host, principal_id + + def _visible(self, spec): + return spec["visibility"] == "agent" or self.__host._principals[self.__principal][0] in ("debug", "evaluator") + + def _instance(self, instance_id): + if type(instance_id) is not str: + return None + _, scope = self.__host._principals[self.__principal] + return self.__host._instances.get(instance_id) if scope is None or instance_id in scope else None + + def _envelope(self, instance_id, request_id=None, *, result=None, observations=None, status="succeeded", error=None): + inst = self._instance(instance_id) + return {"protocol_version": "1.0.0", "instance_id": instance_id if type(instance_id) is str else None, + "request_id": request_id if type(request_id) is str else None, "operation_id": None, "status": status, + "state_revision": None if inst is None else inst["revision"], + "clock": {"domain": "simulation", "time_s": self.__host.time_s}, + "result": _gamry_copy.deepcopy({} if result is None else result), + "observations": _gamry_copy.deepcopy({} if observations is None else observations), "error": error} + + def _error(self, instance_id, code, request_id=None, status="rejected"): + messages = {"UNKNOWN_INSTANCE": "Instance is unavailable in this session.", "UNKNOWN_CAPABILITY": "Capability is unavailable.", + "INVALID_ARGUMENT": "Arguments do not meet the declared schema, finite-number or resource limits.", + "ACCESS_DENIED": "Request is outside the session access policy.", + "PRECONDITION_FAILED": "Required operating state or representable clock configuration is unavailable.", + "BUSY": "Stop active waveform playback before changing this configuration.", + "REQUEST_CONFLICT": "Request ID already belongs to different arguments.", + "UNSUPPORTED": "This execution is unavailable in the current adapter."} + return self._envelope(instance_id, request_id, status=status, + error={"code": code, "message": messages[code], "retryable": False, "side_effects": "none", "progress": None}) + + def describe(self, *, asset_type_id=None, instance_id=None): + host = self.__host + with host._lock: + if (asset_type_id is None) == (instance_id is None): + return self._error(None, "INVALID_ARGUMENT") + if instance_id is not None and self._instance(instance_id) is None: + return self._error(instance_id, "UNKNOWN_INSTANCE") + if asset_type_id is not None and asset_type_id != GAMRY_REFERENCE620_TYPE: + return self._error(None, "INVALID_ARGUMENT") + _, scope = host._principals[self.__principal] + if scope is not None and not scope: + return self._error(instance_id, "ACCESS_DENIED") + spec = _gamry_copy.deepcopy(host._metadata["asset_types"][GAMRY_REFERENCE620_TYPE]) + spec["state_slots"] = {sid: value for sid, value in spec["state_slots"].items() if self._visible(value)} + spec["capabilities"] = {cid: value for cid, value in spec["capabilities"].items() if self._visible(value)} + for capability in spec["capabilities"].values(): + capability["state_effects"] = [effect for effect in capability["state_effects"] if effect["state_id"] in spec["state_slots"]] + capability["observes"] = [sid for sid in capability["observes"] if sid in spec["state_slots"]] + return {"protocol_version": "1.0.0", "asset_type_id": GAMRY_REFERENCE620_TYPE, "instance_id": instance_id, + "adapter": "basic40_runtime_measure.GamryReference620Session", **spec, + "limitations": _gamry_copy.deepcopy(host._metadata["limitations"])} + + def read(self, *, instance_id, state_ids=None): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if inst is None: + return self._error(instance_id, "UNKNOWN_INSTANCE") + slots = host._metadata["asset_types"][GAMRY_REFERENCE620_TYPE]["state_slots"] + if state_ids is None: + state_ids = [sid for sid, value in slots.items() if self._visible(value)] + if type(state_ids) is not list or any(type(sid) is not str for sid in state_ids) or len(state_ids) != len(set(state_ids)): + return self._error(instance_id, "INVALID_ARGUMENT") + if any(sid not in slots or not self._visible(slots[sid]) for sid in state_ids): + return self._error(instance_id, "ACCESS_DENIED") + values = host._values(inst) + observations = {} + for sid in state_ids: + series = sid == "acquisition.series" + derived = slots[sid]["origin"] == "derived" + observations[sid] = {"value": values[sid], "unit": slots[sid]["unit"], + "quality": "unavailable" if values[sid] is None else "estimated" if derived else "valid", + "sample_time_s": host.time_s, + "sample_window_s": [inst["samples"][0]["time_s"], inst["samples"][-1]["time_s"]] if series and inst["samples"] else None, + "reason": slots[sid]["description_zh"] if values[sid] is None else None, + "synthetic": derived} + return self._envelope(instance_id, observations=observations) + + def invoke(self, *, instance_id, capability_id, arguments, request_id): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if inst is None: + return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) + if type(capability_id) is not str or type(arguments) is not dict or type(request_id) is not str or not request_id or len(request_id) > 256: + return self._error(instance_id, "INVALID_ARGUMENT", request_id) + try: + digest = _gamry_hashlib.sha256(_gamry_json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False).encode()).hexdigest() + except (TypeError, ValueError, OverflowError, RecursionError): + return self._error(instance_id, "INVALID_ARGUMENT", request_id) + key = (self.__principal, instance_id, request_id) + if key in host._requests: + old_digest, response = host._requests[key] + return _gamry_copy.deepcopy(response) if old_digest == digest else self._error(instance_id, "REQUEST_CONFLICT", request_id) + response = self._checked(instance_id, inst, capability_id, arguments, request_id) + host._requests[key] = (digest, _gamry_copy.deepcopy(response)) + host._logs[self.__principal].append({"instance_id": instance_id, "capability_id": capability_id, + "request_id": request_id, "response": _gamry_copy.deepcopy(response)}) + return response + + def _checked(self, instance_id, inst, cap, args, request_id): + host = self.__host + fail = lambda code, status="rejected": self._error(instance_id, code, request_id, status) + capabilities = host._metadata["asset_types"][GAMRY_REFERENCE620_TYPE]["capabilities"] + if cap not in capabilities or not self._visible(capabilities[cap]): + return fail("UNKNOWN_CAPABILITY") + if set(args) != set(capabilities[cap]["input_schema"]["properties"]): + return fail("INVALID_ARGUMENT") + if cap == "electrochem.eis": + return fail("UNSUPPORTED", "unsupported") + if cap == "power.set" and type(args["enabled"]) is not bool: + return fail("INVALID_ARGUMENT") + if cap == "slot.set_connection": + port, connection = args["port_id"], args["connection_id"] + if type(port) is not str or port not in GAMRY_REFERENCE620_PORTS or (connection is not None and (type(connection) is not str or not connection.strip())): + return fail("INVALID_ARGUMENT") + if cap == "electrochem.configure_waveform": + program = args["program"] + if type(program) is not dict or set(program) != {"mode", "sample_interval_s", "values"}: + return fail("INVALID_ARGUMENT") + mode, interval, values = program["mode"], program["sample_interval_s"], program["values"] + if type(mode) is not str or mode not in ("potential", "current") or not _gamry_number(interval) or interval < GAMRY_REFERENCE620_MIN_INTERVAL_S: + return fail("INVALID_ARGUMENT") + limit = 11.0 if mode == "potential" else 0.6 + if type(values) is not list or not 1 <= len(values) <= GAMRY_REFERENCE620_MAX_SAMPLES or any(not _gamry_number(v) or not -limit <= v <= limit for v in values): + return fail("INVALID_ARGUMENT") + if not _gamry_number((len(values) - 1) * interval): + return fail("INVALID_ARGUMENT") + if cap in ("slot.set_connection", "electrochem.configure_waveform", "electrochem.start") and inst["running"]: + return fail("BUSY") + if cap == "electrochem.start": + if not inst["enabled"] or inst["program"] is None or not all(inst["connections"].values()): + return fail("PRECONDITION_FAILED") + program = inst["program"] + interval_fraction = _gamry_Fraction(str(program["sample_interval_s"])) + schedule = [] + previous_timestamp = None + for index in range(len(program["values"])): + offset_fraction = index * interval_fraction + timestamp_fraction = host._time_fraction + offset_fraction + try: + timestamp = float(timestamp_fraction) + offset = float(offset_fraction) + except OverflowError: + return fail("PRECONDITION_FAILED") + if (not _gamry_number(timestamp) or not _gamry_number(offset) + or (previous_timestamp is not None and timestamp <= previous_timestamp)): + return fail("PRECONDITION_FAILED") + schedule.append((timestamp_fraction, offset)) + previous_timestamp = timestamp + if cap == "electrochem.read_series": + return self._envelope(instance_id, request_id, result={"samples": inst["samples"], "synthetic": True, + "response_model": None, "status": inst["status"]}) + candidate = _gamry_copy.deepcopy(inst) + if cap == "power.set": + candidate["enabled"] = args["enabled"] + if not args["enabled"]: + if candidate["running"]: + candidate["status"] = "stopped" + candidate["running"] = False + candidate["potential_v"] = candidate["current_a"] = None + result = {"enabled": candidate["enabled"]} + elif cap == "slot.set_connection": + candidate["connections"][args["port_id"]] = args["connection_id"] + result = _gamry_copy.deepcopy(args) + elif cap == "electrochem.configure_waveform": + candidate["program"] = _gamry_copy.deepcopy(args["program"]) + candidate.update(status="idle", running=False, index=0, elapsed_s=0.0, + potential_v=None, current_a=None, samples=[], started_at_s=None, + started_at_fraction=None, schedule=[]) + result = {"program": candidate["program"]} + elif cap == "electrochem.start": + candidate.update(status="running", running=True, index=0, elapsed_s=0.0, + potential_v=None, current_a=None, samples=[], started_at_s=host.time_s, + started_at_fraction=host._time_fraction, schedule=schedule) + result = {"status": "running", "synthetic": True} + else: # electrochem.stop + if candidate["running"]: + candidate["status"] = "stopped" + candidate["running"] = False + candidate["potential_v"] = candidate["current_a"] = None + result = {"status": candidate["status"], "synthetic": True} + if host._values(candidate) != host._values(inst): + candidate["revision"] += 1 + host._instances[instance_id] = candidate + return self._envelope(instance_id, request_id, result=result) + + def write(self, *, instance_id, state_id, value, request_id): + host = self.__host + with host._lock: + if self._instance(instance_id) is None: + return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) + slots = host._metadata["asset_types"][GAMRY_REFERENCE620_TYPE]["state_slots"] + if type(state_id) is not str or state_id not in slots or not self._visible(slots[state_id]) or slots[state_id]["write_via"] is None: + return self._error(instance_id, "ACCESS_DENIED", request_id) + route = slots[state_id]["write_via"] + return self.invoke(instance_id=instance_id, capability_id=route["capability_id"], + arguments={**route["fixed_arguments"], route["parameter"]: value}, request_id=request_id) + + def logs(self): + with self.__host._lock: + return _gamry_copy.deepcopy(self.__host._logs[self.__principal]) + + +# BEGIN CHEM-005 METROHM 914 APPEND-ONLY RUNTIME +import copy as _m914_copy +import hashlib as _m914_hashlib +import json as _m914_json +import math as _m914_math +import threading as _m914_threading +from decimal import Decimal as _m914_Decimal, ROUND_HALF_UP as _m914_ROUND_HALF_UP + +METROHM914_TYPE = "instrument.metrohm_914" +METROHM914_CHANNELS = {"ph": (-13.0, 20.0, "1"), "conductance": (1e-7, 0.5, "S"), "do": (0.0, 0.05, "kg/m3")} + + +def _m914_number(value): + try: + return type(value) in (int, float) and _m914_math.isfinite(value) + except (TypeError, OverflowError): + return False + + +def _m914_num(unit, minimum=None, maximum=None, nullable=False): + schema = {"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 _m914_object(properties): + return {"type": "object", "properties": properties, "required": list(properties), "additionalProperties": False} + + +def export_metrohm914_contract_metadata(): + """Type metadata only: never contains an instance's host-supplied truth.""" + boolean = {"type": "boolean"} + nullable_string = {"anyOf": [{"type": "string"}, {"type": "null"}]} + channel = {"type": "string", "enum": list(METROHM914_CHANNELS)} + def route(cap, parameter, fixed=None): + return {"capability_id": cap, "parameter": parameter, "fixed_arguments": fixed or {}} + def slot(unit, origin, schema, visibility="agent", write=None): + return {"unit": unit, "origin": origin, "visibility": visibility, + "access": "read_write" if write else "read_only", "value_schema": schema, + "write_via": write, "read_binding": "Metrohm914Session.read(instance_id=..., state_ids=[state_id])", + "sampling": {"mode": "instant", "time_domain": "simulation", "window": None}, "reference_conditions": None} + slots = { + "power.enabled": slot("1", "setpoint", boolean, write=route("power.set", "enabled")), + "probe.selected": slot("1", "setpoint", channel, write=route("electrochemistry.select_probe", "slot")), + "temperature.mode": slot("1", "setpoint", {"type": "string", "enum": ["automatic", "manual"]}), + "temperature.manual_k": slot("K", "setpoint", _m914_num("K", nullable=True)), + "temperature.compensation_k": slot("K", "derived", _m914_num("K", nullable=True)), + "endpoint.hold_s": slot("s", "setpoint", _m914_num("s", 0, 3600, nullable=True)), + "endpoint.tolerance_fraction": slot("1", "setpoint", _m914_num("1", 0, 1, nullable=True)), + "endpoint.stable": slot("1", "derived", boolean), + "endpoint.elapsed_s": slot("s", "derived", _m914_num("s", 0)), + "acquisition.interval_s": slot("s", "setpoint", _m914_num("s", 1, 86400), write=route("acquisition.set_interval", "interval_s")), + "acquisition.running": slot("1", "derived", boolean), + "acquisition.record_count": slot("1", "derived", {"type": "integer", "minimum": 0, "x-unit": "1"}), + "measurement.status": slot("1", "derived", {"type": "string", "enum": ["OFF", "PROBE_MISSING", "NO_SAMPLE", "MISSING_CONFIGURATION", "OUT_OF_RANGE", "UNSTABLE", "STABLE", "STALE"]}), + "measurement.ph": slot("1", "derived", _m914_num("1", -13, 20, nullable=True)), + "measurement.potential_v": slot("V", "derived", _m914_num("V", nullable=True)), + "measurement.conductance_s": slot("S", "derived", _m914_num("S", 1e-7, 0.5, nullable=True)), + "measurement.do_kg_m3": slot("kg/m3", "derived", _m914_num("kg/m3", 0, 0.05, nullable=True)), + "measurement.synthetic": slot("1", "derived", {"type": "boolean", "const": True}), + "measurement.sample_time_s": slot("s", "derived", _m914_num("s", 0, nullable=True)), + "display.text": slot("1", "derived", {"type": "string"}), + } + for name in METROHM914_CHANNELS: + slots[f"probe.{name}.installed"] = slot("1", "scene", boolean, write=route("probe.set_installed", "installed", {"slot": name})) + slots[f"probe.{name}.calibrated"] = slot("1", "derived", boolean) + slots[f"probe.{name}.calibration_time_s"] = slot("s", "derived", _m914_num("s", 0, nullable=True)) + slots[f"calibration.{name}.offset"] = slot(METROHM914_CHANNELS[name][2], "process_truth", _m914_num(METROHM914_CHANNELS[name][2], nullable=True), "debug") + for sid, unit in (("ph", "1"), ("conductance_s", "S"), ("do_kg_m3", "kg/m3"), ("temperature_k", "K"), ("reference_ph", "1"), ("reference_potential_v", "V"), ("conductance_temp_coefficient_k_inv", "1/K"), ("conductance_reference_temperature_k", "K"), ("standard_ph", "1"), ("standard_conductance_s", "S"), ("standard_do_kg_m3", "kg/m3")): + slots[f"truth.{sid}"] = slot(unit, "process_truth", _m914_num(unit, nullable=True), "debug") + slots["truth.standard_slot"] = slot("1", "process_truth", nullable_string, "debug") + reading_fields = {"slot": channel, "status": slots["measurement.status"]["value_schema"], "stable": boolean, + "ph": slots["measurement.ph"]["value_schema"], "potential_v": _m914_num("V", nullable=True), + "conductance_s": slots["measurement.conductance_s"]["value_schema"], + "do_kg_m3": slots["measurement.do_kg_m3"]["value_schema"], "calibrated": boolean, + "sample_time_s": _m914_num("s", 0, nullable=True), "synthetic": {"type": "boolean", "const": True}} + measurement_effects = [sid for sid in slots if sid.startswith(("measurement.", "endpoint.stable", "endpoint.elapsed", "temperature.compensation", "display."))] + calibration_effects = [sid for sid in slots if ".calibrat" in sid or sid.startswith("calibration.")] + def cap(inputs, outputs, example, description, effects, observes, preconditions="参数与声明范围匹配。", kind="device_command"): + return {"availability": "implemented", "visibility": "agent", "kind": kind, + "description_zh": description, "input_schema": _m914_object(inputs), "output_schema": _m914_object(outputs), + "example_arguments": [example], "state_effects": [{"state_id": sid, "timing": "immediate", "description_zh": description} for sid in dict.fromkeys(effects)], + "observes": observes, "scene_backend_required": False, "preconditions_zh": preconditions, + "completion_criterion_zh": "同步提交状态；测量与终点只在宿主提供新样本并推进共同时间后更新。"} + caps = { + "power.set": cap({"enabled": boolean}, {"enabled": boolean}, {"enabled": True}, "设置供电；断电停止记录并清除当前读数与终点历史。", ["power.enabled", "acquisition.running"] + measurement_effects, ["power.enabled"]), + "probe.set_installed": cap({"slot": channel, "installed": boolean}, {"slot": channel, "installed": boolean}, {"slot": "ph", "installed": True}, "断电时更换逻辑探头槽；pH与DO共用digital接口且互斥，电导使用独立接口；更换清除该槽校准。", [f"probe.{n}.installed" for n in METROHM914_CHANNELS] + calibration_effects + measurement_effects, [f"probe.{n}.installed" for n in METROHM914_CHANNELS], "供电关闭；安装pH或DO时另一共用digital槽未安装。", "configuration"), + "electrochemistry.select_probe": cap({"slot": channel}, {"slot": channel}, {"slot": "ph"}, "选择已安装的单通道读数配置，切换后重新采样与稳定。", ["probe.selected"] + measurement_effects, ["probe.selected"], "所选槽已安装；未在记录。"), + "electrochemistry.configure_temperature": cap({"mode": {"type": "string", "enum": ["automatic", "manual"]}, "manual_temperature_k": _m914_num("K", nullable=True)}, {"mode": {"type": "string"}, "manual_temperature_k": _m914_num("K", nullable=True)}, {"mode": "automatic", "manual_temperature_k": None}, "自动模式使用宿主样品温度；手动模式必须明确给定正开尔文温度；Nernst及可选电导线性温补均为工程假设。", ["temperature.mode", "temperature.manual_k"] + measurement_effects, ["temperature.mode", "temperature.manual_k"], "未在记录；manual需正有限温度，automatic需null。"), + "electrochemistry.configure_endpoint": cap({"hold_s": _m914_num("s", 0, 3600), "tolerance_fraction": _m914_num("1", 0, 1)}, {"hold_s": _m914_num("s"), "tolerance_fraction": _m914_num("1")}, {"hold_s": 2, "tolerance_fraction": 0.001}, "显式设定稳定窗口与全量程比例阈值；同窗口最大最小值差不超过阈值时为稳定；上限仅为运行层资源边界。", ["endpoint.hold_s", "endpoint.tolerance_fraction"] + measurement_effects, ["endpoint.hold_s", "endpoint.tolerance_fraction"], "未在记录；hold_s必须大于零。"), + "acquisition.set_interval": cap({"interval_s": _m914_num("s", 1, 86400)}, {"interval_s": _m914_num("s")}, {"interval_s": 1}, "记录间隔为1s的整数倍；上限86400s是运行层资源边界，非厂家规格。", ["acquisition.interval_s"], ["acquisition.interval_s"], "未在记录；间隔为整数秒。"), + "electrochemistry.calibrate": cap({"slot": channel, "standard_value": _m914_num("1", -13, 20)}, {"slot": channel, "calibrated": boolean, "synthetic": {"type": "boolean", "const": True}}, {"slot": "ph", "standard_value": 7}, "有界单点合成校准：标准值按slot单位解释（ph=1、conductance=S、do=kg/m3）；建立加性偏置修正，不声称厂家校准算法、精度或溯源。", calibration_effects + measurement_effects, [f"probe.{n}.calibrated" for n in METROHM914_CHANNELS], "供电、选中且安装槽、当前新鲜读数稳定、未记录；宿主明确标定匹配槽与已知标准值；标准值在该槽规格范围内。"), + "acquisition.start": cap({}, {"running": boolean}, {}, "开始记录后续实际宿主样本；不补造中间记录或推进时间。", ["acquisition.running"], ["acquisition.running"], "供电、已安装选中槽、已配置终点。"), + "acquisition.stop": cap({}, {"running": boolean}, {}, "停止后保留已记录数据。", ["acquisition.running"], ["acquisition.running"]), + "electrochemistry.reading": cap({}, reading_fields, {}, "返回所选配置的同版本合成读数；不暴露宿主真值，不推进时间。", [], [sid for sid in slots if sid.startswith("measurement.")] + ["endpoint.stable"], kind="query"), + "acquisition.records": cap({}, {"records": {"type": "array", "items": _m914_object(reading_fields)}, "synthetic": {"type": "boolean", "const": True}}, {}, "返回该实例已记录的可观察合成结果（最多1024条，满时停止），不含真值或宿主配置。", [], ["acquisition.record_count"], kind="query"), + } + # Disjoint schemas preserve each standard's SI unit, even though all are numeric. + caps["electrochemistry.calibrate"]["input_schema"] = _m914_object({"slot": channel, "standard_value": {"anyOf": [_m914_num(unit, lo, hi) for lo, hi, unit in METROHM914_CHANNELS.values()]}}) + caps["electrochemistry.calibrate"]["input_schema"]["allOf"] = [{"anyOf": [_m914_object({"slot": {"type": "string", "const": n}, "standard_value": _m914_num(unit, lo, hi)}) for n, (lo, hi, unit) in METROHM914_CHANNELS.items()]}] + caps["electrochemistry.configure_endpoint"]["input_schema"]["properties"]["hold_s"]["exclusiveMinimum"] = 0 + caps["acquisition.set_interval"]["input_schema"]["properties"]["interval_s"]["multipleOf"] = 1 + caps["electrochemistry.configure_temperature"]["input_schema"]["allOf"] = [{"anyOf": [ + _m914_object({"mode": {"type": "string", "const": "automatic"}, "manual_temperature_k": {"type": "null"}}), + _m914_object({"mode": {"type": "string", "const": "manual"}, "manual_temperature_k": {"type": "number", "exclusiveMinimum": 0, "x-unit": "K"}})]}] + for name, value in caps.items(): + value["binding"] = f"basic40_runtime_measure.Metrohm914Session.invoke(instance_id=..., capability_id='{name}', arguments=..., request_id=...)" + def parameter(value, unit, evidence, source): + return {"value": value, "unit": unit, "evidence": evidence, "source": source} + params = { + "ph_range": parameter([-13, 20], "1", "catalog", "CHEM-005 参数与来源 row10"), + "ph_resolution": parameter(0.001, "1", "catalog", "仅用于显示量化，不是噪声或准确度"), + "ph_instrument_accuracy": parameter(0.003, "1", "catalog", "仪表±0.003、不含探头误差；未用作仿真精度"), + "conductance_range": parameter([1e-7, 0.5], "S", "catalog", "0.1µS..500mS，是电导而非电导率"), + "do_range": parameter([0, 0.05], "kg/m3", "catalog", "0..50mg/L按SI换算"), + "record_base_interval_s": parameter(1, "s", "catalog", "CHEM-005 数据间隔1s"), + "nernst_model": parameter("E=E_ref-ln(10)*R*T/F*(pH-pH_ref); pH_display=pH_ref+(E_ref-E)/(ln(10)*R*T_comp/F)", "1", "engineering_assumption", "理想Nernst响应，R=8.31446261815324 J/(mol K)，F=96485.33212331001 C/mol；参考点和温度必须宿主显式提供"), + "endpoint_model": parameter("max(window)-min(window)<=tolerance_fraction*(channel_max-channel_min)", "1", "engineering_assumption", "窗口hold与容差初始null；以宿主给定样本零阶保持，每个实际样本才更新，不推断厂家终点算法"), + "calibration_model": parameter("corrected=raw+(standard-raw_at_calibration)", "1", "engineering_assumption", "单点合成偏置，仅当前安装探头；更换使校准失效"), + "conductance_temperature_model": parameter("G_ref=G/[1+alpha*(T_comp-T_ref)]", "1", "engineering_assumption", "仅当宿主明确给出alpha和T_ref才启用；否则报告原始电导且不声称完成电导温补"), + } + for n, unit in (("cell_constant_m_inv", "1/m"), ("contamination_coefficient", "1"), ("drift_rate", "1/s"), ("probe_mass_kg", "kg"), ("do_temperature_coefficient", "1/K"), ("reference_potential_v", "V"), ("reference_ph", "1"), ("endpoint_hold_s", "s"), ("endpoint_tolerance_fraction", "1"), ("conductance_temperature_coefficient", "1/K")): + params[n] = parameter(None, unit, "unknown", "表未给出；不默认生成数值或用整机参数代替") + return {"asset_types": {METROHM914_TYPE: {"catalog_id": "CHEM-005", "model": "Metrohm | 914 pH/DO/Conductometer", "asset_version": "1.0.0", "state_slots": slots, "capabilities": caps, "parameters": params}}, + "host_capabilities": {"sim.host_step": {"kind": "simulation", "visibility": "trusted_host_only", "binding": "Metrohm914Runtime.host_step(time_s, inputs={instance_id: sample})"}}, + "limitations": ["All measurement outputs are synthetic and estimated; accuracy ±0.003 is an instrument specification, not simulated accuracy.", "pH and DO share one digital interface and cannot both be installed; conductance is an independent analog interface. Runtime selects one channel at a time; parallel acquisition is not implemented.", "No default cell constant, contamination/drift/noise or probe mass is invented. Conductance is S, not S/m; DO is kg/m3.", "Nernst, optional linear conductance compensation, single-point calibration and stability rules are engineering_assumption; DO temperature/pressure/salinity compensation is absent.", "Readings need explicit host samples; automatic temperature needs explicit host temperature. Missing values stay null. No intermediate samples are fabricated.", "Scene adapter receives only display/power/probe installation state; no robot, contact solver or hardware driver. A failing callback may partly modify the scene but leaves a command's process candidate uncommitted.", "Host-supplied principals enforce API visibility only. Python/process/filesystem sandbox isolation is not implemented.", "Request deduplication is in-memory and does not survive restart."]} + + +class Metrohm914Runtime: + """Trusted host with absolute shared time; expose sessions, not this object.""" + def __init__(self, *, scene_adapter=None): + self.scene_adapter, self.time_s = scene_adapter, 0.0 + self._instances, self._principals, self._requests, self._logs = {}, {}, {}, {} + self._lock = _m914_threading.RLock() + self._metadata = export_metrohm914_contract_metadata() + self.register_principal("__public_agent__", visibility="agent") + self._agent = self.session("__public_agent__") + + def create_instance(self, instance_id, asset_type_id=METROHM914_TYPE): + with self._lock: + if not isinstance(instance_id, str) or not instance_id or instance_id in self._instances or asset_type_id != METROHM914_TYPE: + raise ValueError("Unique instance ID and declared type required") + inst = {"revision": 0, "power": False, "selected": "ph", "installed": {n: False for n in METROHM914_CHANNELS}, + "calibration": {n: {"calibrated": False, "time": None, "offset": None} for n in METROHM914_CHANNELS}, + "temperature_mode": "automatic", "manual_temperature": None, "compensation_temperature": None, + "hold": None, "tolerance": None, "stable": False, "elapsed": 0.0, "history": [], + "interval": 1.0, "running": False, "records": [], "next_record": None, + "truth": {"ph": None, "conductance_s": None, "do_kg_m3": None, "temperature_k": None, + "reference_ph": None, "reference_potential_v": None, "conductance_temp_coefficient_k_inv": None, + "conductance_reference_temperature_k": None, "standard_slot": None, "standard_value": None}, + "sample_time": None, "raw": None, "status": "OFF", "readings": {"ph": None, "potential_v": None, "conductance_s": None, "do_kg_m3": None}} + if self.scene_adapter: + self.scene_adapter(instance_id, self._scene(inst)) + self._instances[instance_id] = inst + + def register_principal(self, principal_id, *, visibility, instance_ids=None): + with self._lock: + if not isinstance(principal_id, str) or not principal_id or principal_id in self._principals or visibility not in ("agent", "debug", "evaluator"): + raise ValueError("Invalid or duplicate trusted identity") + if instance_ids is not None and (not isinstance(instance_ids, (list, tuple, set, frozenset)) or any(not isinstance(x, str) for x in instance_ids)): + raise ValueError("Instance scope must be a string collection") + scope = None if instance_ids is None else frozenset(instance_ids) + if scope is not None and not scope <= self._instances.keys(): + raise ValueError("Unknown instance scope") + self._principals[principal_id], self._logs[principal_id] = (visibility, scope), [] + + def session(self, principal_id): + if principal_id not in self._principals: + raise ValueError("Identity must be registered by trusted host") + return Metrohm914Session(self, principal_id) + + def describe(self, **kwargs): + return self._agent.describe(**kwargs) + + def read(self, **kwargs): + return self._agent.read(**kwargs) + + def invoke(self, **kwargs): + return self._agent.invoke(**kwargs) + + def write(self, **kwargs): + return self._agent.write(**kwargs) + + def describe_host(self): + return _m914_copy.deepcopy(self._metadata["host_capabilities"]) + + @staticmethod + def _reset(inst): + inst["stable"], inst["elapsed"], inst["history"], inst["sample_time"], inst["raw"] = False, 0.0, [], None, None + inst["readings"] = {"ph": None, "potential_v": None, "conductance_s": None, "do_kg_m3": None} + inst["compensation_temperature"] = None + inst["status"] = "OFF" if not inst["power"] else "PROBE_MISSING" if not inst["installed"][inst["selected"]] else "NO_SAMPLE" + + @staticmethod + def _reading(inst): + return {"slot": inst["selected"], "status": inst["status"], "stable": inst["stable"], **inst["readings"], + "calibrated": inst["calibration"][inst["selected"]]["calibrated"], "sample_time_s": inst["sample_time"], "synthetic": True} + + @staticmethod + def _display(inst): + r = Metrohm914Runtime._reading(inst) + key = {"ph": "ph", "conductance": "conductance_s", "do": "do_kg_m3"}[inst["selected"]] + value = r[key] + unit = METROHM914_CHANNELS[inst["selected"]][2] + return f"{inst['selected'].upper()} {'---' if value is None else format(value, '.6g')} {unit} | {inst['status']} | SYNTHETIC" + + @staticmethod + def _scene(inst): + return {"power.enabled": inst["power"], "probe.selected": inst["selected"], "display.text": Metrohm914Runtime._display(inst), + **{f"probe.{n}.installed": v for n, v in inst["installed"].items()}} + + @staticmethod + def _values(inst): + v = {"power.enabled": inst["power"], "probe.selected": inst["selected"], "temperature.mode": inst["temperature_mode"], + "temperature.manual_k": inst["manual_temperature"], "temperature.compensation_k": inst["compensation_temperature"], + "endpoint.hold_s": inst["hold"], "endpoint.tolerance_fraction": inst["tolerance"], "endpoint.stable": inst["stable"], + "endpoint.elapsed_s": inst["elapsed"], "acquisition.interval_s": inst["interval"], "acquisition.running": inst["running"], + "acquisition.record_count": len(inst["records"]), "measurement.status": inst["status"], "measurement.synthetic": True, + "measurement.sample_time_s": inst["sample_time"], "display.text": Metrohm914Runtime._display(inst)} + v.update({f"measurement.{k}": value for k, value in inst["readings"].items()}) + for n in METROHM914_CHANNELS: + v[f"probe.{n}.installed"], v[f"probe.{n}.calibrated"], v[f"probe.{n}.calibration_time_s"] = inst["installed"][n], inst["calibration"][n]["calibrated"], inst["calibration"][n]["time"] + v[f"calibration.{n}.offset"] = inst["calibration"][n]["offset"] + v.update({f"truth.{key}": value for key, value in inst["truth"].items() if key != "standard_value"}) + for name, suffix in (("ph", "ph"), ("conductance", "conductance_s"), ("do", "do_kg_m3")): + v[f"truth.standard_{suffix}"] = inst["truth"]["standard_value"] if inst["truth"]["standard_slot"] == name else None + return v + + def debug_snapshot(self): + with self._lock: + return {"time_s": self.time_s, "instances": {n: {"revision": i["revision"], "state": self._values(i), "internal": _m914_copy.deepcopy(i)} for n, i in self._instances.items()}} + + def _sample(self, inst, time_s, sample): + # Each mapping is a complete explicit sample. Omitted fields are unknown. + inst["truth"] = {k: sample.get(k) for k in inst["truth"]} + self._reset(inst) + if not inst["power"] or not inst["installed"][inst["selected"]]: + return + truth, name = inst["truth"], inst["selected"] + value = truth[{"ph": "ph", "conductance": "conductance_s", "do": "do_kg_m3"}[name]] + if value is None: + return + inst["sample_time"] = time_s + comp_t = truth["temperature_k"] if inst["temperature_mode"] == "automatic" else inst["manual_temperature"] + inst["compensation_temperature"] = comp_t + raw, potential = value, None + if name == "ph": + if any(v is None for v in (comp_t, truth["temperature_k"], truth["reference_ph"], truth["reference_potential_v"])): + inst["status"] = "MISSING_CONFIGURATION" + return + factor = _m914_math.log(10) * 8.31446261815324 / 96485.33212331001 + potential = truth["reference_potential_v"] - factor * truth["temperature_k"] * (value - truth["reference_ph"]) + raw = truth["reference_ph"] + (truth["temperature_k"] / comp_t) * (value - truth["reference_ph"]) + elif name == "conductance": + alpha, reference_t = truth["conductance_temp_coefficient_k_inv"], truth["conductance_reference_temperature_k"] + if alpha is not None or reference_t is not None: + if alpha is None or reference_t is None or comp_t is None: + inst["status"] = "MISSING_CONFIGURATION" + return + denominator = 1 + alpha * (comp_t - reference_t) + if not _m914_number(denominator) or denominator <= 0: + raise ValueError("Invalid explicit conductance compensation configuration") + raw = value / denominator + if not _m914_number(raw) or (potential is not None and not _m914_number(potential)): + raise ValueError("Nonfinite synthetic calculation") + inst["raw"] = raw + offset = inst["calibration"][name]["offset"] + measured = raw if offset is None else raw + offset + lo, hi, _ = METROHM914_CHANNELS[name] + if not _m914_number(measured) or not lo <= measured <= hi: + inst["status"] = "OUT_OF_RANGE" + return + if name == "ph": + measured = float(_m914_Decimal(str(measured)).quantize(_m914_Decimal("0.001"), rounding=_m914_ROUND_HALF_UP)) + inst["readings"][{"ph": "ph", "conductance": "conductance_s", "do": "do_kg_m3"}[name]] = measured + inst["readings"]["potential_v"] = potential + inst["status"] = "UNSTABLE" + + def host_step(self, time_s, *, inputs=None): + """One absolute external time, with no hidden integration or backfill. + + Each supplied sample replaces its full truth record; omitted fields become + null. Omitted instances keep last reading marked stale. Repeated time is a + pure no-op only with no inputs; new samples require strictly greater time. + All validation/calculation precedes process commit. Callback failures after + host commit cannot roll back the shared world's elapsed time. + """ + samples = {} if inputs is None else inputs + with self._lock: + if not _m914_number(time_s) or time_s < self.time_s or not isinstance(samples, dict) or any(not isinstance(n, str) or n not in self._instances or not isinstance(s, dict) for n, s in samples.items()): + raise ValueError("Finite monotonic common time and declared instance sample mapping required") + if time_s == self.time_s: + if samples: + raise ValueError("New samples require increasing common time") + return + allowed = set(next(iter(self._instances.values()))["truth"]) if self._instances else set() + for sample in samples.values(): + if set(sample) - allowed: + raise ValueError("Unknown host sample field") + for key, value in sample.items(): + if key == "standard_slot": + if value is not None and (not isinstance(value, str) or value not in METROHM914_CHANNELS): + raise ValueError("Unknown standard channel") + elif value is not None and not _m914_number(value): + raise ValueError("Host sample values must be finite numbers or null") + elif key.endswith("temperature_k") and value is not None and value <= 0: + raise ValueError("Temperature must be positive kelvin") + standard_slot, standard = sample.get("standard_slot"), sample.get("standard_value") + if (standard_slot is None) != (standard is None): + raise ValueError("Standard channel and explicit known value are a pair") + if standard_slot is not None and not METROHM914_CHANNELS[standard_slot][0] <= standard <= METROHM914_CHANNELS[standard_slot][1]: + raise ValueError("Synthetic standard is outside declared channel range") + candidates = _m914_copy.deepcopy(self._instances) + for n, inst in candidates.items(): + if n in samples: + old_history = inst["history"] + self._sample(inst, float(time_s), samples[n]) + if inst["status"] == "UNSTABLE" and inst["hold"] is not None: + value = inst["readings"][{"ph": "ph", "conductance": "conductance_s", "do": "do_kg_m3"}[inst["selected"]]] + history = old_history + [(float(time_s), value)] + cutoff = time_s - inst["hold"] + while len(history) > 1 and history[1][0] <= cutoff: + history.pop(0) + inst["history"] = history + span = METROHM914_CHANNELS[inst["selected"]][1] - METROHM914_CHANNELS[inst["selected"]][0] + inside = max(v for _, v in history) - min(v for _, v in history) <= inst["tolerance"] * span + inst["elapsed"] = min(inst["hold"], time_s - history[0][0]) if inside else 0.0 + inst["stable"] = bool(inside and time_s - history[0][0] >= inst["hold"]) + inst["status"] = "STABLE" if inst["stable"] else "UNSTABLE" + if inst["running"] and inst["status"] in ("UNSTABLE", "STABLE") and time_s >= inst["next_record"]: + inst["records"].append(self._reading(inst)) + inst["next_record"] = float(time_s) + inst["interval"] + if len(inst["records"]) >= 1024: + inst["running"] = False + elif inst["sample_time"] is not None: + inst["stable"], inst["elapsed"], inst["history"], inst["status"] = False, 0.0, [], "STALE" + inst["revision"] += 1 + self._instances, self.time_s = candidates, float(time_s) + if self.scene_adapter: + failed = False + for n, inst in candidates.items(): + try: + self.scene_adapter(n, self._scene(inst)) + except Exception: + failed = True + if failed: + raise RuntimeError("Host process/time committed; scene callback synchronization failed") from None + + +class Metrohm914Session: + """Filtered API boundary. Python object privacy is not a security sandbox.""" + def __init__(self, host, principal_id): + self.__host, self.__principal = host, principal_id + + def _visible(self, slot): + return slot["visibility"] == "agent" or self.__host._principals[self.__principal][0] in ("debug", "evaluator") + + def _instance(self, instance_id): + if not isinstance(instance_id, str): + return None + _, scope = self.__host._principals[self.__principal] + return self.__host._instances.get(instance_id) if scope is None or instance_id in scope else None + + def _envelope(self, instance_id, request_id=None, *, result=None, observations=None, status="succeeded", error=None): + inst = self._instance(instance_id) + return {"protocol_version": "1.0.0", "instance_id": instance_id if isinstance(instance_id, str) else None, + "request_id": request_id if isinstance(request_id, str) else None, "operation_id": None, "status": status, + "state_revision": inst["revision"] if inst else None, "clock": {"domain": "simulation", "time_s": self.__host.time_s}, + "result": _m914_copy.deepcopy(result or {}), "observations": _m914_copy.deepcopy(observations or {}), "error": error} + + def _error(self, instance_id, code, request_id=None, status="rejected"): + messages = {"UNKNOWN_INSTANCE": "Instance unavailable to this session.", "UNKNOWN_CAPABILITY": "Capability unavailable.", + "INVALID_ARGUMENT": "Arguments do not match schema or bounded configuration.", "ACCESS_DENIED": "Request is outside session access policy.", + "PRECONDITION_FAILED": "Required operating state, calibration fixture or configuration unavailable.", + "REQUEST_CONFLICT": "Request ID already belongs to different arguments.", "DEVICE_ERROR": "Scene synchronization did not complete."} + return self._envelope(instance_id, request_id, status=status, error={"code": code, "message": messages[code], "retryable": False, + "side_effects": "unknown" if code == "DEVICE_ERROR" else "none", "progress": None}) + + def describe(self, *, asset_type_id=None, instance_id=None): + with self.__host._lock: + if (asset_type_id is None) == (instance_id is None) or (asset_type_id is not None and asset_type_id != METROHM914_TYPE): + return self._error(None, "INVALID_ARGUMENT") + if instance_id is not None and self._instance(instance_id) is None: + return self._error(instance_id, "UNKNOWN_INSTANCE") + _, scope = self.__host._principals[self.__principal] + if scope is not None and not scope: + return self._error(instance_id, "ACCESS_DENIED") + spec = _m914_copy.deepcopy(self.__host._metadata["asset_types"][METROHM914_TYPE]) + spec["state_slots"] = {n: s for n, s in spec["state_slots"].items() if self._visible(s)} + for cap in spec["capabilities"].values(): + cap["state_effects"] = [e for e in cap["state_effects"] if e["state_id"] in spec["state_slots"]] + cap["observes"] = [n for n in cap["observes"] if n in spec["state_slots"]] + return {"protocol_version": "1.0.0", "asset_type_id": METROHM914_TYPE, "instance_id": instance_id, + "adapter": "basic40_runtime_measure.Metrohm914Session", **spec, "limitations": _m914_copy.deepcopy(self.__host._metadata["limitations"])} + + def read(self, *, instance_id, state_ids=None): + with self.__host._lock: + inst = self._instance(instance_id) + if inst is None: + return self._error(instance_id, "UNKNOWN_INSTANCE") + slots = self.__host._metadata["asset_types"][METROHM914_TYPE]["state_slots"] + if state_ids is None: + state_ids = [n for n, s in slots.items() if self._visible(s)] + if not isinstance(state_ids, list) or any(not isinstance(n, str) for n in state_ids) or len(state_ids) != len(set(state_ids)): + return self._error(instance_id, "INVALID_ARGUMENT") + if any(n not in slots or not self._visible(slots[n]) for n in state_ids): + return self._error(instance_id, "ACCESS_DENIED") + values = self.__host._values(inst) + observations = {} + for n in state_ids: + derived = slots[n]["origin"] == "derived" + stale = inst["status"] == "STALE" and n.startswith(("measurement.", "temperature.compensation")) and n not in ("measurement.status", "measurement.synthetic") + observations[n] = {"value": values[n], "unit": slots[n]["unit"], "quality": "unavailable" if values[n] is None else "stale" if stale else "estimated" if derived else "valid", + "sample_time_s": inst["sample_time"] if n.startswith(("measurement.", "truth.", "temperature.compensation")) else self.__host.time_s, + "sample_window_s": None, "reason": "No explicit sample/configuration or this output is not selected." if values[n] is None else "No new host sample at current time." if stale else None, + "synthetic": derived} + return self._envelope(instance_id, observations=observations) + + def invoke(self, *, instance_id, capability_id, arguments, request_id): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if inst is None: + return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) + if not isinstance(capability_id, str) or not isinstance(arguments, dict) or not isinstance(request_id, str) or not request_id or len(request_id) > 256: + return self._error(instance_id, "INVALID_ARGUMENT", request_id) + try: + digest = _m914_hashlib.sha256(_m914_json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False).encode()).hexdigest() + except (ValueError, TypeError, OverflowError): + return self._error(instance_id, "INVALID_ARGUMENT", request_id) + key = self.__principal, instance_id, request_id + if key in host._requests: + previous, response = host._requests[key] + return _m914_copy.deepcopy(response) if previous == digest else self._error(instance_id, "REQUEST_CONFLICT", request_id) + response = self._checked(instance_id, inst, capability_id, arguments, request_id) + host._requests[key] = digest, _m914_copy.deepcopy(response) + host._logs[self.__principal].append({"instance_id": instance_id, "capability_id": capability_id, "request_id": request_id, "response": _m914_copy.deepcopy(response)}) + return response + + def _checked(self, instance_id, inst, cap, args, request_id): + host = self.__host + fail = lambda code, status="rejected": self._error(instance_id, code, request_id, status) + definitions = host._metadata["asset_types"][METROHM914_TYPE]["capabilities"] + if cap not in definitions: + return fail("UNKNOWN_CAPABILITY") + expected = {"power.set": {"enabled"}, "probe.set_installed": {"slot", "installed"}, "electrochemistry.select_probe": {"slot"}, + "electrochemistry.configure_temperature": {"mode", "manual_temperature_k"}, "electrochemistry.configure_endpoint": {"hold_s", "tolerance_fraction"}, + "acquisition.set_interval": {"interval_s"}, "electrochemistry.calibrate": {"slot", "standard_value"}}.get(cap, set()) + if set(args) != expected: + return fail("INVALID_ARGUMENT") + if "slot" in args and (not isinstance(args["slot"], str) or args["slot"] not in METROHM914_CHANNELS): + return fail("INVALID_ARGUMENT") + if any(type(args[n]) is not bool for n in ("enabled", "installed") if n in args): + return fail("INVALID_ARGUMENT") + if cap == "electrochemistry.configure_temperature": + t = args["manual_temperature_k"] + if args["mode"] not in ("automatic", "manual") or (args["mode"] == "automatic" and t is not None) or (args["mode"] == "manual" and (not _m914_number(t) or t <= 0)): + return fail("INVALID_ARGUMENT") + if cap == "electrochemistry.configure_endpoint" and (not _m914_number(args["hold_s"]) or not 0 < args["hold_s"] <= 3600 or not _m914_number(args["tolerance_fraction"]) or not 0 <= args["tolerance_fraction"] <= 1): + return fail("INVALID_ARGUMENT") + if cap == "acquisition.set_interval" and (not _m914_number(args["interval_s"]) or not 1 <= args["interval_s"] <= 86400 or args["interval_s"] != int(args["interval_s"])): + return fail("INVALID_ARGUMENT") + if cap == "electrochemistry.calibrate": + lo, hi, _ = METROHM914_CHANNELS[args["slot"]] + if not _m914_number(args["standard_value"]) or not lo <= args["standard_value"] <= hi: + return fail("INVALID_ARGUMENT") + if cap == "probe.set_installed": + other = {"ph": "do", "do": "ph"}.get(args["slot"]) + if inst["power"] or (args["installed"] and other and inst["installed"][other]): + return fail("PRECONDITION_FAILED") + if cap == "electrochemistry.select_probe" and (not inst["installed"][args["slot"]] or inst["running"]): + return fail("PRECONDITION_FAILED") + if cap in ("electrochemistry.configure_temperature", "electrochemistry.configure_endpoint", "acquisition.set_interval") and inst["running"]: + return fail("PRECONDITION_FAILED") + if cap == "electrochemistry.calibrate" and (inst["running"] or not inst["power"] or not inst["stable"] or inst["sample_time"] != host.time_s or inst["selected"] != args["slot"] or not inst["installed"][args["slot"]] or inst["truth"]["standard_slot"] != args["slot"] or inst["truth"]["standard_value"] != args["standard_value"]): + return fail("PRECONDITION_FAILED") + if cap == "acquisition.start" and (not inst["power"] or not inst["installed"][inst["selected"]] or inst["hold"] is None or len(inst["records"]) >= 1024): + return fail("PRECONDITION_FAILED") + if cap == "electrochemistry.reading": + return self._envelope(instance_id, request_id, result=host._reading(inst)) + if cap == "acquisition.records": + return self._envelope(instance_id, request_id, result={"records": inst["records"], "synthetic": True}) + candidate = _m914_copy.deepcopy(inst) + if cap == "power.set": + if candidate["power"] != args["enabled"]: + candidate["power"] = args["enabled"] + if not args["enabled"]: + candidate["running"] = False + host._reset(candidate) + result = {"enabled": candidate["power"]} + elif cap == "probe.set_installed": + n = args["slot"] + if candidate["installed"][n] != args["installed"]: + candidate["installed"][n] = args["installed"] + candidate["calibration"][n] = {"calibrated": False, "time": None, "offset": None} + host._reset(candidate) + result = {"slot": n, "installed": args["installed"]} + elif cap == "electrochemistry.select_probe": + if candidate["selected"] != args["slot"]: + candidate["selected"] = args["slot"] + host._reset(candidate) + result = {"slot": args["slot"]} + elif cap == "electrochemistry.configure_temperature": + candidate["temperature_mode"], candidate["manual_temperature"] = args["mode"], args["manual_temperature_k"] + host._reset(candidate) + result = dict(args) + elif cap == "electrochemistry.configure_endpoint": + candidate["hold"], candidate["tolerance"] = float(args["hold_s"]), float(args["tolerance_fraction"]) + host._reset(candidate) + result = dict(args) + elif cap == "acquisition.set_interval": + candidate["interval"] = float(args["interval_s"]) + result = dict(args) + elif cap == "electrochemistry.calibrate": + candidate["calibration"][args["slot"]] = {"calibrated": True, "time": host.time_s, "offset": float(args["standard_value"]) - candidate["raw"]} + host._reset(candidate) + result = {"slot": args["slot"], "calibrated": True, "synthetic": True} + else: + candidate["running"] = cap == "acquisition.start" + if candidate["running"] and not inst["running"]: + candidate["next_record"] = host.time_s + candidate["interval"] + result = {"running": candidate["running"]} + if host.scene_adapter and host._scene(candidate) != host._scene(inst): + try: + host.scene_adapter(instance_id, host._scene(candidate)) + except Exception: + return fail("DEVICE_ERROR", "failed") + candidate["revision"] += 1 + host._instances[instance_id] = candidate + return self._envelope(instance_id, request_id, result=result) + + def write(self, *, instance_id, state_id, value, request_id): + with self.__host._lock: + if self._instance(instance_id) is None: + return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) + slots = self.__host._metadata["asset_types"][METROHM914_TYPE]["state_slots"] + if not isinstance(state_id, str) or state_id not in slots or not self._visible(slots[state_id]) or slots[state_id]["write_via"] is None: + return self._error(instance_id, "ACCESS_DENIED", request_id) + route = slots[state_id]["write_via"] + return self.invoke(instance_id=instance_id, capability_id=route["capability_id"], arguments={**route["fixed_arguments"], route["parameter"]: value}, request_id=request_id) + + def logs(self): + with self.__host._lock: + return _m914_copy.deepcopy(self.__host._logs[self.__principal]) + + +def write_metrohm914_runtime_reports(output_directory): + import datetime + import importlib.util + import io + import pathlib + import platform + import unittest + root = pathlib.Path(__file__).resolve().parents[1] + spec = importlib.util.spec_from_file_location("test_basic40_measure_metrohm914", root / "tests/test_basic40_measure.py") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + suite = unittest.defaultTestLoader.loadTestsFromTestCase(module.Metrohm914RuntimeTests) + stream = io.StringIO() + result = unittest.TextTestRunner(stream=stream, verbosity=2).run(suite) + metadata = export_metrohm914_contract_metadata() + report = {"catalog_id": "CHEM-005", "recorded_at": datetime.datetime.now(datetime.timezone.utc).isoformat(), + "environment": {"python": platform.python_version(), "platform": platform.platform()}, + "method": "unittest explicit synthetic host samples; all capability outputs/state effects; common external timestamp; three slot calibration; Nernst and SI boundaries; rejection atomicity; identities, deduplication and scene callback failure", + "tests_run": result.testsRun, "failures": len(result.failures), "errors": len(result.errors), "result": "passed" if result.wasSuccessful() else "failed", + "capabilities_verified": sorted(metadata["asset_types"][METROHM914_TYPE]["capabilities"]) if result.wasSuccessful() else [], + "output": stream.getvalue(), "not_run": ["real_hardware", "robot_execution", "contact_solver", "process_filesystem_security_isolation", "parallel_channel_acquisition", "manufacturer_calibration_accuracy", "do_temperature_pressure_salinity_compensation"], + "scene_scope": "Only a recording/failing callback is tested here; evaluated Blender geometry requires the separate scene verification record.", + "synthetic": True} + directory = pathlib.Path(output_directory) + directory.mkdir(parents=True, exist_ok=True) + for name, value in (("runtime_validation.json", report), ("runtime_metadata.json", metadata)): + (directory / name).write_text(_m914_json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report +# END CHEM-005 METROHM 914 APPEND-ONLY RUNTIME + +# BEGIN CHEM-102 METROHM 899 APPEND-ONLY RUNTIME +# All _kf899 names and classes in this block are independent of earlier assets. +import copy as _kf899_copy +import json as _kf899_json +import math as _kf899_math +import threading as _kf899_threading + +METROHM899_TYPE = "instrument.metrohm_899" +KF899_FARADAY_C_MOL = 96485.33212331001 +KF899_WATER_MOLAR_MASS_KG_MOL = 0.01801528 +KF899_KG_PER_COULOMB = KF899_WATER_MOLAR_MASS_KG_MOL / (2 * KF899_FARADAY_C_MOL) +KF899_START_DRIFT_MIN_KG_S = 1e-9 / 60 +KF899_START_DRIFT_MAX_KG_S = 999e-9 / 60 + + +def _kf899_number(value): + try: + return type(value) in (float, int) and _kf899_math.isfinite(value) + except (ValueError, TypeError, OverflowError): + return False + + +def _kf899_num(unit, lo=None, hi=None, nullable=False): + result = {"type": "number", "x-unit": unit} + if lo is not None: + result["minimum"] = lo + if hi is not None: + result["maximum"] = hi + return {"anyOf": [result, {"type": "null"}]} if nullable else result + + +def _kf899_object(properties, required=None): + return {"type": "object", "properties": properties, + "required": list(properties) if required is None else required, "additionalProperties": False} + + +def export_metrohm899_contract_metadata(): + """Type-only authoring metadata. Contains no live instance/sample truth. + + This is a synthetic SI model, not Metrohm firmware. F and molecular mass + support an ideal two-electron/water stoichiometric engineering assumption; + precision, noise, current efficiency and electrode transfer functions are + unknown. Host identities and truth are protected at API boundaries only, + not from Python introspection or shared filesystem access. + """ + boolean = {"type": "boolean"} + enum_slot = {"type": "string", "enum": ["cell", "generator", "indicator"]} + current = {"type": "number", "enum": [0.1, 0.2, 0.4], "x-unit": "A"} + config = { + "current_a": current, + "drift_compensation_kg_s": _kf899_num("kg/s", 0, nullable=True), + "start_drift_threshold_kg_s": _kf899_num("kg/s", KF899_START_DRIFT_MIN_KG_S, KF899_START_DRIFT_MAX_KG_S), + "extraction_time_s": _kf899_num("s", 0, 999999), + "stirring_level": {"type": "integer", "minimum": -15, "maximum": 15, "x-unit": "1"}, + "sample_mass_kg": _kf899_num("kg", 0, nullable=True), + "endpoint_hold_s": _kf899_num("s", 0, nullable=True), + } + routes = {name: {"capability_id": "coulometry.configure", "parameter": name, "fixed_arguments": {}} for name in config} + def slot(unit, origin, value_schema, visibility="agent", route=None, integral=False): + return {"unit": unit, "origin": origin, "value_schema": value_schema, "visibility": visibility, + "access": "read_write" if route else "read_only", "write_via": route, + "read_binding": "Metrohm899Session.read(instance_id=..., state_ids=[state_id])", + "reference_conditions": None, + "sampling": {"mode": "integral" if integral else "instant", "time_domain": "simulation", + "window": "自本次 coulometry.start 至当前或停止时刻" if integral else None}} + state = { + "power.enabled": slot("1", "setpoint", boolean, route={"capability_id": "power.set", "parameter": "enabled", "fixed_arguments": {}}), + "coulometry.running": slot("1", "derived", boolean), + "coulometry.status": slot("1", "derived", {"type": "string", "enum": ["OFF", "IDLE", "READY", "EXTRACTING", "TITRATING", "HOLDING", "COMPLETED", "STOPPED"]}), + "sample.present": slot("1", "scene", boolean), + "reagent.ready": slot("1", "scene", boolean), + "measurement.elapsed_s": slot("s", "derived", _kf899_num("s", 0)), + "measurement.charge_c": slot("C", "derived", _kf899_num("C", 0), integral=True), + "measurement.water_mass_kg": slot("kg", "derived", _kf899_num("kg", 0, nullable=True), integral=True), + "measurement.water_fraction": slot("1", "derived", _kf899_num("1", 0, nullable=True)), + "measurement.drift_kg_s": slot("kg/s", "derived", _kf899_num("kg/s", 0, nullable=True)), + "measurement.synthetic": slot("1", "derived", {"type": "boolean", "const": True}), + "measurement.sample_time_s": slot("s", "derived", _kf899_num("s", 0, nullable=True)), + "endpoint.hold_elapsed_s": slot("s", "derived", _kf899_num("s", 0)), + "truth.water_remaining_kg": slot("kg", "process_truth", _kf899_num("kg", 0, nullable=True), "debug"), + "truth.sample_water_kg": slot("kg", "process_truth", _kf899_num("kg", 0, nullable=True), "debug"), + "truth.background_drift_kg_s": slot("kg/s", "process_truth", _kf899_num("kg/s", 0, nullable=True), "debug"), + } + for name, spec in config.items(): + state["settings." + name] = slot({"current_a": "A", "drift_compensation_kg_s": "kg/s", "start_drift_threshold_kg_s": "kg/s", "extraction_time_s": "s", "stirring_level": "1", "sample_mass_kg": "kg", "endpoint_hold_s": "s"}[name], "setpoint", spec, route=routes[name]) + for name in ("cell", "generator", "indicator"): + state[f"slot.{name}.installed"] = slot("1", "scene", boolean, route={"capability_id": "slot.set_installed", "parameter": "installed", "fixed_arguments": {"slot": name}}) + reading = {"status": state["coulometry.status"]["value_schema"], "running": boolean, + "elapsed_s": _kf899_num("s", 0), "charge_c": _kf899_num("C", 0), + "water_mass_kg": _kf899_num("kg", 0, nullable=True), "water_fraction": _kf899_num("1", 0, nullable=True), + "drift_kg_s": _kf899_num("kg/s", 0, nullable=True), "synthetic": {"type": "boolean", "const": True}} + result_states = ["coulometry.running", "coulometry.status", "measurement.elapsed_s", "measurement.charge_c", + "measurement.water_mass_kg", "measurement.water_fraction", "measurement.sample_time_s", "endpoint.hold_elapsed_s"] + defs = { + "power.set": ({"enabled": boolean}, {"enabled": boolean}, {"enabled": True}, ["power.enabled", "coulometry.running", "coulometry.status"], ["power.enabled"], "设置供电；断电停止运行并保留已发生的积分结果。", "device_command"), + "slot.set_installed": ({"slot": enum_slot, "installed": boolean}, {"slot": enum_slot, "installed": boolean}, {"slot": "cell", "installed": True}, [f"slot.{x}.installed" for x in ("cell", "generator", "indicator")], [f"slot.{x}.installed" for x in ("cell", "generator", "indicator")], "在关机闲置时声明滴定池或电极的场景装配槽位；不是机器人装卸。", "configuration"), + "coulometry.configure": (config, config, {"current_a": 0.2, "drift_compensation_kg_s": 0, "endpoint_hold_s": 1}, ["settings." + x for x in config], ["settings." + x for x in config], "配置手动发生电��、漂移补偿、启动漂移、萃取时间、搅拌档位、样品质量及假设终点保持时间；至少一个字段。", "configuration"), + "coulometry.start": ({}, reading, {}, result_states + ["truth.water_remaining_kg"], list(s for s in state if s.startswith("measurement.") or s.startswith("coulometry.")), "由已装配、具备试剂且漂移满足阈值的状态启动合成库仑过程；重置当前测量积分。", "device_command"), + "coulometry.stop": ({}, reading, {}, ["coulometry.running", "coulometry.status"], list(s for s in state if s.startswith("measurement.") or s.startswith("coulometry.")), "停止并保留部分电荷、漂移补偿结果与曲线。", "device_command"), + "coulometry.reading": ({}, reading, {}, [], list(s for s in state if s.startswith("measurement.") or s.startswith("coulometry.")), "返回合成可观测结果；不推进宿主时间。", "query"), + "coulometry.curve": ({}, {"records": {"type": "array", "items": _kf899_object({**reading, "sample_time_s": _kf899_num("s", 0)})}, "synthetic": {"type": "boolean", "const": True}}, {}, [], list(s for s in state if s.startswith("measurement.") or s.startswith("coulometry.")), "返回实际宿主步进时刻采样的合成滴定曲线，不插值补造采样。", "query"), + } + capabilities = {} + for name, (args, result, example, effects, observes, meaning, kind) in defs.items(): + capabilities[name] = {"input_schema": _kf899_object(args, [] if name == "coulometry.configure" else None), + "output_schema": _kf899_object(result), "example_arguments": [example], "meaning_zh": meaning, + "kind": kind, "visibility": "agent", "availability": "implemented", + "state_effects": [{"state_id": sid, "meaning_zh": "由此调用更新；停止保留既有累计量。", "timing": "immediate"} for sid in effects], + "observes": observes, + "binding": {"backend": "python", "artifact_id": "runtime", "invocation": f"Metrohm899Session.invoke(instance_id=..., capability_id='{name}', arguments=..., request_id=...)"}} + return {"asset_type_id": METROHM899_TYPE, "catalog_id": "CHEM-102", "asset_version": "1.0.0", "state_slots": state, + "capabilities": capabilities, "scene_callback_keys": ["power.enabled", "coulometry.running", "display.text"] + [f"slot.{x}.installed" for x in ("cell", "generator", "indicator")], + "host_capabilities": { + "sim.load_sample": {"invocation": "Metrohm899Host.load_sample(instance_id=..., water_mass_kg=..., background_drift_kg_s=..., reagent_ready=True, request_id=...)", "visibility": "trusted_host_only", "meaning_zh": "初始化合成样品场景；不是物质转移或真实仪器进样。"}, + "sim.step": {"invocation": "Metrohm899Host.step(dt_s)", "visibility": "trusted_host_only", "meaning_zh": "校验全部实例后，以公共世界时钟计算电荷、耗水、漂移和理想终点。"}}, + "parameters": { + "current_choices_a": {"value": [0.1, 0.2, 0.4], "unit": "A", "evidence": "public_document", "source": "CHEM-102 参数与来源第107行；自动电流策略未实现"}, + "initial_current_a": {"value": 0.1, "unit": "A", "evidence": "engineering_assumption", "source": "合成初始设定，不宣称厂家默认"}, + "initial_extraction_time_s": {"value": 0.0, "unit": "s", "evidence": "engineering_assumption", "source": "合成初始设定；合法范围 0–999999 s"}, + "start_drift_default_kg_s": {"value": 20e-9 / 60, "unit": "kg/s", "evidence": "public_document", "source": "CHEM-102 参数与来源第107行；20 µg/min"}, + "faraday_c_mol": {"value": KF899_FARADAY_C_MOL, "unit": "C/mol", "evidence": "engineering_assumption", "source": "理想两电子库仑换算参数；不是厂家整机或部件测量"}, + "water_molar_mass_kg_mol": {"value": KF899_WATER_MOLAR_MASS_KG_MOL, "unit": "kg/mol", "evidence": "engineering_assumption", "source": "约定水摩尔质量用于合成化学计量"}, + "electrode_response_s": {"value": None, "unit": "s", "evidence": "unknown", "source": "缺实测响应"}, + "current_efficiency": {"value": None, "unit": "1", "evidence": "unknown", "source": "未知真实电流效率；模型明确使用理想100%假设"}, + "endpoint_hold_s": {"value": None, "unit": "s", "evidence": "unknown", "source": "由仿真任务显式配置，不套用厂家终点默认"}, + "cell_capacity_m3": {"value": None, "unit": "m3", "evidence": "unknown", "source": "不得从照片推断容量"}}, + "equations": ["Q = integral(I_effective dt)", "m_generated = Q*M_H2O/(2*F)", "m_indicated=max(0,m_generated-drift_compensation_kg_s*elapsed_s)", "water_fraction=m_indicated/sample_mass_kg (null when sample_mass_kg unknown)"], + "boundaries": ["All results synthetic; ideal stoichiometry, 100% modeled current efficiency and ideal depletion endpoint are engineering_assumption.", "Manual 100/200/400 mA only; automatic current firmware, reagent chemistry, electrode potential endpoint, noise, accuracy, hardware and robots not implemented.", "Stirring level is a setting only; no hydrodynamics or invented speed map. Cell capacity and component parameters stay null.", "API truth filtering is not a Python/filesystem sandbox. Keep trusted host and sample fixtures in a separate process for untrusted agents.", "Optional scene callback must be synchronous and atomic; callback tests do not prove evaluated Blender pose or contact physics."]} + + +class Metrohm899Host: + """Trusted synthetic world. Only this object supplies truth or advances time.""" + def __init__(self, scene_adapter=None): + self.scene_adapter = scene_adapter + self.time_s = 0.0 + self._kf899_instances = {} + self._kf899_principals = {} + self._kf899_requests = {} + self._kf899_host_requests = {} + self._kf899_logs = [] + self._kf899_lock = _kf899_threading.RLock() + + def create_instance(self, instance_id): + with self._kf899_lock: + if not isinstance(instance_id, str) or not instance_id or instance_id in self._kf899_instances: + raise ValueError("A unique nonempty instance_id is required") + state = {"power.enabled": False, "coulometry.running": False, "coulometry.status": "OFF", + "sample.present": False, "reagent.ready": False, "measurement.elapsed_s": 0.0, + "measurement.charge_c": 0.0, "measurement.water_mass_kg": None, "measurement.water_fraction": None, + "measurement.drift_kg_s": None, "measurement.synthetic": True, "measurement.sample_time_s": None, + "endpoint.hold_elapsed_s": 0.0, "truth.water_remaining_kg": None, "truth.sample_water_kg": None, + "truth.background_drift_kg_s": None, "settings.current_a": 0.1, + "settings.drift_compensation_kg_s": None, "settings.start_drift_threshold_kg_s": 20e-9 / 60, + "settings.extraction_time_s": 0.0, "settings.stirring_level": 8, "settings.sample_mass_kg": None, + "settings.endpoint_hold_s": None, + **{f"slot.{x}.installed": False for x in ("cell", "generator", "indicator")}} + self._kf899_instances[instance_id] = {"state": state, "revision": 0, "curve": []} + return instance_id + + def register_principal(self, principal_id, *, visibility="agent", instance_ids=None): + with self._kf899_lock: + if not isinstance(principal_id, str) or not principal_id or principal_id in self._kf899_principals or visibility not in ("agent", "debug", "evaluator"): + raise ValueError("Unique principal and host-assigned visibility required") + ids = set(self._kf899_instances if instance_ids is None else instance_ids) + if not ids <= set(self._kf899_instances): + raise ValueError("Unknown instance in policy") + self._kf899_principals[principal_id] = {"visibility": visibility, "instances": ids} + + def session(self, principal_id): + if principal_id not in self._kf899_principals: + raise ValueError("Unregistered principal") + return Metrohm899Session(self, principal_id) + + def debug_snapshot(self): + with self._kf899_lock: + return _kf899_copy.deepcopy({"time_s": self.time_s, "instances": self._kf899_instances}) + + def _kf899_sync(self, instance_id, state): + if self.scene_adapter is not None: + updates = {"power.enabled": state["power.enabled"], "coulometry.running": state["coulometry.running"], + "display.text": state["coulometry.status"], **{f"slot.{x}.installed": state[f"slot.{x}.installed"] for x in ("cell", "generator", "indicator")}} + self.scene_adapter(instance_id, _kf899_copy.deepcopy(updates)) + + def load_sample(self, *, instance_id, water_mass_kg, background_drift_kg_s, reagent_ready, request_id): + """Host-only fixture initialization, never a robot or physical transfer. + + A loaded sample may be started once. Loading another explicit fixture is + needed after any run, so restart cannot regenerate consumed water. + """ + with self._kf899_lock: + if not isinstance(instance_id, str) or instance_id not in self._kf899_instances: + raise ValueError("Unknown instance") + if not isinstance(request_id, str) or not request_id or not _kf899_number(water_mass_kg) or water_mass_kg < 0 or not _kf899_number(background_drift_kg_s) or background_drift_kg_s < 0 or type(reagent_ready) is not bool: + raise ValueError("Finite nonnegative SI truth, boolean reagent state and request_id required") + key = (instance_id, request_id) + fingerprint = (water_mass_kg, background_drift_kg_s, reagent_ready) + if key in self._kf899_host_requests: + if self._kf899_host_requests[key] != fingerprint: + raise ValueError("REQUEST_CONFLICT") + return {"status": "succeeded", "loaded": True, "synthetic": True} + instance = self._kf899_instances[instance_id] + if instance["state"]["coulometry.running"]: + raise ValueError("Cannot replace a running sample") + candidate = _kf899_copy.deepcopy(instance) + s = candidate["state"] + s.update({"sample.present": True, "reagent.ready": reagent_ready, + "truth.sample_water_kg": float(water_mass_kg), "truth.water_remaining_kg": float(water_mass_kg), + "truth.background_drift_kg_s": float(background_drift_kg_s), "measurement.drift_kg_s": float(background_drift_kg_s), + "measurement.water_mass_kg": None, "measurement.water_fraction": None, + "measurement.charge_c": 0.0, "measurement.elapsed_s": 0.0, "measurement.sample_time_s": None, + "endpoint.hold_elapsed_s": 0.0, "coulometry.status": "READY" if s["power.enabled"] else "OFF"}) + candidate["curve"] = [] + candidate["revision"] += 1 + self._kf899_sync(instance_id, s) + self._kf899_instances[instance_id] = candidate + self._kf899_host_requests[key] = fingerprint + return {"status": "succeeded", "loaded": True, "synthetic": True} + + def step(self, dt_s): + """Integrate all devices against one clock; reads never call this method. + + Exhaustion and endpoint hold are split analytically inside each step. + After water exhaustion, an ideal duty cycle supplies the drift current. + No electrode kinetics or manufacturer endpoint algorithm is asserted. + Failed callback leaves process/time unchanged; external scene side effects + remain unknown unless the callback actually satisfies its atomic contract. + """ + with self._kf899_lock: + if not _kf899_number(dt_s) or dt_s < 0 or not _kf899_number(self.time_s + dt_s): + raise ValueError("Finite nonnegative time increment required") + if dt_s == 0: + return {"time_s": self.time_s, "synthetic": True} + candidate = _kf899_copy.deepcopy(self._kf899_instances) + for iid, instance in candidate.items(): + s = instance["state"] + if not s["coulometry.running"]: + continue + remaining_dt = float(dt_s) + advanced = 0.0 + drift = s["truth.background_drift_kg_s"] + rate = s["settings.current_a"] * KF899_KG_PER_COULOMB + extract_remaining = max(0.0, s["settings.extraction_time_s"] - s["measurement.elapsed_s"]) + extract = min(remaining_dt, extract_remaining) + s["truth.water_remaining_kg"] += drift * extract + remaining_dt -= extract + advanced += extract + s["coulometry.status"] = "EXTRACTING" if remaining_dt == 0 and extract_remaining > extract else "TITRATING" + if remaining_dt > 0: + water = s["truth.water_remaining_kg"] + net_rate = rate - drift + depletion_time = water / net_rate if net_rate > 0 else float("inf") + drive = min(remaining_dt, depletion_time) + s["measurement.charge_c"] += s["settings.current_a"] * drive + s["truth.water_remaining_kg"] = max(0.0, water - net_rate * drive) + remaining_dt -= drive + advanced += drive + if depletion_time <= drive: + s["truth.water_remaining_kg"] = 0.0 + s["coulometry.status"] = "HOLDING" + hold_remaining = max(0.0, s["settings.endpoint_hold_s"] - s["endpoint.hold_elapsed_s"]) + hold = min(remaining_dt, hold_remaining) + s["measurement.charge_c"] += drift * hold / KF899_KG_PER_COULOMB + s["endpoint.hold_elapsed_s"] += hold + advanced += hold + if s["endpoint.hold_elapsed_s"] >= s["settings.endpoint_hold_s"]: + s["coulometry.running"] = False + s["coulometry.status"] = "COMPLETED" + s["measurement.elapsed_s"] += advanced + generated = s["measurement.charge_c"] * KF899_KG_PER_COULOMB + compensation = s["settings.drift_compensation_kg_s"] * s["measurement.elapsed_s"] + s["measurement.water_mass_kg"] = max(0.0, generated - compensation) + mass = s["settings.sample_mass_kg"] + s["measurement.water_fraction"] = None if mass is None else s["measurement.water_mass_kg"] / mass + s["measurement.sample_time_s"] = self.time_s + advanced + if any(type(value) in (int, float) and not _kf899_number(value) for value in s.values()): + raise ValueError("Integration would exceed finite numerical range") + instance["revision"] += 1 + record = _kf899_reading(s) + record["sample_time_s"] = s["measurement.sample_time_s"] + instance["curve"].append(record) + for iid, instance in candidate.items(): + if instance != self._kf899_instances[iid]: + self._kf899_sync(iid, instance["state"]) + self._kf899_instances = candidate + self.time_s += float(dt_s) + return {"time_s": self.time_s, "synthetic": True} + + +def _kf899_reading(state): + return {"status": state["coulometry.status"], "running": state["coulometry.running"], + "elapsed_s": state["measurement.elapsed_s"], "charge_c": state["measurement.charge_c"], + "water_mass_kg": state["measurement.water_mass_kg"], "water_fraction": state["measurement.water_fraction"], + "drift_kg_s": state["measurement.drift_kg_s"], "synthetic": True} + + +class Metrohm899Session: + """API observation boundary for a host-registered principal; no hardware.""" + def __init__(self, host, principal_id): + if principal_id not in host._kf899_principals: + raise ValueError("Host-assigned principal required") + self._kf899_host = host + self._kf899_principal = principal_id + + def _kf899_allowed(self, instance_id): + return isinstance(instance_id, str) and instance_id in self._kf899_host._kf899_principals[self._kf899_principal]["instances"] + + def _kf899_visible(self, state_id): + return not state_id.startswith("truth.") or self._kf899_host._kf899_principals[self._kf899_principal]["visibility"] != "agent" + + def _kf899_response(self, instance_id, request_id=None, status="succeeded", result=None, observations=None, code=None, side_effects="none"): + host = self._kf899_host + instance = host._kf899_instances.get(instance_id) if isinstance(instance_id, str) and self._kf899_allowed(instance_id) else None + return {"protocol_version": "1.0.0", "instance_id": instance_id if isinstance(instance_id, str) else None, + "request_id": request_id if isinstance(request_id, str) else None, "operation_id": None, + "status": status, "state_revision": instance["revision"] if instance else None, + "clock": {"domain": "simulation", "time_s": host.time_s}, "result": result or {}, + "observations": observations or {}, "error": None if code is None else {"code": code, + "message": {"UNKNOWN_INSTANCE": "Instance unavailable to this session", "UNKNOWN_CAPABILITY": "Unknown capability", "INVALID_ARGUMENT": "Arguments do not satisfy capability requirements", "PRECONDITION_FAILED": "Required powered, idle, assembled, reagent and method conditions are not met", "ACCESS_DENIED": "Access denied", "BUSY": "Measurement is already running", "REQUEST_CONFLICT": "Request identifier was already used with other arguments", "UNSUPPORTED": "No hardware or automatic-current adapter is implemented", "DEVICE_ERROR": "Scene callback failed; external scene effects are unknown"}.get(code, code), + "retryable": False, "side_effects": side_effects}} + + def describe(self, *, asset_type_id=None, instance_id=None): + with self._kf899_host._kf899_lock: + if (asset_type_id is None) == (instance_id is None): + return self._kf899_response(instance_id, status="rejected", code="INVALID_ARGUMENT") + if instance_id is not None and not self._kf899_allowed(instance_id): + return self._kf899_response(instance_id, status="rejected", code="UNKNOWN_INSTANCE") + if asset_type_id is not None and asset_type_id != METROHM899_TYPE: + return self._kf899_response(instance_id, status="rejected", code="UNKNOWN_INSTANCE") + meta = export_metrohm899_contract_metadata() + meta["state_slots"] = {k: v for k, v in meta["state_slots"].items() if self._kf899_visible(k)} + for cap in meta["capabilities"].values(): + cap["state_effects"] = [e for e in cap["state_effects"] if self._kf899_visible(e["state_id"])] + meta.pop("host_capabilities") + meta["instance_id"] = instance_id + return meta + + def read(self, *, instance_id, state_ids=None): + with self._kf899_host._kf899_lock: + if not self._kf899_allowed(instance_id): + return self._kf899_response(instance_id, status="rejected", code="UNKNOWN_INSTANCE") + instance = self._kf899_host._kf899_instances[instance_id] + if state_ids is None: + state_ids = [sid for sid in instance["state"] if self._kf899_visible(sid)] + if not isinstance(state_ids, list) or not all(isinstance(x, str) and x in instance["state"] for x in state_ids): + return self._kf899_response(instance_id, status="rejected", code="INVALID_ARGUMENT") + if any(not self._kf899_visible(sid) for sid in state_ids): + return self._kf899_response(instance_id, status="rejected", code="ACCESS_DENIED") + meta = export_metrohm899_contract_metadata()["state_slots"] + obs = {} + s = instance["state"] + for sid in state_ids: + value = _kf899_copy.deepcopy(s[sid]) + measurement = sid.startswith("measurement.") and sid not in ("measurement.synthetic", "measurement.drift_kg_s") + sampled_at = s["measurement.sample_time_s"] if measurement else self._kf899_host.time_s + obs[sid] = {"value": value, "unit": meta[sid]["unit"], "quality": "unavailable" if value is None else "estimated" if meta[sid]["origin"] == "derived" else "valid", + "sample_time_s": sampled_at, "sample_window_s": [sampled_at - s["measurement.elapsed_s"], sampled_at] if measurement and sampled_at is not None and meta[sid]["sampling"]["mode"] == "integral" else None} + if value is None: + obs[sid]["reason"] = "No configured or acquired synthetic value" + return self._kf899_response(instance_id, observations=obs) + + def invoke(self, *, instance_id, capability_id, arguments, request_id): + host = self._kf899_host + with host._kf899_lock: + if not self._kf899_allowed(instance_id): + return self._kf899_response(instance_id, request_id, "rejected", code="UNKNOWN_INSTANCE") + if not isinstance(request_id, str) or not request_id or not isinstance(capability_id, str) or not isinstance(arguments, dict): + return self._kf899_response(instance_id, request_id, "rejected", code="INVALID_ARGUMENT") + try: + fingerprint = _kf899_json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False) + except (ValueError, TypeError, OverflowError): + return self._kf899_response(instance_id, request_id, "rejected", code="INVALID_ARGUMENT") + key = (self._kf899_principal, instance_id, request_id) + if key in host._kf899_requests: + previous = host._kf899_requests[key] + if previous[0] != fingerprint: + return self._kf899_response(instance_id, request_id, "rejected", code="REQUEST_CONFLICT") + return _kf899_copy.deepcopy(previous[1]) + meta = export_metrohm899_contract_metadata() + definition = meta["capabilities"].get(capability_id) + if definition is None: + code = "UNSUPPORTED" if capability_id.startswith("hardware.") or capability_id == "coulometry.auto_current" else "ACCESS_DENIED" if capability_id.startswith("sim.") else "UNKNOWN_CAPABILITY" + return self._kf899_response(instance_id, request_id, "unsupported" if code == "UNSUPPORTED" else "rejected", code=code) + def reject(code): + response = self._kf899_response(instance_id, request_id, "rejected", code=code) + host._kf899_requests[key] = (fingerprint, _kf899_copy.deepcopy(response)) + return response + if not _kf899_arguments_valid(capability_id, arguments): + return reject("INVALID_ARGUMENT") + instance = host._kf899_instances[instance_id] + candidate = _kf899_copy.deepcopy(instance) + s = candidate["state"] + result = None + if capability_id == "power.set": + s["power.enabled"] = arguments["enabled"] + if not arguments["enabled"]: + s["coulometry.running"] = False + s["coulometry.status"] = "OFF" + elif s["coulometry.status"] == "OFF": + s["coulometry.status"] = "READY" if s["sample.present"] else "IDLE" + result = {"enabled": arguments["enabled"]} + elif capability_id == "slot.set_installed": + if s["power.enabled"] or s["coulometry.running"]: + return reject("PRECONDITION_FAILED") + slot = arguments["slot"] + if slot != "cell" and arguments["installed"] and not s["slot.cell.installed"]: + return reject("PRECONDITION_FAILED") + if slot == "cell" and not arguments["installed"] and (s["slot.generator.installed"] or s["slot.indicator.installed"]): + return reject("PRECONDITION_FAILED") + s[f"slot.{slot}.installed"] = arguments["installed"] + result = dict(arguments) + elif capability_id == "coulometry.configure": + if s["coulometry.running"]: + return reject("BUSY") + for name, value in arguments.items(): + s["settings." + name] = value + result = {name: s["settings." + name] for name in definition["output_schema"]["properties"]} + elif capability_id == "coulometry.start": + if s["coulometry.running"]: + return reject("BUSY") + if not s["power.enabled"] or not s["sample.present"] or not s["reagent.ready"] or not all(s[f"slot.{x}.installed"] for x in ("cell", "generator", "indicator")) or s["settings.drift_compensation_kg_s"] is None or s["settings.endpoint_hold_s"] is None or s["measurement.drift_kg_s"] > s["settings.start_drift_threshold_kg_s"] or instance["curve"] or s["measurement.sample_time_s"] is not None: + return reject("PRECONDITION_FAILED") + s.update({"coulometry.running": True, "coulometry.status": "EXTRACTING" if s["settings.extraction_time_s"] else "TITRATING", "measurement.elapsed_s": 0.0, + "measurement.charge_c": 0.0, "measurement.water_mass_kg": 0.0, + "measurement.water_fraction": None if s["settings.sample_mass_kg"] is None else 0.0, + "measurement.sample_time_s": host.time_s, "endpoint.hold_elapsed_s": 0.0}) + result = _kf899_reading(s) + elif capability_id == "coulometry.stop": + if s["coulometry.running"]: + s["coulometry.running"] = False + s["coulometry.status"] = "STOPPED" + result = _kf899_reading(s) + elif capability_id == "coulometry.reading": + result = _kf899_reading(s) + elif capability_id == "coulometry.curve": + result = {"records": _kf899_copy.deepcopy(instance["curve"]), "synthetic": True} + if candidate != instance: + candidate["revision"] += 1 + try: + host._kf899_sync(instance_id, s) + except Exception: + return self._kf899_response(instance_id, request_id, "failed", code="DEVICE_ERROR", side_effects="unknown") + host._kf899_instances[instance_id] = candidate + response = self._kf899_response(instance_id, request_id, result=result) + host._kf899_requests[key] = (fingerprint, _kf899_copy.deepcopy(response)) + host._kf899_logs.append({"instance_id": instance_id, "principal_id": self._kf899_principal, "request_id": request_id, "capability_id": capability_id, "status": response["status"]}) + return response + + def write(self, *, instance_id, state_id, value, request_id): + with self._kf899_host._kf899_lock: + if not self._kf899_allowed(instance_id): + return self._kf899_response(instance_id, request_id, "rejected", code="UNKNOWN_INSTANCE") + slots = export_metrohm899_contract_metadata()["state_slots"] + if not isinstance(state_id, str) or state_id not in slots: + return self._kf899_response(instance_id, request_id, "rejected", code="INVALID_ARGUMENT") + route = slots[state_id]["write_via"] + if not self._kf899_visible(state_id) or route is None: + return self._kf899_response(instance_id, request_id, "rejected", code="ACCESS_DENIED") + args = {**route["fixed_arguments"], route["parameter"]: value} + return self.invoke(instance_id=instance_id, capability_id=route["capability_id"], arguments=args, request_id=request_id) + + def logs(self): + with self._kf899_host._kf899_lock: + return _kf899_copy.deepcopy([row for row in self._kf899_host._kf899_logs if row["principal_id"] == self._kf899_principal and self._kf899_allowed(row["instance_id"])]) + + +def _kf899_arguments_valid(capability, arguments): + if capability in ("coulometry.start", "coulometry.stop", "coulometry.reading", "coulometry.curve"): + return not arguments + if capability == "power.set": + return set(arguments) == {"enabled"} and type(arguments["enabled"]) is bool + if capability == "slot.set_installed": + return set(arguments) == {"slot", "installed"} and isinstance(arguments["slot"], str) and arguments["slot"] in ("cell", "generator", "indicator") and type(arguments["installed"]) is bool + if capability != "coulometry.configure": + return False + allowed = {"current_a", "drift_compensation_kg_s", "start_drift_threshold_kg_s", "extraction_time_s", "stirring_level", "sample_mass_kg", "endpoint_hold_s"} + if not arguments or not set(arguments) <= allowed: + return False + for name, value in arguments.items(): + if name in ("drift_compensation_kg_s", "sample_mass_kg", "endpoint_hold_s") and value is None: + continue + if not _kf899_number(value): + return False + if name == "current_a" and value not in (0.1, 0.2, 0.4): + return False + if name == "start_drift_threshold_kg_s" and not KF899_START_DRIFT_MIN_KG_S <= value <= KF899_START_DRIFT_MAX_KG_S: + return False + if name == "extraction_time_s" and not 0 <= value <= 999999: + return False + if name == "stirring_level" and (type(value) is not int or not -15 <= value <= 15): + return False + if name in ("drift_compensation_kg_s", "endpoint_hold_s") and value < 0: + return False + if name == "sample_mass_kg" and value <= 0: + return False + return True +# END CHEM-102 METROHM 899 APPEND-ONLY RUNTIME + +# CHEM-102 additive numerical/schema clarifications (preserve append-only file). +_kf899_original_step = Metrohm899Host.step + + +def _kf899_finite_step(self, dt_s): + """Reject overflow in hidden intermediate integrals before any mutation. + + This is a floating-point domain check, not a manufacturer operating limit. + An excessively large requested world step is rejected conservatively even + when the ideal endpoint would complete earlier inside that interval. + """ + with self._kf899_lock: + if _kf899_number(dt_s) and dt_s > 0: + for item in self._kf899_instances.values(): + s = item["state"] + if s["coulometry.running"]: + candidates = (s["measurement.elapsed_s"] + dt_s, + s["settings.current_a"] * dt_s, + s["truth.water_remaining_kg"] + s["truth.background_drift_kg_s"] * dt_s, + s["settings.drift_compensation_kg_s"] * (s["measurement.elapsed_s"] + dt_s)) + if not all(_kf899_number(v) for v in candidates): + raise ValueError("Requested integration exceeds finite numerical range") + return _kf899_original_step(self, dt_s) + + +Metrohm899Host.step = _kf899_finite_step +_kf899_original_metadata = export_metrohm899_contract_metadata + + +def export_metrohm899_contract_metadata(): + result = _kf899_original_metadata() + for schema in (result["state_slots"]["settings.sample_mass_kg"]["value_schema"], + result["capabilities"]["coulometry.configure"]["input_schema"]["properties"]["sample_mass_kg"], + result["capabilities"]["coulometry.configure"]["output_schema"]["properties"]["sample_mass_kg"]): + number = schema["anyOf"][0] + number.pop("minimum", None) + number["exclusiveMinimum"] = 0 + result["capabilities"]["coulometry.curve"]["meaning_zh"] = "返回每次运行中宿主步进后记录的合成滴定曲线；最后一点可使用步内解析完成时刻，不插值补造采样。" + result["boundaries"].append("Floating-point overflow is rejected before state/time mutation; excessively large requested steps may be conservatively rejected before endpoint clipping.") + return result + + +# BEGIN CHEM-101 METROHM OMNIS APPEND-ONLY RUNTIME +import copy as _omnis_copy +import hashlib as _omnis_hashlib +import json as _omnis_json +import math as _omnis_math +import threading as _omnis_threading + +METROHM_OMNIS_TYPE = "instrument.metrohm_omnis" +METROHM_OMNIS_CYLINDERS_M3 = (5e-6, 1e-5, 2e-5, 5e-5) +METROHM_OMNIS_STEPS_PER_CYLINDER = 100000 +METROHM_OMNIS_MAX_SPEED_RAD_S = 60 * _omnis_math.pi +METROHM_OMNIS_MAX_POINTS = 1024 + + +def _omnis_num(unit, minimum=None, maximum=None, nullable=False, positive=False): + s = {"type": "number", "x-unit": unit} + if minimum is not None: + s["minimum"] = minimum + if maximum is not None: + s["maximum"] = maximum + if positive: + s["exclusiveMinimum"] = 0 + return {"anyOf": [s, {"type": "null"}]} if nullable else s + + +def _omnis_obj(properties): + return {"type": "object", "properties": properties, "required": list(properties), "additionalProperties": False} + + +def _omnis_finite(v): + try: + return type(v) in (int, float) and _omnis_math.isfinite(v) + except (OverflowError, TypeError): + return False + + +def _omnis_matches(s, v): + if "anyOf" in s: + return any(_omnis_matches(branch, v) for branch in s["anyOf"]) + typ = s.get("type") + if typ == "null": + return v is None + if typ == "object": + return isinstance(v, dict) and set(v) == set(s["properties"]) and all(_omnis_matches(s["properties"][k], x) for k, x in v.items()) + if typ == "array": + return isinstance(v, list) and len(v) <= s.get("maxItems", len(v)) and all(_omnis_matches(s["items"], x) for x in v) + if typ in ("number", "integer"): + if not _omnis_finite(v) or (typ == "integer" and type(v) is not int): + return False + if ("minimum" in s and v < s["minimum"]) or ("maximum" in s and v > s["maximum"]) or ("exclusiveMinimum" in s and v <= s["exclusiveMinimum"]): + return False + elif typ == "boolean": + if type(v) is not bool: + return False + elif typ == "string": + if not isinstance(v, str) or len(v) < s.get("minLength", 0) or len(v) > s.get("maxLength", len(v)): + return False + else: + return False + return ("enum" not in s or v in s["enum"]) and ("const" not in s or v == s["const"]) + + +def export_metrohm_omnis_contract_metadata(): + """Static metadata only; no sample fixture or instance truth is exported.""" + boolean, synthetic = {"type": "boolean"}, {"type": "boolean", "const": True} + nullable_id = {"anyOf": [{"type": "string", "minLength": 1, "maxLength": 256}, {"type": "null"}]} + status = {"type": "string", "enum": ["idle", "running", "completed", "stopped", "out_of_range", "limit_reached"]} + mode = {"type": "string", "enum": ["endpoint", "dynamic_equivalent"]} + point = _omnis_obj({"time_s": _omnis_num("s", 0), "volume_m3": _omnis_num("m^3", 0), + "potential_v": _omnis_num("V", -2.4, 2.4), "ph": _omnis_num("1"), "synthetic": synthetic}) + curve_schema = {"type": "array", "items": point, "maxItems": METROHM_OMNIS_MAX_POINTS} + slots = {} + def route(cap, parameter, fixed=None): + return {"capability_id": cap, "parameter": parameter, "fixed_arguments": fixed or {}} + def slot(sid, unit, origin, schema, text, write=None, visibility="agent", sampling="instant"): + slots[sid] = {"description_zh": text, "unit": unit, "origin": origin, "value_schema": schema, + "visibility": visibility, "access": "read_write" if write else "read_only", "write_via": write, + "read_binding": "MetrohmOmnisSession.read(instance_id=..., state_ids=[state_id])", + "sampling": {"mode": sampling, "time_domain": "simulation", "window": None}, "reference_conditions": None} + slot("power.enabled", "1", "setpoint", boolean, "逻辑供电；断电停止滴定，保留已加体积与曲线。", route("power.set", "enabled")) + for p in ("electrode", "titration_cell"): + slot("slot." + p + ".connection_id", "1", "scene", nullable_id, "可替换槽逻辑连接；非机械插拔或兼容性验证。", route("slot.set_connection", "connection_id", {"port_id": p})) + slot("dosing.cylinder_volume_m3", "m^3", "setpoint", {"anyOf": [{"type": "number", "enum": list(METROHM_OMNIS_CYLINDERS_M3), "x-unit": "m^3"}, {"type": "null"}]}, "单个缸槽容量，5/10/20/50mL换算SI。", route("dosing.configure_cylinder", "volume_m3")) + slot("dosing.quantum_m3", "m^3", "derived", _omnis_num("m^3", nullable=True), "选定容量/100000；分辨率不代表准确度。") + slot("dosing.rate_m3_s", "m^3/s", "setpoint", _omnis_num("m^3/s", nullable=True, positive=True), "用户显式加液速率；厂家上限未知。", route("dosing.set_rate", "rate_m3_s")) + slot("dosing.delivered_volume_m3", "m^3", "derived", _omnis_num("m^3", 0), "当前单缸实验已经加入的量化体积。") + slot("dosing.piston_fraction", "1", "derived", _omnis_num("1", 0, 1), "已加入体积/缸容量；仅供示意视觉映射，不等于真实活塞长度。") + slot("stirring.angular_speed_rad_s", "rad/s", "setpoint", _omnis_num("rad/s", 0, METROHM_OMNIS_MAX_SPEED_RAD_S), "1800 rpm = 60π rad/s；实际旋转还需逻辑电源。", route("stirring.set_speed", "angular_speed_rad_s")) + slot("stirring.angle_rad", "rad", "derived", _omnis_num("rad", 0, 2 * _omnis_math.pi), "共同宿主时间积分后的示意搅拌角。") + slot("titrant.concentration_mol_m3", "mol/m^3", "setpoint", _omnis_num("mol/m^3", nullable=True, positive=True), "用户给定强碱滴定剂浓度；不从隐藏样品真值反推。", route("titration.configure_titrant", "concentration_mol_m3")) + slot("method.mode", "1", "setpoint", {"anyOf": [mode, {"type": "null"}]}, "endpoint或dynamic_equivalent，后者为自定义有限差分算法。") + for sid, unit, text, nullable in (("method.dose_increment_m3", "m^3", "最大名义单次增量，动态模式可细分。", True), ("method.maximum_volume_m3", "m^3", "本次单缸最大累积加液体积。", True), ("method.endpoint_potential_v", "V", "endpoint模式明确给定的目标电位，动态模式为null。", True), ("stability.hold_s", "s", "显式稳定保持窗口；没有厂家默认值。", True), ("stability.tolerance_v", "V", "窗口内合成电位最大最小差的允许值。", True)): + slot(sid, unit, "setpoint", _omnis_num(unit, nullable=nullable), text) + slot("stability.stable", "1", "derived", boolean, "停止加液后窗口内合成读数符合显式稳定规则。") + slot("titration.status", "1", "derived", status, "完成只表示本工程假设算法结束；limit_reached可能未得到终点。") + slot("titration.running", "1", "derived", boolean, "只由host_step推进过程。") + slot("titration.phase", "1", "derived", {"type": "string", "enum": ["idle", "settling", "dosing", "finished"]}, "分段加液/稳定采样状态。") + slot("measurement.potential_v", "V", "derived", _omnis_num("V", -2.4, 2.4, True), "理想强酸强碱Nernst合成电位；越界为null。") + slot("measurement.ph", "1", "derived", _omnis_num("1", nullable=True), "由强酸强碱电中性与水离解计算的合成读数。") + slot("measurement.sample_time_s", "s", "derived", _omnis_num("s", 0, nullable=True), "最近宿主生成的合成测量时刻。") + slot("measurement.synthetic", "1", "derived", synthetic, "所有测量与曲线均为synthetic。") + slot("titration.curve", "1", "derived", curve_schema, "仅已稳定采点的观测序列；不含样品真值。", sampling="series") + slot("titration.endpoint_volume_m3", "m^3", "derived", _omnis_num("m^3", 0, nullable=True), "从观测曲线估算的终点体积，不读取宿主酸摩尔数求终点。") + slot("titration.content_mol_m3", "mol/m^3", "derived", _omnis_num("mol/m^3", 0, nullable=True), "按显式用户样品体积和化学计量比计算的含量。") + slot("display.text", "1", "derived", {"type": "string"}, "合成结果与运行状态的显示文本。") + for key, unit in (("volume_m3", "m^3"), ("acid_moles", "mol"), ("temperature_k", "K"), ("reference_ph", "1"), ("reference_potential_v", "V")): + slot("truth." + key, unit, "process_truth", _omnis_num(unit, nullable=True), "宿主专有的合成样品条件；agent不可读。", visibility="debug") + process_effects = [s for s in slots if s.startswith(("dosing.delivered", "dosing.piston", "stability.stable", "titration.", "measurement.", "display.")) and s != "titration.content_mol_m3"] + reset_effects = process_effects + ["titration.content_mol_m3"] + defs = { + "power.set": ({"enabled": boolean}, {"enabled": boolean}, {"enabled": True}, ["power.enabled", "titration.running", "titration.status", "titration.phase", "stability.stable", "display.text"], ["housing"], "设置逻辑供电；断电保留已经加入的体积和曲线。", "实例可用。"), + "slot.set_connection": ({"port_id": {"type": "string", "enum": ["electrode", "titration_cell"]}, "connection_id": nullable_id}, {"port_id": {"type": "string"}, "connection_id": nullable_id}, {"port_id": "electrode", "connection_id": "electrode_01"}, ["slot.electrode.connection_id", "slot.titration_cell.connection_id"], ["electrode_slot", "titration_cell_slot"], "登记可替换部件的逻辑槽连接。", "未在滴定；不执行机械插拔。"), + "dosing.configure_cylinder": ({"volume_m3": {"type": "number", "enum": list(METROHM_OMNIS_CYLINDERS_M3), "x-unit": "m^3"}}, {"volume_m3": _omnis_num("m^3")}, {"volume_m3": 2e-5}, ["dosing.cylinder_volume_m3", "dosing.quantum_m3", "dosing.piston_fraction"], ["cylinder_slot", "dosing_module"], "选择唯一缸槽容量，尚未实验时可改；每缸100000步。", "未运行、尚无已加液体积；已有方法的最大体积不可超容量。"), + "titration.configure_titrant": ({"concentration_mol_m3": _omnis_num("mol/m^3", positive=True)}, {"concentration_mol_m3": _omnis_num("mol/m^3", positive=True)}, {"concentration_mol_m3": 100}, ["titrant.concentration_mol_m3"], ["dosing_module"], "显式配置强碱滴定剂浓度。", "未运行且尚未加液。"), + "titration.configure_method": ({"mode": mode, "dose_increment_m3": _omnis_num("m^3", positive=True), "maximum_volume_m3": _omnis_num("m^3", positive=True), "endpoint_potential_v": _omnis_num("V", -2.4, 2.4, True)}, {"mode": mode, "dose_increment_m3": _omnis_num("m^3", positive=True), "maximum_volume_m3": _omnis_num("m^3", positive=True), "endpoint_potential_v": _omnis_num("V", -2.4, 2.4, True)}, {"mode": "endpoint", "dose_increment_m3": 1e-7, "maximum_volume_m3": 1.5e-5, "endpoint_potential_v": 0}, ["method.mode", "method.dose_increment_m3", "method.maximum_volume_m3", "method.endpoint_potential_v"], ["dosing_module"], "配置定电位终点或动态等当点合成方法。", "未运行且尚未加液；已选缸，增量和上限必须是缸步长整数倍；endpoint需要目标电位，动态模式目标为null。"), + "dosing.set_rate": ({"rate_m3_s": _omnis_num("m^3/s", positive=True)}, {"rate_m3_s": _omnis_num("m^3/s", positive=True)}, {"rate_m3_s": 1e-7}, ["dosing.rate_m3_s"], ["dosing_module"], "显式设定合成加液速率，不推断厂商流量范围。", "未运行；有限正数。"), + "titration.configure_stability": ({"hold_s": _omnis_num("s", positive=True), "tolerance_v": _omnis_num("V", 0)}, {"hold_s": _omnis_num("s", positive=True), "tolerance_v": _omnis_num("V", 0)}, {"hold_s": 0.5, "tolerance_v": 0.001}, ["stability.hold_s", "stability.tolerance_v"], ["electrode_slot"], "稳定窗口与电位容差由调用者显式给定。", "未运行；窗口正且容差非负；理想瞬时混合假设下静止加液窗口电位不变。"), + "stirring.set_speed": ({"angular_speed_rad_s": _omnis_num("rad/s", 0, METROHM_OMNIS_MAX_SPEED_RAD_S)}, {"angular_speed_rad_s": _omnis_num("rad/s", 0, METROHM_OMNIS_MAX_SPEED_RAD_S)}, {"angular_speed_rad_s": 10}, ["stirring.angular_speed_rad_s"], ["stir_bar", "stirrer_platform"], "设定搅拌角速度，上限1800rpm；不虚构混合时间常数。", "滴定运行中不得关闭搅拌；实际角度仅宿主推进。"), + "titration.start": ({}, {"status": status, "synthetic": synthetic}, {}, reset_effects, ["dosing_module", "electrode_slot", "titration_cell_slot", "stir_bar"], "启动分段加液/稳定采样；调用不加液、不产生读数、不推进时钟。", "电源、两个槽、缸、滴定剂、方法、速率、稳定规则、正搅拌速度和宿主样品齐备；开始单次实验前已加体积为0。"), + "titration.stop": ({}, {"status": status, "synthetic": synthetic}, {}, ["titration.status", "titration.running", "titration.phase", "stability.stable", "display.text"], ["dosing_module"], "停止并保留已加液体积及采点，已转移液体不回滚。", "实例可用；不支持停止后的续跑，宿主换样后才能新实验。"), + "titration.read_curve": ({}, {"samples": curve_schema, "endpoint_volume_m3": _omnis_num("m^3", 0, nullable=True), "status": status, "synthetic": synthetic}, {}, [], ["housing"], "读取合成曲线及估算终点，不推进时间、不访问样品真值。", "实例可用。"), + "titration.calculate_content": ({"sample_volume_m3": _omnis_num("m^3", positive=True), "stoichiometric_ratio": _omnis_num("1", positive=True)}, {"content_mol_m3": _omnis_num("mol/m^3", 0), "synthetic": synthetic}, {"sample_volume_m3": 2.5e-5, "stoichiometric_ratio": 1}, ["titration.content_mol_m3"], ["housing"], "含量=终点体积×用户滴定剂浓度×用户计量比/用户样品体积。", "算法已得到终点，且结果为有限数。"), + } + caps = {} + scene_keys = ["power.enabled", "slot.electrode.connection_id", "slot.titration_cell.connection_id", "dosing.cylinder_volume_m3", "dosing.delivered_volume_m3", "dosing.piston_fraction", "stirring.angle_rad", "stirring.angular_speed_rad_s", "display.text"] + for name, (inputs, outputs, example, effects, components, desc, pre) in defs.items(): + scene_effects = [s for s in effects if s in scene_keys] + kind = "query" if name == "titration.read_curve" else "analysis" if name == "titration.calculate_content" else "configuration" if "configure" in name or name == "slot.set_connection" else "device_command" + caps[name] = {"availability": "implemented", "visibility": "agent", "kind": kind, "description_zh": desc, + "input_schema": _omnis_obj(inputs), "output_schema": _omnis_obj(outputs), "example_arguments": [example], + "state_effects": [{"state_id": s, "timing": "immediate", "description_zh": desc} for s in effects], + "observes": list(effects), "component_ids": components, "preconditions_zh": pre, + "binding": "basic40_runtime_measure.MetrohmOmnisSession.invoke(instance_id=..., capability_id='" + name + "', arguments=..., request_id=...)", + "completion_criterion_zh": "同步提交命令；实验完成须由host_step推进到completed并读取推断终点。", + "model_effects": {"mode": "host_required" if scene_effects else "none", "binding_ids": [], "description_zh": "可选scene_adapter接收只含允许场景键的快照；具体几何求值另验。" if scene_effects else "配置、曲线读取或纯分析不改变几何。"}, + "implementation": {"process": "implemented", "host": "implemented", "scene": "declared" if scene_effects else "not_applicable", "robot": "absent", "hardware": "absent"}, + "error_codes": ["UNKNOWN_INSTANCE", "UNKNOWN_CAPABILITY", "INVALID_ARGUMENT", "ACCESS_DENIED", "PRECONDITION_FAILED", "BUSY", "REQUEST_CONFLICT", "DEVICE_ERROR"], "retry": "same_request_id; in-memory only"} + def parameter(value, unit, evidence, text): + return {"value": value, "unit": unit, "meaning_zh": text, "evidence": evidence, "source_ids": ["workbook_parameters" if evidence == "catalog" else "runtime_code"], "uncertainty": None} + params = { + "cylinder_volumes_m3": parameter(list(METROHM_OMNIS_CYLINDERS_M3), "m^3", "catalog", "表列5/10/20/50mL选项。"), + "steps_per_cylinder": parameter(100000, "1", "catalog", "每缸加液分辨率，不等于精度。"), + "maximum_stirring_speed_rad_s": parameter(METROHM_OMNIS_MAX_SPEED_RAD_S, "rad/s", "catalog", "1800rpm换算60πrad/s。"), + "potential_range_v": parameter([-2.4, 2.4], "V", "catalog", "整机±2400mV测量范围。"), + "dynamic_target_delta_v": parameter(0.02, "V", "engineering_assumption", "自定义动态增量算法的目标电位变化；非厂家方法参数。"), + "dynamic_peak_fraction": parameter(0.8, "1", "engineering_assumption", "峰后两个较低斜率小于峰值80%才确认有限差分终点。"), + "max_curve_points": parameter(METROHM_OMNIS_MAX_POINTS, "1", "engineering_assumption", "运行层资源上限，不是厂商数据容量。"), + "water_ionic_product": parameter(1e-14, "1", "engineering_assumption", "浓度按mol/L归一后的Kw，固定25°C近似，温度仅进入Nernst斜率。"), + } + for key, unit in (("manufacturer_max_flow_rate", "m^3/s"), ("electrode_response_time", "s"), ("electrode_mass", "kg"), ("mixing_time_constant", "s"), ("sample_noise", "V"), ("cylinder_actual_stroke", "m"), ("cylinder_mass", "kg"), ("calibration_accuracy", "V"), ("fault_probability", "1")): + params[key] = parameter(None, unit, "unknown", "清单未给出，保持null；不以整机规格代替部件参数。") + limitations = ["All measurements, curves and content are synthetic; no real hardware, robotics, chemical calibration, noise or fault model is implemented.", + "Only ideal monoprotic strong-acid/strong-base 1:1 titration is simulated; redox/complexometry, weak acids, real kinetics, activity corrections, temperature-dependent Kw and manufacturer endpoint firmware are not implemented.", + "Host explicitly supplies sample conditions and absolute shared time. The ideal instantaneous-mixing model has constant potential while dosing is stopped; stability is checked over the explicit hold window.", + "One cylinder per run, no refill, flushing, sample transfer or physical insertion. Integer volume steps represent catalog resolution, not metrological accuracy.", + "Session filtering is an API boundary only; the trusted host, Python runtime and filesystem require separate deployment isolation. Debug truth never enters agent read/invoke/describe/logs or scene snapshots.", + "Request deduplication is in-memory only. Scene callback failure leaves process uncommitted but a partially changed external scene may need reconciliation.", + "Unknown manufacturer flow/stability/calibration parameters remain null; explicitly configured simulation inputs are not manufacturer specifications."] + return {"asset_types": {METROHM_OMNIS_TYPE: {"catalog_id": "CHEM-101", "model": "Metrohm | OMNIS Professional Titrator 2.1001.0320", "asset_version": "1.0.0", "state_slots": slots, "capabilities": caps, "parameters": params}}, + "host_capabilities": {"sim.host_step": {"kind": "simulation", "visibility": "trusted_host_only", "binding": "MetrohmOmnisRuntime.host_step(time_s)", "effects": reset_effects + ["stirring.angle_rad"]}, + "sim.load_sample": {"kind": "simulation", "visibility": "trusted_host_only", "binding": "MetrohmOmnisRuntime.host_load_sample(instance_id, sample)", "semantics_zh": "宿主设置新实验的合成真值、清空旧实验与活塞累计；不代表实际自动换样或缸补液。"}}, + "scene_snapshot_keys": scene_keys, "limitations": limitations, + "engineering_equations": ["d=(n_acid-c_base*V_dosed)/(1000*(V_sample+V_dosed)); H=(d+sqrt(d*d+4*Kw))/2 with cancellation-safe branch; pH=-log10(H)", + "E=E_ref-ln(10)*R*T/F*(pH-pH_ref); R=8.31446261815324 J/(mol K), F=96485.33212331001 C/mol", + "quantum=V_cylinder/100000; delivered=integer_steps*quantum; theta=(theta+omega*dt) mod 2pi", + "endpoint: linear interpolation of observed E crossing; dynamic_equivalent: maximum observed |dE/dV| segment midpoint, confirmed by two later slopes < 0.8*peak", + "dynamic step=min(nominal_step, max(quantum, floor(0.02/last_abs_slope/quantum)*quantum)); content=V_endpoint*c_titrant*stoichiometric_ratio/V_user_sample"]} + + +class MetrohmOmnisRuntime: + """Trusted host; hand a scoped Session, never this host, to an agent.""" + def __init__(self, *, scene_adapter=None): + self.scene_adapter, self.time_s = scene_adapter, 0.0 + self._instances, self._principals, self._requests, self._logs = {}, {}, {}, {} + self._lock, self._metadata = _omnis_threading.RLock(), export_metrohm_omnis_contract_metadata() + self.register_principal("__public_agent__", visibility="agent") + self._agent = self.session("__public_agent__") + + def create_instance(self, instance_id, asset_type_id=METROHM_OMNIS_TYPE): + with self._lock: + if not isinstance(instance_id, str) or not instance_id or instance_id in self._instances or asset_type_id != METROHM_OMNIS_TYPE: + raise ValueError("Unique instance and declared asset type required") + inst = {"revision": 0, "power": False, "connections": {"electrode": None, "titration_cell": None}, + "cylinder": None, "quantum": None, "rate": None, "speed": 0.0, "angle": 0.0, "concentration": None, + "method": None, "hold": None, "tolerance": None, + "truth": {key: None for key in ("volume_m3", "acid_moles", "temperature_k", "reference_ph", "reference_potential_v")}} + self._reset_run(inst) + if self.scene_adapter: + self.scene_adapter(instance_id, self._scene(inst)) + self._instances[instance_id] = inst + + @staticmethod + def _reset_run(inst): + inst.update({"steps": 0, "running": False, "status": "idle", "phase": "idle", "stable": False, + "curve": [], "ph": None, "potential": None, "sample_time": None, "endpoint": None, "content": None, + "event_time": None, "phase_start": None, "phase_start_steps": 0, "target_steps": 0, + "slopes": [], "settling_potential": None}) + + def register_principal(self, principal_id, *, visibility, instance_ids=None): + with self._lock: + if not isinstance(principal_id, str) or not principal_id or principal_id in self._principals or visibility not in ("agent", "debug", "evaluator"): + raise ValueError("Invalid trusted principal") + if instance_ids is not None and (not isinstance(instance_ids, (list, tuple, set, frozenset)) or any(not isinstance(x, str) for x in instance_ids)): + raise ValueError("Invalid instance scope") + scope = None if instance_ids is None else frozenset(instance_ids) + if scope is not None and not scope <= self._instances.keys(): + raise ValueError("Unknown instance scope") + self._principals[principal_id], self._logs[principal_id] = (visibility, scope), [] + + def session(self, principal_id): + if principal_id not in self._principals: + raise ValueError("Trusted registration required") + return MetrohmOmnisSession(self, principal_id) + + def describe(self, **kwargs): + return self._agent.describe(**kwargs) + + def read(self, **kwargs): + return self._agent.read(**kwargs) + + def invoke(self, **kwargs): + return self._agent.invoke(**kwargs) + + def write(self, **kwargs): + return self._agent.write(**kwargs) + + def describe_host(self): + return _omnis_copy.deepcopy(self._metadata["host_capabilities"]) + + @staticmethod + def _volume(inst): + return inst["steps"] * inst["quantum"] if inst["quantum"] else 0.0 + + @staticmethod + def _display(inst): + return "OFF" if not inst["power"] else "SYNTHETIC " + inst["status"] + (" %.3f mL" % (MetrohmOmnisRuntime._volume(inst) * 1e6)) + + @staticmethod + def _scene(inst): + return {"power.enabled": inst["power"], "slot.electrode.connection_id": inst["connections"]["electrode"], + "slot.titration_cell.connection_id": inst["connections"]["titration_cell"], "dosing.cylinder_volume_m3": inst["cylinder"], + "dosing.delivered_volume_m3": MetrohmOmnisRuntime._volume(inst), "dosing.piston_fraction": inst["steps"] / METROHM_OMNIS_STEPS_PER_CYLINDER, + "stirring.angle_rad": inst["angle"], "stirring.angular_speed_rad_s": inst["speed"], "display.text": MetrohmOmnisRuntime._display(inst)} + + def scene_snapshot(self, instance_id): + with self._lock: + if instance_id not in self._instances: + raise ValueError("Unknown instance") + return _omnis_copy.deepcopy(self._scene(self._instances[instance_id])) + + def apply_scene(self, instance_id): + with self._lock: + if self.scene_adapter is None: + raise RuntimeError("No scene adapter registered") + snapshot = self.scene_snapshot(instance_id) + self.scene_adapter(instance_id, snapshot) + return snapshot + + @staticmethod + def _values(inst): + method = inst["method"] or {} + vals = {**MetrohmOmnisRuntime._scene(inst), "dosing.quantum_m3": inst["quantum"], "dosing.rate_m3_s": inst["rate"], + "titrant.concentration_mol_m3": inst["concentration"], "stability.hold_s": inst["hold"], "stability.tolerance_v": inst["tolerance"], + "stability.stable": inst["stable"], "titration.status": inst["status"], "titration.running": inst["running"], "titration.phase": inst["phase"], + "measurement.potential_v": inst["potential"], "measurement.ph": inst["ph"], "measurement.sample_time_s": inst["sample_time"], + "measurement.synthetic": True, "titration.curve": inst["curve"], "titration.endpoint_volume_m3": inst["endpoint"], "titration.content_mol_m3": inst["content"]} + vals.update({"method." + key: method.get(key) for key in ("mode", "dose_increment_m3", "maximum_volume_m3", "endpoint_potential_v")}) + vals.update({"truth." + key: value for key, value in inst["truth"].items()}) + return vals + + def host_load_sample(self, instance_id, sample): + """Explicit synthetic fixture/reset only; never expose through a Session.""" + with self._lock: + inst = self._instances.get(instance_id) + expected = {"volume_m3", "acid_moles", "temperature_k", "reference_ph", "reference_potential_v"} + if inst is None or inst["running"]: + raise ValueError("Available stopped instance required") + if not isinstance(sample, dict) or set(sample) != expected or any(not _omnis_finite(v) for v in sample.values()): + raise ValueError("All explicit finite sample fields required") + if sample["volume_m3"] <= 0 or sample["acid_moles"] < 0 or sample["temperature_k"] <= 0: + raise ValueError("Positive sample volume/temperature and nonnegative acid required") + candidate = _omnis_copy.deepcopy(inst) + candidate["truth"] = {k: float(v) for k, v in sample.items()} + self._reset_run(candidate) + candidate["revision"] += 1 + if self.scene_adapter and self._scene(candidate) != self._scene(inst): + self.scene_adapter(instance_id, self._scene(candidate)) + self._instances[instance_id] = candidate + + @staticmethod + def _potential(inst): + truth = inst["truth"] + volume = MetrohmOmnisRuntime._volume(inst) + d = (truth["acid_moles"] - inst["concentration"] * volume) / (1000 * (truth["volume_m3"] + volume)) + root = _omnis_math.hypot(d, 2e-7) + h = (d + root) / 2 if d >= 0 else 2e-14 / (root - d) + ph = -_omnis_math.log10(h) + potential = truth["reference_potential_v"] - _omnis_math.log(10) * 8.31446261815324 * truth["temperature_k"] / 96485.33212331001 * (ph - truth["reference_ph"]) + if not _omnis_finite(potential) or not _omnis_finite(ph): + raise ValueError("Synthetic response outside numeric domain") + return ph, potential + + @staticmethod + def _measure(inst, time_s): + try: + ph, potential = MetrohmOmnisRuntime._potential(inst) + except (ValueError, OverflowError, ZeroDivisionError): + ph, potential = None, None + inst["sample_time"] = time_s + if potential is None or not -2.4 <= potential <= 2.4: + inst["ph"], inst["potential"], inst["status"], inst["running"], inst["phase"], inst["stable"] = None, None, "out_of_range", False, "finished", False + return False + inst["ph"], inst["potential"] = ph, potential + return True + + @staticmethod + def _complete(inst, status): + inst["status"], inst["running"], inst["phase"], inst["event_time"] = status, False, "finished", None + + @staticmethod + def _record(inst, time_s): + volume, potential = MetrohmOmnisRuntime._volume(inst), inst["potential"] + point = {"time_s": time_s, "volume_m3": volume, "potential_v": potential, "ph": inst["ph"], "synthetic": True} + previous = inst["curve"][-1] if inst["curve"] else None + inst["curve"].append(point) + method = inst["method"] + if method["mode"] == "endpoint": + target = method["endpoint_potential_v"] + if potential == target: + inst["endpoint"] = volume + elif previous and (previous["potential_v"] - target) * (potential - target) < 0: + inst["endpoint"] = previous["volume_m3"] + (volume - previous["volume_m3"]) * (target - previous["potential_v"]) / (potential - previous["potential_v"]) + elif previous: + slope = abs((potential - previous["potential_v"]) / (volume - previous["volume_m3"])) + inst["slopes"].append({"slope": slope, "volume_m3": (volume + previous["volume_m3"]) / 2}) + peak_index = max(range(len(inst["slopes"])), key=lambda n: inst["slopes"][n]["slope"]) + peak = inst["slopes"][peak_index] + if peak_index >= 1 and len(inst["slopes"]) - peak_index >= 3 and all(s["slope"] < 0.8 * peak["slope"] for s in inst["slopes"][-2:]): + inst["endpoint"] = peak["volume_m3"] + if inst["endpoint"] is not None: + MetrohmOmnisRuntime._complete(inst, "completed") + elif inst["steps"] >= round(method["maximum_volume_m3"] / inst["quantum"]) or len(inst["curve"]) >= METROHM_OMNIS_MAX_POINTS: + MetrohmOmnisRuntime._complete(inst, "limit_reached") + else: + increment = round(method["dose_increment_m3"] / inst["quantum"]) + if method["mode"] == "dynamic_equivalent" and inst["slopes"] and inst["slopes"][-1]["slope"] > 0: + increment = min(increment, max(1, int(0.02 / inst["slopes"][-1]["slope"] / inst["quantum"]))) + target_steps = min(inst["steps"] + increment, round(method["maximum_volume_m3"] / inst["quantum"])) + inst["phase"], inst["phase_start"], inst["phase_start_steps"], inst["target_steps"] = "dosing", time_s, inst["steps"], target_steps + inst["event_time"] = time_s + (target_steps - inst["steps"]) * inst["quantum"] / inst["rate"] + inst["stable"] = False + + def _advance(self, inst, start_time, end_time): + if inst["power"]: + inst["angle"] = (inst["angle"] + inst["speed"] * (end_time - start_time)) % (2 * _omnis_math.pi) + while inst["running"] and inst["event_time"] <= end_time: + event = inst["event_time"] + if inst["phase"] == "dosing": + inst["steps"] = inst["target_steps"] + if not self._measure(inst, event): + break + inst["phase"], inst["phase_start"] = "settling", event + inst["settling_potential"] = inst["potential"] + inst["event_time"] = event + inst["hold"] + else: + if not self._measure(inst, event): + break + first = inst["settling_potential"] + # The explicit ideal instantaneous-mixing process is constant during hold. + if first is None: + first = self._potential(inst)[1] + inst["stable"] = abs(inst["potential"] - first) <= inst["tolerance"] + if inst["stable"]: + self._record(inst, event) + else: + inst["settling_potential"], inst["event_time"] = inst["potential"], event + inst["hold"] + if inst["running"] and (not _omnis_finite(inst["event_time"]) or inst["event_time"] <= event): + raise ValueError("Host clock cannot resolve configured process interval") + if inst["running"] and inst["phase"] == "dosing": + elapsed = max(0.0, end_time - inst["phase_start"]) + # Half-open step intervals prevent fractional catalog steps. + added = int(elapsed * inst["rate"] / inst["quantum"] + 1e-8) + inst["steps"] = min(inst["target_steps"], inst["phase_start_steps"] + added) + self._measure(inst, end_time) + + def host_step(self, time_s): + """Advance all instances atomically under one absolute simulation clock.""" + with self._lock: + if not _omnis_finite(time_s) or time_s < self.time_s: + raise ValueError("Finite monotonic absolute host time required") + if time_s == self.time_s: + return {"time_s": self.time_s, "updated_instance_ids": []} + candidates = _omnis_copy.deepcopy(self._instances) + changed = [] + for name, inst in candidates.items(): + self._advance(inst, self.time_s, float(time_s)) + if inst != self._instances[name]: + inst["revision"] += 1 + changed.append(name) + if self.scene_adapter: + for name in changed: + if self._scene(candidates[name]) != self._scene(self._instances[name]): + self.scene_adapter(name, self._scene(candidates[name])) + self._instances, self.time_s = candidates, float(time_s) + return {"time_s": self.time_s, "updated_instance_ids": changed} + + +class MetrohmOmnisSession: + """API filtering; not an in-process Python or filesystem security sandbox.""" + def __init__(self, host, principal_id): + self.__host, self.__principal = host, principal_id + + def _instance(self, instance_id): + _, scope = self.__host._principals[self.__principal] + return self.__host._instances.get(instance_id) if isinstance(instance_id, str) and (scope is None or instance_id in scope) else None + + def _visible(self, slot): + visibility, _ = self.__host._principals[self.__principal] + return slot["visibility"] == "agent" or visibility in ("debug", "evaluator") + + def _envelope(self, instance_id, request_id=None, *, status="succeeded", result=None, observations=None, error=None): + inst = self._instance(instance_id) + return {"protocol_version": "1.0.0", "instance_id": instance_id, "request_id": request_id, "operation_id": None, + "status": status, "state_revision": inst["revision"] if inst else None, "clock": {"domain": "simulation", "time_s": self.__host.time_s}, + "result": _omnis_copy.deepcopy(result or {}), "observations": _omnis_copy.deepcopy(observations or {}), "error": error} + + def _error(self, instance_id, code, request_id=None, status="rejected"): + text = {"UNKNOWN_INSTANCE": "Instance unavailable.", "UNKNOWN_CAPABILITY": "Capability unavailable.", "INVALID_ARGUMENT": "Invalid argument schema or numeric domain.", "ACCESS_DENIED": "Access policy denies this request.", "PRECONDITION_FAILED": "Required sample, configuration or operating state unavailable.", "BUSY": "Titration is running.", "REQUEST_CONFLICT": "Request identifier already used with different arguments.", "DEVICE_ERROR": "External scene synchronization failed; process was not committed."} + return self._envelope(instance_id, request_id, status=status, error={"code": code, "message": text[code], "retryable": False, "side_effects": "unknown" if code == "DEVICE_ERROR" else "none", "progress": None}) + + def describe(self, *, asset_type_id=None, instance_id=None): + with self.__host._lock: + if (asset_type_id is None) == (instance_id is None) or (asset_type_id is not None and asset_type_id != METROHM_OMNIS_TYPE): + return self._error(None, "INVALID_ARGUMENT") + if instance_id is not None and self._instance(instance_id) is None: + return self._error(instance_id, "UNKNOWN_INSTANCE") + _, scope = self.__host._principals[self.__principal] + if scope is not None and not scope: + return self._error(instance_id, "ACCESS_DENIED") + spec = _omnis_copy.deepcopy(self.__host._metadata["asset_types"][METROHM_OMNIS_TYPE]) + spec["state_slots"] = {k: v for k, v in spec["state_slots"].items() if self._visible(v)} + return {"protocol_version": "1.0.0", "asset_type_id": METROHM_OMNIS_TYPE, "instance_id": instance_id, "adapter": "basic40_runtime_measure.MetrohmOmnisSession", **spec, + "limitations": _omnis_copy.deepcopy(self.__host._metadata["limitations"])} + + def read(self, *, instance_id, state_ids=None): + with self.__host._lock: + inst = self._instance(instance_id) + if inst is None: + return self._error(instance_id, "UNKNOWN_INSTANCE") + slots = self.__host._metadata["asset_types"][METROHM_OMNIS_TYPE]["state_slots"] + if state_ids is None: + state_ids = [k for k, v in slots.items() if self._visible(v)] + if not isinstance(state_ids, list) or any(not isinstance(x, str) for x in state_ids) or len(state_ids) != len(set(state_ids)): + return self._error(instance_id, "INVALID_ARGUMENT") + if any(k not in slots or not self._visible(slots[k]) for k in state_ids): + return self._error(instance_id, "ACCESS_DENIED") + values = self.__host._values(inst) + observations = {k: {"value": _omnis_copy.deepcopy(values[k]), "unit": slots[k]["unit"], "quality": "unavailable" if values[k] is None else "estimated" if slots[k]["origin"] == "derived" else "valid", + "sample_time_s": inst["sample_time"] if k.startswith("measurement.") else self.__host.time_s, "sample_window_s": None, + "synthetic": slots[k]["origin"] == "derived", "reason": "No configured value or available synthetic result." if values[k] is None else None} for k in state_ids} + return self._envelope(instance_id, observations=observations) + + def invoke(self, *, instance_id, capability_id, arguments, request_id): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if inst is None: + return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) + if not isinstance(capability_id, str) or not isinstance(arguments, dict) or not isinstance(request_id, str) or not 1 <= len(request_id) <= 256: + return self._error(instance_id, "INVALID_ARGUMENT", request_id) + try: + digest = _omnis_hashlib.sha256(_omnis_json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False).encode()).hexdigest() + except (TypeError, ValueError, OverflowError): + return self._error(instance_id, "INVALID_ARGUMENT", request_id) + key = self.__principal, instance_id, request_id + if key in host._requests: + old_digest, response = host._requests[key] + return _omnis_copy.deepcopy(response) if digest == old_digest else self._error(instance_id, "REQUEST_CONFLICT", request_id) + response = self._checked(instance_id, inst, capability_id, arguments, request_id) + host._requests[key] = digest, _omnis_copy.deepcopy(response) + host._logs[self.__principal].append({"instance_id": instance_id, "capability_id": capability_id, "request_id": request_id, "response": _omnis_copy.deepcopy(response)}) + return response + + def _checked(self, instance_id, inst, cap, args, request_id): + host = self.__host + fail = lambda code, status="rejected": self._error(instance_id, code, request_id, status) + caps = host._metadata["asset_types"][METROHM_OMNIS_TYPE]["capabilities"] + if cap not in caps: + return fail("UNKNOWN_CAPABILITY") + if not _omnis_matches(caps[cap]["input_schema"], args): + return fail("INVALID_ARGUMENT") + idle_caps = ("slot.set_connection", "dosing.configure_cylinder", "titration.configure_titrant", "titration.configure_method", "dosing.set_rate", "titration.configure_stability", "titration.start") + if cap in idle_caps and inst["running"]: + return fail("BUSY") + if cap in ("dosing.configure_cylinder", "titration.configure_titrant", "titration.configure_method", "titration.start") and inst["steps"] > 0: + return fail("PRECONDITION_FAILED") + if cap == "dosing.configure_cylinder" and inst["method"] and inst["method"]["maximum_volume_m3"] > args["volume_m3"]: + return fail("PRECONDITION_FAILED") + if cap == "titration.configure_method": + q = inst["quantum"] + if q is None: + return fail("PRECONDITION_FAILED") + if (args["mode"] == "endpoint") != (args["endpoint_potential_v"] is not None): + return fail("INVALID_ARGUMENT") + if args["dose_increment_m3"] > args["maximum_volume_m3"] or args["maximum_volume_m3"] > inst["cylinder"]: + return fail("INVALID_ARGUMENT") + for key in ("dose_increment_m3", "maximum_volume_m3"): + steps = args[key] / q + if not _omnis_finite(steps) or steps < 1 or abs(steps - round(steps)) > 1e-7: + return fail("INVALID_ARGUMENT") + if cap == "stirring.set_speed" and inst["running"] and args["angular_speed_rad_s"] == 0: + return fail("PRECONDITION_FAILED") + if cap == "titration.start": + if not inst["power"] or not all(inst["connections"].values()) or any(inst[k] is None for k in ("cylinder", "rate", "concentration", "method", "hold", "tolerance")) or inst["speed"] <= 0 or inst["truth"]["volume_m3"] is None: + return fail("PRECONDITION_FAILED") + try: + period = inst["quantum"] / inst["rate"] + response = host._potential(inst) + if not _omnis_finite(period) or period <= 0 or host.time_s + period <= host.time_s or host.time_s + inst["hold"] <= host.time_s or not all(_omnis_finite(x) for x in response): + return fail("INVALID_ARGUMENT") + except (ValueError, OverflowError, ZeroDivisionError): + return fail("INVALID_ARGUMENT") + if cap == "titration.calculate_content": + if inst["endpoint"] is None or inst["running"]: + return fail("PRECONDITION_FAILED") + try: + content = inst["endpoint"] * inst["concentration"] * args["stoichiometric_ratio"] / args["sample_volume_m3"] + except (ValueError, OverflowError, ZeroDivisionError): + return fail("INVALID_ARGUMENT") + if not _omnis_finite(content): + return fail("INVALID_ARGUMENT") + if cap == "titration.read_curve": + return self._envelope(instance_id, request_id, result={"samples": inst["curve"], "endpoint_volume_m3": inst["endpoint"], "status": inst["status"], "synthetic": True}) + candidate, result = _omnis_copy.deepcopy(inst), dict(args) + if cap == "power.set": + candidate["power"] = args["enabled"] + if not args["enabled"] and candidate["running"]: + host._complete(candidate, "stopped") + candidate["stable"] = False + elif cap == "slot.set_connection": + candidate["connections"][args["port_id"]] = args["connection_id"] + elif cap == "dosing.configure_cylinder": + candidate["cylinder"], candidate["quantum"] = args["volume_m3"], args["volume_m3"] / METROHM_OMNIS_STEPS_PER_CYLINDER + elif cap == "titration.configure_titrant": + candidate["concentration"] = args["concentration_mol_m3"] + elif cap == "titration.configure_method": + candidate["method"] = dict(args) + elif cap == "dosing.set_rate": + candidate["rate"] = args["rate_m3_s"] + elif cap == "titration.configure_stability": + candidate["hold"], candidate["tolerance"] = args["hold_s"], args["tolerance_v"] + elif cap == "stirring.set_speed": + candidate["speed"] = args["angular_speed_rad_s"] + elif cap == "titration.start": + host._reset_run(candidate) + candidate["running"], candidate["status"], candidate["phase"] = True, "running", "settling" + candidate["phase_start"], candidate["event_time"] = host.time_s, host.time_s + candidate["hold"] + result = {"status": candidate["status"], "synthetic": True} + elif cap == "titration.stop": + if candidate["running"]: + host._complete(candidate, "stopped") + candidate["stable"] = False + result = {"status": candidate["status"], "synthetic": True} + elif cap == "titration.calculate_content": + candidate["content"] = content + result = {"content_mol_m3": content, "synthetic": True} + if host.scene_adapter and host._scene(candidate) != host._scene(inst): + try: + host.scene_adapter(instance_id, host._scene(candidate)) + except Exception: + return fail("DEVICE_ERROR", "failed") + if candidate != inst: + candidate["revision"] += 1 + host._instances[instance_id] = candidate + return self._envelope(instance_id, request_id, result=result) + + def write(self, *, instance_id, state_id, value, request_id): + with self.__host._lock: + if self._instance(instance_id) is None: + return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) + slots = self.__host._metadata["asset_types"][METROHM_OMNIS_TYPE]["state_slots"] + if not isinstance(state_id, str) or state_id not in slots or not self._visible(slots[state_id]) or slots[state_id]["write_via"] is None: + return self._error(instance_id, "ACCESS_DENIED", request_id) + route = slots[state_id]["write_via"] + return self.invoke(instance_id=instance_id, capability_id=route["capability_id"], arguments={**route["fixed_arguments"], route["parameter"]: value}, request_id=request_id) + + def logs(self): + with self.__host._lock: + return _omnis_copy.deepcopy(self.__host._logs[self.__principal]) + + +def write_metrohm_omnis_runtime_reports(output_directory): + import datetime + import importlib.util + import io + import pathlib + import platform + import unittest + root = pathlib.Path(__file__).resolve().parents[1] + spec = importlib.util.spec_from_file_location("test_basic40_measure_omnis", root / "tests/test_basic40_measure.py") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + stream = io.StringIO() + result = unittest.TextTestRunner(stream=stream, verbosity=2).run(unittest.defaultTestLoader.loadTestsFromTestCase(module.MetrohmOmnisRuntimeTests)) + metadata = export_metrohm_omnis_contract_metadata() + report = {"catalog_id": "CHEM-101", "checked_at": datetime.datetime.now(datetime.timezone.utc).isoformat(), + "environment": {"python": platform.python_version(), "platform": platform.platform(), "runtime": "standard-library Python; synthetic fixtures; no Blender"}, + "method": "unittest: all 12 APIs and schemas/effects; synthetic endpoint and dynamic titration, dose quantization, stable hold, content, partial stop, host time partition equivalence, range rejection, atomic failure, scoped visibility, request deduplication, instance isolation and scene callbacks", + "tests_run": result.testsRun, "failures": len(result.failures), "errors": len(result.errors), "result": "passed" if result.wasSuccessful() else "failed", + "passed_capabilities": sorted(metadata["asset_types"][METROHM_OMNIS_TYPE]["capabilities"]) if result.wasSuccessful() else [], + "output": stream.getvalue(), "not_run": ["real_hardware", "robot_execution", "contact_solver", "Blender_evaluated_pose", "process_filesystem_security_isolation", "manufacturer_calibration_accuracy", "redox_complexometric_weak_acid_response", "real_response_noise_fault_probability"], + "scene_scope": "Only snapshot and recording/failing callbacks tested; parent provides evaluated Blender scene verification separately.", "synthetic": True} + directory = pathlib.Path(output_directory) + directory.mkdir(parents=True, exist_ok=True) + for name, value in (("runtime_validation.json", report), ("runtime_metadata.json", metadata)): + (directory / name).write_text(_omnis_json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report +# END CHEM-101 METROHM OMNIS APPEND-ONLY RUNTIME + + +# CHEM-101 append-only numeric-domain guards and contract mechanism declarations. +_omnis_export_base = export_metrohm_omnis_contract_metadata + + +def export_metrohm_omnis_contract_metadata(): + metadata = _omnis_export_base() + params = metadata["asset_types"][METROHM_OMNIS_TYPE]["parameters"] + def props(*names): + result = {name: _omnis_copy.deepcopy(params[name]) for name in names} + for prop in result.values(): + prop["evidence"] = {"catalog": "documented", "engineering_assumption": "assumption"}.get(prop["evidence"], prop["evidence"]) + return result + metadata["mechanisms"] = { + "ideal_acid_base_potentiometry": { + "component_ids": ["electrode_slot", "titration_cell_slot", "dosing_module"], + "state_ids": ["truth.acid_moles", "truth.volume_m3", "truth.temperature_k", "truth.reference_ph", "truth.reference_potential_v", "titrant.concentration_mol_m3", "dosing.delivered_volume_m3", "measurement.ph", "measurement.potential_v"], + "meaning_zh": "engineering_assumption：单元强酸强碱电中性/水离解理想响应及Nernst电位；所有输出synthetic。", + "implementation": "numerical", "equations": metadata["engineering_equations"][:2], + "parameters": props("water_ionic_product", "potential_range_v", "electrode_response_time", "sample_noise", "calibration_accuracy"), + "source_ids": ["runtime_code", "workbook_parameters"], + "limitations": ["固定Kw的25°C近似，仅Nernst斜率含显式温度；无活度、弱酸、氧化还原、络合和真实动力学。", "严格超过整机±2.4V时输出null并停止，不做限幅伪装读数；不声称厂家准确度。"]}, + "quantized_dosing_and_stirring": { + "component_ids": ["dosing_module", "cylinder_slot", "piston_proxy", "stir_bar"], + "state_ids": ["dosing.cylinder_volume_m3", "dosing.quantum_m3", "dosing.rate_m3_s", "dosing.delivered_volume_m3", "dosing.piston_fraction", "stirring.angular_speed_rad_s", "stirring.angle_rad"], + "meaning_zh": "engineering_assumption：表列每缸100000步作为整数体积格点；宿主时钟推进恒定速率加液并积分搅拌角。", + "implementation": "numerical", "equations": [metadata["engineering_equations"][2]], + "parameters": props("cylinder_volumes_m3", "steps_per_cylinder", "maximum_stirring_speed_rad_s", "manufacturer_max_flow_rate", "mixing_time_constant", "cylinder_actual_stroke"), + "source_ids": ["runtime_code", "workbook_parameters"], + "limitations": ["单缸实验无补液和实际物质转移；host_load_sample仅显式重置合成实验。", "活塞占比为示意模型映射，不代表实际缸行程；搅拌未模拟磁耦合/失步/液体动力学。"]}, + "stable_curve_and_endpoint": { + "component_ids": ["electrode_slot", "titration_cell_slot", "dosing_module"], + "state_ids": ["method.mode", "method.dose_increment_m3", "method.maximum_volume_m3", "method.endpoint_potential_v", "stability.hold_s", "stability.tolerance_v", "stability.stable", "titration.curve", "titration.endpoint_volume_m3", "titration.content_mol_m3"], + "meaning_zh": "engineering_assumption：停液后的显式稳定窗口采点，固定目标电位线性插值或动态有限差分峰值估算终点。", + "implementation": "numerical", "equations": ["stable=(max(E over hold window)-min(E over hold window)<=user tolerance); ideal instantaneous mixing keeps E constant while dosing is stopped", *metadata["engineering_equations"][3:]], + "parameters": props("dynamic_target_delta_v", "dynamic_peak_fraction", "max_curve_points", "fault_probability"), + "source_ids": ["runtime_code", "workbook_parameters"], + "limitations": ["动态方法为可复现教学算法，未复现Metrohm固件；终点可能因剂量上限/点数上限未找到，此时为null。", "结果仅基于代理可观察曲线；计算含量使用调用者明确给出的样品体积、滴定剂浓度和计量比。"]}} + metadata["limitations"].append("Finite numeric representability is checked at host boundaries; changing cylinder preserves the integer-step consistency of an already configured method.") + return metadata + + +class MetrohmOmnisRuntime(MetrohmOmnisRuntime): + """Append-only hardening of the CHEM-101 host; public signature unchanged.""" + def host_step(self, time_s): + with self._lock: + if not _omnis_finite(time_s) or time_s < self.time_s: + raise ValueError("Finite monotonic absolute host time required") + delta = time_s - self.time_s + if not _omnis_finite(delta) or any(inst["power"] and not _omnis_finite(inst["speed"] * delta) for inst in self._instances.values()): + raise ValueError("Step rotation exceeds finite numeric domain") + return super().host_step(time_s) + + +class MetrohmOmnisSession(MetrohmOmnisSession): + """Append-only cylinder/method consistency guard; identity policy unchanged.""" + def _checked(self, instance_id, inst, cap, args, request_id): + if cap == "dosing.configure_cylinder" and set(args) == {"volume_m3"} and _omnis_finite(args["volume_m3"]) and args["volume_m3"] in METROHM_OMNIS_CYLINDERS_M3 and inst["method"] is not None: + quantum = args["volume_m3"] / METROHM_OMNIS_STEPS_PER_CYLINDER + for key in ("dose_increment_m3", "maximum_volume_m3"): + steps = inst["method"][key] / quantum + if steps < 1 or abs(steps - round(steps)) > 1e-7: + return self._error(instance_id, "PRECONDITION_FAILED", request_id) + return super()._checked(instance_id, inst, cap, args, request_id) + +# BEGIN CHEM-068 MAGRITEK SPINSOLVE 80 APPEND-ONLY RUNTIME +import copy as _sp80_copy +import cmath as _sp80_cmath +import hashlib as _sp80_hashlib +import json as _sp80_json +import math as _sp80_math +import threading as _sp80_threading +from datetime import datetime as _sp80_datetime, timezone as _sp80_timezone +from pathlib import Path as _sp80_Path + +MAGRIΤEK_SPINSOLVE80_RESERVED = None # Names below use ASCII identifiers. +SPINSOLVE80_TYPE = "instrument.magritek_spinsolve80" +SPINSOLVE80_SCENE_KEYS = ("power.enabled", "slot.sample_tube.connection_id", "sample.insertion_fraction", "acquisition.running", "acquisition.progress", "display.text") + + +def _sp80_number(value): + try: + return type(value) in (int, float) and _sp80_math.isfinite(value) + except (TypeError, OverflowError): + return False + + +def _sp80_num(unit, lo=None, hi=None, *, integer=False, positive=False, nullable=False): + result = {"type": "integer" if integer else "number", "x-unit": unit} + if lo is not None: + result["minimum"] = lo + if hi is not None: + result["maximum"] = hi + if positive: + result["exclusiveMinimum"] = 0 + return {"anyOf": [result, {"type": "null"}]} if nullable else result + + +def _sp80_obj(properties): + return {"type": "object", "properties": properties, "required": list(properties), "additionalProperties": False} + + +def _sp80_nullable(schema): + return {"anyOf": [schema, {"type": "null"}]} + + +def _sp80_matches(schema, value): + if "anyOf" in schema: + return any(_sp80_matches(s, value) for s in schema["anyOf"]) + typ = schema.get("type") + if typ in ("number", "integer"): + if not _sp80_number(value) or (typ == "integer" and type(value) is not int): + return False + elif typ == "object": + if not isinstance(value, dict) or set(value) != set(schema["properties"]): + return False + return all(_sp80_matches(s, value[k]) for k, s in schema["properties"].items()) + elif typ == "array": + return isinstance(value, list) and schema.get("minItems", 0) <= len(value) <= schema.get("maxItems", 100000) and all(_sp80_matches(schema["items"], v) for v in value) + elif typ == "boolean" and type(value) is not bool: + return False + elif typ == "string" and (not isinstance(value, str) or not schema.get("minLength", 0) <= len(value) <= schema.get("maxLength", 100000)): + return False + elif typ == "null" and value is not None: + return False + if "const" in schema and (type(value) is not type(schema["const"]) or value != schema["const"]): + return False + if "enum" in schema and value not in schema["enum"]: + return False + return all(value >= schema[k] if k == "minimum" else value <= schema[k] if k == "maximum" else value > schema[k] for k in ("minimum", "maximum", "exclusiveMinimum") if k in schema) + + +def export_magritek_spinsolve80_contract_metadata(): + """Contract-ready type metadata, with no runtime sample values or fixtures.""" + boolean, synthetic = {"type": "boolean"}, {"type": "boolean", "const": True} + identifier = {"type": "string", "minLength": 1, "maxLength": 128} + nucleus = {"type": "string", "enum": ["1H", "13C"]} + status = {"type": "string", "enum": ["idle", "running", "completed", "stopped"]} + method = {"nucleus": nucleus, "pulse_sequence": {"type": "string", "enum": ["single_pulse"]}, + "scans": _sp80_num("1", 1, 4096, integer=True), "relaxation_delay_s": _sp80_num("s", 0, 86400), + "acquisition_time_s": _sp80_num("s", 0.001, 60), "points": _sp80_num("1", 32, 512, integer=True), + "decoupling": boolean, "gradient_enabled": boolean} + fid = {"type": "array", "maxItems": 512, "items": _sp80_obj({"time_s": _sp80_num("s", 0), "real": _sp80_num("1"), "imaginary": _sp80_num("1"), "synthetic": synthetic})} + spectrum = {"type": "array", "maxItems": 512, "items": _sp80_obj({"frequency_offset_hz": _sp80_num("Hz"), "real": _sp80_num("1"), "imaginary": _sp80_num("1"), "amplitude": _sp80_num("1", 0), "synthetic": synthetic})} + resonance = _sp80_obj({"frequency_offset_hz": _sp80_num("Hz", -1e6, 1e6), "amplitude": _sp80_num("1", 0, 1e6), "t2_s": _sp80_num("s", 1e-6, 1e6)}) + peaks = {"type": "array", "maxItems": 32, "items": resonance} + fixture = _sp80_obj({"1H": peaks, "13C": peaks}) + registered = {"type": "array", "maxItems": 64, "items": _sp80_obj({"sample_id": identifier, "signals": fixture})} + slots = {} + def slot(sid, schema, unit, origin, text, components, *, visibility="agent", write=None, sampling="instant"): + slots[sid] = {"component_ids": components, "value_schema": schema, "unit": unit, "reference_conditions": None, + "meaning_zh": text, "origin": origin, "access": "read_write" if write else "read_only", "visibility": visibility, + "read_binding": {"backend": "process", "artifact_id": "runtime_code", "accessor": "MagritekSpinsolve80Session.read(instance_id=..., state_ids=['" + sid + "'])"}, + "write_via": write, "sampling": {"mode": sampling, "time_domain": "simulation", "window_description": "已完成扫描的无噪声平均信号。" if sampling == "series" else None}, "source_ids": ["runtime_code"]} + slot("power.enabled", boolean, "1", "setpoint", "逻辑电源；关闭时停止采集并保留已完成扫描。", ["housing"], write={"capability_id": "power.set", "argument": "enabled", "fixed_arguments": {}}) + slot("slot.sample_tube.connection_id", _sp80_nullable(identifier), "1", "scene", "唯一管槽的宿主注册样品标识；不暴露样品信号真值。", ["sample_port", "sample_tube"]) + slot("sample.insertion_fraction", _sp80_num("1", 0, 1), "1", "scene", "放样为1、移除为0；几何插入深度另以假设声明，不是厂家行程。", ["sample_tube"]) + for key, schema in method.items(): + slot("method." + key, _sp80_nullable(schema), schema.get("x-unit", "1"), "setpoint", "用户显式合成采集设置；资源范围为engineering_assumption，不是厂家规格。", ["magnet_module"]) + slot("method.carrier_frequency_hz", _sp80_num("Hz", nullable=True), "Hz", "derived", "1H载频为清单80 MHz；13C载频未知为null，合成横轴始终用Hz偏移。", ["magnet_module"]) + for sid, schema, unit, text in (("acquisition.status", status, "1", "采集状态；完成不代表真实仪器采集。"), ("acquisition.running", boolean, "1", "宿主时间推进的合成采集是否运行。"), ("acquisition.progress", _sp80_num("1", 0, 1), "1", "本次采集计划的时间完成比例。"), ("acquisition.completed_scans", _sp80_num("1", 0, 4096, integer=True), "1", "已完整结束的扫描数量；未完成扫描不输出伪完整数据。"), ("acquisition.elapsed_s", _sp80_num("s", 0), "s", "宿主推进后的本次采集耗时。"), ("measurement.sample_time_s", _sp80_num("s", 0, nullable=True), "s", "最近完整扫描的结束时刻。"), ("measurement.synthetic", synthetic, "1", "FID、1D频谱与积分全部为synthetic。")): + slot(sid, schema, unit, "derived", text, ["magnet_module"]) + slot("measurement.fid", fid, "1", "derived", "阻尼复正弦叠加的合成FID；信号幅值无量纲。", ["magnet_module"], sampling="series") + slot("measurement.spectrum", spectrum, "1", "derived", "对合成FID执行归一化DFT的1D频谱；频率偏移单位Hz，幅值无量纲。", ["magnet_module"], sampling="series") + slot("measurement.integral_hz", _sp80_num("Hz", 0, nullable=True), "Hz", "derived", "按指定频带对幅度做分段线性积分；不是核数、浓度或定量核磁结果。", ["control_panel"]) + slot("display.text", {"type": "string"}, "1", "derived", "状态标签，始终带SYNTHETIC；未新增厂商自带屏幕主张。", ["control_panel"]) + slot("truth.registered_samples", registered, "1", "process_truth", "宿主专有合成样品表；代理describe/read/invoke/logs/scene均不含这些真值。", ["sample_port"], visibility="debug", sampling="static") + reset = ["acquisition.status", "acquisition.running", "acquisition.progress", "acquisition.completed_scans", "acquisition.elapsed_s", "measurement.sample_time_s", "measurement.fid", "measurement.spectrum", "measurement.integral_hz", "display.text"] + example = {"nucleus": "1H", "pulse_sequence": "single_pulse", "scans": 2, "relaxation_delay_s": 1, "acquisition_time_s": 0.5, "points": 64, "decoupling": False, "gradient_enabled": False} + defs = { + "power.set": ("device_command", {"enabled": boolean}, {"enabled": boolean}, {"enabled": True}, ["housing", "control_panel"], ["power.enabled", "acquisition.running", "acquisition.status", "display.text"], "设置逻辑电源，关闭保留已完成扫描。", "实例存在。"), + "sample.insert": ("configuration", {"sample_id": identifier}, {"sample_id": identifier, "insertion_fraction": _sp80_num("1", 0, 1)}, {"sample_id": "sample_01"}, ["sample_port", "sample_tube"], ["slot.sample_tube.connection_id", "sample.insertion_fraction"] + reset, "将已由宿主注册的样品放入唯一逻辑管槽，示意场景同步由宿主适配器执行。", "槽为空、未采集、样品在本实例宿主注册表内；不执行真实机械插入。"), + "sample.remove": ("configuration", {}, {"sample_id": _sp80_nullable(identifier), "insertion_fraction": _sp80_num("1", 0, 1)}, {}, ["sample_port", "sample_tube"], ["slot.sample_tube.connection_id", "sample.insertion_fraction"] + reset, "清空逻辑槽及当前运行结果；不从世界删除样品。", "未采集。"), + "acquisition.configure": ("configuration", method, method, example, ["magnet_module", "control_panel"], ["method." + k for k in method] + ["method.carrier_frequency_hz"] + reset, "显式配置1H/13C单脉冲合成采集；解耦或梯度启用明确拒绝。", "未采集；所有数值有限且满足计算资源范围；decoupling和gradient_enabled须为false。"), + "acquisition.start": ("device_command", {}, {"status": status, "synthetic": synthetic}, {}, ["magnet_module", "control_panel"], reset, "启动采集计划；调用不推进时间，也不立即生成FID。", "逻辑供电、已插样、完整方法齐备、未运行；选定核的宿主信号存在且位于Nyquist范围内。"), + "acquisition.stop": ("device_command", {}, {"status": status, "completed_scans": _sp80_num("1", 0, 4096, integer=True), "synthetic": synthetic}, {}, ["magnet_module", "control_panel"], ["acquisition.running", "acquisition.status", "display.text"], "停止采集，保留已完整扫描及耗时；未完成扫描丢弃，不伪称完成。", "实例存在；未运行时为无操作。"), + "nmr.read_fid": ("query", {}, {"samples": fid, "completed_scans": _sp80_num("1", 0, 4096, integer=True), "status": status, "synthetic": synthetic}, {}, ["magnet_module"], [], "读取已有合成FID，不推进时间、不读取隐藏样品参数。", "实例存在；尚无完整扫描时数组为空。"), + "nmr.read_spectrum": ("query", {}, {"samples": spectrum, "nucleus": _sp80_nullable(nucleus), "carrier_frequency_hz": _sp80_num("Hz", nullable=True), "status": status, "synthetic": synthetic}, {}, ["magnet_module"], [], "读取已有1D合成DFT谱；不提供2D谱或结构约束。", "实例存在；尚无完整扫描时数组为空。"), + "nmr.integrate": ("analysis", {"frequency_min_hz": _sp80_num("Hz"), "frequency_max_hz": _sp80_num("Hz")}, {"integral_hz": _sp80_num("Hz", 0), "synthetic": synthetic}, {"frequency_min_hz": -10, "frequency_max_hz": 10}, ["control_panel"], ["measurement.integral_hz"], "对已观察到的合成频谱幅度执行梯形积分，不使用样品真值。", "已有完整扫描，积分下限小于上限，且整个区间在已采谱范围内。")} + caps = {} + error_texts = {"UNKNOWN_INSTANCE": "实例不可用。", "UNKNOWN_CAPABILITY": "能力不可用。", "INVALID_ARGUMENT": "参数结构、类型或有限数值范围无效。", "ACCESS_DENIED": "访问策略拒绝。", "PRECONDITION_FAILED": "样品、方法或运行状态前提未满足。", "BUSY": "采集正在运行。", "UNSUPPORTED": "当前模型未实现所选解耦或梯度功能。", "REQUEST_CONFLICT": "同一请求标识被用于不同参数。", "DEVICE_ERROR": "场景适配器失败；过程未提交，外部场景可能已有部分变化。"} + for name, (kind, inp, out, ex, components, effects, description, pre) in defs.items(): + scene = any(k in SPINSOLVE80_SCENE_KEYS for k in effects) + caps[name] = {"function_zh": description, "kind": kind, "visibility": "agent", "component_ids": components, "availability": "implemented", + "input_schema": _sp80_obj(inp), "output_schema": _sp80_obj(out), + "implementation": {"process": "implemented", "scene": "declared" if scene else "not_applicable", "robot": "absent", "hardware": "absent", "host": "implemented"}, + "binding": {"backend": "process", "artifact_id": "runtime_code", "entrypoint": "MagritekSpinsolve80Session.invoke", "invocation": "session.invoke(instance_id='spinsolve_01', capability_id='" + name + "', arguments=" + repr(ex) + ", request_id='unique_request')"}, + "preconditions": [{"description_zh": pre, "state_ids": [], "enforced_by": "runtime", "check": "MagritekSpinsolve80Session._checked validates schema and preconditions before committing."}], + "state_effects": [{"state_id": k, "description_zh": description, "timing": "immediate"} for k in dict.fromkeys(effects)], + "observes": [k for k in effects if k != "measurement.synthetic"], + "model_effects": {"mode": "host_required" if scene else "none", "binding_ids": [], "description_zh": "可选scene_adapter接收六个允许的场景键；实际几何求值另验。" if scene else "纯查询或数值分析，无可见几何变化。"}, + "execution": {"mode": "synchronous", "time_domain": "simulation", "completion_criterion": "命令同步提交；acquisition.start只表示计划启动，完成须宿主推进至acquisition.status=completed。", "completion_state_ids": ["acquisition.status"] if name.startswith("acquisition.") else [], "timeout_s": None, "cancellation": "unsupported", "retry": "same_request_id", "resources": ["instance.acquisition"], "partial_failure_zh": "拒绝不改过程；scene_adapter失败可能留下外部场景部分效果。acquisition.stop保留已完成扫描。"}, + "errors": [{"code": code, "meaning_zh": text, "side_effects": "unknown" if code == "DEVICE_ERROR" else "none"} for code, text in error_texts.items()], "example_arguments": [ex], "verification": []} + def prop(value, unit, evidence, text): + return {"value": value, "unit": unit, "meaning_zh": text, "evidence": evidence, "source_ids": ["workbook_parameters"] if evidence == "documented" else ["runtime_code"], "uncertainty": None} + parameters = {"proton_carrier_frequency_hz": prop(80e6, "Hz", "documented", "清单1H频率80MHz；不代表部件工作响应。"), + "carbon_carrier_frequency_hz": prop(None, "Hz", "unknown", "清单未给13C载频，保持null。"), "fwhm_specification_hz": prop(0.4, "Hz", "documented", "Classic整机半高线宽严格小于0.4Hz；不用于生成合成T2。"), + "tail_linewidth_specification_hz": prop(16, "Hz", "documented", "Classic整机0.55%峰高线宽严格小于16Hz；不作为合成响应参数。"), "sensitivity_ratio_lower_bound": prop(200, "1", "documented", "整机双通道1H灵敏度>200:1，条件1%乙苯；未实现噪声与灵敏度验证。"), + "max_points": prop(512, "1", "assumption", "engineering_assumption：本Python DFT计算资源上限，不是厂商规格。")} + for name, unit in (("manufacturer_pulse_duration_s", "s"), ("manufacturer_t1_s", "s"), ("manufacturer_t2_s", "s"), ("noise_amplitude", "1"), ("calibration_accuracy_hz", "Hz"), ("fault_probability", "1")): + parameters[name] = prop(None, unit, "unknown", "清单未提供真实响应证据；保持null。") + limitations = ["所有FID、1D频谱与数值积分均为synthetic；工程假设教学模型不能声称复现Spinsolve响应、Classic线宽、灵敏度或真实测量。", "只实现1H/13C单脉冲1D、宿主显式扫描计时与无噪声平均；2D、耦合多重峰自动求解、解耦、梯度、结构约束、定量核磁、真实校准与故障概率未实现。", "每扫描耗时=用户弛豫延迟+用户采集时间；不模拟T1饱和恢复、脉冲时宽、接收器死区、磁场漂移或厂商固件。", "幅度任意且无量纲，积分单位Hz；积分不是浓度或核数。13C载频未知，不输出ppm横轴。", "样品槽仅逻辑关联；插入占比为示意映射，不执行机器人插入、接触或真实磁场作用。", "注册样品、共同绝对时钟由可信宿主管理；公开session过滤是API边界，不是同进程Python或文件系统沙箱。请求幂等缓存仅在内存中。", "可选scene_adapter失败时过程不提交；外部场景可能已部分修改，需宿主协调恢复。"] + mechanisms = {"synthetic_nmr_signal": {"component_ids": ["magnet_module", "sample_port"], "state_ids": ["truth.registered_samples", "method.nucleus", "method.acquisition_time_s", "method.points", "measurement.fid", "measurement.spectrum", "measurement.integral_hz"], "meaning_zh": "engineering_assumption：阻尼复正弦合成FID、归一化DFT和观测频带积分；全部输出synthetic。", "implementation": "numerical", "equations": ["FID[n]=sum(A_j*exp(-t_n/T2_j)*exp(i*2*pi*f_j*t_n)); t_n=n*T_acq/N", "S[k]=sum(FID[n]*exp(-i*2*pi*k*n/N))/N; f_k=(k-floor(N/2))/T_acq", "integral=piecewise-linear trapezoid integral of abs(S) over explicit observed frequency interval"], "parameters": parameters, "source_ids": ["runtime_code", "workbook_parameters"], "limitations": limitations[:4]}, + "host_timed_scanning": {"component_ids": ["magnet_module", "control_panel"], "state_ids": ["method.scans", "method.relaxation_delay_s", "method.acquisition_time_s", "acquisition.elapsed_s", "acquisition.completed_scans", "acquisition.progress", "acquisition.status"], "meaning_zh": "engineering_assumption：由共享宿主绝对时钟推进离散完整扫描。", "implementation": "numerical", "equations": ["cycle=T_relax+T_acq; completed_scans=min(scans,floor((host_time-start_time)/cycle)); progress=min(1,elapsed/(scans*cycle))"], "parameters": {}, "source_ids": ["runtime_code"], "limitations": ["无自动世界推进；read/describe/query不推进时钟。", "未完成扫描不产生伪完整谱；取消保留已完成扫描。"]}} + return {"asset_types": {SPINSOLVE80_TYPE: {"catalog_id": "CHEM-068", "model": "Magritek | Spinsolve 80 Carbon", "asset_version": "1.0.0", "state_slots": slots, "capabilities": caps, "parameters": parameters}}, "mechanisms": mechanisms, "scene_snapshot_keys": list(SPINSOLVE80_SCENE_KEYS), "limitations": limitations, + "host_capabilities": {"sim.host_step": {"kind": "simulation", "visibility": "trusted_host_only", "binding": "MagritekSpinsolve80Runtime.host_step(time_s)", "state_effects": reset}, "sim.register_sample": {"kind": "simulation", "visibility": "trusted_host_only", "binding": "MagritekSpinsolve80Runtime.register_sample(instance_id, sample_id, signals)", "state_effects": ["truth.registered_samples"]}}, "host_sample_schema": fixture} + + +class MagritekSpinsolve80Runtime: + """Trusted host. Distribute a scoped Session to agents, never this object.""" + def __init__(self, *, scene_adapter=None): + self.time_s, self.scene_adapter = 0.0, scene_adapter + self._instances, self._principals, self._requests, self._logs = {}, {}, {}, {} + self._lock = _sp80_threading.RLock() + self._metadata = export_magritek_spinsolve80_contract_metadata() + self.register_principal("__public_agent__", visibility="agent") + self._agent = self.session("__public_agent__") + + def create_instance(self, instance_id, asset_type_id=SPINSOLVE80_TYPE): + with self._lock: + if not isinstance(instance_id, str) or not 1 <= len(instance_id) <= 128 or instance_id in self._instances or asset_type_id != SPINSOLVE80_TYPE: + raise ValueError("Unique instance id and supported asset type required") + inst = {"revision": 0, "power": False, "sample_id": None, "method": None, "samples": {}} + self._reset(inst) + if self.scene_adapter: + self.scene_adapter(instance_id, self._scene(inst)) + self._instances[instance_id] = inst + + @staticmethod + def _reset(inst): + inst.update({"running": False, "status": "idle", "progress": 0.0, "completed_scans": 0, "elapsed": 0.0, "started_at": None, "sample_time": None, "fid": [], "spectrum": [], "integral": None}) + + def register_principal(self, principal_id, *, visibility, instance_ids=None): + with self._lock: + if not isinstance(principal_id, str) or not principal_id or principal_id in self._principals or visibility not in ("agent", "debug", "evaluator"): + raise ValueError("Invalid trusted principal registration") + if instance_ids is not None and (not isinstance(instance_ids, (list, tuple, set, frozenset)) or any(not isinstance(i, str) for i in instance_ids)): + raise ValueError("Invalid instance scope") + scope = None if instance_ids is None else frozenset(instance_ids) + if scope is not None and not scope <= self._instances.keys(): + raise ValueError("Unknown instance scope") + self._principals[principal_id], self._logs[principal_id] = (visibility, scope), [] + + def session(self, principal_id): + if principal_id not in self._principals: + raise ValueError("Trusted registration required") + return MagritekSpinsolve80Session(self, principal_id) + + def describe(self, **kwargs): + return self._agent.describe(**kwargs) + + def read(self, **kwargs): + return self._agent.read(**kwargs) + + def invoke(self, **kwargs): + return self._agent.invoke(**kwargs) + + def write(self, **kwargs): + return self._agent.write(**kwargs) + + def describe_host(self): + return _sp80_copy.deepcopy(self._metadata["host_capabilities"]) + + def register_sample(self, instance_id, sample_id, signals): + with self._lock: + if instance_id not in self._instances or not isinstance(sample_id, str) or not 1 <= len(sample_id) <= 128 or not _sp80_matches(self._metadata["host_sample_schema"], signals): + raise ValueError("Invalid instance, sample identifier or finite synthetic signal schema") + inst = self._instances[instance_id] + if sample_id in inst["samples"] or len(inst["samples"]) >= 64 or inst["running"]: + raise ValueError("Sample registration unavailable") + inst["samples"][sample_id] = _sp80_copy.deepcopy(signals) + inst["revision"] += 1 + + @staticmethod + def _display(inst): + return "SYNTHETIC " + ("OFF" if not inst["power"] else inst["status"].upper()) + " %d SCANS" % inst["completed_scans"] + + @classmethod + def _scene(cls, inst): + return {"power.enabled": inst["power"], "slot.sample_tube.connection_id": inst["sample_id"], "sample.insertion_fraction": 1.0 if inst["sample_id"] is not None else 0.0, "acquisition.running": inst["running"], "acquisition.progress": inst["progress"], "display.text": cls._display(inst)} + + def scene_snapshot(self, instance_id): + with self._lock: + return _sp80_copy.deepcopy(self._scene(self._instances[instance_id])) + + def apply_scene(self, instance_id): + with self._lock: + if self.scene_adapter is None: + raise RuntimeError("No scene_adapter is configured") + snapshot = self.scene_snapshot(instance_id) + self.scene_adapter(instance_id, _sp80_copy.deepcopy(snapshot)) + return snapshot + + @classmethod + def _values(cls, inst): + values = cls._scene(inst) + config = inst["method"] or {} + for key in ("nucleus", "pulse_sequence", "scans", "relaxation_delay_s", "acquisition_time_s", "points", "decoupling", "gradient_enabled"): + values["method." + key] = config.get(key) + values.update({"method.carrier_frequency_hz": 80e6 if config.get("nucleus") == "1H" else None, "acquisition.status": inst["status"], "acquisition.completed_scans": inst["completed_scans"], "acquisition.elapsed_s": inst["elapsed"], "measurement.sample_time_s": inst["sample_time"], "measurement.synthetic": True, "measurement.fid": inst["fid"], "measurement.spectrum": inst["spectrum"], "measurement.integral_hz": inst["integral"], "truth.registered_samples": [{"sample_id": k, "signals": v} for k, v in sorted(inst["samples"].items())]}) + return _sp80_copy.deepcopy(values) + + @staticmethod + def _signal(inst): + method = inst["method"] + n, duration = method["points"], method["acquisition_time_s"] + peaks = inst["samples"][inst["sample_id"]][method["nucleus"]] + samples, fid = [], [] + for j in range(n): + t = j * duration / n + y = sum(p["amplitude"] * _sp80_cmath.exp(complex(-t / p["t2_s"], 2 * _sp80_math.pi * p["frequency_offset_hz"] * t)) for p in peaks) + samples.append(y) + fid.append({"time_s": t, "real": y.real, "imaginary": y.imag, "synthetic": True}) + spectrum = [] + for k in range(-(n // 2), n - n // 2): + value = sum(samples[j] * _sp80_cmath.exp(-2j * _sp80_math.pi * k * j / n) for j in range(n)) / n + spectrum.append({"frequency_offset_hz": k / duration, "real": value.real, "imaginary": value.imag, "amplitude": abs(value), "synthetic": True}) + return fid, spectrum + + def host_step(self, time_s): + """Advance this host's registered instances to shared absolute SI time.""" + with self._lock: + if not _sp80_number(time_s) or time_s < self.time_s: + raise ValueError("Finite monotonic absolute host time required") + if time_s == self.time_s: + return + staged = {} + for instance_id, old in self._instances.items(): + if not old["running"]: + continue + new = _sp80_copy.deepcopy(old) + cfg = new["method"] + cycle = cfg["relaxation_delay_s"] + cfg["acquisition_time_s"] + total = cfg["scans"] * cycle + elapsed = time_s - new["started_at"] + if not _sp80_number(elapsed): + raise ValueError("Host interval is not numerically representable") + new["elapsed"] = min(elapsed, total) + new["progress"] = new["elapsed"] / total + count = cfg["scans"] if elapsed >= total else min(cfg["scans"], int(elapsed / cycle)) + if count > old["completed_scans"]: + if not old["fid"]: + new["fid"], new["spectrum"] = self._signal(new) + new["completed_scans"] = count + new["sample_time"] = new["started_at"] + count * cycle + new["integral"] = None + if count == cfg["scans"]: + new["running"], new["status"] = False, "completed" + new["revision"] = old["revision"] + 1 + staged[instance_id] = new + if self.scene_adapter: + for iid, new in staged.items(): + if self._scene(new) != self._scene(self._instances[iid]): + self.scene_adapter(iid, self._scene(new)) + self._instances.update(staged) + self.time_s = float(time_s) + + +class MagritekSpinsolve80Session: + """Permission-scoped API view; not a Python object-capability sandbox.""" + def __init__(self, host, principal_id): + self.__host, self.__principal = host, principal_id + + def _instance(self, instance_id): + _, scope = self.__host._principals[self.__principal] + return self.__host._instances.get(instance_id) if isinstance(instance_id, str) and (scope is None or instance_id in scope) else None + + def _visible(self, slot): + return slot["visibility"] == "agent" or self.__host._principals[self.__principal][0] in ("debug", "evaluator") + + def _envelope(self, instance_id, request_id=None, *, status="succeeded", result=None, observations=None, error=None): + inst = self._instance(instance_id) + return {"protocol_version": "1.0.0", "instance_id": instance_id, "request_id": request_id, "operation_id": None, "status": status, "state_revision": inst["revision"] if inst else None, "clock": {"domain": "simulation", "time_s": self.__host.time_s}, "result": _sp80_copy.deepcopy(result or {}), "observations": _sp80_copy.deepcopy(observations or {}), "error": error} + + def _error(self, instance_id, code, request_id=None): + return self._envelope(instance_id, request_id, status="failed" if code == "DEVICE_ERROR" else "rejected", error={"code": code, "message": "Request unavailable under current arguments, state or access policy." if code != "DEVICE_ERROR" else "External scene synchronization failed; process not committed.", "retryable": False, "side_effects": "unknown" if code == "DEVICE_ERROR" else "none", "progress": None}) + + def describe(self, *, asset_type_id=None, instance_id=None): + with self.__host._lock: + if (asset_type_id is None) == (instance_id is None) or (asset_type_id is not None and asset_type_id != SPINSOLVE80_TYPE): + return self._error(instance_id, "INVALID_ARGUMENT") + if instance_id is not None and self._instance(instance_id) is None: + return self._error(instance_id, "UNKNOWN_INSTANCE") + _, scope = self.__host._principals[self.__principal] + if scope is not None and not scope: + return self._error(instance_id, "ACCESS_DENIED") + spec = _sp80_copy.deepcopy(self.__host._metadata["asset_types"][SPINSOLVE80_TYPE]) + spec["state_slots"] = {k: v for k, v in spec["state_slots"].items() if self._visible(v)} + return {"protocol_version": "1.0.0", "asset_type_id": SPINSOLVE80_TYPE, "instance_id": instance_id, "adapter": "basic40_runtime_measure.MagritekSpinsolve80Session", **spec, "limitations": _sp80_copy.deepcopy(self.__host._metadata["limitations"])} + + def read(self, *, instance_id, state_ids=None): + with self.__host._lock: + inst = self._instance(instance_id) + if inst is None: + return self._error(instance_id, "UNKNOWN_INSTANCE") + slots = self.__host._metadata["asset_types"][SPINSOLVE80_TYPE]["state_slots"] + if state_ids is None: + state_ids = [k for k, s in slots.items() if self._visible(s)] + if not isinstance(state_ids, list) or any(not isinstance(k, str) for k in state_ids) or len(set(state_ids)) != len(state_ids): + return self._error(instance_id, "INVALID_ARGUMENT") + if any(k not in slots or not self._visible(slots[k]) for k in state_ids): + return self._error(instance_id, "ACCESS_DENIED") + values = self.__host._values(inst) + observations = {k: {"value": values[k], "unit": slots[k]["unit"], "quality": "unavailable" if values[k] is None else "estimated" if slots[k]["origin"] == "derived" else "valid", "sample_time_s": inst["sample_time"] if k.startswith("measurement.") else self.__host.time_s, "sample_window_s": None, "synthetic": slots[k]["origin"] == "derived", "reason": "No available configured or synthetic value." if values[k] is None else None} for k in state_ids} + return self._envelope(instance_id, observations=observations) + + def invoke(self, *, instance_id, capability_id, arguments, request_id): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if inst is None: + return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) + if not isinstance(capability_id, str) or not isinstance(arguments, dict) or not isinstance(request_id, str) or not 1 <= len(request_id) <= 256: + return self._error(instance_id, "INVALID_ARGUMENT", request_id) + try: + digest = _sp80_hashlib.sha256(_sp80_json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False).encode()).hexdigest() + except (TypeError, ValueError, OverflowError): + return self._error(instance_id, "INVALID_ARGUMENT", request_id) + key = self.__principal, instance_id, request_id + if key in host._requests: + old_digest, response = host._requests[key] + return _sp80_copy.deepcopy(response) if old_digest == digest else self._error(instance_id, "REQUEST_CONFLICT", request_id) + response = self._checked(instance_id, inst, capability_id, arguments, request_id) + host._requests[key] = digest, _sp80_copy.deepcopy(response) + host._logs[self.__principal].append({"instance_id": instance_id, "capability_id": capability_id, "request_id": request_id, "response": _sp80_copy.deepcopy(response)}) + return response + + def _checked(self, instance_id, inst, cap, args, request_id): + host = self.__host + definition = host._metadata["asset_types"][SPINSOLVE80_TYPE]["capabilities"].get(cap) + if definition is None: + return self._error(instance_id, "UNKNOWN_CAPABILITY", request_id) + if not _sp80_matches(definition["input_schema"], args): + return self._error(instance_id, "INVALID_ARGUMENT", request_id) + if cap == "acquisition.configure" and (args["decoupling"] or args["gradient_enabled"]): + return self._error(instance_id, "UNSUPPORTED", request_id) + if inst["running"] and cap in ("sample.insert", "sample.remove", "acquisition.configure", "acquisition.start"): + return self._error(instance_id, "BUSY", request_id) + if cap == "sample.insert" and (inst["sample_id"] is not None or args["sample_id"] not in inst["samples"]): + return self._error(instance_id, "PRECONDITION_FAILED", request_id) + if cap == "acquisition.start": + cfg = inst["method"] + if not inst["power"] or inst["sample_id"] is None or cfg is None: + return self._error(instance_id, "PRECONDITION_FAILED", request_id) + signals = inst["samples"][inst["sample_id"]][cfg["nucleus"]] + nyquist = cfg["points"] / cfg["acquisition_time_s"] / 2 + if not signals or any(abs(p["frequency_offset_hz"]) >= nyquist for p in signals) or host.time_s + cfg["scans"] * (cfg["relaxation_delay_s"] + cfg["acquisition_time_s"]) <= host.time_s: + return self._error(instance_id, "PRECONDITION_FAILED", request_id) + if cap == "nmr.integrate": + a, b, spectrum = args["frequency_min_hz"], args["frequency_max_hz"], inst["spectrum"] + if not spectrum or not spectrum[0]["frequency_offset_hz"] <= a < b <= spectrum[-1]["frequency_offset_hz"]: + return self._error(instance_id, "PRECONDITION_FAILED", request_id) + new = _sp80_copy.deepcopy(inst) + if cap == "power.set": + new["power"] = args["enabled"] + if not new["power"] and new["running"]: + new["running"], new["status"] = False, "stopped" + result = {"enabled": new["power"]} + elif cap in ("sample.insert", "sample.remove"): + old_id = new["sample_id"] + new["sample_id"] = args["sample_id"] if cap == "sample.insert" else None + host._reset(new) + result = {"sample_id": new["sample_id"] if cap == "sample.insert" else old_id, "insertion_fraction": 1.0 if new["sample_id"] is not None else 0.0} + elif cap == "acquisition.configure": + new["method"] = _sp80_copy.deepcopy(args) + host._reset(new) + result = _sp80_copy.deepcopy(args) + elif cap == "acquisition.start": + host._reset(new) + new.update({"running": True, "status": "running", "started_at": host.time_s}) + result = {"status": "running", "synthetic": True} + elif cap == "acquisition.stop": + if new["running"]: + new["running"], new["status"] = False, "stopped" + result = {"status": new["status"], "completed_scans": new["completed_scans"], "synthetic": True} + elif cap == "nmr.read_fid": + result = {"samples": new["fid"], "completed_scans": new["completed_scans"], "status": new["status"], "synthetic": True} + elif cap == "nmr.read_spectrum": + result = {"samples": new["spectrum"], "nucleus": (new["method"] or {}).get("nucleus"), "carrier_frequency_hz": host._values(new)["method.carrier_frequency_hz"], "status": new["status"], "synthetic": True} + elif cap == "nmr.integrate": + integral = 0.0 + for p, q in zip(spectrum, spectrum[1:]): + x0, x1 = p["frequency_offset_hz"], q["frequency_offset_hz"] + lo, hi = max(x0, a), min(x1, b) + if hi <= lo: + continue + y0, y1 = p["amplitude"], q["amplitude"] + yl, yh = y0 + (y1 - y0) * (lo - x0) / (x1 - x0), y0 + (y1 - y0) * (hi - x0) / (x1 - x0) + integral += (yl + yh) * (hi - lo) / 2 + new["integral"] = integral + result = {"integral_hz": integral, "synthetic": True} + if new != inst: + new["revision"] = inst["revision"] + 1 + if host.scene_adapter and host._scene(new) != host._scene(inst): + try: + host.scene_adapter(instance_id, host._scene(new)) + except Exception: + return self._error(instance_id, "DEVICE_ERROR", request_id) + host._instances[instance_id] = new + return self._envelope(instance_id, request_id, result=result) + + def write(self, *, instance_id, state_id, value, request_id): + if state_id != "power.enabled": + return self._error(instance_id, "ACCESS_DENIED", request_id) + return self.invoke(instance_id=instance_id, capability_id="power.set", arguments={"enabled": value}, request_id=request_id) + + def logs(self): + with self.__host._lock: + return _sp80_copy.deepcopy(self.__host._logs[self.__principal]) + + +def write_magritek_spinsolve80_runtime_reports(output_directory): + """Write static type information only; never export instance sample truth.""" + directory = _sp80_Path(output_directory) + directory.mkdir(parents=True, exist_ok=True) + metadata = export_magritek_spinsolve80_contract_metadata() + (directory / "runtime_metadata.json").write_text(_sp80_json.dumps(metadata, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return {"metadata": str(directory / "runtime_metadata.json"), "catalog_id": "CHEM-068", "test_status": "not_run_by_report_writer", "generated_at": _sp80_datetime.now(_sp80_timezone.utc).isoformat()} +# END CHEM-068 MAGRITEK SPINSOLVE 80 APPEND-ONLY RUNTIME + +# CHEM-068 append-only contract normalization and exact decimal scan scheduling. +from decimal import Decimal as _sp80_Decimal +_sp80_export_contract_base = export_magritek_spinsolve80_contract_metadata + + +def export_magritek_spinsolve80_contract_metadata(): + metadata = _sp80_export_contract_base() + specs = metadata["asset_types"][SPINSOLVE80_TYPE]["capabilities"] + observes = { + "power.set": ["power.enabled"], + "sample.insert": ["slot.sample_tube.connection_id", "sample.insertion_fraction"], + "sample.remove": ["slot.sample_tube.connection_id", "sample.insertion_fraction"], + "acquisition.configure": ["method." + k for k in specs["acquisition.configure"]["input_schema"]["properties"]], + "acquisition.start": ["acquisition.status", "measurement.synthetic"], + "acquisition.stop": ["acquisition.status", "acquisition.completed_scans", "measurement.synthetic"], + "nmr.read_fid": ["measurement.fid", "acquisition.completed_scans", "acquisition.status", "measurement.synthetic"], + "nmr.read_spectrum": ["measurement.spectrum", "method.nucleus", "method.carrier_frequency_hz", "acquisition.status", "measurement.synthetic"], + "nmr.integrate": ["measurement.integral_hz", "measurement.synthetic"]} + for name, spec in specs.items(): + spec["example_arguments"] = spec["example_arguments"][0] + spec["source_ids"] = ["runtime_code"] + spec["limitations"] = ["synthetic工程假设；未执行真实仪器、机器人或接触验证。"] + spec["observes"] = observes[name] + metadata["mechanisms"]["synthetic_nmr_signal"]["equations"][1] = "S[k]=sum(FID[n]*exp(-i*2*pi*k*n/N))/N; k=-floor(N/2)..N-floor(N/2)-1; f_k=k/T_acq" + metadata["mechanisms"]["host_timed_scanning"]["limitations"].append("扫描边界以十进制输入时间计算，避免0.3/0.1等二进制舍入导致漏计扫描；信号与进度为浮点近似。") + return metadata + + +def _sp80_host_step_decimal(self, time_s): + """Host-only absolute time: decimal scan boundaries, no query-side stepping.""" + with self._lock: + if not _sp80_number(time_s) or time_s < self.time_s: + raise ValueError("Finite monotonic absolute host time required") + if time_s == self.time_s: + return + staged = {} + now = _sp80_Decimal(str(time_s)) + for iid, old in self._instances.items(): + if not old["running"]: + continue + new, cfg = _sp80_copy.deepcopy(old), old["method"] + start = _sp80_Decimal(str(new["started_at"])) + cycle = _sp80_Decimal(str(cfg["relaxation_delay_s"])) + _sp80_Decimal(str(cfg["acquisition_time_s"])) + total = cfg["scans"] * cycle + elapsed = now - start + bounded = min(elapsed, total) + count = cfg["scans"] if elapsed >= total else int(elapsed // cycle) + new["elapsed"], new["progress"] = float(bounded), float(bounded / total) + if count > old["completed_scans"]: + if not old["fid"]: + new["fid"], new["spectrum"] = self._signal(new) + new["completed_scans"] = count + new["sample_time"] = float(start + count * cycle) + new["integral"] = None + if count == cfg["scans"]: + new["running"], new["status"] = False, "completed" + new["revision"] = old["revision"] + 1 + staged[iid] = new + if self.scene_adapter: + for iid, new in staged.items(): + if self._scene(new) != self._scene(self._instances[iid]): + self.scene_adapter(iid, self._scene(new)) + self._instances.update(staged) + self.time_s = float(time_s) + + +MagritekSpinsolve80Runtime.host_step = _sp80_host_step_decimal +# Remove unused sentinel from the first append without rewriting shared content. +del MAGRIΤEK_SPINSOLVE80_RESERVED + +# BEGIN CHEM-160 RIGAKU MINIFLEX600 APPEND-ONLY RUNTIME +import copy as _mf_copy +import hashlib as _mf_hashlib +import json as _mf_json +import math as _mf_math +import threading as _mf_threading + +RIGAKU_MINIFLEX600_TYPE = "instrument.rigaku_miniflex600_external_cooling" +RIGAKU_MINIFLEX600_MIN_RAD = _mf_math.radians(-3) +RIGAKU_MINIFLEX600_MAX_RAD = _mf_math.radians(145) +RIGAKU_MINIFLEX600_STEP_RAD = _mf_math.radians(0.005) +RIGAKU_MINIFLEX600_DOOR_MAX_RAD = _mf_math.pi / 2 +RIGAKU_MINIFLEX600_MAX_POINTS = 29601 + + +def _mf_number(v): + try: + return type(v) in (int, float) and _mf_math.isfinite(v) + except (TypeError, ValueError, OverflowError): + return False + + +def _mf_num(unit, lo=None, hi=None, nullable=False, positive=False): + s = {"type": "number", "x-unit": unit} + if lo is not None: + s["minimum"] = lo + if hi is not None: + s["maximum"] = hi + if positive: + s["exclusiveMinimum"] = 0 + return {"anyOf": [s, {"type": "null"}]} if nullable else s + + +def _mf_obj(properties): + return {"type": "object", "properties": properties, "required": list(properties), "additionalProperties": False} + + +def _mf_matches(s, v): + if "anyOf" in s: + return any(_mf_matches(branch, v) for branch in s["anyOf"]) + typ = s.get("type") + if typ == "null": + return v is None + if typ == "object": + return isinstance(v, dict) and set(v) == set(s["properties"]) and all(_mf_matches(s["properties"][k], x) for k, x in v.items()) + if typ == "array": + return isinstance(v, list) and s.get("minItems", 0) <= len(v) <= s.get("maxItems", len(v)) and all(_mf_matches(s["items"], x) for x in v) + if typ in ("number", "integer"): + if not _mf_number(v) or (typ == "integer" and type(v) is not int): + return False + if ("minimum" in s and v < s["minimum"]) or ("maximum" in s and v > s["maximum"]) or ("exclusiveMinimum" in s and v <= s["exclusiveMinimum"]): + return False + elif typ == "boolean": + if type(v) is not bool: + return False + elif typ == "string": + if not isinstance(v, str) or len(v) < s.get("minLength", 0) or len(v) > s.get("maxLength", len(v)): + return False + else: + return False + return ("enum" not in s or v in s["enum"]) and ("const" not in s or v == s["const"]) + + +def _mf_grid(value, quantum): + ratio = value / quantum + return _mf_number(ratio) and abs(ratio - round(ratio)) <= 1e-7 + + +def export_rigaku_miniflex600_contract_metadata(): + """Static catalogue, API and approximation metadata; contains no instance truth.""" + boolean, synthetic = {"type": "boolean"}, {"type": "boolean", "const": True} + ident = {"type": "string", "minLength": 1, "maxLength": 256} + nullable_id = {"anyOf": [ident, {"type": "null"}]} + angle = _mf_num("rad", RIGAKU_MINIFLEX600_MIN_RAD, RIGAKU_MINIFLEX600_MAX_RAD) + status = {"type": "string", "enum": ["idle", "running", "completed", "stopped", "cooling_lost", "power_lost"]} + response_point = _mf_obj({"two_theta_rad": angle, "intensity_cps": _mf_num("1/s", 0)}) + response = {"type": "array", "items": response_point, "minItems": 2, "maxItems": RIGAKU_MINIFLEX600_MAX_POINTS} + point = _mf_obj({"two_theta_rad": angle, "intensity_cps": _mf_num("1/s", 0), "expected_counts": _mf_num("1", 0), + "sample_time_s": _mf_num("s", 0), "integration_time_s": _mf_num("s", positive=True), + "sample_window_s": {"type": "array", "items": _mf_num("s", 0), "minItems": 2, "maxItems": 2}, "synthetic": synthetic}) + pattern = {"type": "array", "items": point, "maxItems": RIGAKU_MINIFLEX600_MAX_POINTS} + slots = {} + def route(capability, parameter): + return {"capability_id": capability, "parameter": parameter, "fixed_arguments": {}} + def slot(sid, unit, origin, schema, text, component, write=None, visibility="agent", sampling="instant"): + slots[sid] = {"description_zh": text, "unit": unit, "origin": origin, "value_schema": schema, "component_ids": [component], + "visibility": visibility, "access": "read_write" if write else "read_only", "write_via": write, + "read_binding": "RigakuMiniFlex600Session.read(instance_id=..., state_ids=[state_id])", + "sampling": {"mode": sampling, "time_domain": "simulation", "window": "Each pattern point retains its explicit integration window." if sampling == "series" else "Last completed integration interval; returned as sample_window_s." if sampling == "interval_mean" else None}, + "reference_conditions": "SI rad; instrument-local joint convention, +Z up." if unit == "rad" else None} + slot("power.enabled", "1", "setpoint", boolean, "逻辑供电；非真实高压电源控制。", "housing", route("power.set", "enabled")) + slot("access.door_angle_rad", "rad", "scene", _mf_num("rad", 0, RIGAKU_MINIFLEX600_DOOR_MAX_RAD), "门关节；0为关闭，π/2展示上限为engineering_assumption。", "door", route("access.set_door_angle", "angle_rad")) + slot("slot.sample.connection_id", "1", "scene", nullable_id, "粉末平片或适配样品架的逻辑槽占用，不执行机器人插拔。", "sample_holder", route("slot.set_sample", "connection_id")) + slot("cooling.connection_id", "1", "scene", nullable_id, "外置循环水依赖连接，只可由宿主登记。", "cooling_ports") + slot("cooling.ready", "1", "derived", boolean, "宿主明确提供的循环水就绪信号，未模拟水温/流量传感器。", "cooling_ports") + slot("xray.voltage_v", "V", "setpoint", _mf_num("V", 20000, 40000, True), "20–40kV，1kV步长，尚未设置时null。", "xray_tube") + slot("xray.current_a", "A", "setpoint", _mf_num("A", 0.002, 0.015, True), "2–15mA，1mA步长，尚未设置时null。", "xray_tube") + slot("xray.power_w", "W", "derived", _mf_num("W", 0, 600, True), "设定管压×管流；600W为整机管源最大输出约束。", "xray_tube") + slot("xray.active", "1", "derived", boolean, "仅扫描时为真的逻辑射线使能；不模拟辐射场或屏蔽性能。", "xray_tube") + slot("slit.configuration_id", "1", "setpoint", nullable_id, "显式方法狭缝标签；数值孔径未知，未计算其展宽效应。", "slit_assembly", route("xrd.set_slit", "slit_id")) + slot("goniometer.two_theta_rad", "rad", "scene", angle, "2θ权威机械角，范围−3..145°、量化0.005°后以rad公开。", "goniometer", route("motion.set_two_theta", "angle_rad")) + slot("goniometer.sample_theta_rad", "rad", "derived", _mf_num("rad", RIGAKU_MINIFLEX600_MIN_RAD / 2, RIGAKU_MINIFLEX600_MAX_RAD / 2), "θ=2θ/2是engineering_assumption的理想耦合展示。", "sample_holder") + for key, unit, text, schema in (("start_rad", "rad", "起点", {"anyOf": [angle, {"type": "null"}]}), ("stop_rad", "rad", "终点", {"anyOf": [angle, {"type": "null"}]}), + ("step_rad", "rad", "步长", _mf_num("rad", RIGAKU_MINIFLEX600_STEP_RAD, nullable=True)), ("integration_time_s", "s", "显式积分时间，厂家范围未知", _mf_num("s", nullable=True, positive=True))): + slot("scan." + key, unit, "setpoint", schema, "用户配置扫描" + text + "。", "goniometer") + slot("scan.running", "1", "derived", boolean, "开始调用只置运行标志；采集仅在host_step推进。", "detector") + slot("scan.status", "1", "derived", status, "完成仅表示合成插值扫描已采集所有方法点。", "detector") + for name, text in (("completed_points", "已完成采集点数"), ("total_points", "配置方法的点数")): + slot("scan." + name, "1", "derived", {"type": "integer", "minimum": 0, "maximum": RIGAKU_MINIFLEX600_MAX_POINTS, "x-unit": "1"}, text + "；未积分完的点不计入。", "detector") + slot("measurement.pattern", "1", "derived", pattern, "仅已完成积分点的synthetic曲线；逐点含rad、1/s、期望计数与窗口，不含晶体学真实性声明。", "detector", sampling="series") + slot("measurement.last_intensity_cps", "1/s", "derived", _mf_num("1/s", 0, nullable=True), "最近完整积分窗口的synthetic平均计数率；没有数据时null。", "detector", sampling="interval_mean") + slot("measurement.synthetic", "1", "derived", synthetic, "所有输出结果均为synthetic。", "detector") + slot("truth.response", "1", "process_truth", {"anyOf": [response, {"type": "null"}]}, "宿主输入的合成响应网格，仅debug/evaluator可读。", "detector", visibility="debug") + slot("truth.sample_connection_id", "1", "process_truth", nullable_id, "宿主响应对应的样品槽身份；避免换样后沿用旧响应。", "sample_holder", visibility="debug") + scene_keys = ["power.enabled", "access.door_angle_rad", "slot.sample.connection_id", "goniometer.two_theta_rad", "goniometer.sample_theta_rad", "xray.active", "scan.running"] + reset_effects = ["scan.running", "scan.status", "scan.completed_points", "measurement.pattern", "measurement.last_intensity_cps", "xray.active"] + defs = { + "power.set": ({"enabled": boolean}, {"enabled": boolean}, {"enabled": True}, ["power.enabled", "scan.running", "scan.status", "xray.active"], ["housing", "xray_tube"], "设置逻辑电源；断电终止扫描并保留完整积分点。", [], "实例可用。"), + "access.set_door_angle": ({"angle_rad": _mf_num("rad", 0, RIGAKU_MINIFLEX600_DOOR_MAX_RAD)}, {"angle_rad": _mf_num("rad")}, {"angle_rad": 0.5}, ["access.door_angle_rad"], ["door"], "设置示意门角。", ["xray.active", "scan.running"], "扫描中拒绝开门；门角超出展示限位拒绝。"), + "slot.set_sample": ({"connection_id": nullable_id}, {"connection_id": nullable_id}, {"connection_id": "powder_holder_01"}, ["slot.sample.connection_id", "truth.response", "truth.sample_connection_id"] + reset_effects, ["sample_holder"], "登记样品槽连接；换样清除旧合成响应与旧曲线。", ["access.door_angle_rad", "scan.running"], "门打开且扫描停止；只登记逻辑连接。"), + "xray.configure": ({"voltage_v": _mf_num("V", 20000, 40000), "current_a": _mf_num("A", 0.002, 0.015)}, {"voltage_v": _mf_num("V"), "current_a": _mf_num("A")}, {"voltage_v": 40000, "current_a": 0.015}, ["xray.voltage_v", "xray.current_a", "xray.power_w"], ["xray_tube"], "配置管压/管流，分别验证1kV/1mA量化和600W上限。", ["scan.running"], "扫描停���。"), + "xrd.configure_scan": ({"start_rad": angle, "stop_rad": angle, "step_rad": _mf_num("rad", RIGAKU_MINIFLEX600_STEP_RAD), "integration_time_s": _mf_num("s", positive=True)}, {"start_rad": angle, "stop_rad": angle, "step_rad": _mf_num("rad"), "integration_time_s": _mf_num("s")}, {"start_rad": 0, "stop_rad": _mf_math.radians(1), "step_rad": _mf_math.radians(0.5), "integration_time_s": 1}, ["scan.start_rad", "scan.stop_rad", "scan.step_rad", "scan.integration_time_s", "scan.total_points"] + reset_effects, ["goniometer", "detector"], "配置递增等步长扫描；所有角度对0.005°网格量化，起止区间须整除步长。", ["scan.running"], "扫描停止；0.005°至全程的有限网格；积分时间须正且总时间可表示。"), + "xrd.set_slit": ({"slit_id": ident}, {"slit_id": ident}, {"slit_id": "host_selected_slit"}, ["slit.configuration_id"], ["slit_assembly"], "记录显式狭缝方法标签，不推断未知孔径。", ["scan.running"], "扫描停止。"), + "motion.set_two_theta": ({"angle_rad": angle}, {"angle_rad": angle}, {"angle_rad": _mf_math.radians(20)}, ["goniometer.two_theta_rad", "goniometer.sample_theta_rad"], ["goniometer", "sample_holder"], "设置2θ及θ/2展示耦合，无速度/加速度动态。", ["power.enabled", "access.door_angle_rad", "scan.running"], "供电、门关、扫描停止，角度符合0.005°网格。"), + "xrd.start_scan": ({}, {"status": status, "synthetic": synthetic}, {}, reset_effects + ["goniometer.two_theta_rad", "goniometer.sample_theta_rad"], ["goniometer", "sample_holder", "detector", "xray_tube", "cooling_ports", "door"], "开始合成扫描，定位起点但不推进宿主时间、不产生立即读数。", ["power.enabled", "access.door_angle_rad", "cooling.connection_id", "cooling.ready", "slot.sample.connection_id", "xray.voltage_v", "xray.current_a", "slit.configuration_id", "scan.total_points"], "门关闭、电源开启、循环水连接就绪、样品槽与对应宿主响应/全部方法参数齐备；响应覆盖整个扫描。"), + "xrd.stop_scan": ({}, {"status": status, "synthetic": synthetic}, {}, ["scan.running", "scan.status", "xray.active"], ["detector", "xray_tube"], "停止扫描，保留已完成积分点，未完成积分点丢弃。", [], "实例可用；不提供部分扫描续跑，重新start会清空先前曲线。"), + "xrd.read_pattern": ({}, {"samples": pattern, "status": status, "synthetic": synthetic}, {}, [], ["detector"], "读取现有合成曲线，不推进时间且不生成任何新点。", [], "实例可用。"), + "xrd.phase_search": ({}, {}, {}, [], ["detector"], "物相检索未实现；缺少晶体结构数据库与经过验证的响应。", [], "unsupported。"), + "xrd.refine": ({}, {}, {}, [], ["detector"], "精修未实现；未建立结构因子、仪器展宽、择优取向与计数噪声模型。", [], "unsupported。"), + } + caps = {} + for name, (inputs, outputs, example, effects, components, text, pre_states, pre) in defs.items(): + unsupported = name in ("xrd.phase_search", "xrd.refine") + visible_effects = [s for s in effects if s in scene_keys] + caps[name] = {"availability": "unsupported" if unsupported else "implemented", "visibility": "agent", + "kind": "analysis" if unsupported else "query" if name == "xrd.read_pattern" else "configuration" if name in ("slot.set_sample", "xray.configure", "xrd.configure_scan", "xrd.set_slit") else "device_command", + "description_zh": text, "input_schema": _mf_obj(inputs), "output_schema": _mf_obj(outputs), "example_arguments": [example], + "state_effects": [{"state_id": s, "timing": "immediate", "description_zh": text} for s in effects], + "observes": ["measurement.pattern", "scan.status", "measurement.synthetic"] if name == "xrd.read_pattern" else [s for s in effects if not s.startswith("truth.")], + "component_ids": components, "preconditions_zh": pre, "precondition_state_ids": pre_states, + "binding": "basic40_runtime_measure.RigakuMiniFlex600Session.invoke(instance_id=..., capability_id='" + name + "', arguments=..., request_id=...)", + "completion_criterion_zh": "返回unsupported，无结果变化。" if unsupported else "同步命令已提交；扫描完成须另由host_step推进全部积分点并观察scan.status=completed。", + "partial_failure_zh": "拒绝无过程/场景变化。停止、掉电、冷却丢失保留已完成积分点，丢弃当前未完成积分。scene_adapter异常时过程不提交，但外部场景可能部分写入，需要宿主重新同步。", + "model_effects": {"mode": "host_required" if visible_effects else "none", "binding_ids": [], "description_zh": "scene_adapter接收公开场景快照；实际Blender求值由独立验证记录支撑。" if visible_effects else "配置、数据读取或未实现分析不改变几何。"}, + "implementation": {"process": "absent" if unsupported else "implemented", "host": "absent" if unsupported else "implemented", "scene": "declared" if visible_effects else "not_applicable", "robot": "absent", "hardware": "absent"}, + "error_codes": ["UNKNOWN_INSTANCE", "UNKNOWN_CAPABILITY", "INVALID_ARGUMENT", "ACCESS_DENIED", "PRECONDITION_FAILED", "BUSY", "REQUEST_CONFLICT", "DEVICE_ERROR", "UNSUPPORTED"], "retry": "same_request_id; in-memory only"} + def parameter(value, unit, evidence, text): + return {"value": value, "unit": unit, "meaning_zh": text, "evidence": evidence, + "source_ids": ["workbook_parameters"] if evidence == "documented" else ["runtime_code"], "uncertainty": None} + params = { + "voltage_range_v": parameter([20000, 40000], "V", "documented", "清单给定20–40kV。"), + "voltage_step_v": parameter(1000, "V", "documented", "清单给定1kV步长。"), + "current_range_a": parameter([0.002, 0.015], "A", "documented", "清单给定2–15mA。"), + "current_step_a": parameter(0.001, "A", "documented", "清单给定1mA步长。"), + "maximum_output_w": parameter(600, "W", "documented", "清单整机X射线管最大输出。"), + "goniometer_radius_m": parameter(0.15, "m", "documented", "清单给定测角仪半径150mm。"), + "two_theta_range_rad": parameter([RIGAKU_MINIFLEX600_MIN_RAD, RIGAKU_MINIFLEX600_MAX_RAD], "rad", "documented", "−3..145°换算SI。"), + "angle_quantum_rad": parameter(RIGAKU_MINIFLEX600_STEP_RAD, "rad", "documented", "0.005°最小步进；不代表角度准确度。"), + "door_display_limit_rad": parameter(RIGAKU_MINIFLEX600_DOOR_MAX_RAD, "rad", "assumption", "engineering_assumption：门限位演示上限，厂家未给实际角度。"), + "sample_theta_ratio": parameter(0.5, "1", "assumption", "engineering_assumption：理想θ–2θ展示耦合。"), + } + for key, unit in (("cooling_minimum_flow_m3_s", "m^3/s"), ("cooling_temperature_k", "K"), ("cooling_pressure_pa", "Pa"), + ("slit_aperture_rad", "rad"), ("detector_quantum_efficiency", "1"), ("detector_dark_rate_cps", "1/s"), + ("xray_wavelength_m", "m"), ("instrument_broadening_rad", "rad"), ("preferred_orientation", "1"), + ("detector_mass_kg", "kg"), ("sample_stage_mass_kg", "kg"), ("tube_mass_kg", "kg"), + ("integration_time_min_s", "s"), ("integration_time_max_s", "s"), ("motor_speed_rad_s", "rad/s"), ("actual_diffraction_response", "1/s")): + params[key] = parameter(None, unit, "unknown", "清单未提供；保留null，不将整机规格代替部件参数，不据此声明物理结果。") + limitations = ["All acquired intensities and expected counts are synthetic. The host supplies a response grid for workflow verification; no random peak generation, crystal structure calculation, phase search or refinement is implemented.", + "Linear interpolation and expected_counts=rate*integration_time are engineering_assumption. Counts are expectations, not simulated Poisson events. Tube settings and slit labels do not modify the host-supplied response; each response is valid only for the tube/slit configuration at host_load_synthetic_response.", + "Unknown manufacturer cooling, detector, response, slit aperture and motor parameters remain null. Cooling.ready is a host assertion, not a measured flow or temperature. No actual radiation, shielding or equipment safety certification is simulated.", + "Joint motion is instantaneous commanded pose; sample_theta=two_theta/2 and the 90-degree door display limit are engineering_assumption. No robot insertion, contact solver, acceleration or settling dynamics is implemented.", + "Only explicit absolute host_step advances a shared clock. read, describe and read_pattern do not advance time. Stops retain complete integration points and discard the unfinished interval; starting a new scan clears the previous pattern.", + "Session filtering is an API boundary only, not a Python/process/filesystem sandbox. Pass a scoped session to an agent; protect the trusted host and private response storage separately. No private instance truth is written to runtime report files.", + "Request deduplication is memory-local and does not survive restart. External scene callback failure can leave partial scene effects although process and clock are not committed. Evaluated geometry requires separate scene validation."] + mechanisms = { + "synthetic_scan": {"name_zh": "宿主合成响应的定时采集", "meaning_zh": "engineering_assumption：将显式宿主响应按角度线性插值，每个积分窗口仅生成确定性期望计数；不等于衍射物理模型。", + "component_ids": ["detector", "goniometer", "xray_tube"], "state_ids": ["measurement.pattern", "scan.running", "goniometer.two_theta_rad", "truth.response"], + "implementation": "numerical", "equations": ["theta_i=start+i*step; t_i=t_start+(i+1)*integration_time", "rate(theta)=piecewise_linear(host_response); expected_counts=rate*integration_time"], + "parameters": {k: params[k] for k in ("angle_quantum_rad", "actual_diffraction_response", "detector_quantum_efficiency", "instrument_broadening_rad")}, "source_ids": ["workbook_parameters", "runtime_code"], "limitations": limitations[:2]}, + "theta_two_theta": {"name_zh": "理想θ–2θ展示", "meaning_zh": "engineering_assumption：样品台随2θ按一半角度显示，不模拟驱动器或惯性。", "component_ids": ["sample_holder", "goniometer"], + "state_ids": ["goniometer.two_theta_rad", "goniometer.sample_theta_rad"], "implementation": "numerical", "equations": ["sample_theta_rad=0.5*two_theta_rad"], + "parameters": {"sample_theta_ratio": params["sample_theta_ratio"], "motor_speed_rad_s": params["motor_speed_rad_s"]}, "source_ids": ["runtime_code"], "limitations": ["不宣称厂家实际传动、角度精度或动力学。"]}} + return {"asset_types": {RIGAKU_MINIFLEX600_TYPE: {"catalog_id": "CHEM-160", "model": "Rigaku | MiniFlex600，外置循环水配置", "asset_version": "1.0.0", "state_slots": slots, "capabilities": caps, "parameters": params}}, + "scene_snapshot_keys": scene_keys, "host_capabilities": { + "sim.host_step": {"kind": "simulation", "visibility": "trusted_host_only", "binding": "RigakuMiniFlex600Runtime.host_step(time_s)", "effects": reset_effects + ["goniometer.two_theta_rad", "goniometer.sample_theta_rad"]}, + "sim.set_cooling": {"kind": "simulation", "visibility": "trusted_host_only", "binding": "RigakuMiniFlex600Runtime.host_set_cooling(instance_id, connection_id=..., ready=...)", "semantics_zh": "外置循环水逻辑依赖；失去ready时立即停止扫描，保留完整点。"}, + "sim.load_synthetic_response": {"kind": "simulation", "visibility": "trusted_host_only", "binding": "RigakuMiniFlex600Runtime.host_load_synthetic_response(instance_id, response)", "semantics_zh": "给当前样品、管压/管流与狭缝配置绑定合成响应网格；没有任何真实样品响应默认值。"}}, + "mechanisms": mechanisms, "limitations": limitations} + + +class RigakuMiniFlex600Runtime: + """Trusted simulation host. Give agents scoped sessions, never this host.""" + def __init__(self, *, scene_adapter=None): + self.time_s, self.scene_adapter = 0.0, scene_adapter + self._instances, self._principals, self._requests, self._logs = {}, {}, {}, {} + self._lock, self._metadata = _mf_threading.RLock(), export_rigaku_miniflex600_contract_metadata() + self.register_principal("__public_agent__", visibility="agent") + self._agent = self.session("__public_agent__") + + def create_instance(self, instance_id, asset_type_id=RIGAKU_MINIFLEX600_TYPE): + with self._lock: + if not isinstance(instance_id, str) or not instance_id or instance_id in self._instances or asset_type_id != RIGAKU_MINIFLEX600_TYPE: + raise ValueError("Unique instance and declared asset type required") + inst = {"revision": 0, "power": False, "door": 0.0, "sample": None, "cooling": None, "cooling_ready": False, + "voltage": None, "current": None, "slit": None, "two_theta": 0.0, "method": None, + "response": None, "response_sample": None, "response_configuration": None} + self._reset(inst) + if self.scene_adapter: + self.scene_adapter(instance_id, self._scene(inst)) + self._instances[instance_id] = inst + + @staticmethod + def _reset(inst): + inst.update({"running": False, "status": "idle", "pattern": [], "started_at": None}) + + @staticmethod + def _stop(inst, status): + inst["running"], inst["status"] = False, status + + def register_principal(self, principal_id, *, visibility, instance_ids=None): + with self._lock: + if not isinstance(principal_id, str) or not principal_id or principal_id in self._principals or visibility not in ("agent", "debug", "evaluator"): + raise ValueError("Invalid trusted principal") + if instance_ids is not None and (not isinstance(instance_ids, (list, tuple, set, frozenset)) or any(not isinstance(s, str) for s in instance_ids)): + raise ValueError("Invalid instance scope") + scope = None if instance_ids is None else frozenset(instance_ids) + if scope is not None and not scope <= self._instances.keys(): + raise ValueError("Unknown instance scope") + self._principals[principal_id], self._logs[principal_id] = (visibility, scope), [] + + def session(self, principal_id): + if principal_id not in self._principals: + raise ValueError("Trusted registration required") + return RigakuMiniFlex600Session(self, principal_id) + + def describe(self, **kwargs): + return self._agent.describe(**kwargs) + + def read(self, **kwargs): + return self._agent.read(**kwargs) + + def invoke(self, **kwargs): + return self._agent.invoke(**kwargs) + + def write(self, **kwargs): + return self._agent.write(**kwargs) + + def _values(self, inst): + method = inst["method"] + values = {"power.enabled": inst["power"], "access.door_angle_rad": inst["door"], "slot.sample.connection_id": inst["sample"], + "cooling.connection_id": inst["cooling"], "cooling.ready": inst["cooling_ready"], "xray.voltage_v": inst["voltage"], "xray.current_a": inst["current"], + "xray.power_w": None if inst["voltage"] is None else inst["voltage"] * inst["current"], "xray.active": inst["running"], "slit.configuration_id": inst["slit"], + "goniometer.two_theta_rad": inst["two_theta"], "goniometer.sample_theta_rad": inst["two_theta"] / 2, + "scan.running": inst["running"], "scan.status": inst["status"], "scan.completed_points": len(inst["pattern"]), + "scan.total_points": 0 if method is None else method["point_count"], "measurement.pattern": inst["pattern"], + "measurement.last_intensity_cps": inst["pattern"][-1]["intensity_cps"] if inst["pattern"] else None, + "measurement.synthetic": True, "truth.response": inst["response"], "truth.sample_connection_id": inst["response_sample"]} + values.update({"scan." + k: None if method is None else method[k] for k in ("start_rad", "stop_rad", "step_rad", "integration_time_s")}) + return values + + def _scene(self, inst): + values = self._values(inst) + return _mf_copy.deepcopy({k: values[k] for k in self._metadata["scene_snapshot_keys"]}) + + def scene_snapshot(self, instance_id): + with self._lock: + return self._scene(self._instances[instance_id]) + + def apply_scene(self, instance_id): + with self._lock: + if self.scene_adapter is None: + raise RuntimeError("No scene adapter registered") + snapshot = self.scene_snapshot(instance_id) + self.scene_adapter(instance_id, _mf_copy.deepcopy(snapshot)) + return snapshot + + def _commit(self, instance_id, candidate): + old = self._instances[instance_id] + if old != candidate: + if self.scene_adapter and self._scene(old) != self._scene(candidate): + self.scene_adapter(instance_id, self._scene(candidate)) + candidate["revision"] = old["revision"] + 1 + self._instances[instance_id] = candidate + + def host_set_cooling(self, instance_id, *, connection_id, ready): + with self._lock: + if instance_id not in self._instances or (connection_id is not None and (not isinstance(connection_id, str) or not 1 <= len(connection_id) <= 256)) or type(ready) is not bool or (ready and connection_id is None): + raise ValueError("Valid instance and explicit cooling connection/ready required") + candidate = _mf_copy.deepcopy(self._instances[instance_id]) + candidate["cooling"], candidate["cooling_ready"] = connection_id, ready + if not ready and candidate["running"]: + self._stop(candidate, "cooling_lost") + self._commit(instance_id, candidate) + + def host_load_synthetic_response(self, instance_id, response): + with self._lock: + inst = self._instances.get(instance_id) + schema = self._metadata["asset_types"][RIGAKU_MINIFLEX600_TYPE]["state_slots"]["truth.response"]["value_schema"]["anyOf"][0] + if inst is None or inst["running"] or inst["sample"] is None or any(inst[k] is None for k in ("voltage", "current", "slit")) or not _mf_matches(schema, response): + raise ValueError("Stopped configured sample and finite synthetic response grid required") + if any(a["two_theta_rad"] >= b["two_theta_rad"] for a, b in zip(response, response[1:])): + raise ValueError("Response angles must strictly increase") + candidate = _mf_copy.deepcopy(inst) + candidate["response"], candidate["response_sample"] = _mf_copy.deepcopy(response), inst["sample"] + candidate["response_configuration"] = (inst["voltage"], inst["current"], inst["slit"]) + self._reset(candidate) + self._commit(instance_id, candidate) + + @staticmethod + def _intensity(inst, angle): + response = inst["response"] + if not response[0]["two_theta_rad"] <= angle <= response[-1]["two_theta_rad"]: + raise ValueError("Synthetic response does not cover scan angle") + left, right = 0, len(response) - 1 + while right - left > 1: + middle = (left + right) // 2 + if response[middle]["two_theta_rad"] <= angle: + left = middle + else: + right = middle + a, b = response[left], response[right] + f = (angle - a["two_theta_rad"]) / (b["two_theta_rad"] - a["two_theta_rad"]) + return (1 - f) * a["intensity_cps"] + f * b["intensity_cps"] + + @staticmethod + def _angle(method, index): + if index == method["point_count"] - 1: + return method["stop_rad"] + return method["start_rad"] + index * method["step_rad"] + + def host_step(self, time_s): + """Advance absolute shared simulation time; a read never calls this.""" + with self._lock: + if not _mf_number(time_s) or time_s < self.time_s: + raise ValueError("Finite monotonic absolute host time required") + if time_s == self.time_s: + return + candidates = _mf_copy.deepcopy(self._instances) + for inst in candidates.values(): + if not inst["running"]: + continue + method = inst["method"] + while len(inst["pattern"]) < method["point_count"]: + idx = len(inst["pattern"]) + end = inst["started_at"] + (idx + 1) * method["integration_time_s"] + if end > time_s: + break + start = inst["started_at"] + idx * method["integration_time_s"] + angle = self._angle(method, idx) + rate = self._intensity(inst, angle) + counts = rate * method["integration_time_s"] + if not all(_mf_number(x) for x in (end, start, rate, counts)) or end <= start: + raise ValueError("Synthetic integration exceeds finite numeric domain") + inst["pattern"].append({"two_theta_rad": angle, "intensity_cps": rate, "expected_counts": counts, "sample_time_s": end, + "integration_time_s": method["integration_time_s"], "sample_window_s": [start, end], "synthetic": True}) + done = len(inst["pattern"]) + inst["two_theta"] = self._angle(method, min(done, method["point_count"] - 1)) + if done == method["point_count"]: + self._stop(inst, "completed") + # All process changes and the common clock commit together. An external + # callback may itself have partial effects and must be reconciled by host. + if self.scene_adapter: + for key, candidate in candidates.items(): + if self._scene(candidate) != self._scene(self._instances[key]): + self.scene_adapter(key, self._scene(candidate)) + for key, candidate in candidates.items(): + if candidate != self._instances[key]: + candidate["revision"] = self._instances[key]["revision"] + 1 + self._instances, self.time_s = candidates, float(time_s) + + +class RigakuMiniFlex600Session: + """Identity-scoped API view; not an in-process Python security sandbox.""" + def __init__(self, host, principal_id): + self.__host, self.__principal = host, principal_id + + def _instance(self, instance_id): + _, scope = self.__host._principals[self.__principal] + return self.__host._instances.get(instance_id) if isinstance(instance_id, str) and (scope is None or instance_id in scope) else None + + def _visible(self, definition): + visibility, _ = self.__host._principals[self.__principal] + return definition["visibility"] == "agent" or visibility in ("debug", "evaluator") + + def _envelope(self, instance_id, request_id=None, *, status="succeeded", result=None, observations=None, error=None): + inst = self._instance(instance_id) + return {"protocol_version": "1.0.0", "instance_id": instance_id, "request_id": request_id, "operation_id": None, "status": status, + "state_revision": inst["revision"] if inst is not None else None, "clock": {"domain": "simulation", "time_s": self.__host.time_s}, + "result": _mf_copy.deepcopy(result or {}), "observations": _mf_copy.deepcopy(observations or {}), "error": error} + + def _error(self, instance_id, code, request_id=None, status="rejected"): + messages = {"UNKNOWN_INSTANCE": "Instance unavailable.", "UNKNOWN_CAPABILITY": "Capability unavailable.", "INVALID_ARGUMENT": "Invalid argument schema or numeric domain.", + "ACCESS_DENIED": "Access policy denies this request.", "PRECONDITION_FAILED": "Required sample, response, cooling or configuration unavailable.", "BUSY": "Scan is running.", + "REQUEST_CONFLICT": "Request identifier already used with different arguments.", "DEVICE_ERROR": "External scene synchronization failed; process was not committed.", "UNSUPPORTED": "This analysis is not implemented."} + return self._envelope(instance_id, request_id, status=status, error={"code": code, "message": messages[code], "retryable": False, + "side_effects": "unknown" if code == "DEVICE_ERROR" else "none", "progress": None}) + + def describe(self, *, asset_type_id=None, instance_id=None): + with self.__host._lock: + if (asset_type_id is None) == (instance_id is None) or (asset_type_id is not None and asset_type_id != RIGAKU_MINIFLEX600_TYPE): + return self._error(None, "INVALID_ARGUMENT") + if instance_id is not None and self._instance(instance_id) is None: + return self._error(instance_id, "UNKNOWN_INSTANCE") + _, scope = self.__host._principals[self.__principal] + if scope is not None and not scope: + return self._error(instance_id, "ACCESS_DENIED") + spec = _mf_copy.deepcopy(self.__host._metadata["asset_types"][RIGAKU_MINIFLEX600_TYPE]) + visible = {k: v for k, v in spec["state_slots"].items() if self._visible(v)} + spec["state_slots"] = visible + for cap in spec["capabilities"].values(): + cap["state_effects"] = [e for e in cap["state_effects"] if e["state_id"] in visible] + cap["observes"] = [s for s in cap["observes"] if s in visible] + return {"protocol_version": "1.0.0", "asset_type_id": RIGAKU_MINIFLEX600_TYPE, "instance_id": instance_id, + "adapter": "basic40_runtime_measure.RigakuMiniFlex600Session", **spec, "limitations": _mf_copy.deepcopy(self.__host._metadata["limitations"])} + + def read(self, *, instance_id, state_ids=None): + with self.__host._lock: + inst = self._instance(instance_id) + if inst is None: + return self._error(instance_id, "UNKNOWN_INSTANCE") + slots = self.__host._metadata["asset_types"][RIGAKU_MINIFLEX600_TYPE]["state_slots"] + if state_ids is None: + state_ids = [s for s, d in slots.items() if self._visible(d)] + if not isinstance(state_ids, list) or any(not isinstance(s, str) for s in state_ids) or len(state_ids) != len(set(state_ids)): + return self._error(instance_id, "INVALID_ARGUMENT") + if any(s not in slots or not self._visible(slots[s]) for s in state_ids): + return self._error(instance_id, "ACCESS_DENIED") + values = self.__host._values(inst) + observations = {} + for sid in state_ids: + value = values[sid] + sample_time = self.__host.time_s + window = None + if sid == "measurement.last_intensity_cps": + sample_time = inst["pattern"][-1]["sample_time_s"] if inst["pattern"] else None + window = inst["pattern"][-1]["sample_window_s"] if inst["pattern"] else None + observations[sid] = {"value": _mf_copy.deepcopy(value), "unit": slots[sid]["unit"], + "quality": "unavailable" if value is None else "estimated" if slots[sid]["origin"] == "derived" else "valid", + "sample_time_s": sample_time, "sample_window_s": window, "synthetic": sid.startswith("measurement."), + "reason": "No explicitly configured value or completed synthetic measurement." if value is None else None} + return self._envelope(instance_id, observations=observations) + + def invoke(self, *, instance_id, capability_id, arguments, request_id): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if inst is None: + return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) + if not isinstance(capability_id, str) or not isinstance(arguments, dict) or not isinstance(request_id, str) or not 1 <= len(request_id) <= 256: + return self._error(instance_id, "INVALID_ARGUMENT", request_id) + try: + digest = _mf_hashlib.sha256(_mf_json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False).encode()).hexdigest() + except (TypeError, ValueError, OverflowError): + return self._error(instance_id, "INVALID_ARGUMENT", request_id) + key = self.__principal, instance_id, request_id + if key in host._requests: + old_digest, result = host._requests[key] + return _mf_copy.deepcopy(result) if old_digest == digest else self._error(instance_id, "REQUEST_CONFLICT", request_id) + response = self._checked(instance_id, inst, capability_id, arguments, request_id) + host._requests[key] = digest, _mf_copy.deepcopy(response) + host._logs[self.__principal].append({"instance_id": instance_id, "capability_id": capability_id, "request_id": request_id, "response": _mf_copy.deepcopy(response)}) + return response + + def _checked(self, instance_id, inst, cap, args, request_id): + host = self.__host + fail = lambda code, status="rejected": self._error(instance_id, code, request_id, status) + caps = host._metadata["asset_types"][RIGAKU_MINIFLEX600_TYPE]["capabilities"] + if cap not in caps: + return fail("UNKNOWN_CAPABILITY") + if not _mf_matches(caps[cap]["input_schema"], args): + return fail("INVALID_ARGUMENT") + if caps[cap]["availability"] == "unsupported": + return fail("UNSUPPORTED", "unsupported") + if inst["running"] and cap not in ("power.set", "xrd.stop_scan", "xrd.read_pattern"): + return fail("BUSY") + if cap == "slot.set_sample" and inst["door"] <= 0: + return fail("PRECONDITION_FAILED") + if cap == "xray.configure" and (not _mf_grid(args["voltage_v"], 1000) or not _mf_grid(args["current_a"], 0.001) or args["voltage_v"] * args["current_a"] > 600): + return fail("INVALID_ARGUMENT") + if cap == "motion.set_two_theta": + if not _mf_grid(args["angle_rad"], RIGAKU_MINIFLEX600_STEP_RAD): + return fail("INVALID_ARGUMENT") + if not inst["power"] or inst["door"] != 0: + return fail("PRECONDITION_FAILED") + if cap == "xrd.configure_scan": + if args["start_rad"] > args["stop_rad"] or not all(_mf_grid(args[k], RIGAKU_MINIFLEX600_STEP_RAD) for k in ("start_rad", "stop_rad", "step_rad")): + return fail("INVALID_ARGUMENT") + intervals = (args["stop_rad"] - args["start_rad"]) / args["step_rad"] + if not _mf_number(intervals) or abs(intervals - round(intervals)) > 1e-7 or round(intervals) + 1 > RIGAKU_MINIFLEX600_MAX_POINTS: + return fail("INVALID_ARGUMENT") + count = round(intervals) + 1 + duration = count * args["integration_time_s"] + if not _mf_number(duration) or duration <= 0: + return fail("INVALID_ARGUMENT") + if cap == "xrd.start_scan": + if not inst["power"] or inst["door"] != 0 or not inst["cooling_ready"] or inst["cooling"] is None or inst["sample"] is None or inst["sample"] != inst["response_sample"] or inst["response"] is None or inst["method"] is None or any(inst[k] is None for k in ("voltage", "current", "slit")): + return fail("PRECONDITION_FAILED") + if inst["response_configuration"] != (inst["voltage"], inst["current"], inst["slit"]): + return fail("PRECONDITION_FAILED") + method, response = inst["method"], inst["response"] + if response[0]["two_theta_rad"] > method["start_rad"] or response[-1]["two_theta_rad"] < method["stop_rad"]: + return fail("PRECONDITION_FAILED") + first_end = host.time_s + method["integration_time_s"] + last_end = host.time_s + method["point_count"] * method["integration_time_s"] + max_counts = max(p["intensity_cps"] for p in response) * method["integration_time_s"] + if not all(_mf_number(v) for v in (first_end, last_end, max_counts)) or first_end <= host.time_s or (method["point_count"] > 1 and last_end <= first_end): + return fail("INVALID_ARGUMENT") + if cap == "xrd.read_pattern": + return self._envelope(instance_id, request_id, result={"samples": inst["pattern"], "status": inst["status"], "synthetic": True}) + candidate, result = _mf_copy.deepcopy(inst), dict(args) + if cap == "power.set": + candidate["power"] = args["enabled"] + if not args["enabled"] and candidate["running"]: + host._stop(candidate, "power_lost") + elif cap == "access.set_door_angle": + candidate["door"] = args["angle_rad"] + elif cap == "slot.set_sample": + if candidate["sample"] != args["connection_id"]: + candidate["sample"] = args["connection_id"] + candidate["response"], candidate["response_sample"], candidate["response_configuration"] = None, None, None + host._reset(candidate) + elif cap == "xray.configure": + candidate["voltage"], candidate["current"] = args["voltage_v"], args["current_a"] + elif cap == "xrd.configure_scan": + candidate["method"] = {**args, "point_count": count} + host._reset(candidate) + elif cap == "xrd.set_slit": + candidate["slit"] = args["slit_id"] + elif cap == "motion.set_two_theta": + candidate["two_theta"] = args["angle_rad"] + elif cap == "xrd.start_scan": + host._reset(candidate) + candidate["started_at"], candidate["running"], candidate["status"] = host.time_s, True, "running" + candidate["two_theta"] = candidate["method"]["start_rad"] + result = {"status": "running", "synthetic": True} + elif cap == "xrd.stop_scan": + if candidate["running"]: + host._stop(candidate, "stopped") + result = {"status": candidate["status"], "synthetic": True} + try: + host._commit(instance_id, candidate) + except Exception: + return fail("DEVICE_ERROR", "failed") + return self._envelope(instance_id, request_id, result=result) + + def write(self, *, instance_id, state_id, value, request_id): + with self.__host._lock: + if self._instance(instance_id) is None: + return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) + slots = self.__host._metadata["asset_types"][RIGAKU_MINIFLEX600_TYPE]["state_slots"] + if not isinstance(state_id, str) or state_id not in slots or not self._visible(slots[state_id]) or slots[state_id]["write_via"] is None: + return self._error(instance_id, "ACCESS_DENIED", request_id) + route = slots[state_id]["write_via"] + return self.invoke(instance_id=instance_id, capability_id=route["capability_id"], arguments={**route["fixed_arguments"], route["parameter"]: value}, request_id=request_id) + + def logs(self): + with self.__host._lock: + return _mf_copy.deepcopy(self.__host._logs[self.__principal]) + + +def write_rigaku_miniflex600_runtime_reports(output_directory): + import datetime + import importlib.util + import io + import pathlib + import platform + import unittest + root = pathlib.Path(__file__).resolve().parents[1] + spec = importlib.util.spec_from_file_location("test_basic40_measure_rigaku_miniflex600", root / "tests/test_basic40_measure.py") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + stream = io.StringIO() + result = unittest.TextTestRunner(stream=stream, verbosity=2).run(unittest.defaultTestLoader.loadTestsFromTestCase(module.RigakuMiniFlex600RuntimeTests)) + metadata = export_rigaku_miniflex600_contract_metadata() + caps = metadata["asset_types"][RIGAKU_MINIFLEX600_TYPE]["capabilities"] + report = {"catalog_id": "CHEM-160", "checked_at": datetime.datetime.now(datetime.timezone.utc).isoformat(), + "environment": {"python": platform.python_version(), "platform": platform.platform(), "runtime": "standard-library Python; synthetic fixtures only; no Blender"}, + "method": "unittest: uniform entrypoints, SI limits/quantization, door/sample/cooling/tube interlocks, deterministic explicit-host scans, count integration, partial stops, monotonic shared time, rejection atomicity, instance/session isolation, in-memory idempotency, schemas and declared effects, scene callback boundaries", + "tests_run": result.testsRun, "failures": len(result.failures), "errors": len(result.errors), "result": "passed" if result.wasSuccessful() else "failed", + "passed_capabilities": sorted(k for k, v in caps.items() if v["availability"] == "implemented") if result.wasSuccessful() else [], + "verified_unsupported": ["xrd.phase_search", "xrd.refine"] if result.wasSuccessful() else [], + "output": stream.getvalue(), "synthetic": True, + "not_run": ["real_hardware", "robot_execution", "contact_solver", "Blender_evaluated_pose", "process_filesystem_security_isolation", "real_diffraction_accuracy", "phase_identification", "rietveld_refinement", "instrument_broadening", "preferred_orientation", "poisson_count_noise", "radiation_shielding", "coolant_thermal_hydraulics"], + "scene_scope": "Only recording/failing callbacks and scene snapshot mapping are tested here; the parent owns evaluated Blender validation separately.", + "boundaries": metadata["limitations"]} + directory = pathlib.Path(output_directory) + directory.mkdir(parents=True, exist_ok=True) + for name, value in (("runtime_validation.json", report), ("runtime_metadata.json", metadata)): + (directory / name).write_text(_mf_json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report +# END CHEM-160 RIGAKU MINIFLEX600 APPEND-ONLY RUNTIME + +# CHEM-102 independent review: append-only fixes for failed-request replay and +# representable host time; no prior asset classes or blocks are modified. +_kf899_review_original_invoke = Metrohm899Session.invoke + + +def _kf899_reviewed_invoke(self, *, instance_id, capability_id, arguments, request_id): + host = self._kf899_host + with host._kf899_lock: + response = _kf899_review_original_invoke(self, instance_id=instance_id, + capability_id=capability_id, arguments=arguments, request_id=request_id) + if self._kf899_allowed(instance_id) and isinstance(request_id, str) and request_id and isinstance(capability_id, str) and isinstance(arguments, dict): + try: + fingerprint = _kf899_json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False) + except (ValueError, TypeError, OverflowError): + return response + key = (self._kf899_principal, instance_id, request_id) + if key not in host._kf899_requests: + # In particular cache DEVICE_ERROR/unknown outcomes: repeating + # a logical request must not replay external scene side effects. + host._kf899_requests[key] = (fingerprint, _kf899_copy.deepcopy(response)) + return response + + +Metrohm899Session.invoke = _kf899_reviewed_invoke + + +def _kf899_reviewed_step(self, dt_s): + """Common-clock step with precommit finite/representable-time validation. + + Process states and time commit together after all callbacks return. The + callbacks are per-instance, not a transaction across scene instances: an + exception may leave earlier external scene callbacks applied. The trusted + host must reconcile all affected scene instances after any callback error. + """ + with self._kf899_lock: + if not _kf899_number(dt_s) or dt_s < 0 or not _kf899_number(self.time_s + dt_s): + raise ValueError("Finite nonnegative time increment required") + if dt_s == 0: + return {"time_s": self.time_s, "synthetic": True} + end_time = self.time_s + float(dt_s) + if end_time <= self.time_s: + raise ValueError("Positive increment is not representable at current host time") + candidates = _kf899_copy.deepcopy(self._kf899_instances) + for iid, instance in candidates.items(): + s = instance["state"] + if not s["coulometry.running"]: + continue + pre_elapsed = s["measurement.elapsed_s"] + checks = (pre_elapsed + dt_s, s["settings.current_a"] * dt_s, + s["truth.water_remaining_kg"] + s["truth.background_drift_kg_s"] * dt_s, + s["settings.drift_compensation_kg_s"] * (pre_elapsed + dt_s)) + if not all(_kf899_number(v) for v in checks): + raise ValueError("Requested integration exceeds finite numerical range") + remaining_dt, advanced = float(dt_s), 0.0 + drift = s["truth.background_drift_kg_s"] + rate = s["settings.current_a"] * KF899_KG_PER_COULOMB + extract_remaining = max(0.0, s["settings.extraction_time_s"] - pre_elapsed) + extract = min(remaining_dt, extract_remaining) + s["truth.water_remaining_kg"] += drift * extract + remaining_dt -= extract + advanced += extract + s["coulometry.status"] = "EXTRACTING" if remaining_dt == 0 and extract_remaining > extract else "TITRATING" + if remaining_dt > 0: + water, net_rate = s["truth.water_remaining_kg"], rate - drift + depletion_time = water / net_rate if net_rate > 0 else float("inf") + drive = min(remaining_dt, depletion_time) + s["measurement.charge_c"] += s["settings.current_a"] * drive + s["truth.water_remaining_kg"] = max(0.0, water - net_rate * drive) + remaining_dt -= drive + advanced += drive + if depletion_time <= drive: + s["truth.water_remaining_kg"] = 0.0 + s["coulometry.status"] = "HOLDING" + hold_remaining = max(0.0, s["settings.endpoint_hold_s"] - s["endpoint.hold_elapsed_s"]) + hold = min(remaining_dt, hold_remaining) + s["measurement.charge_c"] += drift * hold / KF899_KG_PER_COULOMB + s["endpoint.hold_elapsed_s"] += hold + advanced += hold + if s["endpoint.hold_elapsed_s"] >= s["settings.endpoint_hold_s"]: + s["coulometry.running"] = False + s["coulometry.status"] = "COMPLETED" + s["measurement.elapsed_s"] = pre_elapsed + advanced + s["measurement.sample_time_s"] = self.time_s + advanced + if advanced > 0 and (s["measurement.elapsed_s"] <= pre_elapsed or s["measurement.sample_time_s"] <= self.time_s): + raise ValueError("Acquisition interval is not representable at current host time") + generated = s["measurement.charge_c"] * KF899_KG_PER_COULOMB + compensation = s["settings.drift_compensation_kg_s"] * s["measurement.elapsed_s"] + if not _kf899_number(generated) or not _kf899_number(compensation): + raise ValueError("Integration exceeds finite numerical range") + s["measurement.water_mass_kg"] = max(0.0, generated - compensation) + mass = s["settings.sample_mass_kg"] + s["measurement.water_fraction"] = None if mass is None else s["measurement.water_mass_kg"] / mass + if any(type(value) in (int, float) and not _kf899_number(value) for value in s.values()): + raise ValueError("Integration exceeds finite numerical range") + instance["revision"] += 1 + instance["curve"].append({**_kf899_reading(s), "sample_time_s": s["measurement.sample_time_s"]}) + # No callback runs before all instances pass numerical validation. + for iid, instance in candidates.items(): + if instance != self._kf899_instances[iid]: + self._kf899_sync(iid, instance["state"]) + self._kf899_instances = candidates + self.time_s = end_time + return {"time_s": self.time_s, "synthetic": True} + + +Metrohm899Host.step = _kf899_reviewed_step +_kf899_review_original_metadata = export_metrohm899_contract_metadata + + +def export_metrohm899_contract_metadata(): + result = _kf899_review_original_metadata() + result["boundaries"].extend([ + "Failed scene callback outcomes are cached by logical request ID; retry does not replay the callback. A new request after reconciliation is explicit host/operator action.", + "Host step commits process/time together, but callbacks across scene instances are not transactional. A later callback failure can leave earlier scene instances changed; host must reconcile every affected scene instance.", + "Positive host increments and nonzero acquisition intervals that cannot be represented at the current floating-point time are rejected before callbacks or process mutation.", + "Slot installation/removal is a powered-off, idle scene configuration with cell-before-electrode dependencies. It does not simulate handling force, reagent spills, physical transfers or sample-container identity changes."]) + return result + +# CHEM-102 reproducible dedicated report writer; no other asset outputs touched. +def write_metrohm899_runtime_reports(output_directory): + import datetime + import importlib.util + import io + import pathlib + import platform + import subprocess + import unittest + root = pathlib.Path(__file__).resolve().parents[1] + spec = importlib.util.spec_from_file_location("test_basic40_measure_metrohm899", root / "tests/test_basic40_measure.py") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + stream = io.StringIO() + suite = unittest.defaultTestLoader.loadTestsFromTestCase(module.Metrohm899RuntimeTests) + result = unittest.TextTestRunner(stream=stream, verbosity=2).run(suite) + meta = export_metrohm899_contract_metadata() + report = {"catalog_id": "CHEM-102", "asset_type_id": METROHM899_TYPE, + "recorded_at": datetime.datetime.now(datetime.timezone.utc).isoformat(), + "shell_utc_at_recording": subprocess.check_output(["date", "-u", "+%Y-%m-%dT%H:%M:%SZ"], text=True).strip(), + "environment": {"python": platform.python_version(), "platform": platform.platform()}, + "method": "unittest Metrohm899RuntimeTests: SI I/Q/m conservation, analytic extraction/depletion/hold with drift compensation and step partitioning; every API output schema and state effect; slots and null drift; retained stop/power effects; two active instances and common representable clock; request idempotency including callback failures; truth/curve/copy filtering; process rollback and explicitly partial external scene callback failure", + "command": "PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=scripts:tests python3 -m unittest test_basic40_measure.Metrohm899RuntimeTests -v", + "report_writer": "scripts.basic40_runtime_measure.write_metrohm899_runtime_reports(output_directory)", + "tests_run": result.testsRun, "failures": len(result.failures), "errors": len(result.errors), + "result": "passed" if result.wasSuccessful() else "failed", "synthetic": True, + "verified_layers": ["process", "host"] if result.wasSuccessful() else [], + "capabilities_verified": sorted(meta["capabilities"]) if result.wasSuccessful() else [], + "scene_scope": "Recording/failing callback tests only; evaluated Blender pose requires a separate geometry verification record. Cross-instance callbacks are not an external scene transaction.", + "not_run": ["real_hardware", "robot_execution", "contact_solver", "real_reagent_or_electrode_kinetics", "manufacturer_accuracy_or_noise", "automatic_current_firmware", "process_filesystem_sandbox", "evaluated_blender_pose_in_runtime_tests"], + "boundaries": meta["boundaries"], "output": stream.getvalue()} + directory = pathlib.Path(output_directory) + directory.mkdir(parents=True, exist_ok=True) + for name, value in (("runtime_validation.json", report), ("runtime_manifest.json", meta)): + (directory / name).write_text(_kf899_json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + (directory / "runtime_test_report.txt").write_text(stream.getvalue(), encoding="utf-8") + return report