Microstructure/tests/test_features.py

from __future__ import annotations

import math

import polars as pl
import pytest

from microstructure.config import FeatureConfig
from microstructure.research.features import (
    ResearchDataError,
    TemporalLeakageError,
    build_research_features,
    build_research_frame,
    model_feature_columns,
    validate_temporal_contract,
)

SECOND = 1_000_000_000


def _feature_config() -> FeatureConfig:
    return FeatureConfig(
        trade_windows=(2,),
        volatility_window=2,
        intensity_window=2,
        label_horizon_events=2,
        large_trade_quantile=0.9,
    )


def _books() -> pl.DataFrame:
    rows = [
        (0, "segment-a", 1, 100.0, 10.0, 102.0, 10.0),
        (1, "segment-a", 2, 100.0, 12.0, 102.0, 8.0),
        (2, "segment-a", 3, 101.0, 5.0, 102.0, 5.0),
        (3, "segment-a", 4, 101.0, 4.0, 103.0, 6.0),
        (4, "segment-a", 5, 102.0, 8.0, 103.0, 4.0),
        (5, "segment-a", 6, 102.0, 6.0, 104.0, 6.0),
        (6, "segment-b", 20, 110.0, 5.0, 112.0, 5.0),
        (7, "segment-b", 21, 110.0, 7.0, 112.0, 3.0),
        (8, "segment-b", 22, 111.0, 5.0, 112.0, 5.0),
    ]
    return pl.DataFrame(
        {
            "symbol": ["BTCUSDT"] * len(rows),
            "event_ts_ns": [row[0] * SECOND for row in rows],
            "available_ts_ns": [row[0] * SECOND for row in rows],
            "continuity_id": [row[1] for row in rows],
            "sequence_end": [row[2] for row in rows],
            "is_valid": [True] * len(rows),
            "best_bid": [row[3] for row in rows],
            "bid_quantity": [row[4] for row in rows],
            "best_ask": [row[5] for row in rows],
            "ask_quantity": [row[6] for row in rows],
        }
    )


def _trades() -> pl.DataFrame:
    return pl.DataFrame(
        {
            "symbol": ["BTCUSDT", "BTCUSDT", "BTCUSDT", "BTCUSDT"],
            "continuity_id": ["segment-a", "segment-a", "segment-a", "segment-b"],
            "trade_id": [1, 2, 3, 4],
            "available_ts_ns": [SECOND // 2, SECOND, 3 * SECOND // 2, 7 * SECOND],
            "quantity": [2.0, 7.0, 3.0, 100.0],
            "aggressor_side": ["buy", "sell", "sell", "buy"],
        }
    )


def test_hand_checked_causal_features_and_strict_trade_tie() -> None:
    frame = build_research_frame(_books(), _trades(), _feature_config())
    at_one = frame.filter(pl.col("decision_ts_ns") == SECOND).row(0, named=True)

    assert at_one["mid_price"] == 101.0
    assert at_one["spread"] == 2.0
    assert at_one["queue_imbalance_l1"] == pytest.approx(0.2)
    assert at_one["causal_microprice"] == pytest.approx(101.2)
    assert at_one["ofi_l1"] == pytest.approx(4.0)
    # The buy at 0.5 seconds is known.  The sell timestamped exactly at this
    # book decision is from a separately ordered archive stream and is excluded.
    assert at_one["signed_trade_volume_w2"] == pytest.approx(2.0)
    assert at_one["trade_feature_max_source_ts_ns"] == SECOND // 2
    assert at_one["trade_feature_max_source_ts_ns"] < at_one["decision_ts_ns"]
    assert at_one["realized_price_impact_bps_1"] == pytest.approx(0.0)
    assert at_one["spread_recovery_bps_1"] == pytest.approx(0.0)
    assert at_one["depth_recovery_l1_1"] == pytest.approx(0.0)


def test_feature_stage_can_be_reused_before_any_label_horizon_is_opened() -> None:
    features = build_research_features(_books(), _trades(), _feature_config())
    labeled = build_research_frame(_books(), _trades(), _feature_config())

    assert "future_mid_return" not in features.columns
    assert features.select("symbol", "continuity_id", "decision_sequence").equals(
        labeled.select("symbol", "continuity_id", "decision_sequence")
    )
    assert (
        features.get_column("max_feature_source_ts_ns").to_list()
        == labeled.get_column("max_feature_source_ts_ns").to_list()
    )


def test_optional_multilevel_depth_and_cancellation_enter_canonical_frame() -> None:
    books = _books().with_columns(
        pl.lit("binance_spot").alias("venue"),
        (pl.col("bid_quantity") + 4.0).alias("depth_bid_5"),
        (pl.col("ask_quantity") + 6.0).alias("depth_ask_5"),
        (pl.col("bid_quantity") + 14.0).alias("depth_bid_10"),
        (pl.col("ask_quantity") + 16.0).alias("depth_ask_10"),
    )
    depth_deltas = pl.DataFrame(
        {
            "venue": ["binance_spot"] * books.height,
            "symbol": ["BTCUSDT"] * books.height,
            "event_ts_ns": books.get_column("event_ts_ns"),
            "available_ts_ns": books.get_column("available_ts_ns"),
            "continuity_id": books.get_column("continuity_id"),
            "first_update_id": books.get_column("sequence_end"),
            "last_update_id": books.get_column("sequence_end"),
            "bids": [
                [{"price_ticks": 10_000, "quantity_lots": 0 if index == 1 else 10}]
                for index in range(books.height)
            ],
            "asks": [[{"price_ticks": 10_200, "quantity_lots": 10}] for _ in range(books.height)],
        }
    )

    frame = build_research_frame(
        books,
        _trades(),
        _feature_config(),
        depth_deltas=depth_deltas,
    )
    at_one = frame.filter(pl.col("decision_ts_ns") == SECOND).row(0, named=True)

    assert at_one["depth_total_l5"] == pytest.approx(30.0)
    assert at_one["queue_imbalance_l5"] == pytest.approx(2.0 / 30.0)
    assert at_one["cancellation_deletes_w2"] == 1
    assert at_one["cancellation_intensity_w2"] == pytest.approx(0.25)
    assert at_one["cancellation_feature_max_source_ts_ns"] == SECOND
    assert "cancellation_intensity_w2" in model_feature_columns(frame)
    validate_temporal_contract(frame)


def test_future_event_label_is_exact_right_censored_and_gap_local() -> None:
    frame = build_research_frame(_books(), _trades(), _feature_config())
    at_two = frame.filter(pl.col("decision_ts_ns") == 2 * SECOND).row(0, named=True)
    assert at_two["future_mid_return"] == pytest.approx(math.log(102.5 / 101.5))
    assert at_two["future_mid_direction"] == 1
    assert at_two["future_mid_up"] == 1
    assert at_two["label_information_end_ts_ns"] == 4 * SECOND

    # The final two rows of segment A may not look into segment B even though
    # later book observations exist globally.
    segment_a_tail = frame.filter(
        (pl.col("continuity_id") == "segment-a") & (pl.col("decision_ts_ns") >= 4 * SECOND)
    )
    assert segment_a_tail.get_column("right_censored").to_list() == [True, True]
    assert segment_a_tail.get_column("future_mid_return").null_count() == 2

    first_b = (
        frame.filter(pl.col("continuity_id") == "segment-b")
        .sort("decision_sequence")
        .row(0, named=True)
    )
    assert first_b["ofi_l1"] == 0.0
    assert first_b["signed_trade_volume_w2"] == 0.0

    audit = validate_temporal_contract(frame)
    assert audit.rows == 9
    assert audit.right_censored_rows == 4
    assert audit.continuity_segments == 2


def test_delayed_old_continuity_trade_cannot_enter_new_segment_features() -> None:
    trades = pl.DataFrame(
        {
            "symbol": ["BTCUSDT", "BTCUSDT"],
            "continuity_id": ["segment-b", "segment-a"],
            "trade_id": [20, 21],
            "available_ts_ns": [6 * SECOND + SECOND // 4, 6 * SECOND + SECOND // 2],
            "quantity": [3.0, 100.0],
            "aggressor_side": ["sell", "buy"],
        }
    )
    frame = build_research_frame(_books(), trades, _feature_config())
    second_b = frame.filter(
        (pl.col("continuity_id") == "segment-b") & (pl.col("decision_ts_ns") == 7 * SECOND)
    ).row(0, named=True)

    assert second_b["signed_trade_volume_w2"] == pytest.approx(-3.0)
    assert second_b["trade_volume_w2"] == pytest.approx(3.0)
    assert second_b["trade_feature_max_source_ts_ns"] == 6 * SECOND + SECOND // 4


def test_unsegmented_trades_fail_closed_for_multi_segment_books() -> None:
    trades_without_continuity = _trades().drop("continuity_id")

    with pytest.raises(ResearchDataError, match="require continuity_id"):
        build_research_frame(_books(), trades_without_continuity, _feature_config())


def test_mutating_the_future_cannot_change_past_features() -> None:
    original_books = _books()
    original = build_research_frame(original_books, _trades(), _feature_config())
    mutated_books = original_books.with_columns(
        pl.when(pl.col("available_ts_ns") > 2 * SECOND)
        .then(pl.col("best_bid") + 10_000.0)
        .otherwise(pl.col("best_bid"))
        .alias("best_bid"),
        pl.when(pl.col("available_ts_ns") > 2 * SECOND)
        .then(pl.col("best_ask") + 10_000.0)
        .otherwise(pl.col("best_ask"))
        .alias("best_ask"),
    )
    mutated_trades = pl.concat(
        [
            _trades(),
            pl.DataFrame(
                {
                    "symbol": ["BTCUSDT"],
                    "continuity_id": ["segment-a"],
                    "trade_id": [99],
                    "available_ts_ns": [3 * SECOND],
                    "quantity": [1_000_000.0],
                    "aggressor_side": ["buy"],
                }
            ),
        ]
    )
    mutated = build_research_frame(mutated_books, mutated_trades, _feature_config())
    feature_columns = [
        "mid_price",
        "spread_bps",
        "queue_imbalance_l1",
        "causal_microprice",
        "ofi_l1",
        "signed_trade_volume_w2",
        "trade_volume_w2",
        "realized_volatility_w2",
    ]
    cutoff = pl.col("decision_ts_ns") <= 2 * SECOND
    assert (
        original.filter(cutoff)
        .select(feature_columns)
        .equals(mutated.filter(cutoff).select(feature_columns))
    )


def test_lineage_guard_rejects_deliberate_future_source() -> None:
    frame = build_research_frame(_books(), _trades(), _feature_config())
    leaked = frame.with_columns(
        (pl.col("feature_cutoff_ts_ns") + 1).alias("max_feature_source_ts_ns")
    )
    with pytest.raises(TemporalLeakageError, match="feature lineage"):
        validate_temporal_contract(leaked)