recipe/pit.py

"""Folding the seven tables into the one a backtest mounts.

`pit` is an entity, a date, an instant and a number. Two kinds of series go
into it and they are dated in completely different ways, which is exactly why
they belong in one table: a strategy that reads both must respect both.

**Curve points** are `UST_CMT_10Y`, `UST_REAL_CMT_10Y`, `UST_BILL_13W_CE`. Their
`event_date` is the day the curve describes and their `knowledge_date` is
18:00 Eastern that day, because that is when the Treasury says the rates are
usually on its site.

**Auction metrics** are `UST_AUCTION_10Y_HIGH_YIELD`, `..._BID_TO_COVER`,
`..._INDIRECT_PCT`. Their `event_date` is the auction day and their
`knowledge_date` is the minute the result artifact states -- 11:32 for an
11:30 close. Those two instants are minutes apart, and the difference is the
whole trading opportunity.

Auction series are keyed by **term**, not by CUSIP. `UST_AUCTION_10Y_BID_TO_COVER`
runs from 1979 to today; a series keyed on one CUSIP is a handful of rows that
stops when that bond is issued.
"""

from __future__ import annotations

import re
from datetime import UTC, datetime

import polars as pl

from .schema import PIT_SCHEMA, align

PERCENT = "percent"
RATIO = "ratio"
# What each auction result contributes, as (column, suffix, unit).
AUCTION_METRICS = (
    ("high_yield", "HIGH_YIELD", PERCENT),
    ("high_discount_rate", "HIGH_DISCOUNT_RATE", PERCENT),
    ("investment_rate", "INVESTMENT_RATE", PERCENT),
    ("bid_to_cover", "BID_TO_COVER", RATIO),
    ("allocation_percentage", "ALLOTMENT_AT_HIGH_PCT", PERCENT),
    ("indirect_accepted_pct", "INDIRECT_PCT", PERCENT),
    ("direct_accepted_pct", "DIRECT_PCT", PERCENT),
    ("dealer_accepted_pct", "DEALER_PCT", PERCENT),
    ("tendered_to_offering", "TENDERED_TO_OFFERING", RATIO),
)
DERIVED = {
    "indirect_accepted_pct", "direct_accepted_pct", "dealer_accepted_pct", "tendered_to_offering",
}
# One auction of a term per day is the rule. A reopening of the same term on
# the same day would be two, and the pair is kept apart by the CUSIP in
# `record_id` while the series stays keyed on the term.
TERM_CODE = re.compile(r"[^A-Z0-9]+")


def term_code(security_term: str | None, security_type: str | None) -> str | None:
    """`10-Year` + `tips` -> `10Y_TIPS`; `4-Week` + `bill` -> `4W`.

    The security type is part of the key because a 10-year note and a 10-year
    TIPS are auctioned on different days at different yields, and a series that
    mixed them would be two series pretending to be one.
    """

    if not security_term:
        return None
    cleaned = TERM_CODE.sub("_", security_term.upper()).strip("_")
    cleaned = (
        cleaned.replace("_YEAR", "Y").replace("_WEEK", "W")
        .replace("_MONTH", "M").replace("_DAY", "D")
    )
    if security_type in {"tips", "frn", "cmb"}:
        cleaned = f"{cleaned}_{security_type.upper()}"
    return cleaned or None


def _auction_rows(results: pl.DataFrame) -> list[dict]:
    rows = []
    for result in results.iter_rows(named=True):
        term = term_code(result["security_term"], result["security_type"])
        if term is None or result["knowledge_at"] is None or result["auction_date"] is None:
            continue
        for column, suffix, unit in AUCTION_METRICS:
            value = result.get(column)
            if value is None:
                continue
            rows.append(
                {
                    "entity_id": f"UST_AUCTION_{term}_{suffix}",
                    "event_date": result["auction_date"],
                    "knowledge_date": result["knowledge_at"],
                    "subset": "auction_results",
                    "record_id": result["result_id"],
                    "actual": float(value),
                    "unit": unit,
                    "value_method": "derived" if column in DERIVED else "reported",
                    "knowledge_time_precision": result["knowledge_time_precision"],
                    "source_url": result["source_url"],
                }
            )
    return rows


def entity_for(prefix: str, maturity: str) -> str:
    """`UST_CMT_` + `10Y` -> `UST_CMT_10Y`, without repeating a prefix.

    The long-term feeds label their rows `LT_COMPOSITE` and `LT_REAL_AVERAGE`,
    which already carry the prefix the feed would add. Concatenating blindly
    gives `UST_REAL_LT_LT_REAL_AVERAGE`.
    """

    head = prefix.rstrip("_")
    if maturity.startswith("LT_") and head.endswith("_LT"):
        return f"{head[:-3]}_{maturity}"
    return f"{prefix}{maturity}"


def _curve_rows(curve: pl.DataFrame, *, prefix: str, subset: str) -> list[dict]:
    if curve.is_empty():
        return []
    return [
        {
            "entity_id": entity_for(prefix, row["maturity"]),
            "event_date": row["curve_date"],
            "knowledge_date": row["knowledge_at"],
            "subset": subset,
            "record_id": row["curve_id"],
            "actual": row["yield_pct"],
            "unit": PERCENT,
            "value_method": "reported",
            "knowledge_time_precision": row["knowledge_time_precision"],
            "source_url": row["source_url"],
        }
        for row in curve.iter_rows(named=True)
        if row["yield_pct"] is not None
    ]


def _bill_rows(bills: pl.DataFrame) -> list[dict]:
    rows = []
    for row in bills.iter_rows(named=True):
        for column, suffix in (
            ("bank_discount_rate", "BD"),
            ("coupon_equivalent_rate", "CE"),
        ):
            value = row.get(column)
            if value is None:
                continue
            rows.append(
                {
                    "entity_id": f"UST_BILL_{row['maturity']}_{suffix}",
                    "event_date": row["rate_date"],
                    "knowledge_date": row["knowledge_at"],
                    "subset": "bill_rates",
                    "record_id": row["bill_rate_id"],
                    "actual": value,
                    "unit": PERCENT,
                    "value_method": "reported",
                    "knowledge_time_precision": row["knowledge_time_precision"],
                    "source_url": row["source_url"],
                }
            )
    return rows


def build_pit(frames: dict[str, pl.DataFrame]) -> pl.DataFrame:
    nominal = frames["nominal_yield_curve"]
    real = frames["real_yield_curve"]
    rows = [
        *_auction_rows(frames["auction_results"]),
        *_curve_rows(
            nominal.filter(pl.col("curve_type") == "nominal"),
            prefix="UST_CMT_", subset="nominal_yield_curve",
        ),
        *_curve_rows(
            nominal.filter(pl.col("curve_type") == "long_term_composite"),
            prefix="UST_LT_", subset="nominal_yield_curve",
        ),
        *_curve_rows(
            real.filter(pl.col("curve_type") == "real"),
            prefix="UST_REAL_CMT_", subset="real_yield_curve",
        ),
        *_curve_rows(
            real.filter(pl.col("curve_type") == "long_term_real"),
            prefix="UST_REAL_LT_", subset="real_yield_curve",
        ),
        *_bill_rows(frames["bill_rates"]),
    ]
    if not rows:
        return pl.DataFrame(schema=dict(PIT_SCHEMA))
    now = datetime.now(UTC)
    frame = pl.DataFrame(rows, infer_schema_length=None).with_columns(
        forecast=pl.lit(None, dtype=pl.Float64),
        parser_version=pl.lit(frames["auction_results"]["parser_version"][0])
        if not frames["auction_results"].is_empty()
        else pl.lit("1.0.0"),
        ingested_at=pl.lit(now).cast(pl.Datetime(time_unit="us", time_zone="UTC")),
    )
    frame = frame.sort(["entity_id", "knowledge_date", "record_id"]).with_columns(
        previous=pl.col("actual").shift(1).over("entity_id")
    )
    frame = frame.with_columns(change=(pl.col("actual") - pl.col("previous")).round(8))
    return align(frame, PIT_SCHEMA).sort(["entity_id", "event_date", "knowledge_date"])


__all__ = ["AUCTION_METRICS", "build_pit", "entity_for", "term_code"]