code/dataloader/load.py

"""Canonical data loader for the MacroLens benchmark.

Sklearn-style: every call to ``load(task, split)`` returns a
``LoadedData = NamedTuple[X, y, meta]`` triple. Train and test schemas are
identical for every task (the v0.1 T2/T5 schema-mismatch bug is fixed
here). Methods MUST consume only ``X`` (and at fit time, ``y``); they
must NOT consume ``meta``. The runner uses ``meta`` to join predictions
back to canonical keys.

Per-task contract (definitive):

* T1 (TSF):       X = (N, lookback, F) float32, y = (N, horizon) float32
* T2 (Val-PT):    X = pd.DataFrame, y = (N,) float32 actual_market_cap
* T3 (Stmt-Gen):  X = pd.DataFrame keyed by (ticker, fiscal_year),
                  y = long-form pd.DataFrame[ticker, fiscal_year, field, value]
* T4 (Scen-Ret):  X = pd.DataFrame[lookback (object), event_type, event_description],
                  y = (N,) float32 return_pct
* T5 (Val-Priv):  same shape as T2; price-derived inputs stripped
* T6 (Gen-Eval):  same shape as T3; X has no stmt_*, only NL company_description
* T7 (RE-Val):    X = pd.DataFrame[property attrs],
                  y = pd.DataFrame[address, rent, price]

``meta.attrs`` is populated by every loader with::

    {
        "task": str, "split": str, "granularity": str,
        "lookback": int | None, "horizon": int | None,
        "feature_names": list[str],            # T1 / T4 only (lookback panel column names)
        "schema_version": int,
        "data_sha256": dict[str, str],         # SHA-256 of every upstream parquet read
        "n_canonical_dropped": int,            # canonical anchors lost (T1 only); RuntimeError if > 1%
    }
"""

from __future__ import annotations

from typing import Any, NamedTuple

import numpy as np
import pandas as pd

from .. import config
from ._provenance import sha256_dataset
from .canonical_indices import get_canonical_indices


_LOADED_DATA_SCHEMA_VERSION = 2


# Curated dense-field panel for T3 (Stmt-Gen). The released T3 ground truth
# parquet carries the full XBRL field universe (~10K tags, ~467K rows), but
# long-tail company-extension tags appear in only 1–2 (ticker, fiscal_year)
# pairs each, which makes whole-universe scoring scientifically meaningless.
# We project T3's `y` to the same 11 standard XBRL line items released in
# T6's curated panel. Projection lives in the loader; the on-disk parquet
# is untouched.
_T3_DENSE_FIELDS = frozenset({
    "Assets",
    "Liabilities",
    "StockholdersEquity",
    "Revenues",
    "NetIncomeLoss",
    "OperatingIncomeLoss",
    "CashAndCashEquivalentsAtCarryingValue",
    "PropertyPlantAndEquipmentNet",
    "LongTermDebt",
    "ResearchAndDevelopmentExpense",
    "NetCashProvidedByUsedInOperatingActivities",
})


# ── Public NamedTuple ─────────────────────────────────────────────────────


class LoadedData(NamedTuple):
    """Sklearn-style ``(X, y, meta)`` triple returned by :func:`load`."""

    X: Any
    y: Any
    meta: pd.DataFrame


# ── Public entrypoint ─────────────────────────────────────────────────────


def load(
    task: str,
    split: str,
    *,
    granularity: str = "daily",
    lookback: int | None = None,
    horizon: int | None = None,
    setting: str | None = None,
) -> LoadedData:
    """Load canonical task data for one ``(task, split)``. Identical across methods.

    ``setting`` (optional, one of ``"A".."E"``) projects the panel feature
    space to the named ablation tier. Applies only to T1, T2, T4, T5.
    """
    if split not in ("train", "test"):
        raise ValueError(f"split must be 'train' or 'test', got {split!r}")
    canon_split = "eval" if split == "test" else "train"

    if lookback is None:
        lookback = config.get_lookback_windows(granularity)[0]
    if horizon is None:
        # Use the LONGEST horizon as the default (e.g. daily 63 trading days):
        # the headline T1 evaluation horizon per the project plan.
        horizon = config.get_horizons(granularity)[-1]

    if task == "T1":
        loaded = _load_t1(canon_split, split, granularity, lookback, horizon)
    elif task in ("T2", "T5"):
        loaded = _load_t2_t5(task, canon_split, split, granularity)
    elif task in ("T3", "T6"):
        loaded = _load_t3_t6(task, canon_split, split, granularity)
    elif task == "T4":
        loaded = _load_t4(canon_split, split, granularity, lookback)
    elif task == "T7":
        loaded = _load_t7(canon_split, split, granularity)
    else:
        raise ValueError(f"Unknown task: {task!r}")

    if setting is not None:
        from ._ablation import apply_to_loaded, ABLATION_SETTINGS
        if setting not in ABLATION_SETTINGS:
            raise ValueError(
                f"setting must be one of {ABLATION_SETTINGS} or None, "
                f"got {setting!r}"
            )
        if task in ("T3", "T6", "T7"):
            raise ValueError(
                f"Ablation setting={setting!r} not supported for task={task!r}; "
                "ABLATION_TASKS = (T1, T2, T4, T5)"
            )
        loaded = apply_to_loaded(loaded, setting)
    return loaded


# ── Helpers ───────────────────────────────────────────────────────────────


def _panel_path(granularity: str, split: str) -> str:
    bench_dir = config.get_benchmark_dir(granularity)
    return str(bench_dir / f"panel_{split}.parquet")


def _set_meta_attrs(
    meta: pd.DataFrame,
    *,
    task: str,
    split: str,
    granularity: str,
    parquets_read: list,
    lookback: int | None = None,
    horizon: int | None = None,
    feature_names: list[str] | None = None,
    n_canonical_dropped: int = 0,
) -> None:
    meta.attrs.update({
        "task": task,
        "split": split,
        "granularity": granularity,
        "lookback": lookback,
        "horizon": horizon,
        "feature_names": list(feature_names) if feature_names is not None else None,
        "schema_version": _LOADED_DATA_SCHEMA_VERSION,
        "data_sha256": sha256_dataset([str(p) for p in parquets_read]),
        "n_canonical_dropped": n_canonical_dropped,
    })


# ── T1 ────────────────────────────────────────────────────────────────────


def _build_t1_x_y(
    panel: pd.DataFrame,
    canon: pd.DataFrame,
    lookback: int,
    horizon: int,
) -> tuple[np.ndarray, np.ndarray, np.ndarray, list[str], np.ndarray]:
    """Build T1 ``(X, y, close_last, feat_names, keep_rows)`` given the
    canonical anchor pairs.
    """
    panel = panel.sort_values(["ticker", "date"]).reset_index(drop=True)
    panel["date"] = pd.to_datetime(panel["date"])

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

    per_ticker_feats: dict[str, np.ndarray] = {}
    per_ticker_close: dict[str, np.ndarray] = {}
    per_ticker_dates: dict[str, np.ndarray] = {}
    for ticker, grp in panel.groupby("ticker", sort=False):
        per_ticker_feats[str(ticker)] = grp[feat_cols].values.astype(np.float32)
        per_ticker_close[str(ticker)] = grp["close"].values.astype(np.float32)
        per_ticker_dates[str(ticker)] = grp["date"].values.astype("datetime64[ns]")

    canon = canon.copy()
    canon["ticker"] = canon["ticker"].astype(str)
    canon["anchor_date"] = pd.to_datetime(canon["anchor_date"]).values.astype("datetime64[ns]")

    X_list, y_list, cl_list, keep_rows = [], [], [], []
    for i, (ticker, anchor) in enumerate(zip(canon["ticker"].values, canon["anchor_date"].values)):
        feats = per_ticker_feats.get(ticker)
        if feats is None:
            continue
        dates = per_ticker_dates[ticker]
        close = per_ticker_close[ticker]
        idx = np.searchsorted(dates, anchor)
        if idx >= len(dates) or dates[idx] != anchor:
            continue
        if idx + 1 < lookback or idx + horizon >= len(dates):
            continue
        lb = feats[idx - lookback + 1 : idx + 1]
        tg = close[idx + 1 : idx + 1 + horizon]
        if lb.shape != (lookback, len(feat_cols)) or tg.shape != (horizon,):
            continue
        X_list.append(lb)
        y_list.append(tg)
        cl_list.append(float(close[idx]))
        keep_rows.append(i)

    if not X_list:
        raise RuntimeError(
            f"T1 loader produced 0 windows from {len(canon)} canonical anchors; "
            "panel and canonical-index cache are out of sync."
        )

    X = np.stack(X_list, axis=0)
    y = np.stack(y_list, axis=0)
    cl = np.array(cl_list, dtype=np.float32)
    return X, y, cl, feat_cols, np.array(keep_rows, dtype=np.int64)


def _load_t1(
    canon_split: str,
    out_split: str,
    granularity: str,
    lookback: int,
    horizon: int,
) -> LoadedData:
    canon = get_canonical_indices("T1", canon_split, granularity=granularity)
    if canon.empty:
        raise RuntimeError(f"Canonical T1/{canon_split} index set is empty.")

    panel_path = _panel_path(granularity, out_split)
    panel = pd.read_parquet(panel_path)
    X, y, close_last, feat_cols, keep_rows = _build_t1_x_y(panel, canon, lookback, horizon)

    n_dropped = len(canon) - len(keep_rows)
    drop_frac = n_dropped / max(1, len(canon))
    if drop_frac > 0.01:
        raise RuntimeError(
            f"T1/{out_split} loader dropped {n_dropped}/{len(canon)} canonical "
            f"anchors ({drop_frac:.1%} > 1% tolerance). The canonical generator "
            "and the benchmark panel are out of sync; rebuild the canonical-indices "
            "cache or fix the benchmark parquet."
        )

    meta = canon.iloc[keep_rows][["ticker", "anchor_date", "sector", "mcap_q"]].copy()
    meta["close_last"] = close_last
    meta = meta.reset_index(drop=True)
    _set_meta_attrs(
        meta, task="T1", split=out_split, granularity=granularity,
        parquets_read=[panel_path], lookback=lookback, horizon=horizon,
        feature_names=feat_cols, n_canonical_dropped=n_dropped,
    )
    return LoadedData(X=X, y=y, meta=meta)


# ── T2 / T5 ───────────────────────────────────────────────────────────────


def _t2_t5_paths(task: str, granularity: str):
    bench_dir = config.get_benchmark_dir(granularity)
    if task == "T2":
        return bench_dir / "valuation_inputs.parquet", bench_dir / "valuation_ground_truth.parquet"
    return bench_dir / "private_valuation_inputs.parquet", bench_dir / "private_valuation_ground_truth.parquet"


def _load_t2_t5(
    task: str, canon_split: str, out_split: str, granularity: str,
) -> LoadedData:
    canon = get_canonical_indices(task, canon_split, granularity=granularity)
    if canon.empty:
        raise RuntimeError(f"Canonical {task}/{canon_split} index set is empty.")

    inputs_path, gt_path = _t2_t5_paths(task, granularity)
    panel_train_path = _panel_path(granularity, "train")
    panel_test_path = _panel_path(granularity, "test")

    inputs = pd.read_parquet(inputs_path)
    gt = pd.read_parquet(gt_path)
    inputs["date"] = pd.to_datetime(inputs["date"])
    gt["date"] = pd.to_datetime(gt["date"])
    canon = canon.copy()
    canon["date"] = pd.to_datetime(canon["date"])

    parquets_read: list = [inputs_path, gt_path]

    # Schema = inputs-file columns + macro snapshot (fred_*/eia_*) joined
    # from the panel. The construction pipeline emits identical macro
    # columns in panel_train and panel_test, so the train/test schemas
    # match exactly after the merge.
    inputs_feature_cols = [c for c in inputs.columns if c not in {"ticker", "date"}]
    panel_train = pd.read_parquet(panel_train_path)
    panel_train["date"] = pd.to_datetime(panel_train["date"])
    parquets_read.append(panel_train_path)
    macro_cols = sorted([
        c for c in panel_train.columns
        if c.startswith("fred_") or c.startswith("eia_")
    ])
    feature_cols = inputs_feature_cols + macro_cols

    if out_split == "train":
        # panel_train carries both the inputs-file columns AND the macro
        # snapshot, so a single inner merge populates everything.
        canon_keep = ["ticker", "date"]
        present = [c for c in inputs_feature_cols if c in panel_train.columns]
        missing = [c for c in inputs_feature_cols if c not in panel_train.columns]

        merged = canon[canon_keep].merge(
            panel_train[["ticker", "date", *present, *macro_cols]],
            on=["ticker", "date"], how="inner",
        )
        for c in missing:
            merged[c] = np.nan

        # Train labels: derived_market_cap from panel_train (already merged).
        if "derived_market_cap" in panel_train.columns:
            mcap = canon.merge(
                panel_train[["ticker", "date", "derived_market_cap"]],
                on=["ticker", "date"], how="inner",
            )["derived_market_cap"]
            y_series = pd.to_numeric(mcap, errors="coerce").reset_index(drop=True)
        else:
            raise RuntimeError(
                f"{task}/train: panel_train has no derived_market_cap column"
            )
    else:
        # Test side: inputs file does not carry fred_*/eia_*; left-join
        # the macro snapshot from the panel. T2/T5 use a company-level
        # holdout (not chronological), so a holdout-ticker's anchor date
        # can fall in either the pre- or post-cutoff window. Union both
        # panels so the macro lookup covers the full 2021–2026 range.
        panel_test = pd.read_parquet(panel_test_path)
        panel_test["date"] = pd.to_datetime(panel_test["date"])
        parquets_read.append(panel_test_path)
        macro_present_train = [c for c in macro_cols if c in panel_train.columns]
        macro_present_test = [c for c in macro_cols if c in panel_test.columns]
        macro_present = sorted(set(macro_present_train) & set(macro_present_test))
        macro_lookup = pd.concat([
            panel_train[["ticker", "date", *macro_present]],
            panel_test[["ticker", "date", *macro_present]],
        ], ignore_index=True).drop_duplicates(
            subset=["ticker", "date"], keep="first",
        )
        merged = canon[["ticker", "date"]].merge(
            inputs, on=["ticker", "date"], how="inner",
        ).merge(
            gt[["ticker", "date", "actual_market_cap"]],
            on=["ticker", "date"], how="inner",
        ).merge(
            macro_lookup, on=["ticker", "date"], how="left",
        )
        for c in macro_cols:
            if c not in merged.columns:
                merged[c] = np.nan
        y_series = pd.to_numeric(
            merged.pop("actual_market_cap"), errors="coerce",
        ).reset_index(drop=True)

    if merged.empty:
        raise RuntimeError(
            f"{task}/{out_split} loader: zero rows after canonical join."
        )

    # Project to the unified schema (inputs cols + macro cols). Train and
    # test now produce the exact same columns.
    feat_cols_present = [c for c in feature_cols if c in merged.columns]
    X = merged[feat_cols_present].copy().reset_index(drop=True)

    meta_cols = ["ticker", "date"]
    if "sector" in merged.columns:
        meta_cols.append("sector")
    meta = merged[meta_cols].copy().reset_index(drop=True)

    # mcap_q (market-cap quartile) — derived from y on the held-out test
    # rows so cross-sectional stratification can run without leaking the
    # train distribution. For train rows we still compute quartiles over
    # the train y for parity but downstream callers only stratify test.
    if y_series.size:
        try:
            qs = pd.qcut(y_series, q=4, labels=["Q1", "Q2", "Q3", "Q4"],
                         duplicates="drop")
            meta["mcap_q"] = qs.astype(str).values
        except ValueError:
            meta["mcap_q"] = "Q?"

    _set_meta_attrs(
        meta, task=task, split=out_split, granularity=granularity,
        parquets_read=parquets_read, feature_names=list(X.columns),
    )
    return LoadedData(X=X, y=y_series.to_numpy(dtype=np.float32), meta=meta)


# ── T3 / T6 ───────────────────────────────────────────────────────────────


def _t3_t6_paths(task: str, granularity: str):
    bench_dir = config.get_benchmark_dir(granularity)
    if task == "T3":
        return bench_dir / "generation_inputs.parquet", bench_dir / "generation_ground_truth.parquet", "field"
    return bench_dir / "generator_eval_inputs.parquet", bench_dir / "generator_eval_ground_truth.parquet", "generator_field"


def _load_t3_t6(
    task: str, canon_split: str, out_split: str, granularity: str,
) -> LoadedData:
    canon = get_canonical_indices(task, canon_split, granularity=granularity)
    if canon.empty:
        raise RuntimeError(f"Canonical {task}/{canon_split} index set is empty.")

    inputs_path, gt_path, field_col = _t3_t6_paths(task, granularity)
    inputs = pd.read_parquet(inputs_path)
    gt = pd.read_parquet(gt_path)
    if field_col not in gt.columns and "field" in gt.columns:
        field_col = "field"
    if "fiscal_year" not in gt.columns:
        if "filing_date" in gt.columns:
            gt["fiscal_year"] = pd.to_datetime(gt["filing_date"]).dt.year
        else:
            gt["fiscal_year"] = 0

    canon = canon.copy()
    canon["fiscal_year"] = pd.to_numeric(canon["fiscal_year"], errors="coerce").astype("Int64")

    # X: per-(ticker, fiscal_year). For T3 inputs file is per-ticker (one
    # row per holdout ticker); broadcast across the canonical (ticker,
    # fiscal_year) pairs.
    if "fiscal_year" in inputs.columns:
        X = canon.merge(inputs, on=["ticker", "fiscal_year"], how="left")
    else:
        X = canon.merge(inputs, on="ticker", how="left")

    # y: long-form restricted to canonical (ticker, fiscal_year) pairs.
    canon_keys = set(zip(
        canon["ticker"].astype(str),
        canon["fiscal_year"].astype("Int64").astype(str),
    ))
    gt_filt = gt.copy()
    gt_filt["fiscal_year"] = pd.to_numeric(gt_filt["fiscal_year"], errors="coerce").astype("Int64")
    gt_filt["_key"] = list(zip(
        gt_filt["ticker"].astype(str),
        gt_filt["fiscal_year"].astype(str),
    ))
    gt_filt = gt_filt[gt_filt["_key"].isin(canon_keys)].drop(columns=["_key"]).reset_index(drop=True)

    if field_col != "field":
        gt_filt = gt_filt.rename(columns={field_col: "field"})
    if task == "T3":
        # T3 evaluates on the dense 11-field panel (same fields T6 uses).
        # The released ``generation_ground_truth.parquet`` ships the full
        # XBRL universe (10,279 unique tags including company-extension
        # tags filed once by one issuer); per-field MAPE on those is noise.
        # Projection happens at load time so the on-disk parquet is
        # preserved; evaluation runs on the meaningful subset.
        gt_filt = gt_filt[gt_filt["field"].astype(str).isin(_T3_DENSE_FIELDS)].reset_index(drop=True)
    y = gt_filt[["ticker", "fiscal_year", "field", "value"]].copy()

    meta = canon[["ticker", "fiscal_year"]].copy().reset_index(drop=True)
    X = X.reset_index(drop=True)

    _set_meta_attrs(
        meta, task=task, split=out_split, granularity=granularity,
        parquets_read=[inputs_path, gt_path],
        feature_names=[c for c in X.columns if c not in {"ticker", "fiscal_year"}],
    )
    return LoadedData(X=X, y=y, meta=meta)


# ── T4 ────────────────────────────────────────────────────────────────────


def _load_t4(
    canon_split: str, out_split: str, granularity: str, lookback: int,
) -> LoadedData:
    canon = get_canonical_indices("T4", canon_split, granularity=granularity)
    if canon.empty:
        raise RuntimeError(f"Canonical T4/{canon_split} index set is empty.")

    bench_dir = config.get_benchmark_dir(granularity)
    gt_path = bench_dir / "scenario_forecast_ground_truth.parquet"
    scen_path = bench_dir / "scenarios.parquet"
    # T4 lookback windows can span the train/test split (an event close to
    # the cutoff needs ~63 trading days of history that may sit on the
    # other side). Read both panels and merge for the lookback build.
    panel_train_path = _panel_path(granularity, "train")
    panel_test_path = _panel_path(granularity, "test")

    gt = pd.read_parquet(gt_path).dropna(subset=["actual_return_pct"])
    gt["event_date"] = pd.to_datetime(gt["event_date"])

    scen_full = pd.read_parquet(scen_path)
    desc_col = "event_description" if "event_description" in scen_full.columns else None
    keep_scen_cols = ["scenario_id"] + ([desc_col] if desc_col else [])
    scen = scen_full[keep_scen_cols].drop_duplicates("scenario_id")

    canon = canon.copy()
    canon["scenario_id"] = canon["scenario_id"].astype(str)
    canon["ticker"] = canon["ticker"].astype(str)
    gt["scenario_id"] = gt["scenario_id"].astype(str)
    gt["ticker"] = gt["ticker"].astype(str)
    scen["scenario_id"] = scen["scenario_id"].astype(str)

    # Filter ground truth to canonical pairs
    canon_keys = set(zip(canon["scenario_id"], canon["ticker"]))
    gt["_key"] = list(zip(gt["scenario_id"], gt["ticker"]))
    gt_filt = gt[gt["_key"].isin(canon_keys)].drop(columns=["_key"]).reset_index(drop=True)
    if gt_filt.empty:
        raise RuntimeError(f"T4/{out_split} loader: zero rows after canonical join.")

    if desc_col is not None:
        gt_filt = gt_filt.merge(
            scen[["scenario_id", desc_col]], on="scenario_id", how="left",
        )

    # Lookback windows from the COMBINED panel (train + test) — a T4
    # event near the chronological cutoff needs lookback rows on the
    # other side of the split.
    panel_train_df = pd.read_parquet(panel_train_path)
    panel_test_df = pd.read_parquet(panel_test_path)
    panel = pd.concat([panel_train_df, panel_test_df], ignore_index=True)
    del panel_train_df, panel_test_df
    panel["date"] = pd.to_datetime(panel["date"])
    panel = panel.sort_values(["ticker", "date"]).drop_duplicates(
        subset=["ticker", "date"], keep="first",
    ).reset_index(drop=True)

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

    per_ticker_feats: dict[str, np.ndarray] = {}
    per_ticker_dates: dict[str, np.ndarray] = {}
    for ticker, grp in panel.groupby("ticker", sort=False):
        per_ticker_feats[str(ticker)] = grp[feat_cols].values.astype(np.float32)
        per_ticker_dates[str(ticker)] = grp["date"].values.astype("datetime64[ns]")

    lb_list: list[np.ndarray] = []
    valid = np.zeros(len(gt_filt), dtype=bool)
    for i, (ticker, ev_date) in enumerate(zip(
        gt_filt["ticker"].values,
        gt_filt["event_date"].values.astype("datetime64[ns]"),
    )):
        feats = per_ticker_feats.get(str(ticker))
        if feats is None:
            lb_list.append(np.zeros((lookback, len(feat_cols)), dtype=np.float32))
            continue
        dates = per_ticker_dates[str(ticker)]
        idx = np.searchsorted(dates, ev_date, side="right") - 1
        if idx + 1 < lookback:
            lb_list.append(np.zeros((lookback, len(feat_cols)), dtype=np.float32))
            continue
        lb = feats[idx - lookback + 1 : idx + 1]
        if lb.shape != (lookback, len(feat_cols)):
            lb_list.append(np.zeros((lookback, len(feat_cols)), dtype=np.float32))
            continue
        lb_list.append(lb)
        valid[i] = True

    keep = np.where(valid)[0]
    if len(keep) == 0:
        raise RuntimeError(f"T4/{out_split} loader: no valid lookback windows after panel join.")
    gt_filt = gt_filt.iloc[keep].reset_index(drop=True)
    lb_arr = [lb_list[i] for i in keep]

    # T4 X is a DataFrame (not a dict): one row per (scenario_id, ticker),
    # with `lookback` as an object-dtype column where each cell is a
    # (lookback, F) np.ndarray. event_type and event_description are string
    # columns. Methods consume X uniformly.
    X = pd.DataFrame({
        "lookback": lb_arr,
        "event_type": gt_filt["event_type"].astype(str).values,
        "event_description": (
            gt_filt[desc_col].astype(str).values if desc_col is not None
            else np.array([""] * len(gt_filt))
        ),
    })

    y = gt_filt["actual_return_pct"].astype(np.float32).to_numpy()
    meta = gt_filt[["scenario_id", "ticker", "event_type", "event_date"]].copy().reset_index(drop=True)

    _set_meta_attrs(
        meta, task="T4", split=out_split, granularity=granularity,
        parquets_read=[gt_path, scen_path, panel_train_path, panel_test_path],
        lookback=lookback, feature_names=feat_cols,
    )
    return LoadedData(X=X, y=y, meta=meta)


# ── T7 ────────────────────────────────────────────────────────────────────


def _load_t7(canon_split: str, out_split: str, granularity: str) -> LoadedData:
    canon = get_canonical_indices("T7", canon_split, granularity=granularity)
    if canon.empty:
        raise RuntimeError(f"Canonical T7/{canon_split} index set is empty.")

    bench_dir = config.get_benchmark_dir(granularity)
    train_src_path = bench_dir / "re_train_properties.parquet"
    test_src_path = bench_dir / "re_eval_inputs.parquet"
    test_gt_path = bench_dir / "re_eval_ground_truth.parquet"

    # Read BOTH src files to compute the column intersection (the smaller
    # test schema is the canonical one; train rows are projected onto it
    # so train ↔ test are schema-identical).
    test_src = pd.read_parquet(test_src_path)
    train_src = pd.read_parquet(train_src_path)
    common_cols = [c for c in test_src.columns if c in train_src.columns]
    if "address" not in common_cols:
        raise RuntimeError(
            "T7 loader: 'address' missing from re_eval_inputs ∩ re_train_properties columns"
        )

    if out_split == "train":
        src = train_src[common_cols].copy()
        # Train ground truth comes from re_train_properties' rent/price columns;
        # they're already in train_src.
        gt_cols = [c for c in ("address", "rent", "price") if c in train_src.columns]
        gt = train_src[gt_cols].copy()
        parquets_read = [train_src_path]
    else:
        src = test_src[common_cols].copy()
        gt = pd.read_parquet(test_gt_path)
        parquets_read = [test_src_path, test_gt_path]

    canon = canon.copy()
    canon["address"] = canon["address"].astype(str)
    src["address"] = src["address"].astype(str)
    gt["address"] = gt["address"].astype(str)

    # Fix the v0.1 T7 duplicate-address Cartesian product bug. Dedup
    # canon, src, and gt — canon itself can carry duplicates (the T7
    # canonical sampler does not enforce address-uniqueness on the train
    # pool), and an upstream duplicate quietly multiplies on the merge.
    canon_dedup = canon.drop_duplicates(subset="address", keep="first").reset_index(drop=True)
    src_dedup = src.drop_duplicates(subset="address", keep="first").reset_index(drop=True)
    gt_dedup = gt.drop_duplicates(subset="address", keep="first").reset_index(drop=True)

    X = canon_dedup[["address"]].merge(src_dedup, on="address", how="left")
    y_join = canon_dedup[["address"]].merge(gt_dedup, on="address", how="left")

    if X.empty:
        raise RuntimeError(
            f"T7/{out_split} loader: zero rows after canonical address join."
        )

    # Lock the y column order so train and test produce identical column
    # ordering. Methods may rely on positional column access.
    y = y_join.reindex(columns=["address", "rent", "price"]).reset_index(drop=True)
    X = X.reset_index(drop=True)

    meta_cols = ["address"] + [c for c in ("property_type", "state") if c in canon_dedup.columns]
    meta = canon_dedup[meta_cols].reset_index(drop=True)

    _set_meta_attrs(
        meta, task="T7", split=out_split, granularity=granularity,
        parquets_read=parquets_read,
        feature_names=[c for c in X.columns if c != "address"],
    )
    return LoadedData(X=X, y=y, meta=meta)