有人问病历被谁看过，我不能只拿出一条登录记录。

"""Synthetic execution example. No patient data, network or durable audit store."""
from dataclasses import dataclass
from uuid import uuid4


@dataclass(frozen=True)
class Call:
    caller: str
    invocation_id: str


class DemoLegacySystem:
    def __init__(self):
        self.events = []

    def read_status(self, reference):
        # The legacy system creates this identifier when it actually reads.
        event_id = str(uuid4())
        self.events.append({"event_id": event_id, "reference": reference})
        return {"status": "ready", "event_id": event_id}


class StatusService:
    def __init__(self, legacy, grants, audit, render):
        self.legacy = legacy
        self.grants = grants  # Provider-controlled caller -> allowed references.
        self.audit = audit
        self.render = render

    def query(self, call, reference):
        base = {"invocation_id": call.invocation_id, "caller": call.caller}
        if reference not in self.grants.get(call.caller, frozenset()):
            self.audit.append({**base, "stage": "access", "outcome": "denied"})
            raise PermissionError("reference not authorized")
        self.audit.append({**base, "stage": "read", "outcome": "started"})
        try:
            result = self.legacy.read_status(reference)
        except Exception:
            # A timeout cannot prove that the legacy system never read anything.
            self.audit.append({**base, "stage": "read", "outcome": "unknown"})
            raise
        evidence = {**base, "legacy_event_id": result["event_id"]}
        self.audit.append({**evidence, "stage": "read", "outcome": "completed"})
        try:
            output = self.render(result["status"])
        except Exception:
            self.audit.append({**evidence, "stage": "render", "outcome": "failed"})
            raise
        self.audit.append({**evidence, "stage": "render", "outcome": "completed"})
        return {"status": output}


if __name__ == "__main__":
    import json

    legacy, audit = DemoLegacySystem(), []
    def timeout_after_read(status):
        raise TimeoutError("synthetic formatting failure")
    service = StatusService(legacy, {"demo-caller": {"DEMO-42"}}, audit, timeout_after_read)
    try:
        service.query(Call("demo-caller", "demo-invocation"), "DEMO-42")
    except TimeoutError:
        pass
    print(json.dumps(audit, indent=2))

"""Registration adapter; the owner supplies the service and starts the node."""
from easyremote import ComputeNode, Context
from audit_demo import Call, StatusService


def create_node(service: StatusService) -> ComputeNode:
    node = ComputeNode(namespace="status_lookup")

    @node.register
    def query_status(ctx: Context, reference: str) -> dict:
        """Return only the status of a record authorized for this caller."""
        return service.query(Call(ctx.caller, ctx.invocation_id), reference)

    return node