Microstructure/src/microstructure/research/analysis.py

"""Reproducible descriptive market-microstructure diagnostics.

No function in this module claims causal or tradable significance.  Thresholds
used for large trades, shocks, recovery, and regimes are supplied explicitly by
the caller and are tagged as train-period inputs; they are never estimated from
the analyzed evaluation sample.
"""

from __future__ import annotations

import math
from collections.abc import Mapping, Sequence
from dataclasses import dataclass
from typing import cast

import numpy as np
import polars as pl
from numpy.typing import NDArray


class DescriptiveAnalysisError(ValueError):
    """Raised when a descriptive diagnostic lacks a valid input contract."""


@dataclass(frozen=True, slots=True)
class HalfLifeResult:
    """Correlation-decay curve and per-instrument descriptive half-life summary."""

    curve: pl.DataFrame
    summary: pl.DataFrame


@dataclass(frozen=True, slots=True)
class LiquidityShockThresholds:
    """Externally fitted shock and recovery thresholds for one instrument."""

    spread_shock_bps: float
    depth_shock_max: float
    spread_recovery_bps: float
    depth_recovery_min: float
    max_recovery_events: int

    def __post_init__(self) -> None:
        values = (
            self.spread_shock_bps,
            self.depth_shock_max,
            self.spread_recovery_bps,
            self.depth_recovery_min,
        )
        if not all(math.isfinite(value) and value >= 0 for value in values):
            raise DescriptiveAnalysisError("liquidity thresholds must be finite and nonnegative")
        if self.max_recovery_events < 1:
            raise DescriptiveAnalysisError("max_recovery_events must be positive")


@dataclass(frozen=True, slots=True)
class RegimeThresholds:
    """Externally fitted volatility and liquidity regime boundaries."""

    volatility_low: float
    volatility_high: float
    spread_tight_bps: float
    spread_wide_bps: float
    depth_low: float
    depth_high: float

    def __post_init__(self) -> None:
        values = (
            self.volatility_low,
            self.volatility_high,
            self.spread_tight_bps,
            self.spread_wide_bps,
            self.depth_low,
            self.depth_high,
        )
        if not all(math.isfinite(value) and value >= 0 for value in values):
            raise DescriptiveAnalysisError("regime thresholds must be finite and nonnegative")
        if self.volatility_low > self.volatility_high:
            raise DescriptiveAnalysisError("volatility_low cannot exceed volatility_high")
        if self.spread_tight_bps > self.spread_wide_bps:
            raise DescriptiveAnalysisError("tight spread cannot exceed wide spread")
        if self.depth_low > self.depth_high:
            raise DescriptiveAnalysisError("low depth cannot exceed high depth")


def _require(frame: pl.DataFrame, columns: Sequence[str], table: str) -> None:
    missing = sorted(set(columns).difference(frame.columns))
    if missing:
        raise DescriptiveAnalysisError(f"{table} is missing required columns: {missing}")
    if frame.is_empty():
        raise DescriptiveAnalysisError(f"{table} must not be empty")


def _finite_pair(
    frame: pl.DataFrame, left: str, right: str
) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
    paired = frame.select(left, right).drop_nulls()
    x = paired.get_column(left).to_numpy().astype(np.float64)
    y = paired.get_column(right).to_numpy().astype(np.float64)
    finite = np.isfinite(x) & np.isfinite(y)
    return x[finite], y[finite]


def _pearson(x: NDArray[np.float64], y: NDArray[np.float64]) -> float:
    if x.size < 2 or np.std(x) == 0 or np.std(y) == 0:
        return math.nan
    return float(np.corrcoef(x, y)[0, 1])


def _average_rank(values: NDArray[np.float64]) -> NDArray[np.float64]:
    order = np.argsort(values, kind="mergesort")
    ranks = np.empty(values.size, dtype=np.float64)
    start = 0
    while start < values.size:
        end = start + 1
        while end < values.size and values[order[end]] == values[order[start]]:
            end += 1
        ranks[order[start:end]] = (start + end - 1) / 2.0
        start = end
    return ranks


def intraday_liquidity_summary(
    frame: pl.DataFrame,
    *,
    timestamp_column: str = "decision_ts_ns",
    bucket_minutes: int = 60,
    utc_offset_minutes: int = 0,
    spread_column: str = "spread_bps",
    depth_column: str = "depth_total_l1",
    imbalance_column: str = "queue_imbalance_l1",
) -> pl.DataFrame:
    """Summarize liquidity by fixed minute-of-day buckets."""

    _require(
        frame,
        ("symbol", timestamp_column, spread_column, depth_column, imbalance_column),
        "intraday frame",
    )
    if bucket_minutes < 1 or bucket_minutes > 1_440 or 1_440 % bucket_minutes:
        raise DescriptiveAnalysisError("bucket_minutes must be a positive divisor of 1440")
    minute_ns = 60_000_000_000
    prepared = frame.with_columns(
        (
            ((pl.col(timestamp_column) // minute_ns + utc_offset_minutes) % 1_440)
            // bucket_minutes
            * bucket_minutes
        )
        .cast(pl.Int32)
        .alias("intraday_bucket_start_minute")
    )
    result = (
        prepared.group_by("symbol", "intraday_bucket_start_minute")
        .agg(
            pl.len().alias("n_observations"),
            pl.col(spread_column).mean().alias("mean_spread_bps"),
            pl.col(spread_column).median().alias("median_spread_bps"),
            pl.col(depth_column).mean().alias("mean_depth_l1"),
            pl.col(depth_column).median().alias("median_depth_l1"),
            pl.col(imbalance_column).mean().alias("mean_queue_imbalance_l1"),
        )
        .with_columns(
            (
                (pl.col("intraday_bucket_start_minute") // 60).cast(pl.String).str.pad_start(2, "0")
                + pl.lit(":")
                + (pl.col("intraday_bucket_start_minute") % 60)
                .cast(pl.String)
                .str.pad_start(2, "0")
            ).alias("intraday_bucket_label"),
            pl.lit(utc_offset_minutes, dtype=pl.Int32).alias("utc_offset_minutes"),
            pl.lit("intraday_liquidity_descriptive").alias("analysis_kind"),
            pl.lit(True).alias("descriptive_only"),
        )
        .sort("symbol", "intraday_bucket_start_minute")
    )
    return result


def ofi_future_return_association(
    frame: pl.DataFrame,
    *,
    horizon_return_columns: Mapping[int, str],
    ofi_column: str = "ofi_l1",
    min_observations: int = 3,
) -> pl.DataFrame:
    """Report descriptive OFI/return slopes and rank/linear correlations."""

    if not horizon_return_columns or any(horizon <= 0 for horizon in horizon_return_columns):
        raise DescriptiveAnalysisError("supplied event horizons must be positive")
    _require(frame, ("symbol", ofi_column, *horizon_return_columns.values()), "OFI frame")
    if min_observations < 2:
        raise DescriptiveAnalysisError("min_observations must be at least two")

    rows: list[dict[str, object]] = []
    for symbol_frame in frame.partition_by("symbol", maintain_order=True):
        symbol = str(symbol_frame.get_column("symbol")[0])
        for horizon, return_column in sorted(horizon_return_columns.items()):
            x, y = _finite_pair(symbol_frame, ofi_column, return_column)
            enough = x.size >= min_observations
            variance = float(np.var(x)) if x.size else math.nan
            slope = (
                float(np.mean((x - x.mean()) * (y - y.mean())) / variance)
                if enough and variance > 0
                else math.nan
            )
            intercept = float(y.mean() - slope * x.mean()) if math.isfinite(slope) else math.nan
            rows.append(
                {
                    "symbol": symbol,
                    "horizon_events": horizon,
                    "ofi_column": ofi_column,
                    "return_column": return_column,
                    "n_observations": int(x.size),
                    "pearson_correlation": _pearson(x, y) if enough else math.nan,
                    "spearman_correlation": (
                        _pearson(_average_rank(x), _average_rank(y)) if enough else math.nan
                    ),
                    "ols_slope_return_per_ofi_unit": slope,
                    "ols_intercept": intercept,
                    "mean_future_return": float(y.mean()) if y.size else math.nan,
                    "analysis_status": "ok" if enough else "insufficient_observations",
                    "analysis_kind": "ofi_future_return_descriptive_association",
                    "descriptive_only": True,
                }
            )
    return pl.DataFrame(rows).sort("symbol", "horizon_events")


def estimate_signal_half_life(
    association_curve: pl.DataFrame,
    *,
    correlation_column: str = "pearson_correlation",
) -> HalfLifeResult:
    """Estimate correlation half-life from a caller-supplied horizon curve."""

    _require(
        association_curve,
        ("symbol", "horizon_events", correlation_column, "n_observations"),
        "association curve",
    )
    curve = association_curve.with_columns(
        pl.col(correlation_column).abs().alias("absolute_correlation")
    ).sort("symbol", "horizon_events")
    curve_rows: list[dict[str, object]] = []
    summaries: list[dict[str, object]] = []
    for symbol_curve in curve.partition_by("symbol", maintain_order=True):
        symbol = str(symbol_curve.get_column("symbol")[0])
        horizons = symbol_curve.get_column("horizon_events").to_numpy().astype(np.float64)
        correlations = symbol_curve.get_column("absolute_correlation").to_numpy().astype(np.float64)
        finite = np.isfinite(horizons) & np.isfinite(correlations)
        horizons = horizons[finite]
        correlations = correlations[finite]
        if not correlations.size:
            for row in symbol_curve.iter_rows(named=True):
                curve_rows.append(
                    {
                        **row,
                        "normalized_absolute_correlation": None,
                        "half_correlation_threshold": None,
                        "analysis_kind": "signal_decay_curve_descriptive",
                        "descriptive_only": True,
                    }
                )
            summaries.append(
                {
                    "symbol": symbol,
                    "reference_horizon_events": None,
                    "reference_absolute_correlation": None,
                    "half_correlation_threshold": None,
                    "first_crossing_half_life_events": None,
                    "exponential_half_life_events": None,
                    "analysis_status": "no_finite_correlations",
                    "analysis_kind": "signal_half_life_descriptive",
                    "descriptive_only": True,
                }
            )
            continue
        reference = float(correlations[0])
        half_threshold = reference / 2.0
        crossing = horizons[correlations <= half_threshold]
        first_crossing = float(crossing[0]) if crossing.size else None
        positive = correlations > 0
        exponential_half_life: float | None = None
        if positive.sum() >= 2:
            slope = float(np.polyfit(horizons[positive], np.log(correlations[positive]), 1)[0])
            if slope < 0:
                exponential_half_life = math.log(2.0) / -slope
        status = "ok" if reference > 0 else "zero_reference_correlation"
        summaries.append(
            {
                "symbol": symbol,
                "reference_horizon_events": int(horizons[0]),
                "reference_absolute_correlation": reference,
                "half_correlation_threshold": half_threshold,
                "first_crossing_half_life_events": first_crossing,
                "exponential_half_life_events": exponential_half_life,
                "analysis_status": status,
                "analysis_kind": "signal_half_life_descriptive",
                "descriptive_only": True,
            }
        )
        for row in symbol_curve.iter_rows(named=True):
            value = float(row["absolute_correlation"])
            curve_rows.append(
                {
                    **row,
                    "normalized_absolute_correlation": (
                        value / reference if reference > 0 and math.isfinite(value) else None
                    ),
                    "half_correlation_threshold": half_threshold,
                    "analysis_kind": "signal_decay_curve_descriptive",
                    "descriptive_only": True,
                }
            )
    return HalfLifeResult(
        curve=pl.DataFrame(curve_rows).sort("symbol", "horizon_events"),
        summary=pl.DataFrame(summaries).sort("symbol"),
    )


def large_trade_price_impact_summary(
    frame: pl.DataFrame,
    *,
    impact_columns: Mapping[int, str],
    train_quantity_thresholds: Mapping[str, float],
    quantity_column: str = "quantity",
) -> pl.DataFrame:
    """Compare impact above/below externally supplied train-period size cutoffs."""

    if not impact_columns or any(horizon <= 0 for horizon in impact_columns):
        raise DescriptiveAnalysisError("impact horizons must be positive")
    _require(frame, ("symbol", quantity_column, *impact_columns.values()), "trade-impact frame")
    symbols = {str(value) for value in frame.get_column("symbol").unique()}
    missing = sorted(symbols.difference(train_quantity_thresholds))
    if missing:
        raise DescriptiveAnalysisError(f"missing train-period quantity thresholds: {missing}")
    if any(
        not math.isfinite(train_quantity_thresholds[symbol])
        or train_quantity_thresholds[symbol] <= 0
        for symbol in symbols
    ):
        raise DescriptiveAnalysisError("large-trade thresholds must be finite and positive")

    rows: list[dict[str, object]] = []
    for symbol_frame in frame.partition_by("symbol", maintain_order=True):
        symbol = str(symbol_frame.get_column("symbol")[0])
        threshold = train_quantity_thresholds[symbol]
        for horizon, impact_column in sorted(impact_columns.items()):
            for is_large in (False, True):
                subset = (
                    symbol_frame.filter((pl.col(quantity_column) >= threshold) == is_large)
                    .select(impact_column)
                    .drop_nulls()
                )
                values = subset.get_column(impact_column).to_numpy().astype(np.float64)
                values = values[np.isfinite(values)]
                rows.append(
                    {
                        "symbol": symbol,
                        "horizon_events": horizon,
                        "impact_column": impact_column,
                        "large_trade": is_large,
                        "train_quantity_threshold": threshold,
                        "n_observations": int(values.size),
                        "mean_signed_impact_bps": (
                            float(values.mean()) if values.size else math.nan
                        ),
                        "median_signed_impact_bps": (
                            float(np.median(values)) if values.size else math.nan
                        ),
                        "mean_absolute_impact_bps": (
                            float(np.abs(values).mean()) if values.size else math.nan
                        ),
                        "threshold_source": "caller_supplied_train_period",
                        "analysis_kind": "large_trade_price_impact_descriptive",
                        "descriptive_only": True,
                    }
                )
    return pl.DataFrame(rows).sort("symbol", "horizon_events", "large_trade")


def liquidity_recovery_summary(
    frame: pl.DataFrame,
    *,
    train_thresholds: Mapping[str, LiquidityShockThresholds],
    spread_column: str = "spread_bps",
    depth_column: str = "depth_total_l1",
    time_column: str = "decision_ts_ns",
    sequence_column: str = "decision_sequence",
) -> pl.DataFrame:
    """Track nonoverlapping recovery episodes after threshold-defined shocks."""

    _require(
        frame,
        ("symbol", "continuity_id", spread_column, depth_column, time_column, sequence_column),
        "liquidity-recovery frame",
    )
    symbols = {str(value) for value in frame.get_column("symbol").unique()}
    missing = sorted(symbols.difference(train_thresholds))
    if missing:
        raise DescriptiveAnalysisError(f"missing train-period liquidity thresholds: {missing}")

    episodes: list[dict[str, object]] = []
    for segment in frame.sort(["symbol", "continuity_id", sequence_column]).partition_by(
        ["symbol", "continuity_id"], maintain_order=True
    ):
        symbol = str(segment.get_column("symbol")[0])
        continuity_id = str(segment.get_column("continuity_id")[0])
        threshold = train_thresholds[symbol]
        rows = list(segment.iter_rows(named=True))
        index = 0
        while index < len(rows):
            row = rows[index]
            spread = cast(float, row[spread_column])
            depth = cast(float, row[depth_column])
            spread_shock = spread >= threshold.spread_shock_bps
            depth_shock = depth <= threshold.depth_shock_max
            if not (spread_shock or depth_shock):
                index += 1
                continue
            search_end = min(len(rows) - 1, index + threshold.max_recovery_events)
            recovery_index: int | None = None
            for candidate_index in range(index + 1, search_end + 1):
                candidate = rows[candidate_index]
                if (
                    cast(float, candidate[spread_column]) <= threshold.spread_recovery_bps
                    and cast(float, candidate[depth_column]) >= threshold.depth_recovery_min
                ):
                    recovery_index = candidate_index
                    break
            full_horizon_observed = index + threshold.max_recovery_events < len(rows)
            right_censored = recovery_index is None and not full_horizon_observed
            information_end_index = (
                recovery_index
                if recovery_index is not None
                else index + threshold.max_recovery_events
                if full_horizon_observed
                else None
            )
            shock_ts = cast(int, row[time_column])
            recovery_row = rows[recovery_index] if recovery_index is not None else None
            episodes.append(
                {
                    "symbol": symbol,
                    "continuity_id": continuity_id,
                    "shock_ts_ns": shock_ts,
                    "shock_sequence": cast(int, row[sequence_column]),
                    "shock_spread_bps": spread,
                    "shock_depth_l1": depth,
                    "spread_shock": spread_shock,
                    "depth_shock": depth_shock,
                    "recovered": None if right_censored else recovery_index is not None,
                    "recovery_events": (
                        recovery_index - index if recovery_index is not None else None
                    ),
                    "recovery_time_ns": (
                        cast(int, recovery_row[time_column]) - shock_ts
                        if recovery_row is not None
                        else None
                    ),
                    "recovery_ts_ns": (
                        cast(int, recovery_row[time_column]) if recovery_row is not None else None
                    ),
                    "recovery_right_censored": right_censored,
                    "recovery_censor_reason": (
                        "segment_ends_before_max_horizon" if right_censored else None
                    ),
                    "recovery_information_end_ts_ns": (
                        cast(int, rows[information_end_index][time_column])
                        if information_end_index is not None
                        else None
                    ),
                    "spread_shock_threshold_bps": threshold.spread_shock_bps,
                    "depth_shock_threshold_max": threshold.depth_shock_max,
                    "spread_recovery_threshold_bps": threshold.spread_recovery_bps,
                    "depth_recovery_threshold_min": threshold.depth_recovery_min,
                    "max_recovery_events": threshold.max_recovery_events,
                    "threshold_source": "caller_supplied_train_period",
                    "analysis_kind": "liquidity_recovery_descriptive",
                    "descriptive_only": True,
                }
            )
            index = (recovery_index + 1) if recovery_index is not None else search_end + 1
    if not episodes:
        return pl.DataFrame(
            schema={
                "symbol": pl.String,
                "continuity_id": pl.String,
                "shock_ts_ns": pl.Int64,
                "analysis_kind": pl.String,
                "descriptive_only": pl.Boolean,
            }
        )
    return pl.DataFrame(episodes, infer_schema_length=None).sort("symbol", "shock_ts_ns")


def assign_market_regimes(
    frame: pl.DataFrame,
    *,
    train_thresholds: Mapping[str, RegimeThresholds],
    volatility_column: str,
    spread_column: str = "spread_bps",
    depth_column: str = "depth_total_l1",
) -> pl.DataFrame:
    """Assign regimes using only explicit instrument-specific train thresholds."""

    _require(
        frame,
        ("symbol", volatility_column, spread_column, depth_column),
        "market-regime frame",
    )
    symbols = {str(value) for value in frame.get_column("symbol").unique()}
    missing = sorted(symbols.difference(train_thresholds))
    if missing:
        raise DescriptiveAnalysisError(f"missing train-period regime thresholds: {missing}")
    outputs: list[pl.DataFrame] = []
    for symbol_frame in frame.partition_by("symbol", maintain_order=True):
        symbol = str(symbol_frame.get_column("symbol")[0])
        threshold = train_thresholds[symbol]
        outputs.append(
            symbol_frame.with_columns(
                pl.when(pl.col(volatility_column) <= threshold.volatility_low)
                .then(pl.lit("low"))
                .when(pl.col(volatility_column) >= threshold.volatility_high)
                .then(pl.lit("high"))
                .otherwise(pl.lit("medium"))
                .alias("volatility_regime"),
                pl.when(
                    (pl.col(spread_column) >= threshold.spread_wide_bps)
                    | (pl.col(depth_column) <= threshold.depth_low)
                )
                .then(pl.lit("stressed"))
                .when(
                    (pl.col(spread_column) <= threshold.spread_tight_bps)
                    & (pl.col(depth_column) >= threshold.depth_high)
                )
                .then(pl.lit("liquid"))
                .otherwise(pl.lit("normal"))
                .alias("liquidity_regime"),
                pl.lit(threshold.volatility_low).alias("train_volatility_low"),
                pl.lit(threshold.volatility_high).alias("train_volatility_high"),
                pl.lit(threshold.spread_tight_bps).alias("train_spread_tight_bps"),
                pl.lit(threshold.spread_wide_bps).alias("train_spread_wide_bps"),
                pl.lit(threshold.depth_low).alias("train_depth_low"),
                pl.lit(threshold.depth_high).alias("train_depth_high"),
            ).with_columns(
                (pl.col("volatility_regime") + pl.lit("__") + pl.col("liquidity_regime")).alias(
                    "joint_market_regime"
                ),
                pl.lit("caller_supplied_train_period").alias("regime_threshold_source"),
                pl.lit("volatility_liquidity_regime_descriptive").alias("analysis_kind"),
                pl.lit(True).alias("descriptive_only"),
            )
        )
    return pl.concat(outputs, how="vertical_relaxed")


def regime_outcome_summary(
    regime_frame: pl.DataFrame,
    *,
    outcome_columns: Sequence[str],
) -> pl.DataFrame:
    """Summarize supplied outcomes without using them to define regimes."""

    _require(
        regime_frame,
        ("symbol", "volatility_regime", "liquidity_regime", *outcome_columns),
        "regime outcomes",
    )
    expressions: list[pl.Expr] = [pl.len().alias("n_observations")]
    for column in outcome_columns:
        expressions.extend(
            [
                pl.col(column).mean().alias(f"mean__{column}"),
                pl.col(column).median().alias(f"median__{column}"),
            ]
        )
    return (
        regime_frame.group_by("symbol", "volatility_regime", "liquidity_regime")
        .agg(expressions)
        .with_columns(
            pl.lit("regime_outcomes_descriptive").alias("analysis_kind"),
            pl.lit(True).alias("descriptive_only"),
        )
        .sort("symbol", "volatility_regime", "liquidity_regime")
    )


def cross_instrument_stability_summary(
    effects: pl.DataFrame,
    *,
    value_column: str,
    comparison_columns: Sequence[str] = ("horizon_events",),
    instrument_column: str = "symbol",
) -> pl.DataFrame:
    """Summarize effect direction and dispersion across instruments."""

    _require(effects, (instrument_column, value_column, *comparison_columns), "effects")
    rows: list[dict[str, object]] = []
    partitions = (
        effects.partition_by(list(comparison_columns), maintain_order=True)
        if comparison_columns
        else [effects]
    )
    for partition in partitions:
        by_instrument = partition.group_by(instrument_column).agg(
            pl.col(value_column).mean().alias("_instrument_effect")
        )
        values = (
            by_instrument.get_column("_instrument_effect")
            .drop_nulls()
            .to_numpy()
            .astype(np.float64)
        )
        values = values[np.isfinite(values)]
        nonzero = values[values != 0]
        sign_agreement = (
            max(float((nonzero > 0).mean()), float((nonzero < 0).mean()))
            if nonzero.size
            else math.nan
        )
        row: dict[str, object] = {
            column: partition.get_column(column)[0] for column in comparison_columns
        }
        row.update(
            {
                "value_column": value_column,
                "n_instruments": int(values.size),
                "mean_effect": float(values.mean()) if values.size else math.nan,
                "median_effect": float(np.median(values)) if values.size else math.nan,
                "effect_std": float(values.std(ddof=0)) if values.size else math.nan,
                "minimum_effect": float(values.min()) if values.size else math.nan,
                "maximum_effect": float(values.max()) if values.size else math.nan,
                "sign_agreement_fraction": sign_agreement,
                "analysis_kind": "cross_instrument_stability_descriptive",
                "descriptive_only": True,
            }
        )
        rows.append(row)
    return (
        pl.DataFrame(rows).sort(list(comparison_columns))
        if comparison_columns
        else pl.DataFrame(rows)
    )


def _population_stability_index(
    reference: NDArray[np.float64],
    comparison: NDArray[np.float64],
    *,
    bins: int,
    reference_missing: int,
    comparison_missing: int,
) -> float:
    quantiles = np.linspace(0.0, 1.0, bins + 1)
    internal = (
        np.unique(np.quantile(reference, quantiles)[1:-1]) if reference.size else np.array([])
    )
    edges = np.concatenate(([-np.inf], internal, [np.inf]))
    reference_counts = np.histogram(reference, bins=edges)[0].astype(np.float64)
    comparison_counts = np.histogram(comparison, bins=edges)[0].astype(np.float64)
    reference_counts = np.append(reference_counts, reference_missing)
    comparison_counts = np.append(comparison_counts, comparison_missing)
    epsilon = 1e-6
    reference_share = (reference_counts + epsilon) / (
        reference_counts.sum() + epsilon * reference_counts.size
    )
    comparison_share = (comparison_counts + epsilon) / (
        comparison_counts.sum() + epsilon * comparison_counts.size
    )
    return float(
        np.sum((comparison_share - reference_share) * np.log(comparison_share / reference_share))
    )


def _max_cdf_distance(reference: NDArray[np.float64], comparison: NDArray[np.float64]) -> float:
    if not reference.size or not comparison.size:
        return math.nan
    points = np.sort(np.unique(np.concatenate((reference, comparison))))
    reference_cdf = np.searchsorted(np.sort(reference), points, side="right") / reference.size
    comparison_cdf = np.searchsorted(np.sort(comparison), points, side="right") / comparison.size
    return float(np.max(np.abs(reference_cdf - comparison_cdf)))


def feature_stability_summary(
    reference: pl.DataFrame,
    comparison: pl.DataFrame,
    *,
    feature_columns: Sequence[str],
    group_columns: Sequence[str] = ("symbol",),
    bins: int = 10,
) -> pl.DataFrame:
    """Compare feature distributions using bins learned from reference only."""

    if not feature_columns:
        raise DescriptiveAnalysisError("feature_columns must not be empty")
    if bins < 2:
        raise DescriptiveAnalysisError("feature stability requires at least two bins")
    _require(reference, (*group_columns, *feature_columns), "reference features")
    _require(comparison, (*group_columns, *feature_columns), "comparison features")

    if group_columns:
        reference_groups = reference.partition_by(list(group_columns), as_dict=True)
        comparison_groups = comparison.partition_by(list(group_columns), as_dict=True)
        missing_groups = sorted(set(reference_groups).difference(comparison_groups), key=str)
        if missing_groups:
            raise DescriptiveAnalysisError(
                f"comparison is missing reference groups: {missing_groups}"
            )
    else:
        reference_groups = {(): reference}
        comparison_groups = {(): comparison}

    rows: list[dict[str, object]] = []
    for key, reference_group in reference_groups.items():
        comparison_group = comparison_groups[key]
        key_tuple = key if isinstance(key, tuple) else (key,)
        group_values = dict(zip(group_columns, key_tuple, strict=True))
        for feature in feature_columns:
            reference_series = reference_group.get_column(feature)
            comparison_series = comparison_group.get_column(feature)
            reference_values = reference_series.drop_nulls().to_numpy().astype(np.float64)
            comparison_values = comparison_series.drop_nulls().to_numpy().astype(np.float64)
            reference_values = reference_values[np.isfinite(reference_values)]
            comparison_values = comparison_values[np.isfinite(comparison_values)]
            reference_invalid = reference_group.height - reference_values.size
            comparison_invalid = comparison_group.height - comparison_values.size
            reference_mean = float(reference_values.mean()) if reference_values.size else math.nan
            comparison_mean = (
                float(comparison_values.mean()) if comparison_values.size else math.nan
            )
            reference_std = (
                float(reference_values.std(ddof=0)) if reference_values.size else math.nan
            )
            comparison_std = (
                float(comparison_values.std(ddof=0)) if comparison_values.size else math.nan
            )
            rows.append(
                {
                    **group_values,
                    "feature": feature,
                    "reference_n": int(reference_group.height),
                    "comparison_n": int(comparison_group.height),
                    "reference_missing_rate": reference_invalid / reference_group.height,
                    "comparison_missing_rate": comparison_invalid / comparison_group.height,
                    "reference_mean": reference_mean,
                    "comparison_mean": comparison_mean,
                    "reference_std": reference_std,
                    "comparison_std": comparison_std,
                    "standardized_mean_shift": (
                        (comparison_mean - reference_mean) / reference_std
                        if reference_std > 0 and math.isfinite(comparison_mean)
                        else None
                    ),
                    "variance_ratio": (
                        (comparison_std**2) / (reference_std**2)
                        if reference_std > 0 and math.isfinite(comparison_std)
                        else None
                    ),
                    "population_stability_index": _population_stability_index(
                        reference_values,
                        comparison_values,
                        bins=bins,
                        reference_missing=reference_invalid,
                        comparison_missing=comparison_invalid,
                    ),
                    "max_empirical_cdf_distance": _max_cdf_distance(
                        reference_values, comparison_values
                    ),
                    "reference_constant": bool(reference_std == 0),
                    "bin_source": "reference_period_only",
                    "analysis_kind": "feature_stability_descriptive",
                    "descriptive_only": True,
                }
            )
    return pl.DataFrame(rows).sort([*group_columns, "feature"])


__all__ = [
    "DescriptiveAnalysisError",
    "HalfLifeResult",
    "LiquidityShockThresholds",
    "RegimeThresholds",
    "assign_market_regimes",
    "cross_instrument_stability_summary",
    "estimate_signal_half_life",
    "feature_stability_summary",
    "intraday_liquidity_summary",
    "large_trade_price_impact_summary",
    "liquidity_recovery_summary",
    "ofi_future_return_association",
    "regime_outcome_summary",
]