Download tests/test_kalshi_engine.py from bryceweiner/fly-trader: direct link, hf CLI and curl.
- Browser
- Download file 16.3 kB
-
https://huggingface.co/bryceweiner/fly-trader/resolve/main/tests/test_kalshi_engine.py
- Command line
-
hf download hf://bryceweiner/fly-trader/tests/test_kalshi_engine.py
-
curl -L -o test_kalshi_engine.py https://huggingface.co/bryceweiner/fly-trader/resolve/main/tests/test_kalshi_engine.py
16.3 kB
| """The Kalshi engine and the fly's session: minute rows become the same feature vectors the corpus builder makes from | |
| the same bars (parity), both sides of every market in the entry window pass to the books, and the plastic Kalshi fly | |
| scores, tags, trades both paper arms, and learns from a settlement when it comes.""" | |
| import json | |
| import math | |
| from datetime import datetime, timedelta, timezone | |
| import numpy as np | |
| import pytest | |
| import torch | |
| from fly_trader import config | |
| from fly_trader.db.connection import transaction | |
| from fly_trader.kalshi import engine as KE, fly as KF, fly_session as KFS, paper as P | |
| from fly_trader.kalshi.features import K_COLS, KIDX, Bar, EventState, MarketMeta, MarketState | |
| from fly_trader.train import fly_selector | |
| from tests.test_kalshi_fly import _boot, _ds, _graph | |
| T0 = datetime(2026, 9, 22, 12, 0, tzinfo=timezone.utc) | |
| TICKERS = ("TSTE-A-YES1", "TSTE-A-YES2") | |
| def _seed_markets(close: datetime): | |
| with transaction() as c: | |
| c.execute("DELETE FROM kalshi_minutes WHERE ticker LIKE 'TSTE-%'"); c.execute("DELETE FROM kalshi_markets WHERE ticker LIKE 'TSTE-%'") | |
| c.execute("DELETE FROM kalshi_events WHERE event_ticker = 'TSTE-A'"); c.execute("DELETE FROM kalshi_series WHERE ticker = 'TSTE'") | |
| c.execute("INSERT INTO kalshi_series (ticker, title, category, frequency, fee_type, fee_multiplier) VALUES ('TSTE', 't', 'Politics', 'one_off', 'quadratic', 1.0)") | |
| c.execute("INSERT INTO kalshi_events (event_ticker, series_ticker, title, category, mutually_exclusive) VALUES ('TSTE-A', 'TSTE', 'e', 'Politics', true)") | |
| for tk, strike in zip(TICKERS, (1.0, 2.0)): | |
| c.execute("INSERT INTO kalshi_markets (ticker, event_ticker, status, open_time, close_time, expected_expiration_time, floor_strike, source) " | |
| "VALUES (%s, 'TSTE-A', 'active', %s, %s, %s, %s, 'test')", (tk, T0 - timedelta(days=3), close, close + timedelta(minutes=5), strike)) | |
| def _minute_rows(minutes: int): | |
| """Both markets quoted every minute, one trade a minute on the first.""" | |
| rows = [] | |
| for k in range(minutes): | |
| ts = T0 - timedelta(minutes=minutes - k) | |
| for i, tk in enumerate(TICKERS): | |
| yb, ya = 60.0 + i * 5 + (k % 3), 63.0 + i * 5 + (k % 3) | |
| rows.append((tk, ts, yb, ya, ya - 1, 20.0, 30.0, 500.0 + k, 400.0, 3.0 if i == 0 else 0.0, 1.0 if i == 0 else 0.0, 2 if i == 0 else 0, 3.0 if i == 0 else 0.0, 0.0, ya - 0.5, yb + 0.5)) | |
| with transaction() as c: | |
| c.cursor().executemany("INSERT INTO kalshi_minutes (ticker, ts, yes_bid, yes_ask, last, bid_size, ask_size, volume_fp, open_interest_fp, taker_buy_yes, taker_buy_no, n_trades, max_trade, " | |
| "block_contracts, yes_ask_low, yes_bid_high) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)", rows) | |
| c.execute("INSERT INTO ui_settings (key, value) VALUES ('kalshi_stream_status', %s) ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value", | |
| (json.dumps({"flushed_through": (T0 - timedelta(minutes=1)).isoformat(), "connected": True}),)) | |
| return rows | |
| class Recorder: | |
| name = "recorder"; done = False | |
| def __init__(self): | |
| self.ctxs = [] | |
| def on_minute(self, ctx): | |
| self.ctxs.append((ctx.X.copy(), list(ctx.keys), ctx.hold_s.copy(), dict(ctx.extremes), ctx.n_rows)); return {"ok": True} | |
| def tickers_watched(self): | |
| return set() | |
| def maybe_reload(self): | |
| return False | |
| def finish(self): | |
| pass | |
| def test_engine_rows_match_the_feature_engine_fed_the_same_bars(monkeypatch): | |
| monkeypatch.setattr(config, "KALSHI_MIN_OPEN_INTEREST", 100); monkeypatch.setattr(config, "KALSHI_MIN_VOLUME_24H", 50) | |
| close = T0 + timedelta(days=2); _seed_markets(close); rows = _minute_rows(5) | |
| eng = KE.KalshiMinuteEngine([rec := Recorder()]) | |
| m1 = T0.timestamp() | |
| assert eng.warm_up(m1, minutes=4) == 8 and len(eng.states) == 2 and set(eng.metas) == set(TICKERS) | |
| out = eng.run_minute(m1, trade=True) | |
| assert out["markets_active"] == 2 and out["in_window"] == 2 and out["eligible"] == 4 | |
| X, keys, hold, extremes, n_rows = rec.ctxs[-1] | |
| assert keys == [(TICKERS[0], "yes"), (TICKERS[0], "no"), (TICKERS[1], "yes"), (TICKERS[1], "no")] and n_rows == 4 | |
| assert np.allclose(hold, close.timestamp() - (m1 - 60.0)) and extremes[TICKERS[0]][:2] == (pytest.approx(63.0 + (4 % 3) - 0.5), pytest.approx(60.0 + (4 % 3) + 0.5)) | |
| # parity: the same bars through a fresh MarketState / EventState give the same vectors | |
| meta = {tk: MarketMeta(tk, event_ticker="TSTE-A", series_ticker="TSTE", category="politics", open_ts=(T0 - timedelta(days=3)).timestamp(), close_ts=close.timestamp(), | |
| mutually_exclusive=1.0, fee_multiplier=1.0, maker_fee=0.0, strike=float(i + 1)) for i, tk in enumerate(TICKERS)} | |
| states = {tk: MarketState(tk) for tk in TICKERS}; ev = EventState() | |
| for r in rows: | |
| tk, ts = r[0], r[1]; t_end = ts.timestamp() + 60.0 | |
| bar = Bar(t_end, r[2], r[3], r[4], r[5], r[6], r[7], r[8], r[9], r[10], float(r[11]), r[12], r[13]) | |
| states[tk].append(bar); ev.update(tk, bar, meta[tk].strike) | |
| want = np.asarray([states[tk].features(m1, meta[tk], side, ev) for tk, side in keys], dtype=np.float32) | |
| assert np.allclose(X, want, atol=1e-5), np.abs(X - want).max(0) | |
| assert X[0, KIDX["mutually_exclusive"]] == 1.0 and X[0, KIDX["log_n_siblings"]] > 0 and X[0, KIDX["cat_politics"]] == 1.0 and X[0, KIDX["ladder_resid"]] >= 0 | |
| # a market outside the window (closing in 2 minutes) is fed but not scored | |
| with transaction() as c: | |
| c.execute("UPDATE kalshi_markets SET close_time = %s WHERE ticker = %s", (T0 + timedelta(minutes=2), TICKERS[1])) # no early-close condition: the listed close is the anchor | |
| eng.metas.clear(); eng.meta_at.clear() | |
| with transaction() as c: | |
| c.cursor().executemany("INSERT INTO kalshi_minutes (ticker, ts, yes_bid, yes_ask, volume_fp, open_interest_fp, taker_buy_yes, taker_buy_no, n_trades, max_trade, block_contracts) " | |
| "VALUES (%s,%s,60,63,600,400,0,0,0,0,0)", [(tk, T0) for tk in TICKERS]) | |
| out = eng.run_minute(m1 + 60, trade=True) | |
| assert out["in_window"] == 1 and out["eligible"] == 2 | |
| with transaction() as c: | |
| c.execute("DELETE FROM kalshi_minutes WHERE ticker LIKE 'TSTE-%'"); c.execute("DELETE FROM kalshi_markets WHERE ticker LIKE 'TSTE-%'") | |
| def _ctx(conn, m1: datetime, X, keys, hold, metas, quotes, extremes): | |
| return KE.KMinute(conn=conn, m0=m1 - timedelta(minutes=1), m1=m1, m1_epoch=m1.timestamp(), X=X, keys=keys, hold_s=hold, metas=metas, quotes=quotes, extremes=extremes, | |
| n_rows=len(keys), fresh=True, trade=True, engine=None) | |
| def _minute(book, ctx): | |
| """The fly's minute whole: its live part, then the rest (kalshi/engine.py runs them as two phases).""" | |
| book.on_minute(ctx) | |
| return book.after_minute(ctx) | |
| def test_the_live_book_trades_and_commits_before_any_paper_work(db_conn, monkeypatch): | |
| """Live money first: the live book's part of the minute runs and commits before any other book's minute; its own | |
| paper work and learning (after_minute) come last.""" | |
| calls = [] | |
| class Live: | |
| name, LIVE, done = "kalshi_fly", True, False | |
| def on_minute(self, ctx): | |
| calls.append("live"); ctx.conn.execute("INSERT INTO events (level, source, message) VALUES ('info', 'kalshi_engine_test', 'live order')") | |
| return {"live": True} | |
| def after_minute(self, ctx): | |
| calls.append("after"); return {"ok": True} | |
| def tickers_watched(self): | |
| return set() | |
| class Paper: | |
| name, done = "kalshi_paper", False | |
| def on_minute(self, ctx): | |
| calls.append("paper") | |
| with transaction() as other: # another connection: the live part is committed already | |
| self.saw = other.execute("SELECT count(*) AS n FROM events WHERE source = 'kalshi_engine_test'").fetchone()["n"] | |
| return {"ok": True} | |
| def tickers_watched(self): | |
| return set() | |
| with transaction() as c: | |
| c.execute("DELETE FROM events WHERE source = 'kalshi_engine_test'") | |
| paper, live = Paper(), Live() | |
| eng = KE.KalshiMinuteEngine([paper, live]); monkeypatch.setattr(eng, "stream_fresh", lambda t: True) | |
| out = eng.run_minute(T0.timestamp(), trade=True) | |
| with transaction() as c: | |
| c.execute("DELETE FROM events WHERE source = 'kalshi_engine_test'") | |
| assert calls == ["live", "paper", "after"] and paper.saw == 1 and out["kalshi_fly"] == {"ok": True} | |
| def test_fly_session_scores_trades_both_arms_and_learns_from_a_settlement(monkeypatch, tmp_path, db_conn): | |
| monkeypatch.setattr(fly_selector.prog, "update", lambda *a, **k: None); monkeypatch.setattr(KF.prog, "update", lambda *a, **k: None) | |
| monkeypatch.setattr(fly_selector, "EPOCHS", 2); monkeypatch.setattr(config, "BRAIN_DIR", tmp_path); monkeypatch.setattr(config, "KALSHI_LIVE_ENABLED", False) | |
| monkeypatch.setattr(config, "KALSHI_CAPITAL_USD", 100.0) | |
| monkeypatch.setattr(KF, "graph", lambda: _graph()); monkeypatch.setattr(KF, "_GRAPH", None) | |
| from fly_trader.ops import reset as R | |
| monkeypatch.setattr(R, "kalshi_fly_state_dir", lambda: tmp_path / "plastic_kalshi"); monkeypatch.setattr(R, "kalshi_activity_dir", lambda: tmp_path / "activity_kalshi") | |
| monkeypatch.setattr(KFS, "kalshi_fly_state_dir", lambda: tmp_path / "plastic_kalshi"); monkeypatch.setattr(KFS, "kalshi_activity_dir", lambda: tmp_path / "activity_kalshi") | |
| ds = _ds(days=12, per_day=300); fly, info = _boot(ds, 10) | |
| for k in fly.lines: # every candidate trades: the test is about the plumbing, not the line | |
| fly.lines[k] = -1.0; fly.sizings[k] = [{"lo": 0.0, "n": 50, "mean": 0.05, "win": 0.7, "kelly": 0.10}] | |
| info["lines"] = dict(fly.lines); info["gates_ok"] = True; info["calibration"] = {"trades": 150, "mean": 0.02} | |
| path, sid = KF.save(fly, info) | |
| with transaction() as c: | |
| c.execute("INSERT INTO ui_settings (key, value) VALUES ('kalshi_fly_replay', %s) ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value", | |
| (json.dumps({"passed": True, "data": KF.KALSHI_FLY_VERSION, "per_strategy": {k: {"alpha": 1e-3, "half_life_days": 3.0} for k in fly.strategies}}),)) | |
| c.execute("DELETE FROM kalshi_markets WHERE ticker LIKE 'TSTS-%'"); c.execute("DELETE FROM kalshi_fly_scored WHERE ticker LIKE 'TSTS-%'") | |
| c.execute("DELETE FROM kalshi_positions WHERE ticker LIKE 'TSTS-%'"); c.execute("DELETE FROM kalshi_orders WHERE ticker LIKE 'TSTS-%'") | |
| c.execute("DELETE FROM ui_settings WHERE key = 'kalshi_fly_command'") | |
| book, why = KFS.try_start() | |
| assert book is not None, why | |
| m1 = T0; close = T0 + timedelta(hours=3) | |
| metas = {"TSTS-1": MarketMeta("TSTS-1", event_ticker="E", category="politics", close_ts=close.timestamp(), maker_fee=0.0), | |
| "TSTS-2": MarketMeta("TSTS-2", event_ticker="E", category="politics", close_ts=close.timestamp(), maker_fee=0.0)} | |
| X = ds.X[:4].copy(); keys = [("TSTS-1", "yes"), ("TSTS-1", "no"), ("TSTS-2", "yes"), ("TSTS-2", "no")] | |
| for i, (tk, side) in enumerate(keys): | |
| ask = 75.0 if side == "yes" else 30.0 | |
| X[i, KIDX["side_ask"]] = ask; X[i, KIDX["side_bid"]] = ask - 2; X[i, KIDX["eff_price"]] = ask + 1.0 | |
| quotes = {"TSTS-1": (73.0, 75.0, 50.0, 50.0), "TSTS-2": (73.0, 75.0, 50.0, 50.0)} | |
| hold = np.full(4, close.timestamp() - (m1.timestamp() - 60.0)) | |
| out = _minute(book, _ctx(db_conn, m1, X, keys, hold, metas, quotes, {})) | |
| assert out["stage"] == "trading" and out["picks"] > 0 and out["pending"] > 0 | |
| n_scored = db_conn.execute("SELECT count(*) AS n FROM kalshi_fly_scored WHERE ticker LIKE 'TSTS-%' AND state = 'pending'").fetchone()["n"] | |
| assert n_scored > 0 and (out["books"]["taker"]["entered"] + out["books"]["maker"]["posted"]) > 0 | |
| assert db_conn.execute("SELECT count(*) AS n FROM wealth_marks WHERE book IN ('paper_kalshi_taker', 'paper_kalshi_maker')").fetchone()["n"] >= 2 | |
| st = json.loads(db_conn.execute("SELECT value FROM ui_settings WHERE key = 'kalshi_fly_status'").fetchone()["value"]) if isinstance(db_conn.execute( | |
| "SELECT value FROM ui_settings WHERE key = 'kalshi_fly_status'").fetchone()["value"], str) else db_conn.execute("SELECT value FROM ui_settings WHERE key = 'kalshi_fly_status'").fetchone()["value"] | |
| assert st["stage"] == "trading" and st["bootstrap"] == sid | |
| # the market settles: tags due after close learn the outcome, positions settle, labels are written | |
| db_conn.execute("INSERT INTO kalshi_markets (ticker, status, result, source) VALUES ('TSTS-1', 'settled', 'yes', 'test'), ('TSTS-2', 'settled', 'no', 'test')") | |
| d0 = float(book.bank.drift()[0]) | |
| m2 = close + timedelta(minutes=2) | |
| out2 = _minute(book, _ctx(db_conn, m2, np.zeros((0, len(K_COLS)), np.float32), [], np.zeros(0), metas, quotes, {})) | |
| assert out2["learned"]["n"] > 0 and float(book.bank.drift()[0]) > d0 and out2["pending"] == 0 | |
| resolved = db_conn.execute("SELECT state, label, strategy FROM kalshi_fly_scored WHERE ticker LIKE 'TSTS-%' AND state <> 'pending'").fetchall() | |
| assert resolved and all(r["state"] in ("resolved", "unfilled") for r in resolved) | |
| taker_labels = [r["label"] for r in resolved if book.arms[r["strategy"]] == "taker"] | |
| assert taker_labels and all(l is not None for l in taker_labels) | |
| assert all(p["status"] == "settled" for p in db_conn.execute("SELECT status FROM kalshi_positions WHERE ticker LIKE 'TSTS-%'").fetchall()) | |
| book.finish() | |
| with transaction() as c: | |
| c.execute("DELETE FROM kalshi_markets WHERE ticker LIKE 'TSTS-%'"); c.execute("DELETE FROM kalshi_fly_scored WHERE ticker LIKE 'TSTS-%'") | |
| def test_the_time_anchor_is_what_a_trader_knew_at_the_time(): | |
| """A market that may close early when its event happens is anchored on its scheduled expected expiration, never on the | |
| close recorded after the event; one without that condition closes on its listed schedule; unfetched details give no anchor.""" | |
| from fly_trader.kalshi.mature import time_anchor | |
| actual = datetime(2026, 10, 2, 11, 10, 22, tzinfo=timezone.utc); expected = datetime(2026, 10, 2, 14, 30, tzinfo=timezone.utc) | |
| assert time_anchor(actual, expected, "This market will close and expire after a winner is declared.") == expected.timestamp() | |
| assert time_anchor(actual, expected, None) == actual.timestamp() and time_anchor(actual, expected, "") == actual.timestamp() | |
| assert time_anchor(actual, None, None) is None and time_anchor(actual, None, "after a winner is declared") is None | |
| def test_an_early_closing_markets_realized_close_never_reaches_the_features(): | |
| """The engine's rows for a match market use its scheduled end: four minutes before the match actually ends it is still | |
| hours from its anchor, and the realized close only times the label (end_ts).""" | |
| close = T0 + timedelta(minutes=4); expected = T0 + timedelta(hours=3) | |
| with transaction() as c: | |
| c.execute("DELETE FROM kalshi_markets WHERE ticker LIKE 'TSTM-%%'"); c.execute("DELETE FROM kalshi_minutes WHERE ticker LIKE 'TSTM-%%'") | |
| c.execute("INSERT INTO kalshi_markets (ticker, event_ticker, status, open_time, close_time, expected_expiration_time, early_close_condition, source) " | |
| "VALUES ('TSTM-A-X', 'TSTM-A', 'active', %s, %s, %s, 'This market will close and expire after a winner is declared.', 'test')", | |
| (T0 - timedelta(days=1), close, expected)) | |
| from fly_trader.kalshi.mature import load_meta | |
| with transaction() as c: | |
| meta = load_meta(c, ["TSTM-A-X"])["TSTM-A-X"] | |
| assert meta.close_ts == expected.timestamp() and meta.end_ts == close.timestamp() | |
| st = MarketState("TSTM-A-X"); st.append(Bar(T0.timestamp(), 70.0, 72.0, 71.0, 10, 10, 50.0, 500.0, 5, 1, 2, 3, 0)) | |
| f = st.features(T0.timestamp(), meta, "yes") | |
| assert abs(np.expm1(f[KIDX["log_h_to_close"]]) - 3.0) < 1e-6 and f[KIDX["last_hour"]] == 0.0 # three hours to the anchor, not four minutes | |
| with transaction() as c: | |
| c.execute("DELETE FROM kalshi_markets WHERE ticker LIKE 'TSTM-%%'") | |