"""Command-line interface for research data, reproduction, and reporting.""" from __future__ import annotations import argparse import asyncio import base64 import hashlib import json import os import sys import tempfile import time from collections.abc import AsyncIterator, Callable, Iterator, Mapping, Sequence from contextlib import suppress from dataclasses import asdict, dataclass from decimal import Decimal from pathlib import Path from typing import Any, Literal, cast import pyarrow as pa # type: ignore[import-untyped] from microstructure import __version__ from microstructure.config import ProjectConfig, datetime_to_ns, load_config from microstructure.data.binance import ( BinanceLiveDepthCollector, BinancePublicClient, CapturedDepth, RawDepthFrame, ) from microstructure.data.book import BookSnapshot, IncrementalBookReconstructor from microstructure.data.quality import IncrementalQualityValidator, ValidationReport from microstructure.data.schemas import get_schema, table_from_records from microstructure.data.storage import write_capture_parquet, write_source_manifest from microstructure.data.synthetic import generate_synthetic_market from microstructure.ingestion import ( IngestionResult, ingest_from_config, validate_configured_input, ) from microstructure.m8_acquisition import ( M8AcquisitionFailureResult, M8AcquisitionResult, acquire_m8_archives, ) from microstructure.m8_config import load_m8_config from microstructure.m8_l2_analysis_config import ( M8L2AnalysisConfig, load_m8_l2_analysis_config, ) from microstructure.m8_l2_binance import BinanceM8L2Capture from microstructure.m8_l2_capture import ( M8L2SessionBundle, capture_m8_l2_session, verify_m8_l2_session_bundle, ) from microstructure.m8_l2_config import M8L2StudyConfig, load_m8_l2_config from microstructure.m8_l2_development import ( L2DevelopmentInputVerifier, L2DevelopmentLockResult, lock_m8_l2_development, verify_m8_l2_development_lock, ) from microstructure.m8_l2_inputs import ( L2CampaignRuntimeIdentity, L2SessionFileAuthority, verify_m8_l2_development_input, ) from microstructure.m8_l2_pipeline import ( L2StudySessionAuthority, M8L2StudyRunResult, load_m8_l2_report_data, reproduce_m8_l2_study, verify_m8_l2_study_run, ) from microstructure.m8_pipeline import M8RunResult, reproduce_m8, verify_m8_result from microstructure.pipeline import reproduce from microstructure.provenance import read_json, sha256_file, utc_now_iso, write_json from microstructure.reporting import ( canonical_report_data_sha256, load_run_bundle, verify_checksums, write_l2_report_set, write_report_set, ) def _json_default(value: object) -> object: if isinstance(value, Path): return str(value) if isinstance(value, Decimal): return str(value) raise TypeError(f"cannot serialize {type(value).__name__}") def _print_json(payload: object) -> None: print(json.dumps(payload, indent=2, sort_keys=True, default=_json_default)) def _ingestion_payload(result: IngestionResult) -> dict[str, Any]: return { "mode": result.mode, "evidence_tier": result.evidence_tier, "output_root": result.output_root, "ingestion_manifest": result.ingestion_manifest_path, "ingestion_manifest_sha256": result.ingestion_manifest_sha256, "rows": result.rows, "datasets": [ { "schema": dataset.schema_name, "rows": dataset.rows, "manifest": dataset.storage.manifest_path, "manifest_sha256": dataset.storage.manifest_sha256, "quality_errors": dataset.validation.error_count, "quality_warnings": dataset.validation.warning_count, } for dataset in result.datasets ], "raw_artifacts": len(result.raw_artifacts), "symbols": [ { "symbol": item.symbol, "rows": item.rows, "complete_range": item.complete_range, "tick_size": item.metadata.tick_size, "lot_size": item.metadata.lot_size, } for item in result.symbols ], "quality": { "passed": result.validation.passed, "rows_checked": result.validation.rows_checked, "errors": result.validation.error_count, "warnings": result.validation.warning_count, }, } def _cmd_ingest(args: argparse.Namespace) -> int: config = load_config(args.config) output_root = ( Path(args.output_root).resolve() if args.output_root else config.data.partition_root.parent ) result = ingest_from_config(config, output_root) _print_json(_ingestion_payload(result)) return 0 def _m8_acquisition_payload(result: M8AcquisitionResult) -> dict[str, Any]: return { "status": "acquired", "scope": "raw_only", "output_root": result.output_root, "raw_manifest": result.manifest_path, "raw_manifest_sha256": result.manifest_sha256, "metadata_responses": result.metadata_count, "archives": result.archive_count, "total_raw_evidence_bytes": result.total_raw_evidence_bytes, "csv_members_opened": False, "economic_fields_inspected": False, } def _m8_acquisition_failure_payload(result: M8AcquisitionFailureResult) -> dict[str, Any]: failed_date = result.failed_date return { "status": "INSUFFICIENT_DATA", "scope": "raw_only", "output_root": result.output_root, "attempt_dir": result.attempt_dir, "failure_manifest": result.attempt_manifest_path, "failure_manifest_sha256": result.attempt_manifest_sha256, "checksums": result.checksums_path, "checksums_sha256": result.checksums_sha256, "terminal_marker": result.terminal_path, "reason_code": result.reason_code, "diagnostic": result.diagnostic, "failed_symbol": result.failed_symbol, "failed_date": None if failed_date is None else failed_date.isoformat(), "failed_role": result.failed_role, "completed_steps": result.completed_count, "remaining_steps": result.remaining_count, "retained_inventory_sha256": result.retained_inventory_sha256, "retained_artifacts": result.retained_artifact_count, "total_raw_evidence_bytes": result.total_raw_evidence_bytes, "csv_members_opened": False, "economic_fields_inspected": False, } def _cmd_acquire_m8(args: argparse.Namespace) -> int: config = load_m8_config(args.config) result = acquire_m8_archives(config, Path(args.output_root).resolve()) if isinstance(result, M8AcquisitionFailureResult): _print_json(_m8_acquisition_failure_payload(result)) return 1 _print_json(_m8_acquisition_payload(result)) return 0 def _synthetic_tables(config: ProjectConfig) -> dict[str, Any]: events = config.data.events_per_symbol if events is None: raise ValueError("synthetic validation requires data.events_per_symbol") generated = generate_synthetic_market( symbols=config.data.symbols, events_per_symbol=events, start_ts_ns=datetime_to_ns(config.data.start), seed=config.run.seed, ) return {"trades": generated.trades, "book_observations": generated.book_observations} def _cmd_validate(args: argparse.Namespace) -> int: config = load_config(args.config) tables = _synthetic_tables(config) if config.data.mode == "synthetic" else None summary = validate_configured_input(config, tables=tables) _print_json( { "passed": summary.passed, "rows_checked": summary.rows_checked, "errors": summary.error_count, "warnings": summary.warning_count, "reports": [ { "dataset": report.dataset, "rows_checked": report.rows_checked, "errors": report.error_count, "warnings": report.warning_count, } for report in summary.reports ], "mutation_policy": "validation did not repair or replace observations", } ) return 0 if summary.passed else 1 def _cmd_reproduce(args: argparse.Namespace) -> int: config = load_config(args.config) output = reproduce( config, Path(args.run_dir), ingestion_manifest_path=args.ingestion_manifest, ingestion_manifest_sha256=args.ingestion_manifest_sha256, ) bundle = load_run_bundle(output) _print_json( { "run_dir": output, "run_id": bundle.run_id, "evidence_tier": bundle.evidence_tier, "observed_start_utc": bundle.observed_start_utc, "observed_end_utc": bundle.observed_end_utc, "status": "complete", } ) return 0 def _cmd_reproduce_m8(args: argparse.Namespace) -> int: config = load_m8_config(args.config) result = reproduce_m8( config, Path(args.run_dir), raw_manifest_path=Path(args.raw_manifest), raw_manifest_sha256=str(args.raw_manifest_sha256), ) if result.status == "INSUFFICIENT_DATA": _print_json(_m8_run_result_payload(result)) return 1 bundle = load_run_bundle(result.path) _print_json( { "run_dir": result.path, "run_id": bundle.run_id, "evidence_tier": bundle.evidence_tier, "observed_start_utc": bundle.observed_start_utc, "observed_end_utc": bundle.observed_end_utc, "status": result.status, "raw_manifest_sha256": result.raw_manifest_sha256, "normalized_manifest_sha256": result.normalized_manifest_sha256, } ) return 0 def _m8_run_result_payload(result: M8RunResult) -> dict[str, Any]: return { "run_dir": result.path, "status": result.status, "raw_manifest_sha256": result.raw_manifest_sha256, "normalized_manifest_sha256": result.normalized_manifest_sha256, } def _cmd_verify_m8(args: argparse.Namespace) -> int: config = load_m8_config(args.config) result = verify_m8_result( args.run_dir, config, raw_manifest_path=args.raw_manifest, raw_manifest_sha256=args.raw_manifest_sha256, ) payload = _m8_run_result_payload(result) payload.update( { "integrity": "verified", "protected_files": verify_checksums(result.path), } ) _print_json(payload) return 0 def _external_report_dir(run_root: Path, requested: Path | None) -> Path: frozen_root = run_root.resolve() output = ( requested.resolve() if requested is not None else frozen_root.with_name(f"{frozen_root.name}-reports") ) if output == frozen_root or frozen_root in output.parents: raise ValueError("report output directory must be outside the immutable run bundle") return output def _atomic_text(path: Path, content: str) -> None: path.parent.mkdir(parents=True, exist_ok=True) descriptor, temporary_name = tempfile.mkstemp( dir=path.parent, prefix=f".{path.name}.", suffix=".tmp", text=True, ) temporary = Path(temporary_name) try: with os.fdopen(descriptor, "w", encoding="utf-8", newline="\n") as handle: handle.write(content) handle.flush() os.fsync(handle.fileno()) os.replace(temporary, path) directory = os.open(path.parent, os.O_RDONLY) try: os.fsync(directory) finally: os.close(directory) except BaseException: temporary.unlink(missing_ok=True) raise def _report_mapping(value: object, label: str) -> Mapping[str, Any]: if not isinstance(value, Mapping): raise ValueError(f"verified M8 {label} is not a JSON object") return cast(Mapping[str, Any], value) def _report_value(value: object) -> str: if isinstance(value, (dict, list, tuple)): rendered = json.dumps(value, sort_keys=True, separators=(",", ":")) elif value is None: rendered = "null" elif value is True: rendered = "true" elif value is False: rendered = "false" else: rendered = str(value) return " ".join(rendered.replace("`", "'").split()) def _m8_failure_period(failure: Mapping[str, Any]) -> tuple[str, str]: dates: list[str] = [] for key in ("completed_normalizations", "stopped_before"): rows = failure.get(key) if isinstance(rows, list): dates.extend( str(row["date"]) for row in rows if isinstance(row, Mapping) and isinstance(row.get("date"), str) and len(str(row["date"])) == 10 ) failed_date = failure.get("failed_date") if isinstance(failed_date, str) and len(failed_date) == 10: dates.append(failed_date) if not dates: raise ValueError("verified M8 failure does not declare its study period") return min(dates), max(dates) def _render_m8_insufficient_report(run_root: Path) -> str: failure = _report_mapping(read_json(run_root / "failure.json"), "failure record") provenance = _report_mapping(read_json(run_root / "provenance.json"), "provenance") manifest = _report_mapping(read_json(run_root / "run_manifest.json"), "run manifest") research = _report_mapping(manifest.get("research"), "run research section") execution = _report_mapping( manifest.get("execution_assumptions"), "execution-assumptions section", ) git = _report_mapping(provenance.get("git"), "Git identity") period_start, period_end = _m8_failure_period(failure) completed_symbols = failure.get("selection_completed_symbols") evaluated_symbols = failure.get("endpoint_evaluation_completed_symbols") heldout_member = failure.get("held_out_member_opened", "not separately recorded") return f"""# M8 study result: INSUFFICIENT_DATA > VERIFIED TERMINAL TRADE-ONLY RESEARCH RESULT — NO DATE REPLACEMENT, LIVE TRADING, OR PERFORMANCE CLAIM ## Frozen scope and failure - Observed/attempted archive date span: `{period_start}` through `{period_end}` (UTC daily archives) - Failed coordinate: symbol=`{_report_value(failure.get("failed_symbol"))}`, date=`{_report_value(failure.get("failed_date"))}`, role=`{_report_value(failure.get("failed_role"))}` - Failure stage: `{_report_value(failure.get("failure_stage"))}` - Reason code: `{_report_value(failure.get("reason_code"))}` - Diagnostic: `{_report_value(failure.get("reason"))}` - Replacement date selected: `{_report_value(failure.get("replacement_date_selected"))}`; reselection performed: `{_report_value(failure.get("reselection_performed"))}` ## Immutable authority - Config semantic SHA-256: `{_report_value(failure.get("config_sha256"))}` - Config source SHA-256: `{_report_value(failure.get("config_source_sha256"))}` - Raw acquisition manifest SHA-256: `{_report_value(failure.get("raw_acquisition_manifest_sha256"))}` - Bundled raw acquisition manifest SHA-256: `{_report_value(failure.get("bundled_raw_acquisition_manifest_sha256"))}` - Protocol SHA-256: `{_report_value(failure.get("protocol_sha256"))}` - Git commit: `{_report_value(git.get("commit"))}` - Git dirty: `{_report_value(git.get("dirty"))}` - Source-tree SHA-256: `{_report_value(git.get("source_tree_sha256"))}` ## Terminal analysis states - Candidate selection started: `{_report_value(failure.get("selection_started"))}`; completed symbols: `{_report_value(completed_symbols)}` - Aggregate analysis lock committed: `{_report_value(failure.get("aggregate_lock_committed"))}` - Held-out member opened: `{_report_value(heldout_member)}` - Endpoint evaluation started: `{_report_value(failure.get("endpoint_evaluation_started"))}`; completed: `{_report_value(failure.get("endpoint_evaluation_completed"))}`; completed symbols: `{_report_value(evaluated_symbols)}` - Predictions published: `{_report_value(failure.get("predictions_published"))}`; endpoint artifacts published: `{_report_value(failure.get("endpoint_artifacts_published"))}` - Research endpoint status: `{_report_value(research.get("endpoint_status"))}` - Execution status: `{_report_value(execution.get("status"))}`; fills calculated: `{_report_value(execution.get("fills_calculated"))}`; P&L calculated: `{_report_value(execution.get("pnl_calculated"))}`; capacity calculated: `{_report_value(execution.get("capacity_calculated"))}` This terminal result preserves the frozen calendar and failure evidence. It authorizes no execution, profitability, capacity, statistical-significance, or persistent-alpha claim. """ def _cmd_report_m8(args: argparse.Namespace) -> int: config = load_m8_config(args.config) result = verify_m8_result( args.run_dir, config, raw_manifest_path=args.raw_manifest, raw_manifest_sha256=args.raw_manifest_sha256, ) output = _external_report_dir(result.path, args.output_dir) if result.status == "COMPLETE": bundle = load_run_bundle(result.path) paths = write_report_set(bundle, output) _print_json( { **_m8_run_result_payload(result), "output_dir": output, "reports_regenerated": True, **asdict(paths), } ) else: rendered = _render_m8_insufficient_report(result.path) confirmed = verify_m8_result( args.run_dir, config, raw_manifest_path=args.raw_manifest, raw_manifest_sha256=args.raw_manifest_sha256, ) if ( confirmed.status != "INSUFFICIENT_DATA" or confirmed.path.resolve() != result.path.resolve() or confirmed.raw_manifest_sha256 != result.raw_manifest_sha256 or confirmed.normalized_manifest_sha256 is not None ): raise ValueError("M8 failure authority changed while rendering its report") failure_report = output / "insufficient_data.md" _atomic_text(failure_report, rendered) _print_json( { **_m8_run_result_payload(result), "output_dir": output, "report": failure_report, "report_sha256": sha256_file(failure_report), "reports_regenerated": True, "source_bundle_modified": False, } ) return 0 def _lowercase_sha256(value: str) -> str: if len(value) != 64 or any(character not in "0123456789abcdef" for character in value): raise argparse.ArgumentTypeError("must be a 64-character lowercase SHA-256 digest") return value def _cmd_verify(args: argparse.Namespace) -> int: bundle = load_run_bundle(args.run_dir) protected = verify_checksums(args.run_dir) _print_json( { "run_dir": bundle.root, "run_id": bundle.run_id, "evidence_tier": bundle.evidence_tier, "protected_files": protected, "integrity": "verified", } ) return 0 def _cmd_report(args: argparse.Namespace) -> int: bundle = load_run_bundle(args.run_dir) output = ( Path(args.output_dir).resolve() if args.output_dir else bundle.root.with_name(f"{bundle.root.name}-reports") ) paths = write_report_set(bundle, output) _print_json({"run_id": bundle.run_id, "output_dir": output, **asdict(paths)}) return 0 _LIVE_BATCH_ROWS = 1_024 _MAX_LIVE_RAW_MESSAGE_BYTES = 1 * 1024 * 1024 _LIVE_BATCH_ESTIMATED_BYTES = 16 * 1024 * 1024 _VARIABLE_RECORD_OVERHEAD_FACTOR = 8 @dataclass(frozen=True, slots=True) class DepthCaptureResult: symbol: str messages: int continuity_epochs: int reconstruction_status: Literal["LIVE", "GAPPED", "INVALID"] book_observations: int sequence_gaps: int stale_events: int excluded_messages: int final_update_id: int quality_errors: int quality_warnings: int raw_path: Path raw_manifest_path: Path raw_manifest_sha256: str summary_path: Path completion_reason: str requested_duration_seconds: float | None elapsed_monotonic_seconds: float receipt_coverage_seconds: float max_continuity_epoch_seconds: float @dataclass(slots=True) class _DepthCaptureStop: reason: str = "not_started" elapsed_monotonic_seconds: float = 0.0 @dataclass(slots=True) class _DepthEpochCoverage: continuity_id: str snapshot_id: str first_received_ns: int last_received_ns: int messages: int = 0 book_observations: int = 0 excluded_messages: int = 0 sequence_gaps: int = 0 reconstruction_status: Literal["LIVE", "GAPPED", "INVALID"] = "LIVE" final_update_id: int = 0 @property def duration_seconds(self) -> float: return max(0.0, (self.last_received_ns - self.first_received_ns) / 1_000_000_000.0) def to_dict(self) -> dict[str, object]: return { "continuity_id": self.continuity_id, "snapshot_id": self.snapshot_id, "first_received_ns": self.first_received_ns, "last_received_ns": self.last_received_ns, "duration_seconds": self.duration_seconds, "messages": self.messages, "book_observations": self.book_observations, "excluded_messages": self.excluded_messages, "sequence_gaps": self.sequence_gaps, "reconstruction_status": self.reconstruction_status, "final_update_id": self.final_update_id, } async def _bounded_depth_items( collector: BinanceLiveDepthCollector, *, max_messages: int, duration_seconds: float | None, stop: _DepthCaptureStop, ) -> AsyncIterator[CapturedDepth]: """Yield a live stream until its safety cap or a graceful duration deadline.""" started = time.monotonic() yielded = 0 iterator = collector.stream(max_messages=max_messages).__aiter__() try: if duration_seconds is None: async for item in iterator: yielded += 1 yield item stop.reason = "message_limit" if yielded == max_messages else "stream_ended_early" return deadline = started + duration_seconds while True: remaining = deadline - time.monotonic() if remaining <= 0: stop.reason = "duration_elapsed" return try: item = await asyncio.wait_for(anext(iterator), timeout=remaining) except TimeoutError: stop.reason = "duration_elapsed" return except StopAsyncIteration: stop.reason = ( "message_safety_ceiling" if yielded == max_messages else "stream_ended_early" ) return yielded += 1 yield item finally: stop.elapsed_monotonic_seconds = max(0.0, time.monotonic() - started) with suppress(BaseException): closer = getattr(iterator, "aclose", None) if callable(closer): await closer() @dataclass(frozen=True, slots=True) class _PublishedRawCapture: path: Path sha256: str manifest_path: Path manifest_sha256: str class _ArrowBatchSpool: """Bounded record buffer backed by a temporary Arrow IPC stream.""" def __init__( self, *, root: Path, schema_name: str, batch_rows: int, max_buffer_bytes: int, on_batch: Callable[[pa.RecordBatch], None] | None = None, ) -> None: if batch_rows < 1: raise ValueError("batch_rows must be positive") if max_buffer_bytes < 1: raise ValueError("max_buffer_bytes must be positive") self.schema_name = schema_name self.batch_rows = batch_rows self.max_buffer_bytes = max_buffer_bytes self.path = root / f"{schema_name}.arrow" self._handle = self.path.open("wb") self._writer = pa.ipc.new_stream(self._handle, get_schema(schema_name)) self._on_batch = on_batch self._records: list[Mapping[str, object]] = [] self.rows = 0 self.max_buffered_rows = 0 self.max_buffered_estimated_bytes = 0 self._buffered_estimated_bytes = 0 self._closed = False def append(self, record: Mapping[str, object], *, estimated_bytes: int) -> None: if self._closed: raise RuntimeError("cannot append to a closed Arrow spool") if estimated_bytes < 1: raise ValueError("estimated_bytes must be positive") if estimated_bytes > self.max_buffer_bytes: raise RuntimeError(f"one {self.schema_name} record exceeds the bounded batch estimate") if ( self._records and self._buffered_estimated_bytes + estimated_bytes > self.max_buffer_bytes ): self._flush() self._records.append(record) self._buffered_estimated_bytes += estimated_bytes self.max_buffered_rows = max(self.max_buffered_rows, len(self._records)) self.max_buffered_estimated_bytes = max( self.max_buffered_estimated_bytes, self._buffered_estimated_bytes, ) if len(self._records) >= self.batch_rows: self._flush() def _flush(self) -> None: if not self._records: return table = table_from_records(self.schema_name, self._records) batches = table.to_batches(max_chunksize=self.batch_rows) if len(batches) != 1 or batches[0].num_rows > self.batch_rows: raise RuntimeError(f"failed to construct one bounded {self.schema_name} batch") batch = batches[0] if self._on_batch is not None: self._on_batch(batch) self._writer.write_batch(batch) self.rows += batch.num_rows self._records.clear() self._buffered_estimated_bytes = 0 def close(self) -> None: if self._closed: return self._flush() self._writer.close() if not self._handle.closed: self._handle.flush() os.fsync(self._handle.fileno()) self._handle.close() self._closed = True def iter_batches(self) -> Iterator[pa.RecordBatch]: if not self._closed: raise RuntimeError("Arrow spool must be closed before it can be read") with self.path.open("rb") as handle: reader = pa.ipc.open_stream(handle) for batch in reader: if batch.num_rows > self.batch_rows: raise RuntimeError( f"spooled {self.schema_name} batch exceeds {self.batch_rows} rows" ) yield batch class _RawMessageSpool: """Incrementally persist an exact, typed live-capture journal.""" def __init__(self, *, root: Path, symbol: str, source_uri: str) -> None: self.root = root self.symbol = symbol self.source_uri = source_uri self.directory = root / "raw" / "binance_spot" / "depth_stream" / symbol self.directory.mkdir(parents=True, exist_ok=True) descriptor, temporary_name = tempfile.mkstemp( dir=self.directory, prefix=".capture-", suffix=".ndjson.tmp", text=True, ) self._temporary_path = Path(temporary_name) self._handle = os.fdopen(descriptor, "w", encoding="utf-8", newline="\n") self.messages = 0 self.snapshot_anchors = 0 self.first_received_ns: int | None = None self.last_received_ns: int | None = None self._closed = False self.published_path: Path | None = None self._last_frame_identity: tuple[str, int, int, str] | None = None @property def evidence_path(self) -> Path: """Return the durable path, or the fsynced temporary path after publish failure.""" return self.published_path or self._temporary_path def _write_event(self, event: Mapping[str, object]) -> None: if self._closed: raise RuntimeError("cannot append to a closed raw capture") json.dump(event, self._handle, sort_keys=True, separators=(",", ":")) self._handle.write("\n") def append_frame(self, frame: RawDepthFrame) -> int: """Journal one exact frame before any UTF-8 or JSON parsing.""" payload_size = len(frame.payload) payload_sha256 = hashlib.sha256(frame.payload).hexdigest() self._write_event( { "capture_seq": frame.capture_seq, "continuity_id": frame.continuity_id, "event_kind": "websocket_frame", "payload_base64": base64.b64encode(frame.payload).decode("ascii"), "payload_bytes": payload_size, "payload_sha256": payload_sha256, "received_ts_ns": frame.received_ts_ns, "websocket_message_type": "text" if frame.was_text else "binary", } ) self.messages += 1 if self.first_received_ns is None: self.first_received_ns = frame.received_ts_ns self.last_received_ns = frame.received_ts_ns self._last_frame_identity = ( frame.continuity_id, frame.capture_seq, frame.received_ts_ns, payload_sha256, ) # The oversize frame is intentionally journaled before capture fails. if payload_size > _MAX_LIVE_RAW_MESSAGE_BYTES: raise RuntimeError( f"live depth message exceeds {_MAX_LIVE_RAW_MESSAGE_BYTES} raw bytes" ) return payload_size def append_captured(self, item: CapturedDepth) -> int: """Verify callback lineage, with a fallback for injected legacy collectors.""" received_ts_ns = item.delta.received_ts_ns capture_seq = item.delta.capture_seq if received_ts_ns is None or capture_seq is None: raise RuntimeError("captured depth messages require receipt time and capture sequence") payload = item.raw_payload.encode("utf-8") payload_sha256 = hashlib.sha256(payload).hexdigest() identity = ( item.delta.continuity_id, capture_seq, received_ts_ns, payload_sha256, ) if self._last_frame_identity != identity: self.append_frame( RawDepthFrame( payload=payload, was_text=True, received_ts_ns=received_ts_ns, capture_seq=capture_seq, continuity_id=item.delta.continuity_id, ) ) if item.delta.source_artifact_id != payload_sha256: raise RuntimeError("normalized depth delta is not bound to its raw frame SHA-256") return len(payload) def append_snapshot(self, snapshot: BookSnapshot) -> None: """Bind one REST snapshot raw artifact into the capture journal.""" raw_path = ( self.root / "raw" / "binance_spot" / "depth_snapshots" / snapshot.symbol / f"{snapshot.source_artifact_id}.json" ) if not raw_path.is_file() or sha256_file(raw_path) != snapshot.source_artifact_id: raise RuntimeError("book snapshot is not bound to its preserved raw response") manifest_path: Path | None = None for candidate in raw_path.parent.glob(f"{raw_path.name}.manifest-*.json"): payload = read_json(candidate) if ( isinstance(payload, dict) and payload.get("path") == raw_path.name and isinstance(payload.get("checksum"), dict) and payload["checksum"].get("value") == snapshot.source_artifact_id and (manifest_path is None or candidate.name > manifest_path.name) ): manifest_path = candidate if manifest_path is None: raise RuntimeError("book snapshot raw response has no valid source manifest") self._write_event( { "continuity_id": snapshot.continuity_id, "event_kind": "rest_snapshot_anchor", "last_update_id": snapshot.last_update_id, "raw_manifest_path": str(manifest_path), "raw_manifest_sha256": sha256_file(manifest_path), "raw_path": str(raw_path), "raw_sha256": snapshot.source_artifact_id, "received_ts_ns": snapshot.received_ts_ns, "snapshot_id": snapshot.snapshot_id, } ) self.snapshot_anchors += 1 def _close(self) -> None: if self._closed: return self._handle.flush() os.fsync(self._handle.fileno()) self._handle.close() self._closed = True def publish( self, *, status: str, error: BaseException | None = None, ) -> _PublishedRawCapture: self._close() if self.published_path is not None: destination = self.published_path digest = sha256_file(destination) else: digest = sha256_file(self._temporary_path) prefix = "capture" if status == "raw_capture_complete" else "capture-failed" destination = self.directory / f"{prefix}-{digest}.ndjson" if destination.exists(): if sha256_file(destination) != digest: raise RuntimeError(f"raw depth capture collision at {destination}") self._temporary_path.unlink(missing_ok=True) else: os.replace(self._temporary_path, destination) self.published_path = destination response_headers = { "x-local-capture-status": status, "x-local-journal-format": "typed-base64-frames-v1", "x-local-message-count": str(self.messages), "x-local-snapshot-anchor-count": str(self.snapshot_anchors), } if error is not None: response_headers["x-local-error-type"] = type(error).__name__ response_headers["x-local-error"] = str(error)[:512] manifest_path, manifest_sha = write_source_manifest( destination, source="binance_spot_public_live_capture_journal", source_uri=self.source_uri, downloaded_at_utc=utc_now_iso(), requested_start_ns=self.first_received_ns, requested_end_ns=( self.last_received_ns + 1 if self.last_received_ns is not None else None ), response_headers=response_headers, ) return _PublishedRawCapture( path=destination, sha256=digest, manifest_path=manifest_path, manifest_sha256=manifest_sha, ) def close_without_deleting(self) -> None: self._close() def _status_max( current: Literal["LIVE", "GAPPED", "INVALID"], observed: Literal["LIVE", "GAPPED", "INVALID"], ) -> Literal["LIVE", "GAPPED", "INVALID"]: rank = {"LIVE": 0, "GAPPED": 1, "INVALID": 2} return observed if rank[observed] > rank[current] else current def _failure_record( *, output_root: Path, capture_id: str, symbol: str, raw_spool: _RawMessageSpool, raw_evidence: _PublishedRawCapture | None, error: BaseException, ) -> None: write_json( output_root / "quality" / f"live_depth_capture.{capture_id}.failed.json", { "generated_at_utc": utc_now_iso(), "capture_id": capture_id, "capture_status": "FAILED", "symbol": symbol, "messages_preserved": raw_spool.messages, "raw_path": str( raw_evidence.path if raw_evidence is not None else raw_spool.evidence_path ), "raw_manifest": (str(raw_evidence.manifest_path) if raw_evidence is not None else None), "error_type": type(error).__name__, "error": str(error), "completion_manifest_published": False, }, ) async def _capture_depth( *, symbol: str, max_messages: int, output_root: Path, duration_seconds: float | None = None, ) -> DepthCaptureResult: if max_messages < 1: raise ValueError("max_messages must be positive") if duration_seconds is not None and duration_seconds <= 0: raise ValueError("duration_seconds must be positive when supplied") output_root.mkdir(parents=True, exist_ok=True) capture_id = f"{symbol.lower()}-{time.time_ns()}" client = BinancePublicClient() metadata = client.fetch_exchange_info(symbol=symbol, raw_root=output_root / "raw") raw_spool_holder: list[_RawMessageSpool] = [] def preserve_raw_frame(frame: RawDepthFrame) -> None: if not raw_spool_holder: # pragma: no cover - collector cannot run during construction raise RuntimeError("raw capture journal is not initialized") raw_spool_holder[0].append_frame(frame) collector = BinanceLiveDepthCollector( symbols=(symbol,), tick_size=metadata.tick_size, lot_size=metadata.lot_size, on_raw_frame=preserve_raw_frame, ) raw_spool = _RawMessageSpool(root=output_root, symbol=symbol, source_uri=collector.url) raw_spool_holder.append(raw_spool) raw_evidence: _PublishedRawCapture | None = None delta_validator = IncrementalQualityValidator( "depth_deltas", row_chunk_size=_LIVE_BATCH_ROWS, ) observation_validator = IncrementalQualityValidator( "book_observations", row_chunk_size=_LIVE_BATCH_ROWS, ) validators_finished = False with tempfile.TemporaryDirectory( dir=output_root, prefix=f".{capture_id}.spool-", ) as temporary_root_name: temporary_root = Path(temporary_root_name) spools = { "book_snapshots": _ArrowBatchSpool( root=temporary_root, schema_name="book_snapshots", batch_rows=_LIVE_BATCH_ROWS, max_buffer_bytes=_LIVE_BATCH_ESTIMATED_BYTES, ), "depth_deltas": _ArrowBatchSpool( root=temporary_root, schema_name="depth_deltas", batch_rows=_LIVE_BATCH_ROWS, max_buffer_bytes=_LIVE_BATCH_ESTIMATED_BYTES, on_batch=delta_validator.update, ), "book_observations": _ArrowBatchSpool( root=temporary_root, schema_name="book_observations", batch_rows=_LIVE_BATCH_ROWS, max_buffer_bytes=_LIVE_BATCH_ESTIMATED_BYTES, on_batch=observation_validator.update, ), "sequence_gaps": _ArrowBatchSpool( root=temporary_root, schema_name="sequence_gaps", batch_rows=_LIVE_BATCH_ROWS, max_buffer_bytes=_LIVE_BATCH_ESTIMATED_BYTES, ), } current_continuity_id: str | None = None reconstructor: IncrementalBookReconstructor | None = None continuity_epochs = 0 status: Literal["LIVE", "GAPPED", "INVALID"] = "LIVE" stale_events = 0 excluded_messages = 0 final_update_id = 0 capture_stop = _DepthCaptureStop() epoch_coverage: list[_DepthEpochCoverage] = [] current_epoch_coverage: _DepthEpochCoverage | None = None try: async for item in _bounded_depth_items( collector, max_messages=max_messages, duration_seconds=duration_seconds, stop=capture_stop, ): raw_message_bytes = raw_spool.append_captured(item) if item.delta.continuity_id != current_continuity_id: snapshot = client.fetch_depth_snapshot( symbol=symbol, raw_root=output_root / "raw", continuity_id=item.delta.continuity_id, tick_size=metadata.tick_size, lot_size=metadata.lot_size, ) raw_spool.append_snapshot(snapshot) snapshot_estimated_bytes = max( 4_096, 128 * (len(snapshot.bids) + len(snapshot.asks)), ) spools["book_snapshots"].append( snapshot.to_record(), estimated_bytes=snapshot_estimated_bytes, ) reconstructor = IncrementalBookReconstructor(snapshot) current_continuity_id = item.delta.continuity_id continuity_epochs += 1 received_ts_ns = item.delta.received_ts_ns if received_ts_ns is None: # pragma: no cover - append_captured validates raise RuntimeError("live depth delta has no receipt timestamp") current_epoch_coverage = _DepthEpochCoverage( continuity_id=item.delta.continuity_id, snapshot_id=snapshot.snapshot_id, first_received_ns=received_ts_ns, last_received_ns=received_ts_ns, ) epoch_coverage.append(current_epoch_coverage) if reconstructor is None: # pragma: no cover - guarded by epoch creation raise RuntimeError("live depth epoch has no reconstructor") if current_epoch_coverage is None: # pragma: no cover - guarded by epoch creation raise RuntimeError("live depth epoch has no coverage tracker") spools["depth_deltas"].append( item.delta.to_record(), estimated_bytes=max( 4_096, raw_message_bytes * _VARIABLE_RECORD_OVERHEAD_FACTOR, ), ) step = reconstructor.update(item.delta) if step.observation is not None: spools["book_observations"].append( step.observation, estimated_bytes=4_096, ) else: excluded_messages += 1 if step.gap is not None: spools["sequence_gaps"].append( step.gap.to_record(), estimated_bytes=2_048, ) if step.outcome == "STALE": stale_events += 1 status = _status_max(status, reconstructor.status) final_update_id = reconstructor.final_update_id received_ts_ns = item.delta.received_ts_ns if received_ts_ns is None: # pragma: no cover - append_captured validates raise RuntimeError("live depth delta has no receipt timestamp") current_epoch_coverage.last_received_ns = received_ts_ns current_epoch_coverage.messages += 1 current_epoch_coverage.book_observations += int(step.observation is not None) current_epoch_coverage.excluded_messages += int(step.observation is None) current_epoch_coverage.sequence_gaps += int(step.gap is not None) current_epoch_coverage.reconstruction_status = reconstructor.status current_epoch_coverage.final_update_id = reconstructor.final_update_id if duration_seconds is None: if raw_spool.messages != max_messages or capture_stop.reason != "message_limit": raise RuntimeError( f"live depth stream ended after {raw_spool.messages} of " f"{max_messages} requested messages" ) else: if capture_stop.reason == "message_safety_ceiling": raise RuntimeError( "live depth message safety ceiling was reached before the requested " "capture duration elapsed" ) if capture_stop.reason != "duration_elapsed": raise RuntimeError( "live depth stream ended before the requested capture duration " f"({capture_stop.reason})" ) if raw_spool.messages == 0: raise RuntimeError("duration-bounded live depth capture received no messages") if raw_spool.snapshot_anchors != continuity_epochs: raise RuntimeError("not every continuity epoch has a raw snapshot anchor") for spool in spools.values(): spool.close() if spools["depth_deltas"].rows != raw_spool.messages: raise RuntimeError("captured and normalized depth-message counts diverged") if spools["book_observations"].rows + excluded_messages != raw_spool.messages: raise RuntimeError("not every normalized depth message has an explicit outcome") delta_quality = delta_validator.finish() observation_quality = observation_validator.finish() validators_finished = True raw_evidence = raw_spool.publish(status="raw_capture_complete") normalized_root = output_root / "normalized" / "captures" / capture_id time_columns = { "book_snapshots": "received_ts_ns", "depth_deltas": "event_ts_ns", "book_observations": "event_ts_ns", "sequence_gaps": "detected_ts_ns", } dataset_manifests: dict[str, dict[str, object]] = {} for schema_name, spool in spools.items(): stored = write_capture_parquet( spool.iter_batches(), root=normalized_root, dataset=schema_name, schema_name=schema_name, venue="binance_spot", symbol=symbol, capture_id=capture_id, source="binance_spot_public_live_capture_journal", source_uri=str(raw_evidence.path), source_checksum_sha256=raw_evidence.sha256, requested_start_ns=raw_spool.first_received_ns, requested_end_ns=( raw_spool.last_received_ns + 1 if raw_spool.last_received_ns is not None else None ), time_column=time_columns[schema_name], max_input_batch_rows=_LIVE_BATCH_ROWS, ) if stored.rows != spool.rows: raise RuntimeError( f"stored {schema_name} row count does not match its verified spool" ) dataset_manifests[schema_name] = { "data_path": str(stored.data_path) if stored.data_path is not None else None, "data_sha256": stored.data_sha256, "manifest_path": str(stored.manifest_path), "manifest_sha256": stored.manifest_sha256, "rows": stored.rows, } quality_reports: tuple[ValidationReport, ...] = ( delta_quality, observation_quality, ) quality_errors = sum(report.error_count for report in quality_reports) quality_warnings = sum(report.warning_count for report in quality_reports) quality_root = output_root / "quality" quality_root.mkdir(parents=True, exist_ok=True) quality_report_paths: dict[str, str] = {} for report in quality_reports: report_path = quality_root / f"live_{report.dataset}.{capture_id}.validation.json" report.write_json(report_path) quality_report_paths[report.dataset] = str(report_path) summary_path = quality_root / f"live_depth_capture.{capture_id}.summary.json" receipt_coverage_seconds = ( (raw_spool.last_received_ns - raw_spool.first_received_ns) / 1_000_000_000.0 if raw_spool.first_received_ns is not None and raw_spool.last_received_ns is not None else 0.0 ) max_continuity_epoch_seconds = max( (epoch.duration_seconds for epoch in epoch_coverage), default=0.0, ) summary_payload = { "generated_at_utc": utc_now_iso(), "capture_id": capture_id, "capture_status": "COMPLETE", "messages": raw_spool.messages, "continuity_epochs": continuity_epochs, "normalized_messages": spools["depth_deltas"].rows, "book_observations": spools["book_observations"].rows, "sequence_gaps": spools["sequence_gaps"].rows, "stale_events": stale_events, "excluded_messages": excluded_messages, "reconstruction_status": status, "quality_errors": quality_errors, "quality_warnings": quality_warnings, "completion_reason": capture_stop.reason, "requested_duration_seconds": duration_seconds, "message_safety_ceiling": max_messages, "elapsed_monotonic_seconds": capture_stop.elapsed_monotonic_seconds, "receipt_coverage_seconds": receipt_coverage_seconds, "continuity_epoch_coverage": [epoch.to_dict() for epoch in epoch_coverage], "max_continuity_epoch_seconds": max_continuity_epoch_seconds, "quality_reports": quality_report_paths, "raw_path": str(raw_evidence.path), "raw_manifest": str(raw_evidence.manifest_path), "raw_manifest_sha256": raw_evidence.manifest_sha256, "normalized_dataset_manifests": dataset_manifests, "max_buffered_rows_per_dataset": { name: spool.max_buffered_rows for name, spool in spools.items() }, "max_buffered_estimated_bytes_per_dataset": { name: spool.max_buffered_estimated_bytes for name, spool in spools.items() }, "policy": ( "every continuity transition receives a fresh snapshot; every captured " "delta is normalized, and non-observed deltas are counted or gap-audited" ), } # The capture-ID-specific completion marker is authoritative and published last. write_json(summary_path, summary_payload) with suppress(BaseException): write_json( quality_root / "live_depth_capture.summary.json", { **summary_payload, "capture_status": "LATEST_POINTER", "latest_capture_status": summary_payload["capture_status"], "authoritative_summary_path": str(summary_path), "authoritative_summary_sha256": sha256_file(summary_path), }, ) return DepthCaptureResult( symbol=symbol, messages=raw_spool.messages, continuity_epochs=continuity_epochs, reconstruction_status=status, book_observations=spools["book_observations"].rows, sequence_gaps=spools["sequence_gaps"].rows, stale_events=stale_events, excluded_messages=excluded_messages, final_update_id=final_update_id, quality_errors=quality_errors, quality_warnings=quality_warnings, raw_path=raw_evidence.path, raw_manifest_path=raw_evidence.manifest_path, raw_manifest_sha256=raw_evidence.manifest_sha256, summary_path=summary_path, completion_reason=capture_stop.reason, requested_duration_seconds=duration_seconds, elapsed_monotonic_seconds=capture_stop.elapsed_monotonic_seconds, receipt_coverage_seconds=receipt_coverage_seconds, max_continuity_epoch_seconds=max_continuity_epoch_seconds, ) except BaseException as error: if raw_evidence is None: try: raw_evidence = raw_spool.publish( status="incomplete_capture_failure", error=error, ) except BaseException: raw_spool.close_without_deleting() else: with suppress(BaseException): raw_evidence = raw_spool.publish( status="normalization_failure", error=error, ) with suppress(BaseException): _failure_record( output_root=output_root, capture_id=capture_id, symbol=symbol, raw_spool=raw_spool, raw_evidence=raw_evidence, error=error, ) raise finally: for spool in spools.values(): with suppress(BaseException): spool.close() if not validators_finished: delta_validator.close() observation_validator.close() def _cmd_collect_l2(args: argparse.Namespace) -> int: output_root = Path(args.output_root).resolve() result = asyncio.run( _capture_depth( symbol=str(args.symbol).upper(), max_messages=int(args.max_messages), output_root=output_root, duration_seconds=( float(args.duration_seconds) if args.duration_seconds is not None else None ), ) ) _print_json( { "symbol": result.symbol, "messages": result.messages, "reconstruction_status": result.reconstruction_status, "book_observations": result.book_observations, "sequence_gaps": result.sequence_gaps, "stale_events": result.stale_events, "excluded_messages": result.excluded_messages, "final_update_id": result.final_update_id, "quality_errors": result.quality_errors, "quality_warnings": result.quality_warnings, "raw_manifest": result.raw_manifest_path, "raw_manifest_sha256": result.raw_manifest_sha256, "capture_summary": result.summary_path, "completion_reason": result.completion_reason, "requested_duration_seconds": result.requested_duration_seconds, "elapsed_monotonic_seconds": result.elapsed_monotonic_seconds, "receipt_coverage_seconds": result.receipt_coverage_seconds, "max_continuity_epoch_seconds": result.max_continuity_epoch_seconds, "output_root": output_root, "live_trading": False, } ) return 0 if result.reconstruction_status == "LIVE" and result.quality_errors == 0 else 1 def _m8_l2_session_payload(result: M8L2SessionBundle) -> dict[str, object]: return { "status": result.status, "session_id": result.session_id, "session_date": result.session_date, "role": result.role, "output_root": result.root, "session_manifest": result.manifest_path, "session_manifest_sha256": result.manifest_sha256, "checksums": result.checksum_path, "terminal_marker": result.marker_path, "reason_codes": list(getattr(result, "reason_codes", ())), "source": "binance_spot_public_live_diff_depth", "live_trading": False, } def _cmd_capture_m8_l2_session(args: argparse.Namespace) -> int: config = load_m8_l2_config(args.config) result = asyncio.run( capture_m8_l2_session( config, str(args.date), Path(args.output_root).resolve(), BinanceM8L2Capture(), ) ) _print_json(_m8_l2_session_payload(result)) return 0 if result.status == "COMPLETE" else 1 def _cmd_verify_m8_l2_session(args: argparse.Namespace) -> int: config = load_m8_l2_config(args.config) result = verify_m8_l2_session_bundle(args.bundle_dir, expected_config=config) payload = _m8_l2_session_payload(result) payload["integrity"] = "verified" _print_json(payload) return 0 def _m8_l2_development_payload( result: L2DevelopmentLockResult, *, integrity: str | None = None, ) -> dict[str, object]: payload: dict[str, object] = { "status": getattr(result, "status", "LOCKED"), "development_lock_dir": result.root, "development_lock": result.aggregate_path, "development_lock_sha256": result.aggregate_sha256, "terminal_marker": result.marker_path, "created_at_utc": result.created_at_utc, "children": [ { "symbol": child.symbol, "endpoint": child.endpoint, "lock": child.path, "lock_sha256": child.sha256, "selection_lock_sha256": child.selection_lock_sha256, "fitted_state_sha256": child.fitted_state_sha256, } for child in result.children ], "reason_codes": list(getattr(result, "reason_codes", ())), "heldout_accessed": False, "source": "binance_spot_public_live_diff_depth", "live_trading": False, } if integrity is not None: payload["integrity"] = integrity return payload def _verify_m8_l2_session_authority( bundle_dir: Path, *, expected_config: M8L2StudyConfig, expected_date: str, expected_role: str, manifest_sha256: str, checksums_sha256: str, ) -> M8L2SessionBundle: bundle = verify_m8_l2_session_bundle(bundle_dir, expected_config=expected_config) if bundle.session_date != expected_date or bundle.role != expected_role: raise ValueError( f"explicit L2 session coordinate differs from {expected_date} {expected_role}" ) if bundle.manifest_sha256 != manifest_sha256: raise ValueError(f"explicit {expected_role} session manifest differs from expected SHA-256") if sha256_file(bundle.checksum_path) != checksums_sha256: raise ValueError(f"explicit {expected_role} session checksums differ from expected SHA-256") return bundle def _m8_l2_insufficient_development_payload( sessions: Sequence[M8L2SessionBundle], ) -> dict[str, object]: return { "status": "INSUFFICIENT_DATA", "stage": "development_lock", "reason_code": "DEVELOPMENT_SESSION_NOT_COMPLETE", "sessions": [ { "session_id": session.session_id, "session_date": session.session_date, "role": session.role, "status": session.status, "session_manifest": session.manifest_path, "session_manifest_sha256": session.manifest_sha256, "checksums": session.checksum_path, "checksums_sha256": sha256_file(session.checksum_path), "reason_codes": list(session.reason_codes), } for session in sessions ], "heldout_accessed": False, "source": "binance_spot_public_live_diff_depth", "live_trading": False, } def _development_session_authorities( args: argparse.Namespace, ) -> dict[str, L2SessionFileAuthority]: return { "2026-08-10": L2SessionFileAuthority( manifest_sha256=args.train_manifest_sha256, checksums_sha256=args.train_checksums_sha256, ), "2026-08-11": L2SessionFileAuthority( manifest_sha256=args.validation_manifest_sha256, checksums_sha256=args.validation_checksums_sha256, ), } def _explicit_development_input_loader( authorities: Mapping[str, L2SessionFileAuthority], ) -> L2DevelopmentInputVerifier: def load( bundle_dir: str | Path, *, expected_config: M8L2StudyConfig, expected_date: str, expected_role: str, expected_file_authority: object | None = None, expected_campaign: object | None = None, ) -> Any: authority = authorities.get(expected_date) if authority is None: raise ValueError("development input date is outside the explicit authority set") if expected_role not in ("train", "validation"): raise ValueError("development input role is outside the explicit authority set") if expected_file_authority is not None and expected_file_authority != authority: raise ValueError("development input authority differs from the explicit CLI authority") return verify_m8_l2_development_input( bundle_dir, expected_config=expected_config, expected_date=expected_date, expected_role=cast(Literal["train", "validation"], expected_role), expected_file_authority=authority, expected_campaign=cast(L2CampaignRuntimeIdentity | None, expected_campaign), ) return load def _load_explicit_development_sessions( args: argparse.Namespace, capture_config: M8L2StudyConfig, ) -> tuple[M8L2SessionBundle, M8L2SessionBundle]: train = _verify_m8_l2_session_authority( args.train_bundle_dir.absolute(), expected_config=capture_config, expected_date="2026-08-10", expected_role="train", manifest_sha256=args.train_manifest_sha256, checksums_sha256=args.train_checksums_sha256, ) validation = _verify_m8_l2_session_authority( args.validation_bundle_dir.absolute(), expected_config=capture_config, expected_date="2026-08-11", expected_role="validation", manifest_sha256=args.validation_manifest_sha256, checksums_sha256=args.validation_checksums_sha256, ) return train, validation def _cmd_lock_m8_l2_development(args: argparse.Namespace) -> int: capture_config = load_m8_l2_config(args.capture_config) analysis_config = load_m8_l2_analysis_config(args.analysis_config) _load_explicit_development_sessions(args, capture_config) result = lock_m8_l2_development( capture_config, analysis_config, args.train_bundle_dir.absolute(), args.validation_bundle_dir.absolute(), args.lock_dir.absolute(), input_loader=_explicit_development_input_loader(_development_session_authorities(args)), expected_session_file_authorities=_development_session_authorities(args), ) _print_json(_m8_l2_development_payload(result)) return 0 if getattr(result, "status", "LOCKED") == "LOCKED" else 1 def _cmd_verify_m8_l2_development_lock(args: argparse.Namespace) -> int: capture_config = load_m8_l2_config(args.capture_config) analysis_config = load_m8_l2_analysis_config(args.analysis_config) _load_explicit_development_sessions(args, capture_config) result = verify_m8_l2_development_lock( capture_config, analysis_config, args.train_bundle_dir.absolute(), args.validation_bundle_dir.absolute(), args.lock_dir.absolute(), expected_lock_sha256=args.development_lock_sha256, ) _print_json(_m8_l2_development_payload(result, integrity="verified")) return 0 if getattr(result, "status", "LOCKED") == "LOCKED" else 1 def _m8_l2_study_authorities( args: argparse.Namespace, ) -> tuple[ L2StudySessionAuthority, L2StudySessionAuthority, L2StudySessionAuthority, L2StudySessionAuthority, ]: def authority(role: str) -> L2StudySessionAuthority: return L2StudySessionAuthority( bundle_path=getattr(args, f"{role}_bundle_dir").absolute(), manifest_sha256=getattr(args, f"{role}_manifest_sha256"), checksums_sha256=getattr(args, f"{role}_checksums_sha256"), ) return ( authority("train"), authority("validation"), authority("primary"), authority("replication"), ) def _m8_l2_study_payload( result: M8L2StudyRunResult, *, integrity: str | None = None, ) -> dict[str, object]: payload: dict[str, object] = { "status": result.status, "run_dir": result.root, "run_manifest": result.manifest_path, "run_manifest_sha256": result.manifest_sha256, "checksums": result.checksum_path, "checksums_sha256": result.checksum_sha256, "terminal_marker": result.marker_path, "reason_codes": list(result.reason_codes), "source": "binance_spot_public_live_diff_depth", "live_trading": False, } if integrity is not None: payload["integrity"] = integrity return payload def _m8_l2_study_arguments( args: argparse.Namespace, capture_config: M8L2StudyConfig, analysis_config: M8L2AnalysisConfig, ) -> tuple[ M8L2StudyConfig, M8L2AnalysisConfig, L2StudySessionAuthority, L2StudySessionAuthority, Path, str, L2StudySessionAuthority, L2StudySessionAuthority, Path, ]: train, validation, primary, replication = _m8_l2_study_authorities(args) return ( capture_config, analysis_config, train, validation, args.development_lock_dir.absolute(), args.development_lock_sha256, primary, replication, args.run_dir.absolute(), ) def _cmd_reproduce_m8_l2(args: argparse.Namespace) -> int: capture_config = load_m8_l2_config(args.capture_config) analysis_config = load_m8_l2_analysis_config(args.analysis_config) result = reproduce_m8_l2_study(*_m8_l2_study_arguments(args, capture_config, analysis_config)) _print_json(_m8_l2_study_payload(result)) return 0 if result.status == "COMPLETE" else 1 def _verify_m8_l2_study_from_args( args: argparse.Namespace, *, capture_config: M8L2StudyConfig, analysis_config: M8L2AnalysisConfig, ) -> M8L2StudyRunResult: return verify_m8_l2_study_run( *_m8_l2_study_arguments(args, capture_config, analysis_config), expected_manifest_sha256=args.run_manifest_sha256, expected_checksums_sha256=args.run_checksums_sha256, ) def _cmd_verify_m8_l2_run(args: argparse.Namespace) -> int: capture_config = load_m8_l2_config(args.capture_config) analysis_config = load_m8_l2_analysis_config(args.analysis_config) result = _verify_m8_l2_study_from_args( args, capture_config=capture_config, analysis_config=analysis_config, ) _print_json(_m8_l2_study_payload(result, integrity="verified")) return 0 if result.status == "COMPLETE" else 1 def _cmd_report_m8_l2(args: argparse.Namespace) -> int: capture_config = load_m8_l2_config(args.capture_config) analysis_config = load_m8_l2_analysis_config(args.analysis_config) positional = _m8_l2_study_arguments(args, capture_config, analysis_config) result = verify_m8_l2_study_run( *positional, expected_manifest_sha256=args.run_manifest_sha256, expected_checksums_sha256=args.run_checksums_sha256, ) output = _external_report_dir(result.root, args.output_dir) report_data = load_m8_l2_report_data( *positional, expected_manifest_sha256=args.run_manifest_sha256, expected_checksums_sha256=args.run_checksums_sha256, ) technical, memo, comparison = write_l2_report_set(output, report_data) payload = _m8_l2_study_payload(result, integrity="verified") payload.update( { "output_dir": output, "technical_report": technical, "executive_memo": memo, "model_comparison": comparison, "report_inputs_sha256": canonical_report_data_sha256(report_data), "source_bundle_modified": False, } ) _print_json(payload) return 0 if result.status == "COMPLETE" else 1 def _add_m8_l2_development_authority_args(parser: argparse.ArgumentParser) -> None: parser.add_argument("--capture-config", required=True, type=Path) parser.add_argument("--analysis-config", required=True, type=Path) parser.add_argument("--train-bundle-dir", required=True, type=Path) parser.add_argument( "--train-manifest-sha256", required=True, type=_lowercase_sha256, ) parser.add_argument( "--train-checksums-sha256", required=True, type=_lowercase_sha256, ) parser.add_argument("--validation-bundle-dir", required=True, type=Path) parser.add_argument( "--validation-manifest-sha256", required=True, type=_lowercase_sha256, ) parser.add_argument( "--validation-checksums-sha256", required=True, type=_lowercase_sha256, ) parser.add_argument("--lock-dir", required=True, type=Path) def _add_m8_l2_study_authority_args( parser: argparse.ArgumentParser, *, require_run_authority: bool, ) -> None: parser.add_argument("--capture-config", required=True, type=Path) parser.add_argument("--analysis-config", required=True, type=Path) for role in ("train", "validation", "primary", "replication"): parser.add_argument(f"--{role}-bundle-dir", required=True, type=Path) parser.add_argument( f"--{role}-manifest-sha256", required=True, type=_lowercase_sha256, ) parser.add_argument( f"--{role}-checksums-sha256", required=True, type=_lowercase_sha256, ) parser.add_argument("--development-lock-dir", required=True, type=Path) parser.add_argument( "--development-lock-sha256", required=True, type=_lowercase_sha256, ) parser.add_argument("--run-dir", required=True, type=Path) if require_run_authority: parser.add_argument( "--run-manifest-sha256", required=True, type=_lowercase_sha256, ) parser.add_argument( "--run-checksums-sha256", required=True, type=_lowercase_sha256, ) def build_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser( prog="microstructure", description="Research-only event-driven market-microstructure system", ) parser.add_argument("--version", action="version", version=__version__) subparsers = parser.add_subparsers(dest="command", required=True) ingest = subparsers.add_parser("ingest", help="ingest configured synthetic or public data") ingest.add_argument("--config", required=True, type=Path) ingest.add_argument("--output-root", type=Path) ingest.set_defaults(handler=_cmd_ingest) acquire_m8 = subparsers.add_parser( "acquire-m8", help="acquire raw M8 evidence without opening any archive CSV member", ) acquire_m8.add_argument("--config", required=True, type=Path) acquire_m8.add_argument("--output-root", required=True, type=Path) acquire_m8.set_defaults(handler=_cmd_acquire_m8) validate = subparsers.add_parser("validate", help="run non-mutating data validation") validate.add_argument("--config", required=True, type=Path) validate.set_defaults(handler=_cmd_validate) reproduce_parser = subparsers.add_parser( "reproduce", help="produce or verify an immutable end-to-end sample run" ) reproduce_parser.add_argument("--config", required=True, type=Path) reproduce_parser.add_argument("--run-dir", required=True, type=Path) reproduce_parser.add_argument( "--ingestion-manifest", type=Path, help="explicit public ingestion manifest; required with its SHA-256 for public mode", ) reproduce_parser.add_argument( "--ingestion-manifest-sha256", help="SHA-256 of --ingestion-manifest; required for public mode", ) reproduce_parser.set_defaults(handler=_cmd_reproduce) reproduce_m8_parser = subparsers.add_parser( "reproduce-m8", help="produce the frozen M8 study from one explicit raw acquisition authority", ) reproduce_m8_parser.add_argument("--config", required=True, type=Path) reproduce_m8_parser.add_argument("--run-dir", required=True, type=Path) reproduce_m8_parser.add_argument("--raw-manifest", required=True, type=Path) reproduce_m8_parser.add_argument( "--raw-manifest-sha256", required=True, type=_lowercase_sha256, ) reproduce_m8_parser.set_defaults(handler=_cmd_reproduce_m8) verify_m8_parser = subparsers.add_parser( "verify-m8", help="verify a complete or INSUFFICIENT_DATA M8 result and its raw authority", ) verify_m8_parser.add_argument("--config", required=True, type=Path) verify_m8_parser.add_argument("--run-dir", required=True, type=Path) verify_m8_parser.add_argument("--raw-manifest", required=True, type=Path) verify_m8_parser.add_argument( "--raw-manifest-sha256", required=True, type=_lowercase_sha256, ) verify_m8_parser.set_defaults(handler=_cmd_verify_m8) report_m8_parser = subparsers.add_parser( "report-m8", help="render a complete M8 result or expose its frozen failure report", ) report_m8_parser.add_argument("--config", required=True, type=Path) report_m8_parser.add_argument("--run-dir", required=True, type=Path) report_m8_parser.add_argument("--raw-manifest", required=True, type=Path) report_m8_parser.add_argument( "--raw-manifest-sha256", required=True, type=_lowercase_sha256, ) report_m8_parser.add_argument("--output-dir", type=Path) report_m8_parser.set_defaults(handler=_cmd_report_m8) verify = subparsers.add_parser("verify", help="verify a frozen run and all checksums") verify.add_argument("--run-dir", required=True, type=Path) verify.set_defaults(handler=_cmd_verify) report = subparsers.add_parser("report", help="render reports from a frozen run") report.add_argument("--run-dir", required=True, type=Path) report.add_argument("--output-dir", type=Path) report.set_defaults(handler=_cmd_report) collect = subparsers.add_parser( "collect-l2", help="capture and reconstruct public live L2 data; never place orders" ) collect.add_argument("--symbol", choices=("BTCUSDT", "ETHUSDT"), required=True) collect.add_argument("--max-messages", type=int, default=1_000) collect.add_argument( "--duration-seconds", type=float, help=( "gracefully complete after this wall duration; max-messages remains a safety " "ceiling and fails the capture if reached first" ), ) collect.add_argument("--output-root", type=Path, default=Path("data")) collect.set_defaults(handler=_cmd_collect_l2) capture_m8_l2 = subparsers.add_parser( "capture-m8-l2-session", help="capture one frozen concurrent BTCUSDT/ETHUSDT prospective L2 session", ) capture_m8_l2.add_argument("--config", required=True, type=Path) capture_m8_l2.add_argument("--date", required=True) capture_m8_l2.add_argument("--output-root", required=True, type=Path) capture_m8_l2.set_defaults(handler=_cmd_capture_m8_l2_session) verify_m8_l2 = subparsers.add_parser( "verify-m8-l2-session", help="verify a complete or INSUFFICIENT_DATA frozen L2 session bundle", ) verify_m8_l2.add_argument("--config", required=True, type=Path) verify_m8_l2.add_argument("--bundle-dir", required=True, type=Path) verify_m8_l2.set_defaults(handler=_cmd_verify_m8_l2_session) lock_m8_l2_development_parser = subparsers.add_parser( "lock-m8-l2-development", help="fit and freeze the Aug 8/9 L2 development state before held-out access", ) _add_m8_l2_development_authority_args(lock_m8_l2_development_parser) lock_m8_l2_development_parser.set_defaults(handler=_cmd_lock_m8_l2_development) verify_m8_l2_development_parser = subparsers.add_parser( "verify-m8-l2-development-lock", help="verify the frozen L2 development lock and its explicit session authorities", ) _add_m8_l2_development_authority_args(verify_m8_l2_development_parser) verify_m8_l2_development_parser.add_argument( "--development-lock-sha256", required=True, type=_lowercase_sha256, ) verify_m8_l2_development_parser.set_defaults(handler=_cmd_verify_m8_l2_development_lock) reproduce_m8_l2_parser = subparsers.add_parser( "reproduce-m8-l2", help="produce the frozen four-session prospective live-L2 study", ) _add_m8_l2_study_authority_args( reproduce_m8_l2_parser, require_run_authority=False, ) reproduce_m8_l2_parser.set_defaults(handler=_cmd_reproduce_m8_l2) verify_m8_l2_run_parser = subparsers.add_parser( "verify-m8-l2-run", help="verify a terminal live-L2 study and all external authorities", ) _add_m8_l2_study_authority_args( verify_m8_l2_run_parser, require_run_authority=True, ) verify_m8_l2_run_parser.set_defaults(handler=_cmd_verify_m8_l2_run) report_m8_l2_parser = subparsers.add_parser( "report-m8-l2", help="render verified live-L2 report inputs outside the immutable run bundle", ) _add_m8_l2_study_authority_args( report_m8_l2_parser, require_run_authority=True, ) report_m8_l2_parser.add_argument("--output-dir", required=True, type=Path) report_m8_l2_parser.set_defaults(handler=_cmd_report_m8_l2) return parser def main(argv: Sequence[str] | None = None) -> int: parser = build_parser() args = parser.parse_args(argv) if getattr(args, "max_messages", 1) < 1: parser.error("--max-messages must be positive") duration_seconds = getattr(args, "duration_seconds", None) if duration_seconds is not None and duration_seconds <= 0: parser.error("--duration-seconds must be positive") handler = args.handler try: return int(handler(args)) except (KeyboardInterrupt, asyncio.CancelledError): print("operation canceled", file=sys.stderr) return 130 except Exception as error: print(f"error: {error}", file=sys.stderr) return 2 if __name__ == "__main__": # pragma: no cover raise SystemExit(main())