"""Fail-closed parser for the frozen M8 multi-date trade study. This module intentionally does not reuse the exploratory sample configuration. Protocol version 1.0.2 is a fixed, outcome-blind study contract: changing any date, role, source, feature, model, safety ceiling, or claim permission requires a new protocol version and corresponding parser review. """ from __future__ import annotations import hashlib import json import math import tomllib from collections.abc import Mapping from dataclasses import dataclass from datetime import date as Date from pathlib import Path from typing import Any, Literal, cast M8PeriodRole = Literal["train", "validation", "primary_test", "replication_test"] _TOP_LEVEL_KEYS = frozenset({"study", "periods", "features", "models", "quality", "claims"}) _STUDY_KEYS = frozenset( { "name", "protocol_version", "evidence_tier", "seed", "source", "symbols", "selection_metric", "target", "label_horizon_events", "calibration_fraction", "bootstrap_samples", "bootstrap_block_events", "feature_stability_bins", "max_archive_compressed_bytes", "max_archive_uncompressed_bytes", "max_total_download_bytes", } ) _PERIOD_KEYS = frozenset({"date", "role"}) _FEATURE_KEYS = frozenset( {"trade_windows", "volatility_window", "intensity_window", "large_trade_quantile"} ) _MODEL_KEYS = frozenset({"logistic_c_values", "tree_max_depth_values", "tree_min_samples_leaf"}) _QUALITY_KEYS = frozenset( { "fail_on_error", "require_complete_daily_archive", "require_contiguous_trade_ids_within_symbol_date", "require_nondecreasing_event_time", "allow_quality_warnings", } ) _CLAIM_KEYS = frozenset( { "allow_p_values", "allow_significance_claim", "allow_cross_instrument_pooling", "allow_execution_claim", "allow_profitability_claim", } ) _FROZEN_PERIODS: tuple[tuple[str, M8PeriodRole], ...] = ( ("2024-01-03", "train"), ("2024-01-04", "validation"), ("2024-01-05", "primary_test"), ("2024-01-06", "replication_test"), ) _FROZEN_SYMBOLS = ("BTCUSDT", "ETHUSDT") class M8ConfigError(ValueError): """Raised when an M8 study file violates its frozen protocol contract.""" @dataclass(frozen=True, slots=True) class M8Study: name: str protocol_version: str evidence_tier: str seed: int source: str symbols: tuple[str, ...] selection_metric: str target: str label_horizon_events: int calibration_fraction: float bootstrap_samples: int bootstrap_block_events: int feature_stability_bins: int max_archive_compressed_bytes: int max_archive_uncompressed_bytes: int max_total_download_bytes: int @dataclass(frozen=True, slots=True) class M8Period: date: Date role: M8PeriodRole @dataclass(frozen=True, slots=True) class M8Features: trade_windows: tuple[int, ...] volatility_window: int intensity_window: int large_trade_quantile: float @dataclass(frozen=True, slots=True) class M8Models: logistic_c_values: tuple[float, ...] tree_max_depth_values: tuple[int, ...] tree_min_samples_leaf: int @dataclass(frozen=True, slots=True) class M8Quality: fail_on_error: bool require_complete_daily_archive: bool require_contiguous_trade_ids_within_symbol_date: bool require_nondecreasing_event_time: bool allow_quality_warnings: bool @dataclass(frozen=True, slots=True) class M8Claims: allow_p_values: bool allow_significance_claim: bool allow_cross_instrument_pooling: bool allow_execution_claim: bool allow_profitability_claim: bool @dataclass(frozen=True, slots=True) class M8StudyConfig: """Typed, immutable representation of the frozen M8 study specification.""" path: Path source_sha256: str study: M8Study periods: tuple[M8Period, ...] features: M8Features models: M8Models quality: M8Quality claims: M8Claims def _semantic_payload(self) -> dict[str, object]: return { "study": { "name": self.study.name, "protocol_version": self.study.protocol_version, "evidence_tier": self.study.evidence_tier, "seed": self.study.seed, "source": self.study.source, "symbols": list(self.study.symbols), "selection_metric": self.study.selection_metric, "target": self.study.target, "label_horizon_events": self.study.label_horizon_events, "calibration_fraction": self.study.calibration_fraction, "bootstrap_samples": self.study.bootstrap_samples, "bootstrap_block_events": self.study.bootstrap_block_events, "feature_stability_bins": self.study.feature_stability_bins, "max_archive_compressed_bytes": self.study.max_archive_compressed_bytes, "max_archive_uncompressed_bytes": self.study.max_archive_uncompressed_bytes, "max_total_download_bytes": self.study.max_total_download_bytes, }, "periods": [ {"date": period.date.isoformat(), "role": period.role} for period in self.periods ], "features": { "trade_windows": list(self.features.trade_windows), "volatility_window": self.features.volatility_window, "intensity_window": self.features.intensity_window, "large_trade_quantile": self.features.large_trade_quantile, }, "models": { "logistic_c_values": list(self.models.logistic_c_values), "tree_max_depth_values": list(self.models.tree_max_depth_values), "tree_min_samples_leaf": self.models.tree_min_samples_leaf, }, "quality": { "fail_on_error": self.quality.fail_on_error, "require_complete_daily_archive": self.quality.require_complete_daily_archive, "require_contiguous_trade_ids_within_symbol_date": ( self.quality.require_contiguous_trade_ids_within_symbol_date ), "require_nondecreasing_event_time": self.quality.require_nondecreasing_event_time, "allow_quality_warnings": self.quality.allow_quality_warnings, }, "claims": { "allow_p_values": self.claims.allow_p_values, "allow_significance_claim": self.claims.allow_significance_claim, "allow_cross_instrument_pooling": self.claims.allow_cross_instrument_pooling, "allow_execution_claim": self.claims.allow_execution_claim, "allow_profitability_claim": self.claims.allow_profitability_claim, }, } @property def hash(self) -> str: """Return a location- and formatting-independent semantic SHA-256.""" encoded = json.dumps( self._semantic_payload(), sort_keys=True, separators=(",", ":"), allow_nan=False, ).encode("utf-8") return hashlib.sha256(encoded).hexdigest() def public_dict(self) -> dict[str, object]: """Return a JSON-safe representation with both semantic and byte hashes.""" return { "path": str(self.path), "config_sha256": self.hash, "source_sha256": self.source_sha256, **self._semantic_payload(), } def _mapping(value: object, label: str) -> Mapping[str, Any]: if not isinstance(value, Mapping): raise M8ConfigError(f"{label} must be a TOML table") if not all(isinstance(key, str) for key in value): raise M8ConfigError(f"{label} contains a non-string key") return cast(Mapping[str, Any], value) def _exact_keys(value: Mapping[str, Any], expected: frozenset[str], label: str) -> None: observed = frozenset(value) missing = sorted(expected - observed) unknown = sorted(observed - expected) if missing or unknown: details: list[str] = [] if missing: details.append("missing=" + ",".join(missing)) if unknown: details.append("unknown=" + ",".join(unknown)) raise M8ConfigError(f"{label} keys do not match the frozen contract ({'; '.join(details)})") def _text(value: object, label: str) -> str: if type(value) is not str: raise M8ConfigError(f"{label} must be a string") return value def _integer(value: object, label: str) -> int: if type(value) is not int: raise M8ConfigError(f"{label} must be an integer") return value def _number(value: object, label: str) -> float: if type(value) not in {int, float}: raise M8ConfigError(f"{label} must be a finite number") result = float(cast(int | float, value)) if not math.isfinite(result): raise M8ConfigError(f"{label} must be a finite number") return result def _boolean(value: object, label: str) -> bool: if type(value) is not bool: raise M8ConfigError(f"{label} must be a boolean") return value def _list(value: object, label: str) -> list[Any]: if not isinstance(value, list): raise M8ConfigError(f"{label} must be an array") return value def _text_tuple(value: object, label: str) -> tuple[str, ...]: return tuple(_text(item, f"{label}[{index}]") for index, item in enumerate(_list(value, label))) def _integer_tuple(value: object, label: str) -> tuple[int, ...]: return tuple( _integer(item, f"{label}[{index}]") for index, item in enumerate(_list(value, label)) ) def _number_tuple(value: object, label: str) -> tuple[float, ...]: return tuple( _number(item, f"{label}[{index}]") for index, item in enumerate(_list(value, label)) ) def _require_equal(observed: object, expected: object, label: str) -> None: if observed != expected: raise M8ConfigError(f"{label} is frozen at {expected!r}, observed {observed!r}") def _parse_study(raw: object) -> M8Study: table = _mapping(raw, "study") _exact_keys(table, _STUDY_KEYS, "study") study = M8Study( name=_text(table["name"], "study.name"), protocol_version=_text(table["protocol_version"], "study.protocol_version"), evidence_tier=_text(table["evidence_tier"], "study.evidence_tier"), seed=_integer(table["seed"], "study.seed"), source=_text(table["source"], "study.source"), symbols=_text_tuple(table["symbols"], "study.symbols"), selection_metric=_text(table["selection_metric"], "study.selection_metric"), target=_text(table["target"], "study.target"), label_horizon_events=_integer(table["label_horizon_events"], "study.label_horizon_events"), calibration_fraction=_number(table["calibration_fraction"], "study.calibration_fraction"), bootstrap_samples=_integer(table["bootstrap_samples"], "study.bootstrap_samples"), bootstrap_block_events=_integer( table["bootstrap_block_events"], "study.bootstrap_block_events" ), feature_stability_bins=_integer( table["feature_stability_bins"], "study.feature_stability_bins" ), max_archive_compressed_bytes=_integer( table["max_archive_compressed_bytes"], "study.max_archive_compressed_bytes" ), max_archive_uncompressed_bytes=_integer( table["max_archive_uncompressed_bytes"], "study.max_archive_uncompressed_bytes" ), max_total_download_bytes=_integer( table["max_total_download_bytes"], "study.max_total_download_bytes" ), ) if len(set(study.symbols)) != len(study.symbols): raise M8ConfigError("study.symbols must be unique") expected: dict[str, object] = { "name": "binance-m8-multidate-trades", "protocol_version": "1.0.2", "evidence_tier": "FULL_DATA", "seed": 20260807, "source": "binance_spot_daily_aggtrades_archive", "symbols": _FROZEN_SYMBOLS, "selection_metric": "log_loss", "target": "future_trade_up", "label_horizon_events": 20, "calibration_fraction": 0.20, "bootstrap_samples": 2000, "bootstrap_block_events": 40, "feature_stability_bins": 10, "max_archive_compressed_bytes": 268_435_456, "max_archive_uncompressed_bytes": 2_147_483_648, "max_total_download_bytes": 8_589_934_592, } for field, frozen in expected.items(): _require_equal(getattr(study, field), frozen, f"study.{field}") if not ( study.max_archive_compressed_bytes < study.max_archive_uncompressed_bytes < study.max_total_download_bytes ): raise M8ConfigError("study byte ceilings must increase from compressed to total") return study def _parse_periods(raw: object) -> tuple[M8Period, ...]: items = _list(raw, "periods") periods: list[M8Period] = [] for index, item in enumerate(items): table = _mapping(item, f"periods[{index}]") _exact_keys(table, _PERIOD_KEYS, f"periods[{index}]") raw_date = _text(table["date"], f"periods[{index}].date") try: parsed_date = Date.fromisoformat(raw_date) except ValueError as exc: raise M8ConfigError(f"periods[{index}].date must be an ISO UTC date") from exc if parsed_date.isoformat() != raw_date: raise M8ConfigError(f"periods[{index}].date must use canonical YYYY-MM-DD form") raw_role = _text(table["role"], f"periods[{index}].role") if raw_role not in {"train", "validation", "primary_test", "replication_test"}: raise M8ConfigError(f"periods[{index}].role is unsupported: {raw_role!r}") periods.append(M8Period(date=parsed_date, role=cast(M8PeriodRole, raw_role))) if len({period.date for period in periods}) != len(periods): raise M8ConfigError("period dates must be unique") observed = tuple((period.date.isoformat(), period.role) for period in periods) _require_equal(observed, _FROZEN_PERIODS, "period date/role order") return tuple(periods) def _parse_features(raw: object) -> M8Features: table = _mapping(raw, "features") _exact_keys(table, _FEATURE_KEYS, "features") features = M8Features( trade_windows=_integer_tuple(table["trade_windows"], "features.trade_windows"), volatility_window=_integer(table["volatility_window"], "features.volatility_window"), intensity_window=_integer(table["intensity_window"], "features.intensity_window"), large_trade_quantile=_number( table["large_trade_quantile"], "features.large_trade_quantile" ), ) expected: dict[str, object] = { "trade_windows": (5, 20, 100), "volatility_window": 100, "intensity_window": 50, "large_trade_quantile": 0.95, } for field, frozen in expected.items(): _require_equal(getattr(features, field), frozen, f"features.{field}") return features def _parse_models(raw: object) -> M8Models: table = _mapping(raw, "models") _exact_keys(table, _MODEL_KEYS, "models") models = M8Models( logistic_c_values=_number_tuple(table["logistic_c_values"], "models.logistic_c_values"), tree_max_depth_values=_integer_tuple( table["tree_max_depth_values"], "models.tree_max_depth_values" ), tree_min_samples_leaf=_integer( table["tree_min_samples_leaf"], "models.tree_min_samples_leaf" ), ) expected: dict[str, object] = { "logistic_c_values": (0.1, 1.0, 10.0), "tree_max_depth_values": (2, 4, 6), "tree_min_samples_leaf": 40, } for field, frozen in expected.items(): _require_equal(getattr(models, field), frozen, f"models.{field}") return models def _parse_quality(raw: object) -> M8Quality: table = _mapping(raw, "quality") _exact_keys(table, _QUALITY_KEYS, "quality") quality = M8Quality( fail_on_error=_boolean(table["fail_on_error"], "quality.fail_on_error"), require_complete_daily_archive=_boolean( table["require_complete_daily_archive"], "quality.require_complete_daily_archive", ), require_contiguous_trade_ids_within_symbol_date=_boolean( table["require_contiguous_trade_ids_within_symbol_date"], "quality.require_contiguous_trade_ids_within_symbol_date", ), require_nondecreasing_event_time=_boolean( table["require_nondecreasing_event_time"], "quality.require_nondecreasing_event_time", ), allow_quality_warnings=_boolean( table["allow_quality_warnings"], "quality.allow_quality_warnings" ), ) expected = { "fail_on_error": True, "require_complete_daily_archive": True, "require_contiguous_trade_ids_within_symbol_date": True, "require_nondecreasing_event_time": True, "allow_quality_warnings": False, } for field, frozen in expected.items(): _require_equal(getattr(quality, field), frozen, f"quality.{field}") return quality def _parse_claims(raw: object) -> M8Claims: table = _mapping(raw, "claims") _exact_keys(table, _CLAIM_KEYS, "claims") claims = M8Claims( allow_p_values=_boolean(table["allow_p_values"], "claims.allow_p_values"), allow_significance_claim=_boolean( table["allow_significance_claim"], "claims.allow_significance_claim" ), allow_cross_instrument_pooling=_boolean( table["allow_cross_instrument_pooling"], "claims.allow_cross_instrument_pooling", ), allow_execution_claim=_boolean( table["allow_execution_claim"], "claims.allow_execution_claim" ), allow_profitability_claim=_boolean( table["allow_profitability_claim"], "claims.allow_profitability_claim" ), ) for field in _CLAIM_KEYS: _require_equal(getattr(claims, field), False, f"claims.{field}") return claims def load_m8_config(path: str | Path) -> M8StudyConfig: """Load and validate the exact M8 protocol-v1.0.2 machine specification.""" config_path = Path(path).resolve() source_bytes = config_path.read_bytes() try: decoded = source_bytes.decode("utf-8") raw = tomllib.loads(decoded) except (UnicodeDecodeError, tomllib.TOMLDecodeError) as exc: raise M8ConfigError(f"cannot parse M8 TOML configuration: {exc}") from exc root = _mapping(raw, "configuration") _exact_keys(root, _TOP_LEVEL_KEYS, "configuration") return M8StudyConfig( path=config_path, source_sha256=hashlib.sha256(source_bytes).hexdigest(), study=_parse_study(root["study"]), periods=_parse_periods(root["periods"]), features=_parse_features(root["features"]), models=_parse_models(root["models"]), quality=_parse_quality(root["quality"]), claims=_parse_claims(root["claims"]), ) __all__ = [ "M8Claims", "M8ConfigError", "M8Features", "M8Models", "M8Period", "M8PeriodRole", "M8Quality", "M8Study", "M8StudyConfig", "load_m8_config", ]