#!/usr/bin/env python3 """Generate causal QuantInvBench JSONL splits for Hugging Face.""" from __future__ import annotations import argparse import json from datetime import timedelta, timezone from pathlib import Path import numpy as np import pandas as pd from common import ( ASSETS, ATTACK_PROTOCOL_VERSION, BENCHMARK_VERSION, COINS, EVALUATION_PROTOCOL, EXPECTED_SPLIT_COUNTS, EXPECTED_SPLIT_RANGES, REBALANCE_DAYS, STRATEGIES, TRANSACTION_COST, sha256_file, write_jsonl, ) from strategies import SentimentIndex, compute_proposals PROJECT_ROOT = Path(__file__).resolve().parents[3] RELEASE_ROOT = Path(__file__).resolve().parents[1] SPLIT_BOUNDS = { "train": (None, pd.Timestamp("2024-03-15", tz="UTC")), "validation": ( pd.Timestamp("2024-03-16", tz="UTC"), pd.Timestamp("2025-03-15", tz="UTC"), ), "test": ( pd.Timestamp("2025-03-16", tz="UTC"), pd.Timestamp("2026-03-15", tz="UTC"), ), } def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--data-dir", type=Path, default=PROJECT_ROOT / "data") parser.add_argument( "--sentiment-file", type=Path, default=RELEASE_ROOT / "cache" / "crypto_news_sentiment.json", ) parser.add_argument("--output-dir", type=Path, default=RELEASE_ROOT / "data") return parser.parse_args() def load_daily_data(data_dir: Path) -> dict[str, pd.DataFrame]: frames = {} required_columns = { "date", "open", "high", "low", "close", "volume", "quote_volume", } for coin in COINS: path = data_dir / f"{coin}_prices_1h.csv" if not path.exists(): raise FileNotFoundError(f"Missing source data: {path}") hourly = pd.read_csv(path) missing = required_columns - set(hourly.columns) if missing: raise ValueError(f"{path}: missing columns {sorted(missing)}") hourly["date"] = pd.to_datetime(hourly["date"], utc=True) for column in required_columns - {"date"}: hourly[column] = pd.to_numeric(hourly[column], errors="raise") if hourly["date"].duplicated().any(): raise ValueError(f"{path}: duplicate hourly timestamps") if not hourly["date"].is_monotonic_increasing: hourly = hourly.sort_values("date") daily = ( hourly.set_index("date") .resample("1D") .agg( { "open": "first", "high": "max", "low": "min", "close": "last", "volume": "sum", "quote_volume": "sum", } ) .dropna() ) if not np.isfinite(daily.to_numpy(dtype=float)).all(): raise ValueError(f"{path}: daily data contains NaN or Infinity") if (daily[["open", "high", "low", "close"]] <= 0).any().any(): raise ValueError(f"{path}: source contains non-positive prices") frames[coin] = daily common_dates = frames[COINS[0]].index for coin in COINS[1:]: common_dates = common_dates.intersection(frames[coin].index) if common_dates.empty: raise ValueError("The five assets have no common daily dates") return {coin: frame.loc[common_dates].copy() for coin, frame in frames.items()} def scalar_at(frame: pd.DataFrame, date: pd.Timestamp, column: str) -> float: try: value = frame.at[date, column] except KeyError as exc: raise ValueError(f"Missing {column} for {date.date()}") from exc if isinstance(value, pd.Series): raise ValueError(f"Duplicate value for {date.date()}") return float(value) def split_dates( split: str, common_dates: pd.DatetimeIndex, ) -> list[pd.Timestamp]: configured_start, configured_end = SPLIT_BOUNDS[split] history_ready = common_dates.min() + pd.Timedelta(days=61) start = ( max(history_ready, configured_start) if configured_start is not None else history_ready ) latest_source_execution = common_dates.max() - pd.Timedelta(days=REBALANCE_DAYS) latest_split_execution = configured_end - pd.Timedelta(days=REBALANCE_DAYS) end = min(latest_split_execution, latest_source_execution) if start > end: raise ValueError(f"{split}: no dates available between {start} and {end}") dates = list(pd.date_range(start=start, end=end, freq=f"{REBALANCE_DAYS}D")) common_set = set(common_dates) for execution in dates: if execution not in common_set: raise ValueError(f"{split}: missing execution date {execution.date()}") exit_date = execution + pd.Timedelta(days=REBALANCE_DAYS) if exit_date not in common_set: raise ValueError(f"{split}: missing exit date {exit_date.date()}") return dates def make_record( split: str, index: int, execution: pd.Timestamp, frames: dict[str, pd.DataFrame], sentiment: SentimentIndex, ) -> dict: history = {coin: frame.loc[frame.index < execution] for coin, frame in frames.items()} if min(len(frame) for frame in history.values()) < 61: raise ValueError(f"{execution.date()}: insufficient causal history") as_of_timestamp = execution.to_pydatetime() - timedelta(microseconds=1) exit_date = execution + pd.Timedelta(days=REBALANCE_DAYS) daily_returns = [] for offset in range(REBALANCE_DAYS): entry_date = execution + pd.Timedelta(days=offset) daily_exit_date = entry_date + pd.Timedelta(days=1) daily_returns.append( [ round( scalar_at(frames[coin], daily_exit_date, "open") / scalar_at(frames[coin], entry_date, "open") - 1.0, 10, ) for coin in COINS ] ) next_returns = np.prod(1.0 + np.asarray(daily_returns), axis=0) - 1.0 next_returns = [round(float(value), 10) for value in next_returns] proposals = compute_proposals(history, sentiment, as_of_timestamp) if [proposal["strategy"] for proposal in proposals] != list(STRATEGIES): raise ValueError(f"{execution.date()}: strategy roster changed") return { "id": f"quantinv_{split}_{index:04d}_{execution:%Y%m%d}", "split": split, "as_of": as_of_timestamp.astimezone(timezone.utc).isoformat().replace("+00:00", "Z"), "execution_at": execution.isoformat().replace("+00:00", "Z"), "label_end_at": exit_date.isoformat().replace("+00:00", "Z"), "assets": list(ASSETS), "strategy_proposals": proposals, "next_7d_daily_returns": daily_returns, "next_7d_returns": next_returns, } def main() -> None: args = parse_args() data_dir = args.data_dir.resolve() sentiment_file = args.sentiment_file.resolve() output_dir = args.output_dir.resolve() frames = load_daily_data(data_dir) sentiment = SentimentIndex(sentiment_file) common_dates = frames[COINS[0]].index split_records = {} for split in SPLIT_BOUNDS: dates = split_dates(split, common_dates) records = [ make_record(split, index, execution, frames, sentiment) for index, execution in enumerate(dates) ] split_records[split] = records actual_counts = { split: len(records) for split, records in split_records.items() } if actual_counts != EXPECTED_SPLIT_COUNTS: raise ValueError( f"split counts changed: expected {EXPECTED_SPLIT_COUNTS}, got {actual_counts}" ) output_dir.mkdir(parents=True, exist_ok=True) for split, records in split_records.items(): write_jsonl(output_dir / f"{split}.jsonl", records) source_hashes = { f"{coin}_prices_1h.csv": sha256_file(data_dir / f"{coin}_prices_1h.csv") for coin in COINS } source_hashes[sentiment_file.name] = sha256_file(sentiment_file) split_ranges = { split: { "execution_start": records[0]["execution_at"], "execution_end": records[-1]["execution_at"], "label_end": records[-1]["label_end_at"], } for split, records in split_records.items() } if split_ranges != EXPECTED_SPLIT_RANGES: raise ValueError( f"split ranges changed: expected {EXPECTED_SPLIT_RANGES}, got {split_ranges}" ) manifest = { "dataset": "QuantInvBench", "version": BENCHMARK_VERSION, "assets": list(ASSETS), "strategies": list(STRATEGIES), "rebalance_days": REBALANCE_DAYS, "label_horizon_days": REBALANCE_DAYS, "transaction_cost": TRANSACTION_COST, "splits": actual_counts, "split_ranges": split_ranges, "evaluation_protocol": EVALUATION_PROTOCOL, "attack_protocol": ATTACK_PROTOCOL_VERSION, "data_sha256": { f"{split}.jsonl": sha256_file(output_dir / f"{split}.jsonl") for split in split_records }, "source_sha256": source_hashes, "notes": {"USDT": "synthetic cash-like series in the current source data"}, } with (output_dir / "manifest.json").open("w", encoding="utf-8") as handle: json.dump(manifest, handle, indent=2, ensure_ascii=False, allow_nan=False) handle.write("\n") counts = ", ".join(f"{split}={len(records)}" for split, records in split_records.items()) print(f"Generated QuantInvBench in {output_dir} ({counts})") if __name__ == "__main__": main()