roboapi 0.4.2__py3-none-any.whl

roboapi/records.py

@@ -0,0 +1,149 @@
+"""Local execution records, independent of hardware and model transport."""
+
+import collections
+import json
+import logging
+import re
+import threading
+import time
+from pathlib import Path
+
+import numpy as np
+
+from .errors import PolicyUnavailable
+
+logger = logging.getLogger(__name__)
+
+
+def _inference_error_kind(exc: Exception) -> str:
+    """Keep monitor errors useful without retaining arbitrary server or driver text."""
+    if not isinstance(exc, PolicyUnavailable):
+        return "runtime_error"
+    detail = str(exc).lower()
+    for name, marker in (
+        ("connect_timeout", "connect timeout"),
+        ("read_timeout", "read timeout"),
+        ("transport_error", "transport error"),
+        ("not_authorized", "model not authorized"),
+        ("authentication_rejected", "authentication rejected"),
+        ("http_error", "http error"),
+        ("model_unavailable", "model unavailable"),
+        ("invalid_response", "invalid response"),
+    ):
+        if marker in detail:
+            return name
+    return "policy_unavailable"
+
+
+def _diagnostic_request_id(exc: Exception) -> str | None:
+    # Only the policy client's validated response-header form is accepted here.
+    match = re.search(r"(?:^|; )request_id=([A-Za-z0-9_.-]{1,128})(?:;|$)", str(exc))
+    return match.group(1) if match else None
+
+
+class RunRecords:
+    def __init__(self, cfg):
+        self.cfg = cfg
+        self.path = None
+        self.call_log = collections.deque(maxlen=200)
+        self.inference_events = collections.deque(maxlen=120)
+        self._inference_active = None
+        self._lock = threading.Lock()
+        self._activity = collections.deque(maxlen=120)
+        self._event_id = 0
+
+    def event(self, message: str, level: str = "info") -> None:
+        with self._lock:
+            self._event_id += 1
+            self._activity.append({"id": self._event_id, "t": time.time(),
+                                   "message": message, "level": level})
+        logger.log({"error": logging.ERROR, "warning": logging.WARNING}.get(level, logging.INFO), message)
+
+    def activity(self) -> list[dict]:
+        with self._lock:
+            return list(self._activity)
+
+    def open(self):
+        directory = Path(self.cfg.log_dir).expanduser()
+        directory.mkdir(parents=True, exist_ok=True)
+        self.path = directory / f"run-{time.strftime('%Y%m%d-%H%M%S')}.jsonl"
+
+    def write(self, chunk, result, image_age, image, *, state, control_trace) -> None:
+        if self.path is None:
+            return
+        record = {
+            "t": time.time(),
+            "instruction": chunk.instruction,
+            "state": state,
+            "chunk_head": chunk.arm[:3].round(5).tolist(),
+            "gripper_head": chunk.gripper[:3].round(4).tolist(),
+            "infer_ms": round(chunk.infer_ms, 2),
+            "chunk_len": len(chunk),
+            "image_age_ms": round(image_age * 1e3, 1),
+            "control_trace": control_trace,
+            **result,
+        }
+        try:
+            with self.path.open("a") as fh:
+                fh.write(json.dumps(record) + "\n")
+            if self.cfg.save_images:
+                self._save_image(image, record["t"])
+        except Exception as exc:
+            logger.warning("log write failed: %s", exc)
+
+    def _save_image(self, image: np.ndarray, stamp: float) -> None:
+        from PIL import Image
+
+        out = self.path.with_suffix("") / f"{stamp:.3f}.jpg"
+        out.parent.mkdir(parents=True, exist_ok=True)
+        Image.fromarray(image).save(out, quality=85)
+
+    def set_phase(self, phase: str, request_ms: float | None = None) -> None:
+        with self._lock:
+            if self._inference_active is not None:
+                self._inference_active["phase"] = phase
+                if request_ms is not None:
+                    self._inference_active["request_ms"] = round(request_ms, 1)
+
+    def record_inference(self, started_at: float, started: float, *,
+                         result: dict | None = None, exc: Exception | None = None) -> None:
+        monitor = result.pop("_monitor", {}) if result is not None else {}
+        with self._lock:
+            try:
+                active_request_ms = (self._inference_active or {}).get("request_ms")
+                phase = "complete" if exc is None else (
+                    self._inference_active["phase"] if self._inference_active else "unknown"
+                )
+                self.inference_events.append({
+                    "t": started_at,
+                    "status": "ok" if exc is None else "error",
+                    "phase": phase,
+                    "infer_ms": round(result["infer_ms"], 1) if result is not None and result.get("infer_ms") is not None else None,
+                    "request_ms": monitor.get("request_ms", active_request_ms),
+                    "action_ms": monitor.get("action_ms"),
+                    "step_ms": round((time.perf_counter() - started) * 1e3, 1),
+                    "image_age_ms": monitor.get("image_age_ms"),
+                    "request_id": monitor.get("request_id") if exc is None else _diagnostic_request_id(exc),
+                    "output": monitor.get("output"),
+                    "error_kind": _inference_error_kind(exc) if exc is not None else None,
+                })
+            finally:
+                self._inference_active = None
+
+    def begin_inference(self, timestamp, started):
+        with self._lock:
+            self._inference_active = {"t": timestamp, "started": started, "phase": "observation"}
+
+    def clear_errors(self):
+        with self._lock:
+            retained = [event for event in self.inference_events if event.get("status") != "error"]
+            self.inference_events.clear()
+            self.inference_events.extend(retained)
+
+    def snapshot(self):
+        with self._lock:
+            active = self._inference_active
+            current = ({"t": active["t"], "phase": active["phase"],
+                        "elapsed_ms": round((time.perf_counter() - active["started"]) * 1e3, 1),
+                        "request_ms": active.get("request_ms")} if active is not None else None)
+            return {"inference_active": current, "inference_events": list(self.inference_events)}