Datasets:
Tasks:
Tabular Classification
Formats:
parquet
Languages:
English
Size:
< 1K
Tags:
economics
quantitative-finance
causal-inference
macroeconomics
housing-economics
market-microstructure
License:
| """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 | |
| 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 | |
| class _DepthCaptureStop: | |
| reason: str = "not_started" | |
| elapsed_monotonic_seconds: float = 0.0 | |
| 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 | |
| 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() | |
| 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 | |
| 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()) | |