| |
| """Causally replay one materialized Morphosis root against a DSV4 endpoint.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import asyncio |
| import hashlib |
| import io |
| import json |
| import os |
| import re |
| import sys |
| import tarfile |
| import time |
| import traceback |
| from collections import Counter, defaultdict |
| from dataclasses import dataclass |
| from pathlib import Path, PurePosixPath |
| from typing import Any, Awaitable, Callable |
|
|
|
|
| TRIE_SRC = Path( |
| os.environ.get( |
| "MORPHOSIS_TRIE_SRC", |
| str(Path(__file__).resolve().parents[1] / "trie" / "src"), |
| ) |
| ) |
| sys.path.insert(0, str(TRIE_SRC)) |
|
|
| from trie.client import Client |
| from trie.results import StreamAccumulator |
| from trie.types import Generate, ReplayTrace |
|
|
|
|
| ROOT_ID_RE = re.compile(r"root-\d{3}-[A-Za-z0-9_.-]+") |
|
|
|
|
| def atomic_json(path: Path, payload: Any) -> None: |
| temp = path.with_suffix(path.suffix + ".tmp") |
| temp.write_text( |
| json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True) + "\n", |
| encoding="utf-8", |
| ) |
| os.replace(temp, path) |
|
|
|
|
| class EventWriter: |
| def __init__(self, path: Path, run_id: str) -> None: |
| self._handle = path.open("w", encoding="utf-8", buffering=1) |
| self._run_id = run_id |
| self._sequence = 0 |
|
|
| def emit(self, event: str, **fields: Any) -> None: |
| self._sequence += 1 |
| row = { |
| "schema_version": 1, |
| "event": event, |
| "event_sequence": self._sequence, |
| "run_id": self._run_id, |
| "wall_time_s": time.time(), |
| "monotonic_time_s": time.monotonic(), |
| **fields, |
| } |
| self._handle.write( |
| json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n" |
| ) |
|
|
| def close(self) -> None: |
| self._handle.close() |
|
|
|
|
| @dataclass(frozen=True) |
| class ChildEdge: |
| parent_trace_id: str |
| child_trace_id: str |
| fork_generate_index: int |
| join_generate_index: int |
| child_final_generate_index: int |
| batch_id: str |
| dispatch_index: int |
| join_policy: str |
|
|
|
|
| @dataclass |
| class RootProgram: |
| root_id: str |
| lead_trace_id: str |
| traces: dict[str, ReplayTrace] |
| edges: list[ChildEdge] |
| manifest: dict[str, Any] |
| profile: dict[str, Any] |
|
|
|
|
| @dataclass |
| class RequestOutcome: |
| prompt_tokens: int |
| completion_tokens: int |
| cached_tokens: int |
| cached_tokens_details: dict[str, Any] | None |
| latency_s: float |
| ttft_s: float |
|
|
|
|
| RequestExecutor = Callable[ |
| [ReplayTrace, int, Generate, str, str], Awaitable[RequestOutcome] |
| ] |
|
|
|
|
| def generate_events(trace: ReplayTrace) -> list[Generate]: |
| return [event for event in trace.events if isinstance(event, Generate)] |
|
|
|
|
| def _safe_member_name(name: str, root_id: str) -> bool: |
| path = PurePosixPath(name) |
| return ( |
| not path.is_absolute() |
| and ".." not in path.parts |
| and len(path.parts) == 2 |
| and path.parts[0] == root_id |
| and path.parts[1] in {"actors.jsonl", "manifest.json"} |
| ) |
|
|
|
|
| def load_root_archive(path: Path) -> RootProgram: |
| if not path.name.endswith(".tar.gz"): |
| raise ValueError(f"archive does not end with .tar.gz: {path}") |
| root_id = path.name[: -len(".tar.gz")] |
| if ROOT_ID_RE.fullmatch(root_id) is None: |
| raise ValueError(f"invalid root id: {root_id!r}") |
|
|
| with tarfile.open(path, "r:gz") as archive: |
| files = [member for member in archive.getmembers() if member.isfile()] |
| if any(not _safe_member_name(member.name, root_id) for member in files): |
| raise ValueError("archive contains an unexpected or unsafe file") |
| by_name = {member.name: member for member in files} |
| expected = { |
| f"{root_id}/actors.jsonl", |
| f"{root_id}/manifest.json", |
| } |
| if set(by_name) != expected: |
| raise ValueError( |
| f"archive file set differs: got={sorted(by_name)} expected={sorted(expected)}" |
| ) |
| manifest_stream = archive.extractfile(by_name[f"{root_id}/manifest.json"]) |
| actors_stream = archive.extractfile(by_name[f"{root_id}/actors.jsonl"]) |
| if manifest_stream is None or actors_stream is None: |
| raise ValueError("archive member cannot be read") |
| manifest = json.load(manifest_stream) |
| traces: dict[str, ReplayTrace] = {} |
| for line_number, raw in enumerate(io.TextIOWrapper(actors_stream), 1): |
| if not raw.strip(): |
| continue |
| trace = ReplayTrace.from_jsonl_row(json.loads(raw)) |
| if trace.trace_id in traces: |
| raise ValueError(f"duplicate actor trace: {trace.trace_id}") |
| traces[trace.trace_id] = trace |
|
|
| if manifest.get("root_id") != root_id or manifest.get("actors") != len(traces): |
| raise ValueError("root manifest identity/count mismatch") |
| lead_ids = [ |
| trace_id |
| for trace_id, trace in traces.items() |
| if trace.metadata["multiagent"].get("parent_trace_id") is None |
| ] |
| if len(lead_ids) != 1: |
| raise ValueError(f"expected one lead actor, found {lead_ids}") |
| lead_id = lead_ids[0] |
|
|
| edges: list[ChildEdge] = [] |
| child_to_edge: dict[str, ChildEdge] = {} |
| for parent_id, parent in traces.items(): |
| metadata = parent.metadata.get("multiagent") |
| if not isinstance(metadata, dict) or metadata.get("root_task_id") != root_id: |
| raise ValueError(f"{parent_id}: root metadata mismatch") |
| parent_generates = generate_events(parent) |
| for raw in metadata.get("children") or []: |
| edge = ChildEdge( |
| parent_trace_id=parent_id, |
| child_trace_id=str(raw["child_trace_id"]), |
| fork_generate_index=int(raw["parent_fork_generate_index"]), |
| join_generate_index=int(raw["parent_join_generate_index"]), |
| child_final_generate_index=int(raw["child_final_generate_index"]), |
| batch_id=str(raw["batch_id"]), |
| dispatch_index=int(raw["dispatch_index"]), |
| join_policy=str(raw["join_policy"]), |
| ) |
| if edge.child_trace_id not in traces: |
| raise ValueError(f"missing child actor: {edge.child_trace_id}") |
| if edge.child_trace_id in child_to_edge: |
| raise ValueError(f"child has multiple incoming edges: {edge.child_trace_id}") |
| if ( |
| edge.join_policy != "all_terminal" |
| or not 0 <= edge.fork_generate_index < edge.join_generate_index |
| or edge.join_generate_index >= len(parent_generates) |
| ): |
| raise ValueError(f"invalid fork/join edge: {edge}") |
| child_generates = generate_events(traces[edge.child_trace_id]) |
| if edge.child_final_generate_index != len(child_generates) - 1: |
| raise ValueError(f"child final request mismatch: {edge.child_trace_id}") |
| assistant = parent_generates[edge.fork_generate_index].recorded_assistant or {} |
| function_names = { |
| call.get("function", {}).get("name") |
| for call in assistant.get("tool_calls") or [] |
| if isinstance(call, dict) |
| } |
| if "run_subagents" not in function_names: |
| raise ValueError(f"fork request lacks run_subagents: {edge}") |
| child_parent = traces[edge.child_trace_id].metadata["multiagent"].get( |
| "parent_trace_id" |
| ) |
| if child_parent != parent_id: |
| raise ValueError(f"child parent metadata differs: {edge.child_trace_id}") |
| child_to_edge[edge.child_trace_id] = edge |
| edges.append(edge) |
|
|
| expected_children = set(traces) - {lead_id} |
| if set(child_to_edge) != expected_children: |
| raise ValueError( |
| f"edge inventory differs from actors: " |
| f"missing={sorted(expected_children-set(child_to_edge))}" |
| ) |
|
|
| reachable = {lead_id} |
| while True: |
| new = { |
| edge.child_trace_id |
| for edge in edges |
| if edge.parent_trace_id in reachable |
| } |
| if new <= reachable: |
| break |
| reachable |= new |
| if reachable != set(traces): |
| raise ValueError("actor DAG is disconnected or cyclic") |
|
|
| request_count = sum(len(generate_events(trace)) for trace in traces.values()) |
| if request_count != manifest.get("requests"): |
| raise ValueError("request count differs from root manifest") |
| profile = { |
| "schema_version": 1, |
| "task_id": root_id, |
| "root_id": root_id, |
| "actors": len(traces), |
| "main_sessions": 1, |
| "subagent_sessions": len(traces) - 1, |
| "turns": request_count, |
| "main_turns": len(generate_events(traces[lead_id])), |
| "subagent_turns": request_count - len(generate_events(traces[lead_id])), |
| "task_calls": len({(e.parent_trace_id, e.batch_id) for e in edges}), |
| "task_children": len(edges), |
| "max_task_fanout_per_main_turn": max( |
| Counter( |
| (edge.parent_trace_id, edge.fork_generate_index) for edge in edges |
| ).values(), |
| default=0, |
| ), |
| "expected_prompt_tokens": manifest["target_prompt_tokens"], |
| "expected_output_tokens": manifest["target_output_tokens"], |
| "session_names": sorted(traces), |
| "supported_for_causal_smoke": True, |
| } |
| return RootProgram( |
| root_id=root_id, |
| lead_trace_id=lead_id, |
| traces=traces, |
| edges=edges, |
| manifest=manifest, |
| profile=profile, |
| ) |
|
|
|
|
| class CausalRootRunner: |
| def __init__( |
| self, |
| program: RootProgram, |
| request_executor: RequestExecutor, |
| writer: EventWriter, |
| *, |
| tool_time_scale: float, |
| run_id: str, |
| ) -> None: |
| self.program = program |
| self.request_executor = request_executor |
| self.writer = writer |
| self.tool_time_scale = tool_time_scale |
| self.run_id = run_id |
| self.actor_tasks: dict[str, asyncio.Task[None]] = {} |
| self.completed_actors: set[str] = set() |
| self.request_rows: list[dict[str, Any]] = [] |
| self.barrier_rows: list[dict[str, Any]] = [] |
| self.active_llm = 0 |
| self.peak_llm = 0 |
| self._edges_by_parent: dict[str, list[ChildEdge]] = defaultdict(list) |
| for edge in program.edges: |
| self._edges_by_parent[edge.parent_trace_id].append(edge) |
|
|
| def _identity(self, trace: ReplayTrace) -> tuple[str, str]: |
| identity = f"morphosis:{self.run_id}:{trace.trace_id}" |
| return identity, identity |
|
|
| def _start_actor(self, trace_id: str) -> asyncio.Task[None]: |
| if trace_id in self.actor_tasks: |
| raise RuntimeError(f"actor started twice: {trace_id}") |
| task = asyncio.create_task(self._run_actor(self.program.traces[trace_id])) |
| self.actor_tasks[trace_id] = task |
| return task |
|
|
| async def _await_edges( |
| self, |
| parent: ReplayTrace, |
| edges: list[ChildEdge], |
| awaited: set[tuple[str, int, int]], |
| ) -> None: |
| groups: dict[tuple[str, int, int], list[ChildEdge]] = defaultdict(list) |
| for edge in edges: |
| groups[ |
| (edge.batch_id, edge.fork_generate_index, edge.join_generate_index) |
| ].append(edge) |
| for key, group in groups.items(): |
| if key in awaited: |
| continue |
| missing = [ |
| edge.child_trace_id |
| for edge in group |
| if edge.child_trace_id not in self.actor_tasks |
| ] |
| if missing: |
| raise RuntimeError(f"join reached before child launch: {missing}") |
| started = time.perf_counter() |
| self.writer.emit( |
| "barrier_wait_started", |
| parent_trace_id=parent.trace_id, |
| batch_id=key[0], |
| fork_generate_index=key[1], |
| join_generate_index=key[2], |
| child_trace_ids=[edge.child_trace_id for edge in group], |
| ) |
| await asyncio.gather( |
| *(self.actor_tasks[edge.child_trace_id] for edge in group) |
| ) |
| row = { |
| "parent_trace_id": parent.trace_id, |
| "batch_id": key[0], |
| "fork_generate_index": key[1], |
| "join_generate_index": key[2], |
| "child_trace_ids": [edge.child_trace_id for edge in group], |
| "duration_s": time.perf_counter() - started, |
| } |
| self.barrier_rows.append(row) |
| self.writer.emit("barrier_wait_completed", **row) |
| awaited.add(key) |
|
|
| async def _run_actor(self, trace: ReplayTrace) -> None: |
| metadata = trace.metadata["multiagent"] |
| category = "main" if trace.trace_id == self.program.lead_trace_id else "subagent" |
| routing_key, cache_salt = self._identity(trace) |
| edges = self._edges_by_parent.get(trace.trace_id, []) |
| by_fork: dict[int, list[ChildEdge]] = defaultdict(list) |
| by_join: dict[int, list[ChildEdge]] = defaultdict(list) |
| for edge in edges: |
| by_fork[edge.fork_generate_index].append(edge) |
| by_join[edge.join_generate_index].append(edge) |
| awaited: set[tuple[str, int, int]] = set() |
| last_fork_edges: list[ChildEdge] = [] |
| generate_index = 0 |
|
|
| self.writer.emit( |
| "session_started", |
| session=trace.trace_id, |
| category=category, |
| actor_id=metadata.get("actor_id"), |
| parent_trace_id=metadata.get("parent_trace_id"), |
| source_start_offset_s=trace.start_offset_s, |
| ) |
| for event in trace.events: |
| if isinstance(event, Generate): |
| if by_join.get(generate_index): |
| await self._await_edges( |
| trace, by_join[generate_index], awaited |
| ) |
| self.active_llm += 1 |
| self.peak_llm = max(self.peak_llm, self.active_llm) |
| self.writer.emit( |
| "llm_started", |
| session=trace.trace_id, |
| category=category, |
| turn=generate_index, |
| active_llm=self.active_llm, |
| expected_prompt_tokens=len(event.recorded_prompt_token_ids or []), |
| expected_output_tokens=len(event.recorded_output_token_ids or []), |
| ) |
| started = time.perf_counter() |
| try: |
| outcome = await self.request_executor( |
| trace, generate_index, event, routing_key, cache_salt |
| ) |
| finally: |
| self.active_llm -= 1 |
| row = { |
| "session": trace.trace_id, |
| "category": category, |
| "turn": generate_index, |
| "expected_prompt_tokens": len( |
| event.recorded_prompt_token_ids or [] |
| ), |
| "actual_prompt_tokens": outcome.prompt_tokens, |
| "expected_output_tokens": len( |
| event.recorded_output_token_ids or [] |
| ), |
| "actual_output_tokens": outcome.completion_tokens, |
| "cached_tokens": outcome.cached_tokens, |
| "cached_tokens_details": outcome.cached_tokens_details, |
| "latency_s": outcome.latency_s, |
| "ttft_s": outcome.ttft_s, |
| "request_wall_s": time.perf_counter() - started, |
| } |
| self.request_rows.append(row) |
| self.writer.emit("llm_completed", **row) |
|
|
| last_fork_edges = by_fork.get(generate_index, []) |
| for edge in sorted(last_fork_edges, key=lambda item: item.dispatch_index): |
| self._start_actor(edge.child_trace_id) |
| self.writer.emit( |
| "child_started", |
| parent_trace_id=trace.trace_id, |
| child_trace_id=edge.child_trace_id, |
| batch_id=edge.batch_id, |
| fork_generate_index=edge.fork_generate_index, |
| join_generate_index=edge.join_generate_index, |
| dispatch_index=edge.dispatch_index, |
| ) |
| generate_index += 1 |
| continue |
|
|
| kind = type(event).__name__ |
| if kind == "Wait": |
| if last_fork_edges: |
| await self._await_edges(trace, last_fork_edges, awaited) |
| last_fork_edges = [] |
| elif event.seconds > 0 and self.tool_time_scale > 0: |
| await asyncio.sleep(event.seconds * self.tool_time_scale) |
| continue |
| |
| |
|
|
| if edges: |
| await self._await_edges(trace, edges, awaited) |
| self.completed_actors.add(trace.trace_id) |
| self.writer.emit( |
| "session_completed", |
| session=trace.trace_id, |
| category=category, |
| turns=generate_index, |
| ) |
|
|
| async def run(self) -> dict[str, Any]: |
| started = time.perf_counter() |
| self.writer.emit( |
| "root_started", |
| task_id=self.program.root_id, |
| actors=len(self.program.traces), |
| requests=self.program.profile["turns"], |
| ) |
| lead = self._start_actor(self.program.lead_trace_id) |
| await lead |
| await asyncio.gather(*self.actor_tasks.values()) |
| if set(self.actor_tasks) != set(self.program.traces): |
| raise RuntimeError("not every actor was launched") |
| if self.completed_actors != set(self.program.traces): |
| raise RuntimeError("not every actor completed") |
| elapsed = time.perf_counter() - started |
| summary = { |
| "schema_version": 1, |
| "task_id": self.program.root_id, |
| "success": True, |
| "elapsed_s": elapsed, |
| "requests": len(self.request_rows), |
| "actual_prompt_tokens": sum( |
| row["actual_prompt_tokens"] for row in self.request_rows |
| ), |
| "actual_output_tokens": sum( |
| row["actual_output_tokens"] for row in self.request_rows |
| ), |
| "cached_tokens": sum(row["cached_tokens"] for row in self.request_rows), |
| "peak_active_llm": self.peak_llm, |
| "barriers": self.barrier_rows, |
| "trace_profile": self.program.profile, |
| } |
| self.writer.emit("root_completed", **summary) |
| return summary |
|
|
|
|
| def request_rid(run_id: str, trace_id: str, generate_index: int) -> str: |
| digest = hashlib.sha256( |
| f"{run_id}|{trace_id}|{generate_index}".encode("utf-8") |
| ).hexdigest()[:32] |
| return f"rid_{digest}" |
|
|
|
|
| def production_executor( |
| client: Client, |
| *, |
| run_id: str, |
| root_start: float, |
| ) -> RequestExecutor: |
| accumulators: dict[str, StreamAccumulator] = defaultdict(StreamAccumulator) |
|
|
| async def execute( |
| trace: ReplayTrace, |
| generate_index: int, |
| event: Generate, |
| routing_key: str, |
| cache_salt: str, |
| ) -> RequestOutcome: |
| prompt_ids = event.recorded_prompt_token_ids |
| output_ids = event.recorded_output_token_ids |
| if ( |
| not isinstance(prompt_ids, list) |
| or not prompt_ids |
| or not isinstance(output_ids, list) |
| or not output_ids |
| or event.max_tokens != len(output_ids) |
| ): |
| raise ValueError( |
| f"incomplete DSV4 token contract: {trace.trace_id}/{generate_index}" |
| ) |
| result = await client._execute_request( |
| prompt_ids, |
| len(output_ids), |
| stream=True, |
| trace_start=root_start, |
| stream_acc=accumulators[trace.trace_id], |
| cache_salt=cache_salt, |
| routing_key=routing_key, |
| return_token_ids=True, |
| deterministic_sampling=True, |
| forced_output_token_ids=output_ids, |
| rid=request_rid(run_id, trace.trace_id, generate_index), |
| strict_replay_deadline_audit=True, |
| disconnect_abort_delay_seconds=0.0, |
| connect_retry_limit=0, |
| ) |
| if result.prompt_token_ids != prompt_ids: |
| raise ValueError( |
| f"server prompt IDs differ: {trace.trace_id}/{generate_index}" |
| ) |
| if result.generated_token_ids != output_ids: |
| raise ValueError( |
| f"server output IDs differ: {trace.trace_id}/{generate_index}" |
| ) |
| if ( |
| result.request_started_at_s is None |
| or result.request_finished_at_s is None |
| or result.first_token_at_s is None |
| ): |
| raise ValueError("server request timing is incomplete") |
| return RequestOutcome( |
| prompt_tokens=result.prompt_tokens, |
| completion_tokens=result.completion_tokens, |
| cached_tokens=result.cached_tokens, |
| cached_tokens_details=result.cached_tokens_details, |
| latency_s=result.request_finished_at_s - result.request_started_at_s, |
| ttft_s=result.first_token_at_s - result.request_started_at_s, |
| ) |
|
|
| return execute |
|
|
|
|
| def simulated_executor() -> RequestExecutor: |
| async def execute( |
| trace: ReplayTrace, |
| generate_index: int, |
| event: Generate, |
| routing_key: str, |
| cache_salt: str, |
| ) -> RequestOutcome: |
| await asyncio.sleep(0) |
| return RequestOutcome( |
| prompt_tokens=len(event.recorded_prompt_token_ids or []), |
| completion_tokens=len(event.recorded_output_token_ids or []), |
| cached_tokens=0, |
| cached_tokens_details=None, |
| latency_s=0.001, |
| ttft_s=0.0005, |
| ) |
|
|
| return execute |
|
|
|
|
| def parser() -> argparse.ArgumentParser: |
| result = argparse.ArgumentParser() |
| result.add_argument("--archive", type=Path, required=True) |
| result.add_argument("--output-dir", type=Path, required=True) |
| result.add_argument("--endpoint") |
| result.add_argument("--model", default="deepseek-v4-flash") |
| result.add_argument("--tool-time-scale", type=float, default=1.0) |
| result.add_argument("--stream-interval", type=int, default=64) |
| result.add_argument("--timeout-s", type=float, default=7200.0) |
| result.add_argument("--run-id") |
| result.add_argument("--strict-turns", type=Path) |
| result.add_argument("--strict-compactions", type=Path) |
| result.add_argument("--simulate", action="store_true") |
| return result |
|
|
|
|
| def main() -> None: |
| args = parser().parse_args() |
| if args.model != "deepseek-v4-flash": |
| raise ValueError("materialized workload requires model=deepseek-v4-flash") |
| if args.tool_time_scale != 1.0: |
| raise ValueError("this campaign requires tool_time_scale=1") |
| if args.stream_interval <= 0 or args.timeout_s <= 0: |
| raise ValueError("stream interval and timeout must be positive") |
| if not args.simulate and not args.endpoint: |
| raise ValueError("--endpoint is required outside simulation") |
| if args.endpoint and not args.endpoint.endswith("/v1"): |
| raise ValueError("--endpoint must end with /v1") |
| for path in (args.strict_turns, args.strict_compactions): |
| if path is not None and not path.is_file(): |
| raise FileNotFoundError(path) |
| if not args.simulate: |
| if args.strict_turns is None or args.strict_compactions is None: |
| raise ValueError("production replay requires the materialization seal") |
| if args.strict_turns.resolve() != args.strict_compactions.resolve(): |
| raise ValueError("both strict-store arguments must bind the same seal") |
| seal = json.loads(args.strict_turns.read_text(encoding="utf-8")) |
| if ( |
| seal.get("kind") != "morphosis-dsv4-materialization" |
| or seal.get("roots") != 100 |
| or seal.get("target", {}).get("model") != "deepseek-v4-flash" |
| ): |
| raise ValueError("materialization seal does not authorize this replay") |
|
|
| program = load_root_archive(args.archive) |
| args.output_dir.mkdir(parents=True, exist_ok=True) |
| atomic_json(args.output_dir / "trace-profile.json", program.profile) |
| run_id = args.run_id or f"morphosis-{time.time_ns()}" |
| writer = EventWriter(args.output_dir / "replay-events.jsonl", run_id) |
| root_start = time.perf_counter() |
| client = None |
| if args.simulate: |
| executor = simulated_executor() |
| else: |
| client = Client( |
| endpoint=args.endpoint, |
| model=args.model, |
| api_key="unused", |
| seed=0, |
| max_retries=0, |
| timeout=args.timeout_s, |
| strict_replay_connect_retries=0, |
| stream_interval=args.stream_interval, |
| ) |
| executor = production_executor(client, run_id=run_id, root_start=root_start) |
|
|
| summary_path = args.output_dir / "replay-summary.json" |
| try: |
| summary = asyncio.run( |
| CausalRootRunner( |
| program, |
| executor, |
| writer, |
| tool_time_scale=args.tool_time_scale, |
| run_id=run_id, |
| ).run() |
| ) |
| except BaseException as error: |
| atomic_json( |
| summary_path, |
| { |
| "schema_version": 1, |
| "task_id": program.root_id, |
| "success": False, |
| "error_type": type(error).__name__, |
| "error": str(error), |
| "traceback": traceback.format_exc(), |
| "trace_profile": program.profile, |
| }, |
| ) |
| raise |
| finally: |
| writer.close() |
| atomic_json(summary_path, summary) |
| print(json.dumps(summary, indent=2, sort_keys=True)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
