Microstructure/src/microstructure/research/l2_analysis.py

"""Reproducible descriptive economics for the frozen live-L2 study.

These functions run only after endpoint labels are opened.  They never select a
model or refit a threshold used by prediction.  Shock thresholds and stability
bins are fitted on the declared development reference, then applied unchanged
to held-out sessions.
"""

from __future__ import annotations

import math
from collections.abc import Sequence
from dataclasses import dataclass

import polars as pl

from microstructure.research.analysis import feature_stability_summary
from microstructure.research.l2_multidate import L2ResearchError, validate_l2_endpoint_frame

_NANOSECONDS_PER_MINUTE = 60_000_000_000
_DEVELOPMENT_ROLES = frozenset({"train", "validation"})
_TEST_ROLES = ("primary_test", "replication_test")


@dataclass(frozen=True, slots=True)
class L2DescriptiveAnalysis:
    """Machine-readable L2 economic analyses, kept separate from model scores."""

    intraday_liquidity: pl.DataFrame
    ofi_return_association: pl.DataFrame
    signal_half_life: pl.DataFrame
    liquidity_recovery: pl.DataFrame
    regime_diagnostics: pl.DataFrame
    feature_stability: pl.DataFrame
    cross_instrument_stability: pl.DataFrame


def _combined(frames: Sequence[pl.DataFrame]) -> pl.DataFrame:
    values = tuple(frames)
    if not values:
        raise L2ResearchError("L2 descriptive analysis requires endpoint frames")
    for frame in values:
        validate_l2_endpoint_frame(frame)
    combined = pl.concat(values, how="diagonal_relaxed")
    keys = ["study_date", "symbol", "endpoint_name", "sample_id"]
    if combined.select(keys).unique().height != combined.height:
        raise L2ResearchError("L2 descriptive endpoint identities are not unique")
    return combined


def _canonical_books(combined: pl.DataFrame) -> pl.DataFrame:
    endpoint_names = sorted(str(value) for value in combined.get_column("endpoint_name").unique())
    chosen = "event_20" if "event_20" in endpoint_names else endpoint_names[0]
    books = combined.filter(pl.col("endpoint_name") == chosen)
    keys = ["study_date", "symbol", "continuity_id", "decision_sequence"]
    if books.select(keys).unique().height != books.height:
        raise L2ResearchError("canonical L2 book observations are not unique")
    return books


def _intraday_liquidity(books: pl.DataFrame) -> pl.DataFrame:
    return (
        books.with_columns(
            ((pl.col("decision_ts_ns") // _NANOSECONDS_PER_MINUTE) % (24 * 60))
            .cast(pl.Int32)
            .alias("utc_minute_of_day")
        )
        .group_by("study_date", "study_role", "symbol", "utc_minute_of_day")
        .agg(
            pl.len().alias("n_observations"),
            pl.col("spread_bps").mean().alias("mean_spread_bps"),
            pl.col("spread_bps").median().alias("median_spread_bps"),
            pl.col("depth_total_l1").mean().alias("mean_depth_l1"),
            pl.col("depth_total_l5").mean().alias("mean_depth_l5"),
            pl.col("depth_total_l10").mean().alias("mean_depth_l10"),
            pl.col("queue_imbalance_l1").mean().alias("mean_queue_imbalance_l1"),
            pl.col("realized_volatility_w100").mean().alias("mean_realized_volatility_w100"),
        )
        .sort("study_date", "symbol", "utc_minute_of_day")
    )


def _finite_correlation(x: pl.Series, y: pl.Series) -> float | None:
    pairs = (
        pl.DataFrame({"x": x, "y": y})
        .drop_nulls()
        .filter(pl.col("x").is_finite() & pl.col("y").is_finite())
    )
    if (
        pairs.height < 3
        or pairs.get_column("x").n_unique() < 2
        or pairs.get_column("y").n_unique() < 2
    ):
        return None
    value = pairs.select(pl.corr("x", "y")).item()
    return float(value) if value is not None and math.isfinite(float(value)) else None


def _ofi_association(combined: pl.DataFrame) -> pl.DataFrame:
    rows: list[dict[str, object]] = []
    for key, frame in combined.filter(~pl.col("right_censored")).group_by(
        "study_date", "study_role", "symbol", "endpoint_name", maintain_order=True
    ):
        study_date, study_role, symbol, endpoint_name = (str(value) for value in key)
        side_source = str(frame.get_column("signed_markout_side_source")[0])
        rows.append(
            {
                "study_date": study_date,
                "study_role": study_role,
                "symbol": symbol,
                "endpoint_name": endpoint_name,
                "side_source": side_source,
                "n_observations": frame.height,
                "ofi_return_correlation": _finite_correlation(
                    frame.get_column(side_source), frame.get_column("future_mid_return")
                ),
                "mean_ofi_signed_future_mid_markout_bps": frame.get_column(
                    "ofi_signed_future_mid_markout_bps"
                ).mean(),
                "positive_direction_rate": frame.get_column("future_mid_up").mean(),
                "interpretation": "descriptive_book_flow_markout_not_trade_impact",
            }
        )
    return pl.DataFrame(rows, infer_schema_length=None).sort(
        "study_date", "symbol", "endpoint_name"
    )


def _signal_half_life(association: pl.DataFrame, combined: pl.DataFrame) -> pl.DataFrame:
    endpoint_contract = (
        combined.select(
            "endpoint_name", "endpoint_domain", "endpoint_horizon_value", "endpoint_horizon_unit"
        )
        .unique()
        .sort("endpoint_domain", "endpoint_horizon_value")
    )
    enriched = association.join(endpoint_contract, on="endpoint_name", how="left")
    rows: list[dict[str, object]] = []
    for key, frame in enriched.group_by(
        "study_date", "study_role", "symbol", "endpoint_domain", maintain_order=True
    ):
        study_date, study_role, symbol, domain = (str(value) for value in key)
        ordered = frame.sort("endpoint_horizon_value")
        correlations = ordered.get_column("ofi_return_correlation").to_list()
        baseline = (
            abs(float(correlations[0])) if correlations and correlations[0] is not None else None
        )
        crossed: int | None = None
        if baseline is not None and baseline > 0:
            for horizon, correlation in zip(
                ordered.get_column("endpoint_horizon_value").to_list(),
                correlations,
                strict=True,
            ):
                if correlation is not None and abs(float(correlation)) <= 0.5 * baseline:
                    crossed = int(horizon)
                    break
        for row in ordered.to_dicts():
            correlation = row["ofi_return_correlation"]
            association_ratio = None
            if correlation is not None and baseline is not None and baseline != 0.0:
                association_ratio = abs(float(correlation)) / baseline
            rows.append(
                {
                    "study_date": study_date,
                    "study_role": study_role,
                    "symbol": symbol,
                    "endpoint_domain": domain,
                    "endpoint_name": row["endpoint_name"],
                    "horizon_value": row["endpoint_horizon_value"],
                    "horizon_unit": row["endpoint_horizon_unit"],
                    "ofi_return_correlation": correlation,
                    "absolute_association_ratio_to_shortest": association_ratio,
                    "half_life_crossed_at_horizon": crossed,
                    "half_life_status": (
                        "crossed_within_declared_horizons"
                        if crossed is not None
                        else "not_crossed_or_unidentified"
                    ),
                }
            )
    return pl.DataFrame(rows, infer_schema_length=None).sort(
        "study_date", "symbol", "endpoint_domain", "horizon_value"
    )


def _training_shock_thresholds(books: pl.DataFrame) -> pl.DataFrame:
    train = books.filter(pl.col("study_role") == "train").with_columns(
        pl.min_horizontal("bid_quantity", "ask_quantity").alias("executable_l1_depth")
    )
    symbols = set(str(value) for value in books.get_column("symbol").unique())
    if set(str(value) for value in train.get_column("symbol").unique()) != symbols:
        raise L2ResearchError("liquidity shock thresholds require train rows for every symbol")
    return train.group_by("symbol").agg(
        pl.col("spread_bps").quantile(0.95, interpolation="linear").alias("train_spread_q95"),
        pl.col("executable_l1_depth")
        .quantile(0.05, interpolation="linear")
        .alias("train_executable_depth_q05"),
    )


def _liquidity_recovery(books: pl.DataFrame) -> pl.DataFrame:
    thresholds = _training_shock_thresholds(books)
    joined = books.with_columns(
        pl.min_horizontal("bid_quantity", "ask_quantity").alias("executable_l1_depth")
    ).join(thresholds, on="symbol", how="left")
    group = ["study_date", "symbol", "continuity_id"]
    rows: list[pl.DataFrame] = []
    for horizon in (20, 100):
        rows.append(
            joined.with_columns(
                pl.col("spread_bps").shift(-horizon).over(group).alias("future_spread_bps"),
                pl.col("executable_l1_depth")
                .shift(-horizon)
                .over(group)
                .alias("future_executable_l1_depth"),
            )
            .filter(
                (pl.col("spread_bps") >= pl.col("train_spread_q95"))
                | (pl.col("executable_l1_depth") <= pl.col("train_executable_depth_q05"))
            )
            .drop_nulls(["future_spread_bps", "future_executable_l1_depth"])
            .with_columns(
                pl.lit(horizon).alias("recovery_horizon_events"),
                (pl.col("future_spread_bps") - pl.col("spread_bps")).alias("spread_change_bps"),
                (pl.col("future_executable_l1_depth") - pl.col("executable_l1_depth")).alias(
                    "executable_depth_change"
                ),
            )
            .group_by("study_date", "study_role", "symbol", "recovery_horizon_events")
            .agg(
                pl.len().alias("n_shocks"),
                pl.col("spread_change_bps").mean().alias("mean_spread_change_bps"),
                pl.col("executable_depth_change").mean().alias("mean_executable_depth_change"),
                pl.col("train_spread_q95").first(),
                pl.col("train_executable_depth_q05").first(),
            )
        )
    return pl.concat(rows, how="vertical_relaxed").sort(
        "study_date", "symbol", "recovery_horizon_events"
    )


def _regime_diagnostics(combined: pl.DataFrame) -> pl.DataFrame:
    required = {"volatility_regime", "liquidity_regime"}
    missing = sorted(required.difference(combined.columns))
    if missing:
        raise L2ResearchError(f"regime diagnostics are missing columns: {missing}")
    return (
        combined.filter(~pl.col("right_censored"))
        .group_by(
            "study_date",
            "study_role",
            "symbol",
            "endpoint_name",
            "volatility_regime",
            "liquidity_regime",
        )
        .agg(
            pl.len().alias("n_observations"),
            pl.col("future_mid_up").mean().alias("positive_direction_rate"),
            pl.col("future_mid_return").mean().alias("mean_future_mid_return"),
            pl.col("ofi_signed_future_mid_markout_bps")
            .mean()
            .alias("mean_ofi_signed_future_mid_markout_bps"),
        )
        .sort("study_date", "symbol", "endpoint_name", "volatility_regime", "liquidity_regime")
    )


def _feature_stability(
    combined: pl.DataFrame, *, feature_columns: tuple[str, ...], bins: int
) -> pl.DataFrame:
    reference = combined.filter(pl.col("study_role").is_in(list(_DEVELOPMENT_ROLES)))
    if reference.is_empty():
        raise L2ResearchError("feature stability requires development rows")
    outputs: list[pl.DataFrame] = []
    for role in _TEST_ROLES:
        comparison = combined.filter(pl.col("study_role") == role)
        if comparison.is_empty():
            raise L2ResearchError(f"feature stability requires {role} rows")
        outputs.append(
            feature_stability_summary(
                reference,
                comparison,
                feature_columns=feature_columns,
                group_columns=("symbol", "endpoint_name"),
                bins=bins,
            ).with_columns(
                pl.lit(role).alias("comparison_role"),
                pl.lit("train_plus_validation_only").alias("reference_scope"),
            )
        )
    return pl.concat(outputs, how="vertical_relaxed").sort(
        "comparison_role", "symbol", "endpoint_name", "feature"
    )


def _cross_instrument_stability(association: pl.DataFrame) -> pl.DataFrame:
    rows: list[dict[str, object]] = []
    for key, frame in association.group_by(
        "study_date", "study_role", "endpoint_name", maintain_order=True
    ):
        study_date, study_role, endpoint_name = (str(value) for value in key)
        by_symbol: dict[str, float | None] = {
            str(row["symbol"]): (
                None
                if row["ofi_return_correlation"] is None
                else float(row["ofi_return_correlation"])
            )
            for row in frame.to_dicts()
        }
        btc = by_symbol.get("BTCUSDT")
        eth = by_symbol.get("ETHUSDT")
        same_direction = None
        if btc is not None and eth is not None and btc != 0.0 and eth != 0.0:
            same_direction = math.copysign(1.0, btc) == math.copysign(1.0, eth)
        rows.append(
            {
                "study_date": study_date,
                "study_role": study_role,
                "endpoint_name": endpoint_name,
                "btc_ofi_return_correlation": btc,
                "eth_ofi_return_correlation": eth,
                "both_observed": btc is not None and eth is not None,
                "same_direction": same_direction,
                "cross_instrument_pooling": False,
            }
        )
    return pl.DataFrame(rows, infer_schema_length=None).sort("study_date", "endpoint_name")


def build_l2_descriptive_analysis(
    endpoint_frames: Sequence[pl.DataFrame],
    *,
    feature_columns: Sequence[str],
    stability_bins: int,
) -> L2DescriptiveAnalysis:
    """Build all frozen descriptive outputs without fitting a predictive model."""

    features = tuple(str(value) for value in feature_columns)
    if not features or stability_bins < 2:
        raise L2ResearchError("descriptive feature columns and stability bins are required")
    combined = _combined(endpoint_frames)
    books = _canonical_books(combined)
    association = _ofi_association(combined)
    return L2DescriptiveAnalysis(
        intraday_liquidity=_intraday_liquidity(books),
        ofi_return_association=association,
        signal_half_life=_signal_half_life(association, combined),
        liquidity_recovery=_liquidity_recovery(books),
        regime_diagnostics=_regime_diagnostics(combined),
        feature_stability=_feature_stability(
            combined, feature_columns=features, bins=stability_bins
        ),
        cross_instrument_stability=_cross_instrument_stability(association),
    )


__all__ = ["L2DescriptiveAnalysis", "build_l2_descriptive_analysis"]