#!/usr/bin/env python3 """Strict validation for a generated QuantInvBench release.""" from __future__ import annotations import argparse import json import math import re import sys from datetime import datetime, timedelta from pathlib import Path import pandas as pd from common import ( ASSETS, ATTACK_PROTOCOL_VERSION, BENCHMARK_VERSION, EVALUATION_PROTOCOL, EXPECTED_SPLIT_COUNTS, EXPECTED_SPLIT_RANGES, REBALANCE_DAYS, STRATEGIES, TRANSACTION_COST, WEIGHT_TOLERANCE, read_jsonl, sha256_file, ) ID_PATTERN = re.compile(r"^quantinv_(train|validation|test)_\d{4}_\d{8}$") REQUIRED_FIELDS = { "id", "split", "as_of", "execution_at", "label_end_at", "assets", "strategy_proposals", "next_7d_daily_returns", "next_7d_returns", } class Validation: def __init__(self) -> None: self.checks = 0 self.errors: list[str] = [] def check(self, condition: bool, message: str) -> None: self.checks += 1 if not condition: self.errors.append(message) def parse_timestamp(value: object, label: str) -> datetime: if not isinstance(value, str): raise ValueError(f"{label}: timestamp must be a string") parsed = datetime.fromisoformat(value.replace("Z", "+00:00")) if parsed.tzinfo is None: raise ValueError(f"{label}: timestamp must include a timezone") return parsed def validate_weights(values: object, label: str, result: Validation) -> None: result.check(isinstance(values, list), f"{label}: weights must be a list") if not isinstance(values, list): return result.check(len(values) == len(ASSETS), f"{label}: expected five weights") if len(values) != len(ASSETS): return numeric = all(isinstance(value, (int, float)) and not isinstance(value, bool) for value in values) result.check(numeric, f"{label}: weights must be numeric") if not numeric: return finite = all(math.isfinite(float(value)) for value in values) result.check(finite, f"{label}: weights contain NaN or Infinity") if not finite: return result.check(all(value >= 0 for value in values), f"{label}: weights must be non-negative") result.check( abs(sum(values) - 1.0) <= WEIGHT_TOLERANCE, f"{label}: weights sum to {sum(values)}, not 1", ) def validate_record( record: dict, split: str, index: int, result: Validation, ) -> tuple[datetime | None, datetime | None]: label = f"{split}[{index}]" result.check(set(record) == REQUIRED_FIELDS, f"{label}: fields do not match schema") result.check(record.get("split") == split, f"{label}: wrong split value") identifier = record.get("id") result.check(isinstance(identifier, str) and bool(ID_PATTERN.fullmatch(identifier)), f"{label}: invalid id") result.check(record.get("assets") == list(ASSETS), f"{label}: asset roster/order changed") try: as_of = parse_timestamp(record.get("as_of"), f"{label}.as_of") execution = parse_timestamp(record.get("execution_at"), f"{label}.execution_at") label_end = parse_timestamp(record.get("label_end_at"), f"{label}.label_end_at") result.check(as_of < execution, f"{label}: as_of must precede execution_at") result.check(execution - as_of <= timedelta(seconds=1), f"{label}: unexpected decision gap") result.check( label_end - execution == timedelta(days=REBALANCE_DAYS), f"{label}: label horizon is not seven days", ) if isinstance(identifier, str): expected_id = f"quantinv_{split}_{index:04d}_{execution:%Y%m%d}" result.check(identifier == expected_id, f"{label}: id does not match split/index/date") except (TypeError, ValueError) as exc: result.check(False, str(exc)) execution = None label_end = None proposals = record.get("strategy_proposals") result.check(isinstance(proposals, list), f"{label}: strategy_proposals must be a list") if isinstance(proposals, list): result.check( len(proposals) == len(STRATEGIES), f"{label}: expected {len(STRATEGIES)} strategies", ) names = [proposal.get("strategy") for proposal in proposals if isinstance(proposal, dict)] result.check(names == list(STRATEGIES), f"{label}: strategy roster/order changed") for proposal_index, proposal in enumerate(proposals): proposal_label = f"{label}.strategy_proposals[{proposal_index}]" result.check(isinstance(proposal, dict), f"{proposal_label}: must be an object") if isinstance(proposal, dict): result.check(set(proposal) == {"strategy", "weights"}, f"{proposal_label}: invalid fields") validate_weights(proposal.get("weights"), proposal_label, result) returns = record.get("next_7d_returns") result.check(isinstance(returns, list) and len(returns) == len(ASSETS), f"{label}: invalid returns") endpoint_returns_valid = False if isinstance(returns, list) and len(returns) == len(ASSETS): endpoint_returns_valid = all( isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(float(value)) and float(value) > -1.0 for value in returns ) result.check(endpoint_returns_valid, f"{label}: returns contain invalid values") daily_returns = record.get("next_7d_daily_returns") result.check( isinstance(daily_returns, list) and len(daily_returns) == REBALANCE_DAYS, f"{label}: next_7d_daily_returns must contain seven rows", ) daily_returns_valid = False if isinstance(daily_returns, list) and len(daily_returns) == REBALANCE_DAYS: rows_valid = [] for day_index, row in enumerate(daily_returns): row_valid = ( isinstance(row, list) and len(row) == len(ASSETS) and all( isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(float(value)) and float(value) > -1.0 for value in row ) ) result.check(row_valid, f"{label}.next_7d_daily_returns[{day_index}]: invalid row") rows_valid.append(row_valid) daily_returns_valid = all(rows_valid) if endpoint_returns_valid and daily_returns_valid: for asset_index, asset in enumerate(ASSETS): compounded = math.prod( 1.0 + float(daily_returns[day_index][asset_index]) for day_index in range(REBALANCE_DAYS) ) - 1.0 result.check( abs(compounded - float(returns[asset_index])) <= 1e-8, f"{label}: {asset} endpoint return does not compound from daily returns", ) return execution, label_end def main() -> int: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("data_dir", type=Path, nargs="?", default=Path(__file__).resolve().parents[1] / "data") parser.add_argument( "--source-data-dir", type=Path, help="Optional original hourly data directory for replaying next_7d_returns", ) args = parser.parse_args() data_dir = args.data_dir.resolve() result = Validation() manifest_path = data_dir / "manifest.json" result.check(manifest_path.exists(), f"missing {manifest_path}") manifest = {} if manifest_path.exists(): try: manifest = json.loads(manifest_path.read_text(encoding="utf-8")) except (OSError, json.JSONDecodeError) as exc: result.check(False, f"invalid manifest: {exc}") result.check(manifest.get("dataset") == "QuantInvBench", "manifest: wrong dataset name") result.check(manifest.get("version") == BENCHMARK_VERSION, f"manifest: expected benchmark version {BENCHMARK_VERSION}") result.check(manifest.get("assets") == list(ASSETS), "manifest: asset roster/order changed") result.check(manifest.get("strategies") == list(STRATEGIES), "manifest: strategy roster/order changed") result.check(manifest.get("rebalance_days") == REBALANCE_DAYS, "manifest: wrong rebalance period") result.check(manifest.get("label_horizon_days") == REBALANCE_DAYS, "manifest: wrong label horizon") result.check(manifest.get("transaction_cost") == TRANSACTION_COST, "manifest: wrong transaction cost") result.check(manifest.get("splits") == EXPECTED_SPLIT_COUNTS, "manifest: wrong fixed split counts") result.check(manifest.get("split_ranges") == EXPECTED_SPLIT_RANGES, "manifest: wrong fixed split ranges") result.check(manifest.get("evaluation_protocol") == EVALUATION_PROTOCOL, "manifest: wrong evaluation protocol") result.check(manifest.get("attack_protocol") == ATTACK_PROTOCOL_VERSION, "manifest: wrong attack protocol") seen_ids = set() split_ranges = {} all_records = [] for split in ("train", "validation", "test"): path = data_dir / f"{split}.jsonl" result.check(path.exists(), f"missing {path}") if not path.exists(): continue try: records = read_jsonl(path) except ValueError as exc: result.check(False, str(exc)) continue all_records.extend(records) result.check(bool(records), f"{split}: split is empty") periods = [] for index, record in enumerate(records): result.check(isinstance(record, dict), f"{split}[{index}]: record must be an object") if not isinstance(record, dict): continue execution, label_end = validate_record(record, split, index, result) if execution is not None and label_end is not None: periods.append((execution, label_end)) identifier = record.get("id") result.check(identifier not in seen_ids, f"duplicate id: {identifier}") seen_ids.add(identifier) execution_times = [execution for execution, _ in periods] result.check(execution_times == sorted(execution_times), f"{split}: records are not sorted") for (left_execution, left_end), (right_execution, _) in zip(periods, periods[1:]): result.check( right_execution - left_execution == timedelta(days=REBALANCE_DAYS), f"{split}: rebalance interval is not seven days", ) result.check( left_end == right_execution, f"{split}: holding periods are not contiguous", ) if periods: split_ranges[split] = (periods[0][0], periods[-1][1]) expected_count = EXPECTED_SPLIT_COUNTS[split] result.check(expected_count == len(records), f"{split}: manifest count does not match") expected_hash = manifest.get("data_sha256", {}).get(path.name) result.check(expected_hash == sha256_file(path), f"{split}: SHA-256 does not match manifest") if periods: expected_range = { "execution_start": records[0]["execution_at"], "execution_end": records[-1]["execution_at"], "label_end": records[-1]["label_end_at"], } result.check( manifest.get("split_ranges", {}).get(split) == expected_range, f"{split}: manifest range does not match records", ) ordered_ranges = [split_ranges.get(split) for split in ("train", "validation", "test")] if all(ordered_ranges): result.check(ordered_ranges[0][1] < ordered_ranges[1][0], "train labels overlap validation") result.check(ordered_ranges[1][1] < ordered_ranges[2][0], "validation labels overlap test") if args.source_data_dir: from generate import load_daily_data, scalar_at frames = load_daily_data(args.source_data_dir.resolve()) for record in all_records: execution = parse_timestamp(record["execution_at"], record["id"]) execution_date = pd.Timestamp(execution) exit_date = execution_date + pd.Timedelta(days=REBALANCE_DAYS) label_end = parse_timestamp(record["label_end_at"], record["id"]) result.check(pd.Timestamp(label_end) == exit_date, f"{record['id']}: wrong label_end_at") for asset_index, coin in enumerate(("bitcoin", "ethereum", "tether", "xrp", "bnb")): entry = scalar_at(frames[coin], execution_date, "open") exit_price = scalar_at(frames[coin], exit_date, "open") expected = exit_price / entry - 1.0 actual = record["next_7d_returns"][asset_index] result.check( abs(expected - actual) <= 1e-9, f"{record['id']}: {ASSETS[asset_index]} next_7d_returns does not match source", ) for day_index in range(REBALANCE_DAYS): day_start = execution_date + pd.Timedelta(days=day_index) day_end = day_start + pd.Timedelta(days=1) start_price = scalar_at(frames[coin], day_start, "open") end_price = scalar_at(frames[coin], day_end, "open") expected_daily = end_price / start_price - 1.0 actual_daily = record["next_7d_daily_returns"][day_index][asset_index] result.check( abs(expected_daily - actual_daily) <= 1e-9, f"{record['id']}: {ASSETS[asset_index]} day {day_index} return does not match source", ) if result.errors: for error in result.errors: print(f"[FAIL] {error}", file=sys.stderr) print(f"Validation failed: {len(result.errors)} errors across {result.checks} checks", file=sys.stderr) return 1 print(f"Validation passed: {result.checks} checks, {len(seen_ids)} records") return 0 if __name__ == "__main__": raise SystemExit(main())