src/data_prep/node_features.py

"""
src/data_prep/node_features.py

Replacement for the (duplicated, half-finished) Phase-3 node-feature code inside
``temporal_data.py``. It reproduces *exactly* the node tensors that the deprecated
``DynamicGraphBuilder`` (graph_builder.py) fed to ``BipartiteSAGEExtended``, using the
same data sources and the same lookups in ``feature_lookups.py`` -- but aligned to the
global node-id maps emitted by Phase 4 instead of the old per-snapshot LabelEncoders.

It provides two entry points:

  build_node_features(...)   -- Phase 3. Assembles and SAVES the five static node
                                tensors (x_pol, pol_state, x_comp, comp_sec, comp_ind)
                                plus a metadata sidecar. Must run AFTER Phase 4, because
                                it aligns to src_id_map.npy / dst_id_map.npy.

  load_combined_graph(...)   -- Recombines the per-year shards into ONE static graph
                                (the yearly split was only to keep file sizes sane),
                                converts the unified node ids back to the bipartite-local
                                convention the model expects, loads the saved node
                                tensors, and returns everything ready for the model.

------------------------------------------------------------------------------------
WHY THE OLD PHASE 3 WAS WRONG
------------------------------------------------------------------------------------
``BipartiteSAGEExtended.forward`` needs five node tensors:
    x_pol [n_pol, pol_dim], pol_state [n_pol],
    x_comp [n_comp, comp_dim], comp_sec [n_comp], comp_ind [n_comp]
The old Phase 3 produced free-floating committee/SEC parquets that were (a) never
aligned to the node-id maps, (b) missing the categorical embedding indices entirely,
and (c) reading from ad-hoc ``data/cropped`` paths instead of the config paths the
lookups use. This module fixes all three.

------------------------------------------------------------------------------------
COMPOSITION (mirrors DynamicGraphBuilder, with your current config flags)
------------------------------------------------------------------------------------
x_pol  (pol_dim = 42 with PERFORMANCE+BIO+IDEOLOGY+COMMITTEES, ECON off):
    [ win_rate, log_count, buy_ratio ]                     performance (3)
    [ chamber, party x4, is_leader ]                       bio  = full_bio[:5]+[leader] (6)
    [ coord1D, coord2D ]                                   ideology (2)
    [ committee one-hot ]                                  committees (31)
  NB: the 56-dim state one-hot from PoliticianBioLookup is intentionally dropped --
      state is carried as the learned `pol_state` embedding instead.

x_comp (comp_dim = 10 with COMPANY_SIC, FINANCIALS off):
    [ SIC-division one-hot ]                               (10)

Categoricals (from the transactions CSV, NOT the lookups -- matches the old
get_categorical_ids snippet):
    pol_state  <- dominant `State`   per BioGuideID, label-encoded
    comp_sec   <- dominant `Sector`  per Ticker,     label-encoded
    comp_ind   <- dominant `Industry`per Ticker,     label-encoded
Index 0 of every categorical vocabulary is reserved for "UNK" so that nodes which only
appear in structural edges (and therefore have no transaction row) get a valid index.

Snapshot policy: time-varying lookups are evaluated as-of the LAST event date in the
window (per your call). Performance stats are aggregated over the full window, exactly
as the deprecated builder did.
"""

from __future__ import annotations

import os
import glob
import json
from typing import Dict, List, Optional, Tuple

import numpy as np
import pandas as pd

# torch / config / lookups are guarded so the pure-pandas helpers in this module remain
# importable and unit-testable in environments without the full project / torch stack.
try:
    import torch
except ImportError:  # pragma: no cover
    torch = None


# ----------------------------------------------------------------------------------
# Constants -- msg column layout must stay in sync with all_msg_cols in temporal_data.py
# ----------------------------------------------------------------------------------
MSG_COLUMNS = [
    "Trade_Size_USD", "Filing_Gap", "Transaction",
    "is_sponsorship", "voted_yea", "Fin_Amt", "Geo_Weight",
    "vol_20d", "vol_60d", "vol_120d", "vol_252d", "vol_of_vol_60d", "vol_trend", "idio_vol_60d",
    "mom_60d", "mom_252d", "reversal_21d",
    "beta_20d", "beta_60d", "downside_beta", "excess_vol", "max_dd_60d", "skew_60d", "sharpe_60d",
]
_COL = {c: i for i, c in enumerate(MSG_COLUMNS)}

# Trade-edge feature columns fed to the decoder when trade features are ON.
# = trade mechanics (3) + 17 market features. The 4 structural-only msg columns
# (is_sponsorship/voted_yea/Fin_Amt/Geo_Weight) are zero on trade edges and excluded.
# -> trade_feat_dim = 20.
TRADE_FEAT_COLS = [
    "Trade_Size_USD", "Filing_Gap", "Transaction",
    "vol_20d", "vol_60d", "vol_120d", "vol_252d", "vol_of_vol_60d", "vol_trend", "idio_vol_60d",
    "mom_60d", "mom_252d", "reversal_21d",
    "beta_20d", "beta_60d", "downside_beta", "excess_vol", "max_dd_60d", "skew_60d", "sharpe_60d",
]
_TRADE_IDX = [_COL[c] for c in TRADE_FEAT_COLS]

EVENT_TRADE, EVENT_LOBBY, EVENT_CAMPAIGN, EVENT_GEO = 0, 1, 2, 3

INCLUDE_PERFORMANCE = True               # matches the flag hard-set in graph_builder.py
PERF_DEFAULT = [0.5, 0.0, 0.5]           # win_rate, log_count, buy_ratio for non-traders
UNK = "UNK"

NODE_BUNDLE_NAME = "node_features_static.pt"
NODE_META_NAME = "node_features_meta.json"


def _require_torch():
    if torch is None:
        raise ImportError("PyTorch is required for this function but is not installed.")


# ==================================================================================
# Pure helpers (no torch / no project deps) -- unit-testable
# ==================================================================================
def invert_node_maps(src_map: dict, dst_map: dict) -> Tuple[List, List, int, int]:
    """Given Phase-4 maps (bioguide->idx in [0,n_pol); ticker->global idx in
    [n_pol, n_pol+n_comp)), return ordered id lists plus (n_pol, n_comp).

    ordered_bio[i]  = bioguide id whose politician index is i
    ordered_tick[j] = ticker whose *local* company index is j (== global - n_pol)
    """
    n_pol = len(src_map)
    n_comp = len(dst_map)
    inv_src = {int(idx): bio for bio, idx in src_map.items()}
    inv_dst_local = {int(idx) - n_pol: tick for tick, idx in dst_map.items()}

    missing_pol = [i for i in range(n_pol) if i not in inv_src]
    missing_comp = [j for j in range(n_comp) if j not in inv_dst_local]
    if missing_pol or missing_comp:
        raise ValueError(f"Node maps are not a contiguous 0..N-1 range "
                         f"(missing pol idx {missing_pol[:5]}, comp idx {missing_comp[:5]}).")

    ordered_bio = [inv_src[i] for i in range(n_pol)]
    ordered_tick = [inv_dst_local[j] for j in range(n_comp)]
    return ordered_bio, ordered_tick, n_pol, n_comp


def _dominant(series: pd.Series):
    """Most frequent non-null value in a Series, or None if all null/empty."""
    s = series.dropna()
    if s.empty:
        return None
    m = s.mode()
    return m.iloc[0] if not m.empty else s.iloc[0]


def build_label_encoder(values, reserve_unk: bool = True) -> Dict[str, int]:
    """Stable str->index map. Index 0 is reserved for UNK when requested."""
    uniq = sorted({str(v) for v in values if pd.notna(v) and str(v) != "nan"})
    classes = ([UNK] + uniq) if reserve_unk else uniq
    return {c: i for i, c in enumerate(classes)}


def encode_per_node(ordered_ids: List, id_to_value: Dict, vocab: Dict[str, int]) -> np.ndarray:
    """Map ordered node ids -> categorical index via (id_to_value) then (vocab),
    falling back to UNK (0) for unknown ids/values."""
    out = np.zeros(len(ordered_ids), dtype=np.int64)
    for i, nid in enumerate(ordered_ids):
        val = id_to_value.get(nid, None)
        out[i] = vocab.get(str(val), 0) if val is not None else 0
    return out


def aggregate_pair_edges(
    src_local: np.ndarray,
    dst_local: np.ndarray,
    times_sec: np.ndarray,
    snapshot_sec: int,
    amount: Optional[np.ndarray] = None,
) -> Tuple[np.ndarray, np.ndarray]:
    """Collapse repeated (politician, company) structural edges into one weighted edge,
    reconstructing the per-pair stats the old lookups produced.

    Returns
    -------
    edge_index : int64 [2, P]   bipartite-local (row0 = pol, row1 = comp)
    feats      : float32 [P, F]
        amount is None  -> F=2: [interaction_count, days_since]      (lobbying)
        amount given    -> F=3: [log1p(sum_amount), pair_count, days_since]  (campaign)

    days_since is measured from the most recent edge in each pair to the snapshot.
    """
    if len(src_local) == 0:
        F = 3 if amount is not None else 2
        return np.empty((2, 0), dtype=np.int64), np.empty((0, F), dtype=np.float32)

    df = pd.DataFrame({"s": src_local, "d": dst_local, "t": times_sec})
    if amount is not None:
        df["amt"] = amount

    agg = {"t": ["count", "max"]}
    if amount is not None:
        agg["amt"] = "sum"
    g = df.groupby(["s", "d"], sort=False).agg(agg)
    g.columns = ["_".join(c).strip("_") for c in g.columns]
    g = g.reset_index()

    edge_index = np.stack([g["s"].to_numpy(), g["d"].to_numpy()]).astype(np.int64)
    days_since = np.maximum(0.0, (snapshot_sec - g["t_max"].to_numpy()) / 86400.0)
    count = g["t_count"].to_numpy().astype(np.float32)

    if amount is not None:
        log_amt = np.log1p(np.maximum(0.0, g["amt_sum"].to_numpy()))
        feats = np.column_stack([log_amt, count, days_since]).astype(np.float32)
    else:
        feats = np.column_stack([count, days_since]).astype(np.float32)
    return edge_index, feats


# ==================================================================================
# PHASE 3 -- build & save the static node tensors (needs torch + project deps)
# ==================================================================================
def build_node_features(
    map_dir: str = "data/processed/pyg_graph",
    trades_csv: str = "data/cropped/ml_dataset_continuous.csv",
    processed_dir: str = "data/processed",
    snapshot_date: Optional[str] = None,
    save: bool = True,
) -> Dict:
    """Assemble the five static node tensors aligned to the Phase-4 node-id maps.

    Replicates DynamicGraphBuilder.__init__ / build_pol_features / build_comp_features
    plus the categorical-id construction that used to live in the training script.
    """
    _require_torch()
    from src import config  # local import: keeps module importable without the project
    from src.data_prep.feature_lookups import (
        TermLookup, PoliticianBioLookup, IdeologyLookup,
        CommitteeLookup, CompanySICLookup, CompanyFinancialsLookup,
    )

    def flag(name, default=False):
        return getattr(config, name, default)

    print("==================================================")
    print("PHASE 3: STATIC NODE FEATURE EXTRACTION")
    print("==================================================")

    # --- 0. Node universe from the Phase-4 maps -----------------------------------
    src_map = np.load(os.path.join(map_dir, "src_id_map.npy"), allow_pickle=True).item()
    dst_map = np.load(os.path.join(map_dir, "dst_id_map.npy"), allow_pickle=True).item()
    ordered_bio, ordered_tick, n_pol, n_comp = invert_node_maps(src_map, dst_map)
    print(f" -> Node universe: {n_pol} politicians | {n_comp} companies")

    # --- 1. Transactions: performance stats + categorical sources -----------------
    df_tx = pd.read_csv(trades_csv, low_memory=False)
    ticker_col = next((c for c in ("Ticker", "Matched_Ticker") if c in df_tx.columns), None)
    if ticker_col is None:
        raise ValueError("Transactions CSV needs a 'Ticker' or 'Matched_Ticker' column.")
    for cat in ("State", "Sector", "Industry"):
        if cat not in df_tx.columns:
            print(f"   [WARN] '{cat}' missing from transactions -> all UNK for that embedding.")
            df_tx[cat] = np.nan
    df_tx["BioGuideID"] = df_tx["BioGuideID"].astype(str)
    df_tx[ticker_col] = df_tx[ticker_col].astype(str).str.upper()

    snapshot = pd.to_datetime(snapshot_date) if snapshot_date else pd.to_datetime(df_tx["Filed"]).max()
    print(f" -> Snapshot (as-of) date for time-varying features: {snapshot.date()}")

    # Performance dict over the full window (matches the deprecated behaviour).
    perf: Dict[str, list] = {}
    if INCLUDE_PERFORMANCE:
        label_col = "Excess_Return_6M"
        t = df_tx.copy()
        t["_lbl"] = (pd.to_numeric(t[label_col], errors="coerce") > 0).astype(float) if label_col in t else 0.0
        t["_buy"] = t["Transaction"].astype(str).str.lower().str.contains("purchase", na=False).astype(float)
        for bio_id, grp in t.groupby("BioGuideID"):
            perf[bio_id] = [grp["_lbl"].mean(), float(np.log1p(len(grp))), grp["_buy"].mean()]

    # --- 2. Instantiate the same lookups graph_builder used ------------------------
    need_term = any(flag(f, False) or d for f, d in [
        ("INCLUDE_POLITICIAN_BIO", True), ("INCLUDE_IDEOLOGY", True), ("INCLUDE_COMMITTEES", True)
    ])
    term_lookup = TermLookup(config.CONGRESS_TERMS_PATH) if need_term else None

    lookups: Dict[str, object] = {}
    pol_dim = 0
    if INCLUDE_PERFORMANCE:
        pol_dim += 3
    if flag("INCLUDE_POLITICIAN_BIO", True):
        lookups["bio"] = PoliticianBioLookup(config.CONGRESS_TERMS_PATH, term_lookup)
        pol_dim += lookups["bio"].dim - lookups["bio"].state_dim   # drop state one-hot
    if flag("INCLUDE_IDEOLOGY", True):
        lookups["ideology"] = IdeologyLookup(config.IDEOLOGY_PATH, term_lookup)
        pol_dim += lookups["ideology"].dim
    if flag("INCLUDE_COMMITTEES", True):
        lookups["committee"] = CommitteeLookup(config.COMMITTEE_PATH, term_lookup)
        pol_dim += lookups["committee"].dim

    comp_dim = 0
    if flag("INCLUDE_COMPANY_SIC", True):
        lookups["sic"] = CompanySICLookup(config.COMPANY_SIC_PATH)
        comp_dim += lookups["sic"].dim
    if flag("INCLUDE_COMPANY_FINANCIALS", False):
        lookups["financials"] = CompanyFinancialsLookup(config.COMPANY_FIN_PATH)
        comp_dim += lookups["financials"].dim

    print(f" -> Dimensions: pol_dim={pol_dim}, comp_dim={comp_dim}")

    # --- 3. Dense politician features ---------------------------------------------
    print(" -> Building politician features...")
    x_pol = np.zeros((n_pol, pol_dim), dtype=np.float32)
    for i, bio_id in enumerate(ordered_bio):
        vec: List[float] = []
        if INCLUDE_PERFORMANCE:
            vec += perf.get(str(bio_id), list(PERF_DEFAULT))
        if "bio" in lookups:
            fb = lookups["bio"].get_vector(bio_id, snapshot).tolist()
            leader_idx = lookups["bio"].dim - 1            # last entry is is_leader
            vec += fb[:5] + [fb[leader_idx]]               # chamber + party(4) + leader
        if "ideology" in lookups:
            vec += lookups["ideology"].get_vector(bio_id, snapshot).tolist()
        if "committee" in lookups:
            vec += lookups["committee"].get_vector(bio_id, snapshot).tolist()
        if vec:
            x_pol[i] = np.asarray(vec, dtype=np.float32)

    # --- 4. Dense company features ------------------------------------------------
    print(" -> Building company features...")
    x_comp = np.zeros((n_comp, comp_dim), dtype=np.float32)
    for j, tick in enumerate(ordered_tick):
        vec = []
        if "sic" in lookups:
            vec += lookups["sic"].get_vector(tick, snapshot).tolist()
        if "financials" in lookups:
            vec += lookups["financials"].get_vector(tick, snapshot).tolist()
        if vec:
            x_comp[j] = np.asarray(vec, dtype=np.float32)

    # --- 5. Categorical embedding indices (from transactions) ---------------------
    print(" -> Encoding categorical embedding indices (state / sector / industry)...")
    state_by_bio = {str(k): _dominant(v) for k, v in df_tx.groupby("BioGuideID")["State"]}
    sector_by_tick = {str(k): _dominant(v) for k, v in df_tx.groupby(ticker_col)["Sector"]}
    ind_by_tick = {str(k): _dominant(v) for k, v in df_tx.groupby(ticker_col)["Industry"]}

    state_vocab = build_label_encoder(state_by_bio.values())
    sector_vocab = build_label_encoder(sector_by_tick.values())
    ind_vocab = build_label_encoder(ind_by_tick.values())

    pol_state = encode_per_node([str(b) for b in ordered_bio], state_by_bio, state_vocab)
    comp_sec = encode_per_node([str(t) for t in ordered_tick], sector_by_tick, sector_vocab)
    comp_ind = encode_per_node([str(t) for t in ordered_tick], ind_by_tick, ind_vocab)

    num_states, num_sectors, num_industries = len(state_vocab), len(sector_vocab), len(ind_vocab)
    # The deprecated model defaulted to Embedding sizes 60/20/150; warn if data outgrew them.
    for nm, n, old in [("states", num_states, 60), ("sectors", num_sectors, 20),
                       ("industries", num_industries, 150)]:
        if n > old:
            print(f"   [NOTE] num_{nm}={n} exceeds the old default {old}; size embeddings with the value above.")

    meta = {
        "pol_dim": int(pol_dim), "comp_dim": int(comp_dim),
        "num_states": int(num_states), "num_sectors": int(num_sectors),
        "num_industries": int(num_industries),
        "n_pol": int(n_pol), "n_comp": int(n_comp),
        "snapshot_date": str(snapshot),
        "state_vocab": state_vocab, "sector_vocab": sector_vocab, "industry_vocab": ind_vocab,
    }

    bundle = {
        "x_pol": torch.from_numpy(x_pol),
        "pol_state": torch.from_numpy(pol_state),
        "x_comp": torch.from_numpy(x_comp),
        "comp_sec": torch.from_numpy(comp_sec),
        "comp_ind": torch.from_numpy(comp_ind),
        "meta": meta,
    }

    if save:
        os.makedirs(processed_dir, exist_ok=True)
        torch.save(bundle, os.path.join(processed_dir, NODE_BUNDLE_NAME))
        with open(os.path.join(processed_dir, NODE_META_NAME), "w") as f:
            json.dump(meta, f, indent=2)
        print(f" -> Saved node tensors to {os.path.join(processed_dir, NODE_BUNDLE_NAME)}")
    print("==================================================\n")
    return bundle


# ==================================================================================
# Recombine shards -> one static bipartite graph for the model
# ==================================================================================
def load_combined_graph(
    shard_dir: str = "data/processed/pyg_graph",
    node_bundle_path: Optional[str] = None,
    processed_dir: str = "data/processed",
    device: str = "cpu",
    build_aux: bool = True,
    time_max=None,   # str/Timestamp or epoch-seconds int; keep only edges with time <= cutoff
) -> Dict:
    """Concatenate all yearly shards into one static graph and attach node tensors.

    Converts unified node ids back to the bipartite-local convention the model expects
    (company index = global index - n_pol). Trades are the primary supervised edges;
    lobbying / campaign are returned as the model's ``aux_edges`` dict; geo edges are
    returned separately (the deprecated model has no geo conv).

    Returns a dict with: x_pol, pol_state, x_comp, comp_sec, comp_ind, meta,
    edge_index (trades, [2,E]), y (trade labels), aux_edges (model-ready),
    geo_edges (for future use), and edge_time (trade epoch-seconds).
    """
    _require_torch()

    bundle_path = node_bundle_path or os.path.join(processed_dir, NODE_BUNDLE_NAME)
    bundle = torch.load(bundle_path, map_location=device, weights_only=False)
    meta = bundle["meta"]
    n_pol = int(meta["n_pol"])
    snapshot_sec = int(pd.to_datetime(meta["snapshot_date"]).timestamp())

    # --- recombine shards ---------------------------------------------------------
    shard_paths = sorted(glob.glob(os.path.join(shard_dir, "hillstreet_temporal_graph_*.pt")))
    if not shard_paths:
        raise FileNotFoundError(f"No shards found in {shard_dir}.")
    src_l, dst_l, t_l, msg_l, y_l, et_l, ls_l = [], [], [], [], [], [], []
    for p in shard_paths:
        d = torch.load(p, map_location=device, weights_only=False)
        src_l.append(d.src); dst_l.append(d.dst); t_l.append(d.t)
        msg_l.append(d.msg); y_l.append(d.y); et_l.append(d.event_type)
        # last_seen is the recency endpoint added when structural edges are collapsed.
        # Older shards predate it; fall back to t (earliest == latest for un-collapsed).
        ls_l.append(getattr(d, "last_seen", d.t))
    src = torch.cat(src_l); dst = torch.cat(dst_l); t = torch.cat(t_l)
    msg = torch.cat(msg_l); y = torch.cat(y_l); event_type = torch.cat(et_l)
    last_seen = torch.cat(ls_l)
    print(f" -> Recombined {len(shard_paths)} shards: {src.numel():,} total edges")

    if time_max is not None:
        tmax = int(time_max) if isinstance(time_max, (int, float)) else int(pd.to_datetime(time_max).timestamp())
        # Filter on t (relationship START). An edge whose relationship began on or
        # before the cutoff is kept even if its last_seen extends past it -- correct
        # for expanding-window studies (the relationship existed as of the cutoff).
        keep = t <= tmax
        src, dst, t = src[keep], dst[keep], t[keep]
        msg, y, event_type = msg[keep], y[keep], event_type[keep]
        last_seen = last_seen[keep]
        snapshot_sec = tmax  # days_since measured as-of the cutoff, not the global meta snapshot
        print(f" -> time_max applied (t <= {tmax}): {src.numel():,} edges remain")

    dst_local = dst - n_pol  # unified -> bipartite-local company index

    def _split(et):
        # Returns the EARLIEST timestamp as `t` (relationship age) and the most
        # recent as `ls` (recency). Aggregations that want days-since pass `ls`.
        m = event_type == et
        return src[m], dst_local[m], t[m], msg[m], y[m], last_seen[m]

    # --- trades (primary, supervised) ---------------------------------------------
    s, d, tt, mm, yy, _ = _split(EVENT_TRADE)
    edge_index = torch.stack([s, d], dim=0).to(torch.long)
    out = {
        "x_pol": bundle["x_pol"].to(device), "pol_state": bundle["pol_state"].to(device),
        "x_comp": bundle["x_comp"].to(device), "comp_sec": bundle["comp_sec"].to(device),
        "comp_ind": bundle["comp_ind"].to(device), "meta": meta,
        "edge_index": edge_index, "y": yy.to(torch.long), "edge_time": tt,
        "edge_attr": mm[:, _TRADE_IDX].to(torch.float32),  # [E, 20] trade features for the decoder
        "aux_edges": {}, "geo_edges": None,
    }

    if not build_aux:
        return out

    # --- auxiliary edges ----------------------------------------------------------
    def _to_dev(ei_np, ft_np):
        return {
            "edge_index": torch.from_numpy(ei_np).to(torch.long).to(device),
            "features": torch.from_numpy(ft_np).to(torch.float32).to(device),
        }

    # Lobbying: split by the structural flags packed in msg, aggregate per pair -> [count, days_since].
    # days_since is computed from last_seen (recency), not t (which is now relationship age).
    s, d, tt, mm, _, ls = _split(EVENT_LOBBY)
    if s.numel() > 0:
        spons = mm[:, _COL["is_sponsorship"]] > 0.5
        voted = mm[:, _COL["voted_yea"]] > 0.5
        for key, mask in (("lobby_strong", spons), ("lobby_weak", voted)):
            if mask.any():
                ei, ft = aggregate_pair_edges(
                    s[mask].cpu().numpy(), d[mask].cpu().numpy(),
                    ls[mask].cpu().numpy(), snapshot_sec)
                if ei.shape[1] > 0:
                    out["aux_edges"][key] = _to_dev(ei, ft)

    # Campaign: aggregate per pair -> [log1p(sum Fin_Amt), donation_count, days_since]
    s, d, tt, mm, _, ls = _split(EVENT_CAMPAIGN)
    if s.numel() > 0:
        ei, ft = aggregate_pair_edges(
            s.cpu().numpy(), d.cpu().numpy(), ls.cpu().numpy(),
            snapshot_sec, amount=mm[:, _COL["Fin_Amt"]].cpu().numpy())
        if ei.shape[1] > 0:
            out["aux_edges"]["campaign"] = _to_dev(ei, ft)

    # Geo: carried but not consumed by the deprecated model. Aggregate weight per pair.
    s, d, tt, mm, _, ls = _split(EVENT_GEO)
    if s.numel() > 0:
        ei, ft = aggregate_pair_edges(
            s.cpu().numpy(), d.cpu().numpy(), ls.cpu().numpy(),
            snapshot_sec, amount=mm[:, _COL["Geo_Weight"]].cpu().numpy())
        if ei.shape[1] > 0:
            out["geo_edges"] = _to_dev(ei, ft)

    present = list(out["aux_edges"].keys()) + (["geo"] if out["geo_edges"] is not None else [])
    print(f" -> Edge groups ready: trades={edge_index.shape[1]:,} | aux/extra={present}")
    return out

# ==================================================================================
# Raw-edge loader for expanding-window studies
# ==================================================================================
def load_raw_edges(
    shard_dir: str = "data/processed/pyg_graph",
    node_bundle_path: Optional[str] = None,
    processed_dir: str = "data/processed",
    device: str = "cpu",
) -> Dict:
    """Recombine all yearly shards ONCE and return the raw concatenated tensors plus
    the static node bundle, so an expanding-window driver can build each monthly
    window cheaply (boolean time masks + per-cutoff aux re-aggregation) without
    re-reading the shards twelve times.

    Unlike load_combined_graph, this does NOT pre-aggregate aux edges or fix a
    snapshot -- recency (days_since) depends on the window cutoff, so the driver
    must call aggregate_pair_edges per cutoff with snapshot = that cutoff.

    Returns
    -------
    dict with:
        src        int64 [E]      politician local idx in [0, n_pol)
        dst_local  int64 [E]      company    local idx in [0, n_comp)
        t          int64 [E]      epoch seconds -- EARLIEST event of the edge (relationship start)
        last_seen  int64 [E]      epoch seconds -- MOST RECENT event of the edge; pass THIS
                                  (not t) as the time source to aggregate_pair_edges so
                                  days_since measures recency, not relationship age
        msg        float [E, 24]  full message tensor (use _COL / _TRADE_IDX to slice)
        y          int64 [E]      labels (-1 on structural edges)
        event_type int64 [E]      EVENT_TRADE/LOBBY/CAMPAIGN/GEO
        n_pol      int
        bundle     dict           node tensors (x_pol, pol_state, x_comp, comp_sec, comp_ind, meta)
        meta       dict
    """
    _require_torch()
    bundle_path = node_bundle_path or os.path.join(processed_dir, NODE_BUNDLE_NAME)
    if not os.path.exists(bundle_path):
        raise FileNotFoundError(
            f"Node bundle not found: {bundle_path}. Did Phase 3 run? "
            f"(re-run temporal_data.py WITHOUT --skip_node_features)")
    print(f" -> Loading node bundle: {bundle_path}", flush=True)
    bundle = torch.load(bundle_path, map_location=device, weights_only=False)
    meta = bundle["meta"]
    n_pol = int(meta["n_pol"])

    shard_paths = sorted(glob.glob(os.path.join(shard_dir, "hillstreet_temporal_graph_*.pt")))
    if not shard_paths:
        raise FileNotFoundError(
            f"No shards (hillstreet_temporal_graph_*.pt) found in {shard_dir}. Did Phase 4 run?")
    print(f" -> Found {len(shard_paths)} shard(s) in {shard_dir}; loading...", flush=True)

    src_l, dst_l, t_l, msg_l, y_l, et_l, ls_l = [], [], [], [], [], [], []
    running = 0
    for i, p in enumerate(shard_paths, 1):
        try:
            d = torch.load(p, map_location=device, weights_only=False)
        except Exception as e:
            raise RuntimeError(f"Failed to load shard {p}: {e}") from e
        src_l.append(d.src); dst_l.append(d.dst); t_l.append(d.t)
        msg_l.append(d.msg); y_l.append(d.y); et_l.append(d.event_type)
        # Recency endpoint; fall back to t on shards built before the dedup change.
        ls_l.append(getattr(d, "last_seen", d.t))
        running += int(d.src.numel())
        print(f"    [{i}/{len(shard_paths)}] {os.path.basename(p)}: "
              f"{int(d.src.numel()):,} edges (running total {running:,})", flush=True)
    print(" -> Concatenating shard tensors...", flush=True)

    raw = {
        "src": torch.cat(src_l),
        "dst_local": torch.cat(dst_l) - n_pol,
        "t": torch.cat(t_l),
        "last_seen": torch.cat(ls_l),
        "msg": torch.cat(msg_l),
        "y": torch.cat(y_l),
        "event_type": torch.cat(et_l),
        "n_pol": n_pol,
        "bundle": bundle,
        "meta": meta,
    }
    n_trade = int((raw["event_type"] == EVENT_TRADE).sum())
    print(f" -> load_raw_edges: {n_trade:,} trade edges across {len(shard_paths)} shards "
          f"({n_pol} politicians | {int(meta['n_comp'])} companies)")
    return raw