code/benchmark_loader.py

"""Runtime: Hybrid DataLoader for the MacroLens benchmark.

Provides ``WhatIfTSFDataset`` -- a lightweight, on-the-fly instance
generator that reads from pre-built benchmark artifacts
(``panel_train.parquet`` / ``panel_test.parquet``, ``scenarios.parquet``,
``filing_corpus.parquet``).

One "instance" = a tuple of:
    (lookback_window, forecast_target, context_dict)

where ``context_dict`` holds metadata, filing text, macro, and any scenario
information that falls within the instance's time window.

Usage example
-------------
.. code-block:: python

    from whatif_bench.benchmark_loader import WhatIfTSFDataset

    # Defaults to granularity-appropriate lookback/horizon from config
    ds = WhatIfTSFDataset(split="train")
    print(len(ds))          # total number of sliding-window instances
    sample = ds[0]          # dict with 'lookback', 'target', 'context'

    # Each scenario in context["scenarios"] has a "scenario_role" field:
    #   "observed" = already happened (in lookback window)
    #   "hypothetical" = in forecast horizon (the "what-if" condition)
"""

from __future__ import annotations

import json
import logging
from pathlib import Path
from typing import Any

import numpy as np
import pandas as pd

from . import config

logger = logging.getLogger(__name__)


class WhatIfTSFDataset:
    """Sliding-window dataset over the MacroLens benchmark panel.

    Parameters
    ----------
    split : str
        ``"train"`` or ``"test"``.
    lookback : int, optional
        Number of past time-steps visible to the model (in panel periods).
        Defaults to the first entry of ``config.LOOKBACK_WINDOWS_BY_GRANULARITY``
        for the chosen granularity (63 for daily, 13 for weekly, 3 for monthly).
    horizon : int, optional
        Number of future time-steps to predict (in panel periods).
        Defaults to the first entry of ``config.HORIZONS_BY_GRANULARITY``
        for the chosen granularity (5 for daily, 4 for weekly, 1 for monthly).
    granularity : str, optional
        Defaults to ``config.GRANULARITY``.
    target_col : str
        Column name of the prediction target. Default: ``"close"``.
    load_text : bool
        If True, load ``filing_corpus.parquet`` and attach filing text to
        context.  Set to False for fast iteration.
    """

    def __init__(
        self,
        split: str = "train",
        lookback: int | None = None,
        horizon: int | None = None,
        granularity: str | None = None,
        target_col: str = "close",
        load_text: bool = True,
    ) -> None:
        if granularity is None:
            granularity = config.GRANULARITY
        self.granularity = granularity
        self.split = split

        # Granularity-aware defaults from config
        if lookback is None:
            lookback = config.get_lookback_windows(granularity)[0]
        if horizon is None:
            horizon = config.get_horizons(granularity)[0]
        self.lookback = lookback
        self.horizon = horizon
        self.target_col = target_col

        bench_dir = config.DATA_DIR / "benchmark" / granularity

        # ---- Load panel split ------------------------------------------------
        panel_path = bench_dir / f"panel_{split}.parquet"
        if not panel_path.exists():
            raise FileNotFoundError(f"Benchmark not assembled: {panel_path}")
        self._panel = pd.read_parquet(panel_path)
        self._panel["date"] = pd.to_datetime(self._panel["date"])
        self._panel = self._panel.sort_values(["ticker", "date"]).reset_index(drop=True)

        # ---- Validate target column exists -----------------------------------
        if target_col not in self._panel.columns:
            available = [c for c in self._panel.columns if self._panel[c].dtype.kind in "fiub"]
            raise ValueError(
                f"target_col={target_col!r} not in panel columns. "
                f"Available numeric columns: {available}"
            )

        # ---- Build instance index (ticker, start_idx, end_idx) ---------------
        self._instances: list[tuple[str, int, int]] = []
        required_len = lookback + horizon
        for ticker, grp in self._panel.groupby("ticker"):
            n = len(grp)
            if n < required_len:
                continue
            start_positions = range(n - required_len + 1)
            grp_idx = grp.index.tolist()
            for s in start_positions:
                self._instances.append((ticker, grp_idx[s], grp_idx[s + required_len - 1]))

        # ---- Scenarios -------------------------------------------------------
        scenarios_path = bench_dir / "scenarios.parquet"
        if scenarios_path.exists():
            self._scenarios = pd.read_parquet(scenarios_path)
            self._scenarios["event_date"] = pd.to_datetime(self._scenarios["event_date"])
        else:
            self._scenarios = pd.DataFrame()

        # ---- Filing corpus index (optional, text loaded on-demand) -----------
        self._corpus: pd.DataFrame | None = None
        self._corpus_by_ticker: dict[str, pd.DataFrame] = {}
        if load_text:
            corpus_path = bench_dir / "filing_corpus.parquet"
            if corpus_path.exists():
                self._corpus = pd.read_parquet(corpus_path)
                self._corpus["filing_date"] = pd.to_datetime(
                    self._corpus["filing_date"], errors="coerce",
                )
                self._corpus = self._corpus.sort_values("filing_date")
                # Pre-build per-ticker index for O(1) lookup
                for ticker, grp in self._corpus.groupby("ticker"):
                    self._corpus_by_ticker[str(ticker)] = grp

        # ---- Task definition -------------------------------------------------
        task_path = bench_dir / "task_definition.json"
        self.task_definition: dict = {}
        if task_path.exists():
            self.task_definition = json.loads(task_path.read_text())

        n_tickers = self._panel["ticker"].nunique()
        logger.info(
            "WhatIfTSFDataset(%s/%s, lookback=%d, horizon=%d): %d instances from %d tickers.",
            split, granularity, lookback, horizon, len(self._instances), n_tickers,
        )
        if len(self._instances) == 0 and n_tickers > 0:
            max_len = self._panel.groupby("ticker").size().max()
            logger.warning(
                "ZERO instances generated! lookback(%d) + horizon(%d) = %d periods required, "
                "but longest ticker has only %d periods. "
                "Consider using smaller lookback/horizon values for %s granularity. "
                "Suggested defaults: lookback=%d, horizon=%d.",
                lookback, horizon, lookback + horizon, max_len, granularity,
                config.get_lookback_windows(granularity)[0],
                config.get_horizons(granularity)[0],
            )

    # ------------------------------------------------------------------
    # Sequence protocol
    # ------------------------------------------------------------------

    def __len__(self) -> int:
        return len(self._instances)

    def canonical_indices(self, task: str = "T1") -> list[int]:
        """Return the dataset-instance indices matching the canonical
        ``(ticker, anchor_date)`` pairs from
        ``dataloader.canonical_indices.get_canonical_indices(task)``.

        For T1, ``anchor_date`` is the lookback-end date (i.e. the latest
        date in the window). Every T1 baseline must iterate exactly these
        indices so cross-method comparison is on identical instances.
        """
        from .dataloader.canonical_indices import get_canonical_indices

        canonical = get_canonical_indices(
            task, "eval", granularity=self.granularity,
        )
        canonical_set = {
            (str(t), pd.Timestamp(a))
            for t, a in zip(
                canonical["ticker"].astype(str),
                pd.to_datetime(canonical["anchor_date"]),
            )
        }
        out: list[int] = []
        for i, (ticker, row_start, _row_end) in enumerate(self._instances):
            lookback_end_date = pd.Timestamp(
                self._panel.loc[row_start + self.lookback - 1, "date"]
            )
            if (str(ticker), lookback_end_date) in canonical_set:
                out.append(i)
        return out

    def __getitem__(self, idx: int) -> dict[str, Any]:
        if idx < 0 or idx >= len(self._instances):
            raise IndexError(f"Index {idx} out of range [0, {len(self._instances)})")
        ticker, row_start, row_end = self._instances[idx]

        window = self._panel.loc[row_start: row_end].copy()
        lookback_df = window.iloc[: self.lookback]
        target_df = window.iloc[self.lookback:]

        date_start = lookback_df["date"].iloc[0]
        date_end = target_df["date"].iloc[-1]

        # Numeric feature columns
        exclude = {"ticker", "date", "label", "split",
                   "nearest_filing_type", "nearest_filing_date", "nearest_filing_path"}
        feat_cols = [c for c in lookback_df.columns if c not in exclude and lookback_df[c].dtype.kind in "fiub"]

        # Context
        context: dict[str, Any] = {
            "ticker": ticker,
            "date_start": str(date_start.date()),
            "date_end": str(date_end.date()),
            "sector": lookback_df.get("sector", pd.Series()).iloc[0] if "sector" in lookback_df.columns else None,
            "industry": lookback_df.get("industry", pd.Series()).iloc[0] if "industry" in lookback_df.columns else None,
            "label": lookback_df["label"].iloc[0] if "label" in lookback_df.columns else None,
        }

        # Macro state summary for LLM agents -- human-readable snapshot of the
        # latest macro values at the lookback end.
        _MACRO_LABELS = {
            "fred_FEDFUNDS": "Fed Funds Rate",
            "fred_DGS2": "2Y Treasury",
            "fred_DGS10": "10Y Treasury",
            "fred_VIXCLS": "VIX",
            "fred_SP500": "S&P 500",
            "fred_NASDAQCOM": "NASDAQ",
            "fred_DTWEXBGS": "USD Index",
            "eia_crude_spot": "WTI Crude ($/bbl)",
            "eia_ng_spot": "Nat Gas ($/MMBtu)",
        }
        macro_snapshot: dict[str, float | str] = {}
        last_row = lookback_df.iloc[-1]
        for col, label in _MACRO_LABELS.items():
            if col in lookback_df.columns:
                val = last_row[col]
                if pd.notna(val):
                    macro_snapshot[label] = round(float(val), 2)
        if macro_snapshot:
            context["macro_state"] = macro_snapshot

        # Filing text (nearest 10-K/10-Q as-of the lookback end) -- O(1) dict lookup
        if self._corpus_by_ticker:
            lookback_end = lookback_df["date"].iloc[-1]
            ticker_filings = self._corpus_by_ticker.get(ticker)
            if ticker_filings is not None:
                valid = ticker_filings[ticker_filings["filing_date"] <= lookback_end]
                if not valid.empty:
                    # Nearest 10-K/10-Q for primary filing context
                    annual_q = valid[valid["filing_type"].isin(["10-K", "10-Q"])]
                    if not annual_q.empty:
                        latest = annual_q.iloc[-1]
                        context["filing_type"] = latest.get("filing_type", "")
                        context["filing_date"] = str(latest.get("filing_date", ""))
                        filing_path = latest.get("filing_path", "")
                        if filing_path:
                            full_path = config.DATA_DIR / filing_path
                            try:
                                context["filing_text"] = full_path.read_text(
                                    encoding="utf-8", errors="replace"
                                )
                            except Exception:
                                context["filing_text"] = ""
                        else:
                            context["filing_text"] = ""

                    # 8-K filings within the lookback window
                    lookback_start = lookback_df["date"].iloc[0]
                    eightk = valid[
                        (valid["filing_type"] == "8-K")
                        & (valid["filing_date"] >= lookback_start)
                    ]
                    if not eightk.empty:
                        eightk_texts = []
                        for _, row in eightk.iterrows():
                            fp = row.get("filing_path", "")
                            if fp:
                                full_path = config.DATA_DIR / fp
                                try:
                                    eightk_texts.append(full_path.read_text(
                                        encoding="utf-8", errors="replace"
                                    ))
                                except Exception:
                                    pass
                        if eightk_texts:
                            context["filing_8k_texts"] = eightk_texts

        # Recent news from yfinance per-ticker JSON
        news_path = config.NEWS_DIR / "tickers" / f"{ticker}.json"
        if news_path.exists():
            try:
                all_news = json.loads(news_path.read_text(encoding="utf-8"))
                lookback_end_dt = lookback_df["date"].iloc[-1]
                lookback_start_dt = lookback_df["date"].iloc[0]
                recent = []
                for art in all_news:
                    pub = art.get("pubDate") or art.get("pub_date") or art.get("providerPublishTime")
                    if pub is None:
                        continue
                    try:
                        ts = pd.Timestamp(pub)
                    except Exception:
                        continue
                    if lookback_start_dt <= ts <= lookback_end_dt:
                        recent.append(art)
                if recent:
                    context["recent_news"] = recent
            except Exception:
                pass

        # Scenario overlay -- label each as "observed" (in lookback) or
        # "hypothetical" (in forecast horizon), which is the core semantic
        # distinction for what-if evaluation.
        if not self._scenarios.empty:
            lookback_end = lookback_df["date"].iloc[-1]
            overlapping = self._scenarios[
                (self._scenarios["event_date"] >= date_start)
                & (self._scenarios["event_date"] <= date_end)
            ].copy()
            if not overlapping.empty:
                overlapping["scenario_role"] = np.where(
                    overlapping["event_date"] <= lookback_end,
                    "observed",       # Already happened -- model should know this
                    "hypothetical",   # In forecast window -- the "what-if" condition
                )
                sc_cols = [
                    "scenario_id", "event_type", "event_date",
                    "event_description", "scenario_role",
                ]
                # Include news_context if available
                if "news_context" in self._scenarios.columns:
                    sc_cols.append("news_context")
                context["scenarios"] = overlapping[
                    [c for c in sc_cols if c in overlapping.columns]
                ].to_dict("records")

        return {
            "lookback": lookback_df[feat_cols].values.astype(np.float32),
            "lookback_dates": lookback_df["date"].dt.strftime("%Y-%m-%d").tolist(),
            "target": target_df[self.target_col].values.astype(np.float32),
            "target_dates": target_df["date"].dt.strftime("%Y-%m-%d").tolist(),
            "context": context,
            "feature_names": feat_cols,
        }

    # ------------------------------------------------------------------
    # Convenience
    # ------------------------------------------------------------------

    def summary(self) -> dict[str, Any]:
        """Quick dataset summary statistics."""
        return {
            "split": self.split,
            "granularity": self.granularity,
            "lookback": self.lookback,
            "horizon": self.horizon,
            "num_instances": len(self._instances),
            "num_tickers": self._panel["ticker"].nunique(),
            "date_range": [
                str(self._panel["date"].min().date()),
                str(self._panel["date"].max().date()),
            ],
            "num_scenarios": len(self._scenarios),
            "corpus_loaded": self._corpus is not None and not self._corpus.empty,
        }


# ===================================================================
# ValuationDataset: point-in-time valuation benchmark loader
# ===================================================================

class ValuationDataset:
    """Dataset for valuation benchmark tasks (A–F).

    Each instance is a point-in-time snapshot suitable for:
      Task A: estimate equity value given observable financials (public company)
      Task B: generate financial statements given company profile
      Task C: forecast scenario impact given pre-event data
      Task D: estimate equity value given only financials + sector (PE simulation)
      Task E: generate financial statements for unseen companies (Generator eval)
      Task F: estimate rent/price for properties (RE valuation)

    Parameters
    ----------
    task : str
        ``"A"``–``"F"`` (or full name like ``"valuation_accuracy"``).
    granularity : str
        Defaults to ``config.GRANULARITY``.
    """

    _TASK_MAP = {
        "A": "A_valuation_accuracy",
        "B": "B_statement_generation",
        "C": "C_scenario_forecast",
        "D": "D_private_valuation",
        "E": "E_generator_evaluation",
        "F": "F_real_estate_valuation",
        "valuation_accuracy": "A_valuation_accuracy",
        "statement_generation": "B_statement_generation",
        "scenario_forecast": "C_scenario_forecast",
        "private_valuation": "D_private_valuation",
        "generator_evaluation": "E_generator_evaluation",
        "real_estate_valuation": "F_real_estate_valuation",
    }

    def __init__(
        self,
        task: str = "A",
        granularity: str | None = None,
    ) -> None:
        if granularity is None:
            granularity = config.GRANULARITY
        self.granularity = granularity
        self.task = self._TASK_MAP.get(task, task)

        bench_dir = config.DATA_DIR / "benchmark" / granularity

        # Load task definitions
        task_path = bench_dir / "valuation_tasks.json"
        if task_path.exists():
            self.task_definitions = json.loads(task_path.read_text())
        else:
            self.task_definitions = {}

        task_def = self.task_definitions.get("tasks", {}).get(self.task, {})
        input_file = task_def.get("input")
        gt_file = task_def.get("ground_truth")

        # Load inputs
        self._inputs = pd.DataFrame()
        if input_file:
            p = bench_dir / input_file
            if p.exists():
                self._inputs = pd.read_parquet(p) if p.suffix == ".parquet" else pd.read_csv(p)

        # Load ground truth
        self._ground_truth = pd.DataFrame()
        if gt_file:
            p = bench_dir / gt_file
            if p.exists():
                self._ground_truth = pd.read_parquet(p) if p.suffix == ".parquet" else pd.read_csv(p)

        # Holdout tickers
        self.holdout_tickers = self.task_definitions.get("holdout_tickers", [])

        logger.info(
            "ValuationDataset(task=%s, gran=%s): %d inputs, %d ground_truth rows",
            self.task, granularity, len(self._inputs), len(self._ground_truth),
        )

    @property
    def inputs(self) -> pd.DataFrame:
        return self._inputs

    @property
    def ground_truth(self) -> pd.DataFrame:
        return self._ground_truth

    def __len__(self) -> int:
        return len(self._inputs)

    def __getitem__(self, idx: int) -> dict[str, Any]:
        if idx < 0 or idx >= len(self._inputs):
            raise IndexError(f"Index {idx} out of range [0, {len(self._inputs)})")

        row = self._inputs.iloc[idx]
        item: dict[str, Any] = {"input": row.to_dict()}

        # Attach ground truth if available
        if not self._ground_truth.empty:
            if self.task in ("A_valuation_accuracy", "D_private_valuation"):
                tk = row.get("ticker")
                dt = row.get("date")
                match = self._ground_truth[
                    (self._ground_truth["ticker"] == tk)
                    & (self._ground_truth["date"] == dt)
                ]
                if not match.empty:
                    item["ground_truth"] = match.iloc[0].to_dict()
            elif self.task in ("B_statement_generation", "E_generator_evaluation"):
                tk = row.get("ticker")
                match = self._ground_truth[self._ground_truth["ticker"] == tk]
                if not match.empty:
                    item["ground_truth"] = match.to_dict("records")
            elif self.task == "C_scenario_forecast":
                sid = row.get("scenario_id")
                if sid:
                    match = self._ground_truth[self._ground_truth["scenario_id"] == sid]
                    if not match.empty:
                        item["ground_truth"] = match.to_dict("records")
            elif self.task == "F_real_estate_valuation":
                # Match by index position (inputs and GT are aligned)
                if idx < len(self._ground_truth):
                    item["ground_truth"] = self._ground_truth.iloc[idx].to_dict()

        return item

    def summary(self) -> dict[str, Any]:
        """Quick dataset summary."""
        s: dict[str, Any] = {
            "task": self.task,
            "granularity": self.granularity,
            "n_inputs": len(self._inputs),
            "n_ground_truth": len(self._ground_truth),
            "n_holdout_tickers": len(self.holdout_tickers),
        }
        if not self._inputs.empty and "ticker" in self._inputs.columns:
            s["n_tickers"] = self._inputs["ticker"].nunique()
        return s