Blame for EMFactorTiming/src/emft/data.py

"""Load Jensen-Kelly-Pedersen (JKP) global factor returns, or generate a synthetic panel.

Two input layouts are accepted and normalised to one long table:

* jkpfactors.com download:   location, name, freq, weighting, direction,
                             n_stocks, n_stocks_min, date, ret
* JKP code output (internal): excntry, characteristic, direction, date,
                             ret_ew, ret_vw, ret_vw_cap, n_stocks_min

Output columns: country, factor, month (pandas Period[M]), ret, region
Returns are decimal excess returns (0.01 = 1%). JKP factors are already signed so
that the long leg is the side the original paper predicts to earn more.
"""

from __future__ import annotations

import glob
import io
import logging
import zipfile
from dataclasses import dataclass
from pathlib import Path

import numpy as np
import pandas as pd
import yaml

log = logging.getLogger(__name__)

ROOT = Path(__file__).resolve().parents[2]
MARKETS_FILE = ROOT / "config" / "markets.yaml"

_COUNTRY_COLS = ("location", "excntry", "country")
_FACTOR_COLS = ("name", "characteristic", "factor")
_DATE_COLS = ("date", "eom", "month")


@dataclass(frozen=True)
class Markets:
    developed: frozenset[str]
    emerging: frozenset[str]

    def region(self, country: str) -> str:
        if country in self.developed:
            return "DM"
        if country in self.emerging:
            return "EM"
        return "OTHER"


def load_markets(path: Path = MARKETS_FILE) -> Markets:
    cfg = yaml.safe_load(path.read_text())
    return Markets(frozenset(cfg["developed"]), frozenset(cfg["emerging"]))


MACRO_FEATURES = ["mac_vix", "mac_term", "mac_usd12"]


def load_macro(directory: str | Path) -> pd.DataFrame:
    """Monthly U.S. state variables from FRED CSVs (fredgraph.csv layout), indexed by Period[M].

    mac_vix    log of the last VIX close in the month (VIXCLS, from 1990)
    mac_term   last 10-year minus 3-month Treasury spread in the month (T10Y3M, percent)
    mac_usd12  12-month log change of the broad trade-weighted dollar: the discontinued
               monthly TWEXBMTH through 2005-12, then the monthly average of DTWEXBGS,
               level-spliced at 2006-01 (the two indexes differ in coverage)
    Every value dated t is observable at the end of month t.
    """
    d = Path(directory)

    def series(name: str) -> pd.Series:
        f = pd.read_csv(d / f"{name}.csv")
        s = pd.to_numeric(f.iloc[:, 1], errors="coerce")
        s.index = pd.to_datetime(f.iloc[:, 0]).dt.to_period("M")
        return s.dropna()

    vix = series("VIXCLS").groupby(level=0).last()
    term = series("T10Y3M").groupby(level=0).last()
    old = np.log(series("TWEXBMTH").groupby(level=0).mean())
    new = np.log(series("DTWEXBGS").groupby(level=0).mean())
    splice = pd.Period("2006-01", freq="M")
    if splice not in old.index or splice not in new.index:
        raise ValueError("TWEXBMTH and DTWEXBGS must both cover 2006-01 to splice the dollar index")
    usd = pd.concat([old[old.index < splice], new[new.index >= splice] + old[splice] - new[splice]])
    usd = usd.reindex(pd.period_range(usd.index.min(), usd.index.max(), freq="M"))
    out = pd.DataFrame({"mac_vix": np.log(vix), "mac_term": term, "mac_usd12": usd - usd.shift(12)})
    out.index.name = "month"
    return out


MARKET_HISTORY_FILE = ROOT / "config" / "market_history.yaml"


def apply_market_history(
    panel: pd.DataFrame, markets: Markets | None = None, path: Path = MARKET_HISTORY_FILE
) -> pd.DataFrame:
    """Replace the static region with the region in force in each month (see market_history.yaml)."""
    markets = markets or load_markets()
    events = pd.DataFrame(yaml.safe_load(Path(path).read_text())["events"])
    events["from_month"] = pd.PeriodIndex(events["from_month"].astype(str), freq="M")
    events = events.sort_values(["country", "from_month"])
    out = panel.copy()
    for country, ev in events.groupby("country"):
        if ev.iloc[-1]["region"] != markets.region(country):
            raise ValueError(f"{country}: last event region {ev.iloc[-1]['region']} "
                             f"differs from markets.yaml ({markets.region(country)})")
        rows = out["country"] == country
        if not rows.any():
            continue
        month = out.loc[rows, "month"]
        region = pd.Series(ev.iloc[0]["was"], index=month.index)
        for _, e in ev.iterrows():
            region[month >= e["from_month"]] = e["region"]
        out.loc[rows, "region"] = region
    return out


def _read_any(path: str | Path) -> pd.DataFrame:
    """Read one CSV, every CSV or .zip in a directory/glob, or every CSV inside a .zip."""
    p = Path(path)
    frames: list[pd.DataFrame] = []
    if p.is_dir():
        files = sorted(f for f in p.iterdir() if f.suffix.lower() in (".csv", ".zip"))
    elif any(ch in str(path) for ch in "*?["):
        files = [Path(f) for f in sorted(glob.glob(str(path)))]
    else:
        files = [p]
    if not files:
        raise FileNotFoundError(f"No CSV files found at {path}")
    for f in files:
        if f.suffix.lower() == ".zip":
            with zipfile.ZipFile(f) as z:
                for name in sorted(n for n in z.namelist() if n.lower().endswith(".csv")):
                    frames.append(pd.read_csv(io.BytesIO(z.read(name))))
        else:
            frames.append(pd.read_csv(f))
    return pd.concat(frames, ignore_index=True)


def _pick(cols: pd.Index, candidates: tuple[str, ...], what: str) -> str:
    for c in candidates:
        if c in cols:
            return c
    raise ValueError(f"Cannot find a {what} column; expected one of {candidates}, got {list(cols)}")


def normalise(
    raw: pd.DataFrame,
    weighting: str = "vw_cap",
    min_stocks: int = 5,
    markets: Markets | None = None,
) -> pd.DataFrame:
    """Map either JKP layout to the canonical long table and validate it."""
    markets = markets or load_markets()
    cols = raw.columns
    c_country = _pick(cols, _COUNTRY_COLS, "country")
    c_factor = _pick(cols, _FACTOR_COLS, "factor")
    c_date = _pick(cols, _DATE_COLS, "date")

    if "ret" in cols:
        c_ret = "ret"
        if "weighting" in cols:
            kept = raw["weighting"].astype(str).str.lower().unique()
            if len(kept) > 1:
                raw = raw[raw["weighting"].astype(str).str.lower() == weighting]
                log.info("Kept weighting=%s out of %s", weighting, list(kept))
    else:
        c_ret = f"ret_{weighting}"
        if c_ret not in cols:
            raise ValueError(f"No 'ret' or '{c_ret}' column in input")

    df = pd.DataFrame(
        {
            "country": raw[c_country].astype(str).str.lower().str.strip(),
            "factor": raw[c_factor].astype(str).str.strip(),
            "month": pd.to_datetime(raw[c_date]).dt.to_period("M"),
            "ret": pd.to_numeric(raw[c_ret], errors="coerce"),
        }
    )
    if "n_stocks_min" in cols and min_stocks > 0:
        n = pd.to_numeric(raw["n_stocks_min"], errors="coerce")
        before = len(df)
        df = df[(n >= min_stocks).to_numpy()]
        log.info("Dropped %d rows with n_stocks_min < %d", before - len(df), min_stocks)

    df = df.dropna(subset=["ret"])

    # Unit check: JKP returns are decimals. A median absolute return above 0.2
    # (20% a month for a long-short factor) means the file is in percent.
    if df["ret"].abs().median() > 0.2:
        raise ValueError(
            "Returns look like percentages (median |ret| > 0.2). "
            "Pass decimal returns or divide by 100 before loading."
        )

    dup = df.duplicated(["country", "factor", "month"])
    if dup.any():
        raise ValueError(f"{int(dup.sum())} duplicate country-factor-month rows")

    df["region"] = df["country"].map(markets.region)
    return df.sort_values(["country", "factor", "month"]).reset_index(drop=True)


def load_jkp(path: str | Path, **kwargs) -> pd.DataFrame:
    return normalise(_read_any(path), **kwargs)


def coverage(df: pd.DataFrame) -> pd.DataFrame:
    """One row per country: region, factors, first and last month, months."""
    g = df.groupby(["region", "country"])
    out = g.agg(
        factors=("factor", "nunique"),
        first=("month", "min"),
        last=("month", "max"),
        months=("month", "nunique"),
        obs=("ret", "size"),
    )
    return out.reset_index().sort_values(["region", "country"])


# ---------------------------------------------------------------------------
# Synthetic panel with a known data-generating process (software validation)
# ---------------------------------------------------------------------------


def synthetic_panel(
    n_dm: int = 8,
    n_em: int = 8,
    n_factors: int = 20,
    n_months: int = 360,
    signal_sd: float = 0.004,
    noise_sd: float = 0.03,
    phi: float = 0.95,
    global_share: float = 0.6,
    premium: float = 0.002,
    premium_sd: float = 0.003,
    seed: int = 0,
) -> tuple[pd.DataFrame, pd.DataFrame]:
    """Returns (panel, truth).

    r[c,f,t+1] = mu[c,f] + x[c,f,t] + e[c,f,t+1],   mu[c,f] ~ N(premium, premium_sd)
    x[c,f,t]   = sqrt(global_share) * z[f,t] + sqrt(1 - global_share) * u[c,f,t]
    z, u       = independent AR(1) processes with persistence phi, sd signal_sd

    x is the predictable part. It is persistent, so trailing mean returns carry
    information about it, and its global component z is shared across
    countries, so developed-market history is informative about emerging markets.
    Setting signal_sd = 0 gives a panel with no predictability at all.
    """
    rng = np.random.default_rng(seed)
    dm = [f"d{i:02d}" for i in range(n_dm)]
    em = [f"e{i:02d}" for i in range(n_em)]
    countries = dm + em
    factors = [f"f{j:03d}" for j in range(n_factors)]
    months = pd.period_range("1990-01", periods=n_months, freq="M")

    def ar1(shape):
        x = np.zeros(shape)
        innov_sd = signal_sd * np.sqrt(1 - phi**2)
        x[0] = rng.normal(0, signal_sd, shape[1:])
        for t in range(1, shape[0]):
            x[t] = phi * x[t - 1] + rng.normal(0, innov_sd, shape[1:])
        return x

    z = ar1((n_months, n_factors))
    u = ar1((n_months, len(countries), n_factors))
    x = np.sqrt(global_share) * z[:, None, :] + np.sqrt(1 - global_share) * u
    e = rng.normal(0, noise_sd, (n_months, len(countries), n_factors))
    # Unconditional premia differ by country and factor, as in real data, so the
    # series' own historical mean is the right null benchmark.
    mu = rng.normal(premium, premium_sd, (len(countries), n_factors))

    r = np.full_like(x, np.nan)
    r[1:] = mu + x[:-1] + e[1:]  # return at t+1 depends on state at t

    idx = pd.MultiIndex.from_product([months, countries, factors], names=["month", "country", "factor"])
    panel = pd.DataFrame({"ret": r.reshape(-1)}, index=idx).reset_index().dropna()
    panel["region"] = np.where(panel["country"].str.startswith("d"), "DM", "EM")
    truth = pd.DataFrame(
        {"true_expected_next": (mu[None, :, :] + x).reshape(-1)}, index=idx
    ).reset_index()
    return panel.sort_values(["country", "factor", "month"]).reset_index(drop=True), truth