code/assemble_benchmark.py

"""Layer 3 – Step 8: Assemble benchmark artifacts from the processed panel.

Reads ``data/processed/{granularity}/panel.parquet`` and produces:

    data/benchmark/{granularity}/panel_train.parquet
    data/benchmark/{granularity}/panel_test.parquet
    data/benchmark/{granularity}/panel_full.csv      (CSV compatibility)
    data/benchmark/{granularity}/task_definition.json
    data/benchmark/{granularity}/filing_corpus.parquet
    data/benchmark/{granularity}/metadata.json

Does NOT re-process raw data.  All heavy lifting happened in
``preprocess.py`` (Layer 2).
"""

from __future__ import annotations

import json
import logging
from pathlib import Path

import numpy as np
import pandas as pd

from . import config

logger = logging.getLogger(__name__)


# ------------------------------------------------------------------
# Filing corpus
# ------------------------------------------------------------------

def _build_filing_corpus() -> pd.DataFrame:
    """Build a filing corpus index from ``data/filings/{TICKER}/*.md``.

    Stores only **metadata** (ticker, filing_type, filing_date, filing_path)
    -- NOT the full text -- to avoid OOM with thousands of large filings.
    Text is loaded on-demand by ``benchmark_loader.py`` using ``filing_path``.

    Columns: ticker, filing_type, filing_date, filing_path, text_length.
    """
    import re as _re

    rows: list[dict] = []
    if not config.FILINGS_DIR.is_dir():
        logger.warning("Filings directory does not exist: %s", config.FILINGS_DIR)
        return pd.DataFrame(columns=["ticker", "filing_type", "filing_date", "filing_path", "text_length"])

    for ticker_dir in sorted(config.FILINGS_DIR.iterdir()):
        if not ticker_dir.is_dir():
            continue
        ticker = ticker_dir.name
        for md_file in sorted(ticker_dir.glob("*.md")):
            ftype = "10-K" if "10-K" in md_file.name else "10-Q" if "10-Q" in md_file.name else "8-K" if "8-K" in md_file.name else "other"
            match = _re.search(r"(\d{4}-\d{2}-\d{2})", md_file.name)
            fdate = match.group(1) if match else None
            # Only measure length (not load entire text into memory)
            try:
                text_len = md_file.stat().st_size
            except Exception:
                text_len = 0
            rows.append({
                "ticker": ticker,
                "filing_type": ftype,
                "filing_date": fdate,
                "filing_path": str(md_file.relative_to(config.DATA_DIR)),
                "text_length": text_len,
            })

    df = pd.DataFrame(rows)
    if not df.empty and "filing_date" in df.columns:
        df["filing_date"] = pd.to_datetime(df["filing_date"], errors="coerce")
    logger.info("Filing corpus index: %d documents across %d tickers.",
                 len(df), df["ticker"].nunique() if not df.empty else 0)
    return df


# ------------------------------------------------------------------
# Task definition
# ------------------------------------------------------------------

def _build_task_definition(panel: pd.DataFrame, granularity: str) -> dict:
    """Create the formal forecasting-task contract."""
    # Read column roles from the processed output
    col_roles_path = config.DATA_DIR / "processed" / granularity / "columns.json"
    if col_roles_path.exists():
        column_roles = json.loads(col_roles_path.read_text())
    else:
        column_roles = {}

    return {
        "benchmark_name": "MacroLens",
        "version": "1.0",
        "granularity": granularity,
        "targets": {
            "primary": "close",
            "secondary": "volume",
        },
        "horizons": config.get_horizons(granularity),
        "lookback_windows": config.get_lookback_windows(granularity),
        "column_roles": column_roles,
        "context_taxonomy": {
            "historical": "10-K / 10-Q filing text (nearest filing as-of each date)",
            "covariate": "FRED / EIA macro indicators (exogenous_macro + exogenous_commodity)",
            "causal": "Fundamental ratios derived from statements + price (exogenous_fundamental)",
            "future_scenario": "Natural experiment events detected from macro data (scenarios.parquet)",
            "intemporal": "Sector / industry knowledge (metadata columns)",
        },
        "evaluation": {
            "metrics": ["MSE", "MAE", "RMSE", "directional_accuracy"],
            "baseline": "naive_last_value",
            "primary_metric": "MSE",
        },
        "scenario_method": "natural_experiments",
    }


# ------------------------------------------------------------------
# Public API
# ------------------------------------------------------------------

def run(granularity: str | None = None) -> None:
    """Execute Layer 3 benchmark assembly."""
    if granularity is None:
        granularity = config.GRANULARITY

    panel_path = config.DATA_DIR / "processed" / granularity / "panel.parquet"
    if not panel_path.exists():
        raise FileNotFoundError(f"Run Step 7 (preprocess) first: {panel_path}")

    out_dir = config.DATA_DIR / "benchmark" / granularity
    out_dir.mkdir(parents=True, exist_ok=True)

    # ---- Load processed panel ------------------------------------------------
    panel = pd.read_parquet(panel_path)
    logger.info("Loaded processed panel: %d rows, %d tickers, %d columns.",
                 len(panel), panel["ticker"].nunique(), len(panel.columns))

    # ---- Temporal split ------------------------------------------------------
    if config.TEMPORAL_SPLIT_DATE is not None:
        split_date = pd.Timestamp(config.TEMPORAL_SPLIT_DATE)
    else:
        unique_dates = np.sort(panel["date"].unique())
        split_idx = int(len(unique_dates) * config.TEMPORAL_SPLIT_RATIO)
        split_idx = max(1, min(split_idx, len(unique_dates) - 1))
        split_date = pd.Timestamp(unique_dates[split_idx])
        logger.info("Ratio-based split (%.0f:%.0f): split date = %s (%d/%d unique dates)",
                     config.TEMPORAL_SPLIT_RATIO * 100,
                     (1 - config.TEMPORAL_SPLIT_RATIO) * 100,
                     split_date.date(), split_idx, len(unique_dates))

    panel["split"] = np.where(panel["date"] < split_date, "train", "test")
    train = panel[panel["split"] == "train"]
    test = panel[panel["split"] == "test"]

    # Cold-start tickers: IPOs that appear only in the test period.
    # Kept intentionally — tests model generalisation to unseen companies.
    train_tickers = set(train["ticker"].unique())
    test_only = set(test["ticker"].unique()) - train_tickers
    if test_only:
        logger.info("%d cold-start tickers in test (IPOs).", len(test_only))

    train.to_parquet(out_dir / "panel_train.parquet", index=False)
    test.to_parquet(out_dir / "panel_test.parquet", index=False)
    panel.to_csv(out_dir / "panel_full.csv", index=False)
    logger.info("Saved train (%d rows) + test (%d rows) + CSV.", len(train), len(test))

    # ---- Task definition -----------------------------------------------------
    task_def = _build_task_definition(panel, granularity)
    (out_dir / "task_definition.json").write_text(json.dumps(task_def, indent=2, default=str))
    logger.info("Saved task_definition.json.")

    # ---- Filing corpus -------------------------------------------------------
    corpus = _build_filing_corpus()
    if not corpus.empty:
        corpus.to_parquet(out_dir / "filing_corpus.parquet", index=False)
    logger.info("Saved filing_corpus.parquet (%d documents).", len(corpus))

    # ---- Metadata ------------------------------------------------------------
    metadata = {
        "format": "panel_data",
        "granularity": granularity,
        "primary_key": ["ticker", "date"],
        "total_rows": len(panel),
        "total_tickers": int(panel["ticker"].nunique()),
        "date_range": {
            "start": str(panel["date"].min().date()),
            "end": str(panel["date"].max().date()),
        },
        "temporal_split": {
            "split_date": str(split_date.date()),
            "split_method": (
                "fixed_date" if config.TEMPORAL_SPLIT_DATE
                else f"ratio_{config.TEMPORAL_SPLIT_RATIO}"
            ),
            "train_rows": len(train),
            "test_rows": len(test),
            "train_date_range": {
                "start": str(train["date"].min().date()) if len(train) > 0 else None,
                "end": str(train["date"].max().date()) if len(train) > 0 else None,
            },
            "test_date_range": {
                "start": str(test["date"].min().date()) if len(test) > 0 else None,
                "end": str(test["date"].max().date()) if len(test) > 0 else None,
            },
        },
        "label_distribution": panel["label"].value_counts().to_dict() if "label" in panel.columns else {},
        "columns": list(panel.columns),
        "column_count": len(panel.columns),
        "column_roles": task_def.get("column_roles", {}),
        "filing_corpus_stats": {
            "total_documents": len(corpus),
            "tickers_with_filings": int(corpus["ticker"].nunique()) if not corpus.empty else 0,
        },
        "evaluation_protocol": task_def.get("evaluation", {}),
    }
    (out_dir / "metadata.json").write_text(json.dumps(metadata, indent=2, default=str))
    logger.info("Saved metadata.json.  Base benchmark assembly complete -> %s", out_dir)

    # ---- Valuation benchmark (Tasks A–F) ---------------------------------
    try:
        from .build_valuation_tasks import build_valuation_benchmark
        logger.info("Building valuation benchmark artifacts (%s) …", granularity)
        val_summary = build_valuation_benchmark(granularity=granularity)
        logger.info("Valuation benchmark: %s", val_summary)
    except Exception:
        logger.warning("Valuation benchmark build skipped or failed", exc_info=True)