"""The console's Overview page and the 3D brain (fly_trader/ui/api/{overview,brain}.py): the narrative says what the Streamlit page said, the book's metrics, this minute's scoring, the race (hidden, racing, handed over) and the open positions answer on either chain; wealth lines are thinned but keep their last mark; the brain topics keep the payload contract (version 1 and the two-fly version 2 with /static/brain index URLs), and the playback endpoints serve a minute's raw int8 activity and one neuron's day.""" from __future__ import annotations import base64 import contextlib import json import re import uuid from datetime import datetime, timedelta, timezone import numpy as np import pytest from psycopg.types.json import Jsonb from fly_trader import config, markets from fly_trader.brain import activity, geometry from fly_trader.db.connection import transaction from fly_trader.ui.api import brain, overview from tests.test_fly_brain_view import _npz, _tsv MINT_A = "FLYmintAAAA1111111111111111111111111111pump" MINT_B = "FLYmintBBBB2222222222222222222222222222pump" @contextlib.contextmanager def setting(key: str, value): """ui_settings[key] = value (None: absent) for the block, then the row as it was.""" with transaction() as c: old = c.execute("SELECT value, updated_at FROM ui_settings WHERE key = %s", (key,)).fetchone() c.execute("DELETE FROM ui_settings WHERE key = %s", (key,)) if value is not None: c.execute("INSERT INTO ui_settings (key, value) VALUES (%s, %s)", (key, Jsonb(value))) try: yield finally: with transaction() as c: c.execute("DELETE FROM ui_settings WHERE key = %s", (key,)) if old: c.execute("INSERT INTO ui_settings (key, value, updated_at) VALUES (%s, %s, %s)", (key, Jsonb(old["value"]), old["updated_at"])) @contextlib.contextmanager def quiet(*extra: str): """No fly, no selector blob, no training, no handover on either chain: the state a stopped install shows.""" keys = ("fly_status", "fly_status_rh", "selector_status", "selector_status_rh", "training_status", "handover", "handover_rh") + extra with contextlib.ExitStack() as st: for k in keys: st.enter_context(setting(k, None)) yield @contextlib.contextmanager def seeded(marks=(), positions=()): """Insert wealth marks ``(beat_id, book, ts, wealth, exposure, n_open, drawdown)`` and positions (dicts), remove them after.""" ids = [] with transaction() as c: for beat, book, ts, w, exp, n_open, dd in marks: c.execute("INSERT INTO wealth_marks (beat_id, book, ts, wealth, exposure, n_open, drawdown) VALUES (%s, %s, %s, %s, %s, %s, %s)", (beat, book, ts, w, exp, n_open, dd)) for p in positions: cols = list(p) ids.append(c.execute(f"INSERT INTO positions ({', '.join(cols)}) VALUES ({', '.join(['%s'] * len(cols))}) RETURNING id", [p[k] for k in cols]).fetchone()["id"]) try: yield ids finally: with transaction() as c: c.execute("DELETE FROM wealth_marks WHERE beat_id = ANY(%s)", ([m[0] for m in marks],)) c.execute("DELETE FROM positions WHERE id = ANY(%s)", (ids,)) def _ok(r): assert r.status_code == 200, r.text return r.json() # ---------------------------------------------------------------- the narrative def _state(**kw) -> dict: s = {"model": {"id": 154, "run": {"threshold": 0.115, "horizon_min": 120}, "meta": {"trained_through": "2026-10-02", "horizon_min": 120, "model": {"min_age_h": 6.0, "min_resq_sol": 10.0, "min_vol_15m_sol": 5.0}}}, "market": markets.SOL, "live_money": False, "trading_why": "Trading every minute.", "fly": {"stage": "trading", "line": 0.161}, "handover": None, "training": False, "train_status": {}} return {**s, **kw} def test_narrative_says_what_the_streamlit_page_said(monkeypatch): monkeypatch.setattr(overview, "pinned_snapshot", lambda: None) paras = overview.narrative(_state()).split("\n\n") assert paras[0] == ("**Trading every minute.** The selector is paper trading with model **#154** (trained through 2026-10-02). Every minute it predicts the net " "120-minute return of each PumpSwap token that traded, at least 6.0 hours past graduation, with a pool of at least 10.0 SOL and 5.0 SOL traded " "in the last 15 minutes, and buys those predicted to make at least **+11.5%** — sized by how certain the model is (up to " f"{config.MAX_POSITION_FRACTION:.0%} of the bankroll, never the {markets.SOL.gas_reserve():g} SOL gas reserve) — and sells it **120 minutes** " "later. No real money is at risk.") assert "you pinned it" not in paras[1] and len(paras) == 3 assert paras[2] == ("**The plastic fly** races the selector on its own paper book: it buys at a predicted +16.1% and learns every minute from each scored " "token's realized return, two hours later.") monkeypatch.setattr(overview, "pinned_snapshot", lambda: 154) paras = overview.narrative(_state(live_money=True, handover={"at": "x"}, training=True, train_status={"stage": "training", "step": 3, "total": 10})).split("\n\n") assert paras[0].endswith("Trades spend real SOL from the bot wallet.") assert paras[1].endswith(" **It trades because you pinned it** (Model page); unpin it to let a current model take over.") assert paras[0].startswith("**Trading every minute.** The selector races the fly on paper with model **#154**") assert paras[2].startswith("**The plastic fly** holds the seat and trades the bot wallet live; its paper book is the mirror.") and paras[3] == "Training is running: training (3/10)." live = overview.narrative(_state(live_money=True)).split("\n\n") # live money without the handover (LIVE_WITHOUT_HANDOVER) assert "The selector picks what the bot wallet trades, live, with model **#154**" in live[0] and "paper trading" not in live[0] assert live[-1].startswith("**The plastic fly** trades the bot wallet live: it buys what the selector buys") and live[-1].endswith("races the selector for the seat.") rh = overview.narrative(_state(market=markets.RH, fly={}, trading_why="The trading engine is stopped.")).split("\n\n") assert "graduated Pons pool on Robinhood Chain (prices in ETH" in rh[0] and f"a pool of at least {markets.RH.min_resq():.3g} ETH" in rh[0] assert rh[-1] == "**The trading engine is stopped.** Start the trading engine on the Processes page to trade." assert overview.narrative(_state(model=None, fly={"stage": "not trading"}, trading_why="X.")) == "**X.** Start the trading engine on the Processes page to trade." # ---------------------------------------------------------------- summary, this minute, race, book def test_summary_metrics_follow_the_selector_book(console): with quiet(): base = _ok(console.topic("overview.summary", chain="sol")) marks = [(-81001, "paper_selector", "2100-01-01 00:00+00", 5.1, 0.1, 1, 0.0), (-81002, "paper_selector", "2100-01-01 00:01+00", 5.2, 0.2, 1, 0.0), (-81003, "paper_selector", "2100-01-01 00:02+00", 5.3, 0.25, 2, 0.0123)] now = datetime.now(timezone.utc) pos = [{"book": "paper_selector", "mint": MINT_A, "status": "closed", "realized_sol": 0.2, "cost_sol": 0.5, "closed_at": now}, {"book": "paper_selector", "mint": MINT_B, "status": "closed", "realized_sol": -0.05, "cost_sol": 0.5, "closed_at": now}] with seeded(marks, pos): d = _ok(console.topic("overview.summary", chain="sol")) cap = markets.SOL.capital() assert d["market"]["chain"] == "sol" and d["market"]["unit"] == "SOL" and d["capital"] == cap assert d["narrative"] == "**The trading engine is stopped.** Start the trading engine on the Processes page to trade." assert d["marked"] and d["wealth"] == 5.3 and d["exposure"] == 0.25 and d["n_open"] == 2 and d["drawdown"] == pytest.approx(0.0123) assert d["closed"] == base["closed"] + 2 and d["wins"] == base["wins"] + 1 and d["pnl"] == pytest.approx((base["pnl"] or 0) + 0.15) assert d["spark"][-1] == 5.3 and len(d["spark"]) <= 180 and len(d["dd_spark"]) == len(d["spark"]) assert d["pnl_spark"][-2:] == pytest.approx([d["pnl"] + 0.05, d["pnl"]]) # cumulative, ending at the total (the −0.05 trade closed last) assert d["wealth_help"] == f"Started at {cap:g} SOL; open positions valued net of exit costs." def test_this_minute_from_the_selector_blob(console): blob = {"minute": "2026-10-16T14:53:00+00:00", "mints_traded": 411, "eligible": 150, "score_max": 0.21, "threshold": 0.115, "picks": 1, "entered": 1, "exited": 2, "latency_s": 9.2, "top_scores": [[MINT_A, 0.21], [MINT_B, 0.05]]} with quiet(): d = _ok(console.topic("overview.minute", chain="sol")) assert d["minute"] is None and d["runner"] is False and d["top"] == [] console.sup.alive_set.add("runner") with transaction() as c: c.execute("INSERT INTO corpus_meta (mint, symbol) VALUES (%s, 'FLY') ON CONFLICT (mint) DO UPDATE SET symbol = 'FLY'", (MINT_A,)) try: with setting("selector_status", blob): d = _ok(console.topic("overview.minute", chain="sol")) finally: with transaction() as c: c.execute("DELETE FROM corpus_meta WHERE mint = %s", (MINT_A,)) assert d["runner"] is True and d["minute_hm"] == "14:53" and d["scored_at"] assert (d["mints_traded"], d["eligible"], d["score_max"], d["threshold"], d["picks"], d["entered"], d["exited"], d["latency_s"]) == (411, 150, 0.21, 0.115, 1, 1, 2, 9.2) assert d["top"] == [{"mint": MINT_A, "token": f"FLY · {MINT_A[:4]}…", "score": 0.21}, {"mint": MINT_B, "token": f"{MINT_B[:6]}…", "score": 0.05}] assert d["trading"] == "holding" and d["trading_why"].startswith("The market feed is stale") # the feed thread is not running mk = markets.SOL assert d["eligible_help"] == f"Pool ≥ {mk.min_resq():.3g} SOL and ≥ {mk.min_vol_15m():.3g} SOL traded in the last 15 minutes." def test_race_hidden_racing_and_handed_over(console, monkeypatch): with quiet(): real = overview.marks monkeypatch.setattr(overview, "marks", lambda *a, **k: []) assert _ok(console.topic("overview.race", chain="sol")) == {"hidden": True, "unit": "SOL"} monkeypatch.setattr(overview, "marks", real) base = {m["book"]: m for m in _ok(console.topic("overview.race", chain="sol")).get("metrics") or []} now = datetime.now(timezone.utc) marks = [(-82001, "paper_selector", now - timedelta(days=3), 5.0, 0, 0, 0), (-82002, "paper_fly", now - timedelta(days=3), 5.0, 0, 0, 0), (-82003, "paper_selector", now - timedelta(days=1), 5.4, 0, 0, 0), (-82004, "paper_fly", now - timedelta(days=1), 5.2, 0, 0, 0)] pos = [{"book": b, "mint": m, "status": "closed", "realized_sol": r, "cost_sol": 0.5, "closed_at": now - timedelta(days=2)} for b, m, r in (("paper_selector", MINT_A, 0.4), ("paper_fly", MINT_A, 0.1), ("paper_fly", MINT_B, 0.1), ("paper_fly", "OLDmint", 9.0))] pos[-1]["closed_at"] = now - timedelta(days=20) # outside the 14 days with seeded(marks, pos): d = _ok(console.topic("overview.race", chain="sol")) with setting("handover", {"at": (now - timedelta(hours=3)).isoformat(), "fly_pnl_sol": 0.5, "selector_pnl_sol": 0.25, "days": 14}): h = _ok(console.topic("overview.race", chain="sol")) assert d["hidden"] is False and d["handover"] is False and d["success"] is None assert re.fullmatch(r"The fly takes the seat when its realized P&L over the last 14 days is at least the selector's, with at least 30 trades · racing for \d+\.\d days\.", d["caption"]) m = {x["book"]: x for x in d["metrics"]} assert [x["title"] for x in d["metrics"]] == ["Selector · 14 days", "Fly · 14 days"] assert m["paper_selector"]["n"] == base.get("paper_selector", {}).get("n", 0) + 1 and m["paper_fly"]["n"] == base.get("paper_fly", {}).get("n", 0) + 2 assert m["paper_fly"]["pnl"] == pytest.approx((base.get("paper_fly", {}).get("pnl") or 0) + 0.2) assert len(d["days"]) == 15 and all(len(x["daily"]) == 15 for x in d["metrics"]) assert sum(m["paper_fly"]["daily"]) == pytest.approx(m["paper_fly"]["pnl"]) and sum(m["paper_selector"]["daily"]) == pytest.approx(m["paper_selector"]["pnl"]) names = [s["name"] for s in d["series"]] assert names == [b for b in ("paper_selector", "paper_fly", "live") if b in names] and {"paper_selector", "paper_fly"} <= set(names) assert h["handover"] is True and h["caption"] is None and [x["title"] for x in h["metrics"]][-1] == "Live · 14 days" assert h["success"] == ("The fly took the selector's seat 3.0 h ago: +0.5 SOL vs +0.25 SOL over 14 days. " "Live trading waits for LIVE_ENABLED=1, the live prerequisites and a funded wallet.") def test_book_lists_open_positions_and_the_wealth_line(console): now = datetime.now(timezone.utc) pos = [{"book": "paper_selector", "mint": MINT_A, "status": "open", "cost_sol": 0.5, "entry_price": 1.0, "last_mark_price": 1.1, "hold_s": 1800, "opened_at": now - timedelta(minutes=10)}, {"book": "paper_selector", "mint": MINT_B, "status": "open", "cost_sol": 0.25, "entry_price": None, "last_mark_price": None, "hold_s": None, "opened_at": now - timedelta(minutes=12), "strategy": "capitulation"}] marks = [(-83001, "paper_selector", "2100-01-02 00:00+00", 6.0, 0, 0, 0), (-83002, "paper_selector", "2100-01-02 00:01+00", 6.5, 0, 0, 0)] with quiet(), seeded(marks, pos): d = _ok(console.topic("overview.book", chain="sol")) assert d["unit"] == "SOL" and d["history"][-2:] == [["2100-01-02T00:00:00+00:00", 6.0], ["2100-01-02T00:01:00+00:00", 6.5]] rows = {r["mint"]: r for r in d["positions"]} a, b = rows[MINT_A], rows[MINT_B] assert a["token"] == f"{MINT_A[:6]}…" and a["strategy"] == "—" and a["held_min"] == pytest.approx(10, abs=0.2) and a["exits_in_min"] == pytest.approx(20, abs=0.2) assert a["cost"] == 0.5 and a["ret"] == pytest.approx(10.0) assert b["strategy"] == "capitulation" and b["ret"] is None and b["exits_in_min"] == pytest.approx(30 - 12, abs=0.2) # no hold_s: the model's horizon, else 30 def test_sell_now_sells_a_live_position_through_its_chains_mirror(console, monkeypatch): """Sell Now (``overview.sell_now``): refused while the wallet may not sign (a test never signs) and for a position not open in the chain's live book; else the chain's mirror sells it, and the message says what the booked sale brought.""" from types import SimpleNamespace from fly_trader.agent import live_first class Mirror: sold: list = [] def sell_now(self, conn, position_id): # the sale, filled and booked at once: +0.01 SOL on 0.2 self.sold.append(position_id) conn.execute("UPDATE positions SET status = 'closed', closed_at = now(), realized_sol = 0.01 WHERE id = %s", (position_id,)) return 0 def sale_result(self, did, timeout): return SimpleNamespace(ok=True, error=None) pos = [{"book": "live", "mint": MINT_A, "status": "open", "cost_sol": 0.2, "entry_price": 1.0, "opened_at": datetime.now(timezone.utc)}] monkeypatch.setitem(live_first._MIRRORS, "sol", Mirror()) with seeded(positions=pos) as (pid,): r = console.act("overview.sell_now", {"chain": "sol", "position_id": pid}) assert r.status_code == 409 and "may not sign" in r.json()["error"] and Mirror.sold == [] monkeypatch.setattr(live_first, "signing_refused", lambda chain: None) assert console.act("overview.sell_now", {"chain": "sol", "position_id": -1}).status_code == 404 monkeypatch.setattr(config, "RH_ENABLED", True) assert console.act("overview.sell_now", {"chain": "rh", "position_id": pid}).status_code == 404 # not in Robinhood Chain's live book d = _ok(console.act("overview.sell_now", {"chain": "sol", "position_id": pid})) assert d["message"] == f"Sold {MINT_A[:6]}…: +0.01 SOL (+5.0%)" and d["booked"] and Mirror.sold == [pid] r = console.act("overview.sell_now", {"chain": "sol", "position_id": pid}) assert r.status_code == 409 and "no longer open" in r.json()["error"] and Mirror.sold == [pid] def test_wealth_lines_are_thinned_but_end_at_the_last_mark(): t0 = datetime(2100, 2, 1, tzinfo=timezone.utc) marks = [(-84000 - i, "test_overview_thin", t0 + timedelta(minutes=i), 1.0 + i / 100, 0, 0, 0) for i in range(60)] with seeded(marks): raw = overview.marks(["test_overview_thin"], points=100) thin = overview.marks(["test_overview_thin"], points=10) assert len(raw) == 60 and [r["wealth"] for r in raw] == [m[3] for m in marks] assert 8 <= len(thin) <= 12 and thin[-1]["ts"] == marks[-1][2] and thin[-1]["wealth"] == pytest.approx(marks[-1][3]) assert [r["ts"] for r in thin] == sorted(r["ts"] for r in thin) def test_overview_answers_on_robinhood_chain(console, monkeypatch): """The page follows the chain picker: Robinhood Chain's books and unit (test_rh_ui rendered overview.py on both chains).""" monkeypatch.setattr(config, "RH_ENABLED", True) with quiet(): s = _ok(console.topic("overview.summary", chain="rh")) m = _ok(console.topic("overview.minute", chain="rh")) r = _ok(console.topic("overview.race", chain="rh")) b = _ok(console.topic("overview.book", chain="rh")) assert s["market"]["chain"] == "rh" and s["market"]["selector_book"] == "paper_rh_selector" and s["wealth_help"].endswith("ETH; open positions valued net of exit costs.") assert m["unit"] == "ETH" and "ETH traded in the last 15 minutes" in m["eligible_help"] assert r["unit"] == "ETH" and b["unit"] == "ETH" monkeypatch.setattr(config, "RH_ENABLED", False) # RH off: the picker's choice falls back to Solana assert _ok(console.topic("overview.summary", chain="rh"))["market"]["chain"] == "sol" # ---------------------------------------------------------------- setups by day def test_a_tokens_picks_are_one_setup_until_a_gap_and_its_trades_count_on_their_day(): t = datetime(2026, 10, 10, 3, 0, tzinfo=timezone.utc) picks = [("paper_selector", "A", t, True), ("paper_selector", "A", t + timedelta(minutes=10), False), # one setup, taken ("paper_selector", "A", t + timedelta(minutes=50), False), # 40 minutes on: a new one, vetoed ("paper_selector", "B", t + timedelta(hours=20, minutes=55), False), ("paper_selector", "B", t + timedelta(hours=21, minutes=10), True), # over midnight ("paper_rh_selector", "C", t, True)] per = overview.setups_by_day(picks) assert per[("paper_selector", t.date())] == {"setups": 3, "trades": 1} assert per[("paper_selector", (t + timedelta(days=1)).date())] == {"setups": 0, "trades": 1} assert per[("paper_rh_selector", t.date())] == {"setups": 1, "trades": 1} assert overview._is_pick("selector_enter", None) and overview._is_pick("blocked", "dump veto (P(≤-17 %) ≥ 0.43)") assert not overview._is_pick("blocked", "held") and not overview._is_pick("selector_exit", None) def test_setups_topic_counts_todays_picks_and_marks_the_days_the_selector_did_not_run(console, monkeypatch, tmp_path): monkeypatch.setattr(config, "PG_ARCHIVE_DIR", tmp_path) # no reset archives now = datetime.now(timezone.utc).replace(second=0, microsecond=0); run = str(uuid.uuid4()); mint = f"FLYsetup{uuid.uuid4().hex[:8]}" book = {"book": "paper_selector"} with transaction() as c: c.execute("INSERT INTO runs (run_id, kind, config) VALUES (%s, 'selector', %s)", (run, Jsonb(book))) c.execute("INSERT INTO beats (run_id, ts, beat_no) VALUES (%s, %s, 1)", (run, now)) c.execute("INSERT INTO decisions (ts, kind, mint, detail) VALUES (%s, 'selector_enter', %s, %s)", (now, mint, Jsonb(book))) c.execute("INSERT INTO decisions (ts, kind, mint, rail, reason, detail) VALUES (%s, 'blocked', %s, 'held', 'selector pick not taken', %s)", (now + timedelta(minutes=1), mint, Jsonb(book))) # a re-pick of the held token: no new setup try: before = {r["day"]: r for r in _ok(console.topic("overview.setups"))["chains"][0]["days"]} with transaction() as c: c.execute("DELETE FROM decisions WHERE mint = %s", (mint,)) after = {r["day"]: r for r in _ok(console.topic("overview.setups"))["chains"][0]["days"]} finally: with transaction() as c: c.execute("DELETE FROM decisions WHERE mint = %s", (mint,)); c.execute("DELETE FROM beats WHERE run_id = %s", (run,)) c.execute("DELETE FROM runs WHERE run_id = %s", (run,)) today = now.date().isoformat() assert len(before) == 30 and list(before)[-1] == today and before[today]["ran"] > 0 assert (before[today]["setups"] - after[today]["setups"], before[today]["trades"] - after[today]["trades"]) == (1, 1) quiet_day = (now - timedelta(days=29)).date().isoformat() assert before[quiet_day]["ran"] > 0 or before[quiet_day]["setups"] is None # no bar on a day the selector book did not run # ---------------------------------------------------------------- the brain T0 = datetime(2026, 10, 16, 14, 0, tzinfo=timezone.utc).timestamp() META = {"connectome_sha256": "abc", "connectome_file": "c.npz", "n": 6, "pop_ranges": {"KC": [0, 2], "MBON_APP": [2, 3], "MBON_AV": [3, 4]}, "coverage": {"centroid": 2}} META_FULL = {"connectome_sha256": "abc", "connectome_file": "c.npz", "n": 8, "pop_ranges": {"KC": [0, 2], "MBON_APP": [2, 3], "MBON_AV": [3, 4]}, "flies": {"memecoin": {"n": 6, "index": "index_memecoin.bin"}, "kalshi": {"n": 6, "index": "index_kalshi.bin"}}} @pytest.fixture def brain_dirs(tmp_path, monkeypatch): """Each fly's activity and state directories under tmp_path, the brain caches cleared.""" d = {"memecoin": (tmp_path / "act", tmp_path / "plastic"), "kalshi": (tmp_path / "act_k", tmp_path / "plastic_k")} monkeypatch.setattr(brain, "_dirs", lambda fly: d[fly]) monkeypatch.setattr(brain, "activity_dir", lambda: d["memecoin"][0]) monkeypatch.setattr(brain, "geometry", lambda: META) monkeypatch.setattr(brain, "geometry_full", lambda: META_FULL) for fn in (brain.minutes, brain.activity_at, brain.neuron_history): fn.cache_clear() return d def _write(d, minute: int, values, *, n_rows=40, n_cand=7, connectome="c.npz"): activity.write(d, T0 + 60 * minute, np.asarray(values, dtype=np.int8), n_rows=n_rows, n_cand=n_cand, connectome=connectome) def test_activity_endpoint_serves_a_minute_as_raw_int8(console, brain_dirs): d = brain_dirs["memecoin"][0] _write(d, 0, [1, 2, 3, 4, 5, 6]); _write(d, 1, [-127, 0, 127, 9, 8, 7], n_cand=0) r = console.get("/api/brain/activity/memecoin/20261016T1401") assert r.status_code == 200 and r.headers["content-type"] == "application/octet-stream" assert np.frombuffer(r.content, dtype=np.int8).tolist() == [-127, 0, 127, 9, 8, 7] assert (r.headers["x-minute"], r.headers["x-rows"], r.headers["x-candidates"], r.headers["x-connectome"]) == ("2026-10-16T14:01:00+00:00", "40", "0", "c.npz") assert "immutable" in r.headers["cache-control"] for bad in ("/api/brain/activity/memecoin/20261016T1402", "/api/brain/activity/memecoin/..%2F..%2Fx", "/api/brain/activity/memecoin/2026101", "/api/brain/activity/dog/20261016T1401"): assert console.get(bad).status_code == 404, bad assert console.get("/api/brain/activity/kalshi/20261016T1401").status_code == 404 # the Kalshi fly keeps its own minutes def test_neuron_endpoint_returns_a_neurons_day(console, brain_dirs): d = brain_dirs["kalshi"][0] for k in range(3): _write(d, k, [k, 10 * k, -k, 0, 0, 0], n_cand=k) r = _ok(console.get("/api/brain/neuron/kalshi/1")) assert r["fly"] == "kalshi" and r["index"] == 1 assert r["series"] == [{"t": f"2026-10-16T14:0{k}:00+00:00", "v": 10 * k, "candidates": k} for k in range(3)] assert _ok(console.get("/api/brain/neuron/kalshi/99"))["series"] == [] # beyond the sub-graph: no points assert _ok(console.get("/api/brain/neuron/memecoin/0"))["series"] == [] # no minutes on disk assert console.get("/api/brain/neuron/kalshi/-1").status_code == 404 and console.get("/api/brain/neuron/dog/1").status_code == 404 def test_brain_memecoin_topic_keeps_the_version_1_contract(console, brain_dirs): d = brain_dirs["memecoin"][0] with quiet(): p = _ok(console.topic("brain.memecoin", mode="bootstrap")) assert p["message"] == "The fly is not running: this is the resting brain." and p["activity_b64"] is None and p["minutes"] == [] _write(d, 0, [0] * 6); _write(d, 1, [1, -2, 3, -4, 5, -6]) brain.minutes.cache_clear() with setting("fly_status", {"stage": "trading", "bootstrap": 987654321, "channels": {"ev": [0.0, None], "capitulation": [0.0001, 1.0]}, "drift_by_strategy": {"ev": 0.0, "capitulation": 0.0002}}): p = _ok(console.topic("brain.memecoin", mode="24h")) assert p["version"] == 1 and p["fly"] == "memecoin" and p["running"] is True and p["message"] is None assert p["geometry"] == {"url": "/static/brain/geometry.bin?v=abc", "meta_url": "/static/brain/geometry.json?v=abc", "sha": "abc", "n": 6} assert p["minutes"] == ["20261016T1400", "20261016T1401"] and p["stamp"] == "20261016T1401" and p["minute"] == "2026-10-16T14:01:00+00:00" assert np.frombuffer(base64.b64decode(p["activity_b64"]), dtype=np.int8).tolist() == [1, -2, 3, -4, 5, -6] and (p["rows"], p["candidates"]) == (40, 7) assert p["strategies"] == ["ev", "capitulation"] and p["emphasis"] == ["KC", "MBON_APP", "MBON_AV", "MBON_OTHER"] assert p["pathways"]["mode"] == "24h" and p["pathways"]["items"] == [] and p["pathways"]["note"] == "the fly's bootstrap file is missing" rest = ("drift ev 0.00%, capitulation 0.02% · no KC→MBON synapse has changed yet · the fly's bootstrap file is missing · " "ev: channel does not learn (α = 0), so its pathways never change · 2 neurons without a recorded position sit at their population's centroid") assert p["caption_rest"] == rest and p["caption"] == "16 Oct 14:01 UTC: mean activity over 7 candidate rows of 40 eligible · " + rest assert p["fly_detail"]["bootstrap"] == 987654321 assert console.topic("brain.memecoin", mode="bogus").status_code == 400 def test_brain_memecoin_topic_flags_a_foreign_connectome_and_a_missing_geometry(console, brain_dirs, monkeypatch): _write(brain_dirs["memecoin"][0], 0, [1] * 6, connectome="other.npz") with quiet(): p = _ok(console.topic("brain.memecoin")) assert p["activity_b64"] is None and p["minute"] is None and p["message"] == "this minute's activity was recorded on another connectome" assert p["minutes"] == ["20261016T1400"] and p["pathways"]["key"] == "bootstrap:none" def gone(): raise FileNotFoundError("connectome missing") monkeypatch.setattr(brain, "geometry", gone) assert _ok(console.topic("brain.memecoin")) == {"version": 1, "unavailable": "No brain to draw: connectome missing"} def test_brain_flies_topic_places_each_fly_and_flags_a_foreign_connectome(console, brain_dirs): """Port of test_kalshi_ui's payload_flies contract: each fly's index map URL (now /static/brain/...), its own minute, and a fly whose minute was recorded on another connectome reported in the message instead of drawn.""" _write(brain_dirs["memecoin"][0], 5, [0, 1, 2, 3, 4, 5]) _write(brain_dirs["kalshi"][0], 3, [9] * 6, connectome="other.npz") with quiet(): p = _ok(console.topic("brain.flies", mode="bootstrap")) assert p["version"] == 2 and p["geometry"] == {"url": "/static/brain/geometry_full.bin?v=abc", "meta_url": "/static/brain/geometry_full.json?v=abc", "sha": "abc:full", "n": 8} m, k = p["flies"] assert [m["name"], k["name"]] == ["memecoin", "kalshi"] and "central_owner" not in p # the browser picks the central owner assert m["index"] == {"url": "/static/brain/index_memecoin.bin?v=abc", "n": 6} and k["index"] == {"url": "/static/brain/index_kalshi.bin?v=abc", "n": 6} assert np.frombuffer(base64.b64decode(m["activity_b64"]), dtype=np.int8).tolist() == list(range(6)) and m["candidates"] == 7 and m["minute"].startswith("2026-10-16T14:05") assert m["minutes"] == ["20261016T1405"] and m["stamp"] == "20261016T1405" and m["n"] == 6 and m["note"] is None assert k["activity_b64"] is None and k["minutes"] == ["20261016T1403"] and k["note"] == "kalshi: this minute's activity was recorded on another connectome" assert p["message"] == "kalshi: this minute's activity was recorded on another connectome" assert p["caption"] == "memecoin: 14:05 UTC, 7 candidates of 40 rows · kalshi: no minute" assert all(f["pathways"]["key"] == "bootstrap:none" and f["running"] is False for f in p["flies"]) json.dumps(p) def test_brain_flies_topic_rests_when_neither_fly_has_scored(console, brain_dirs): with quiet(): p = _ok(console.topic("brain.flies")) assert p["message"] == "Neither fly has scored a minute yet: this is the resting brain." and all(f["activity_b64"] is None for f in p["flies"]) def test_full_geometry_maps_each_fly_into_the_whole_brain(tmp_path, monkeypatch): """The whole-brain geometry the flies view draws carries a sub→full index map per fly (ported from test_kalshi_ui).""" npz, tsv, out = tmp_path / "c.npz", tmp_path / "ann.tsv", tmp_path / "static" _npz(npz, "sha-f"); _tsv(tsv) monkeypatch.setattr(geometry, "FLY_EXCLUDES", {"memecoin": ("VISUAL",), "kalshi": ("OTHER",)}) m = geometry.build_full_geometry(out, npz, tsv) xyz = np.frombuffer((out / "geometry_full.bin").read_bytes(), dtype=np.float32).reshape(-1, 3) assert m["n"] == 8 and xyz.shape == (8, 3) and m["excluded"] == [] and m["pop_ranges"]["VISUAL"] == [4, 6] mi = np.frombuffer((out / m["flies"]["memecoin"]["index"]).read_bytes(), dtype=np.int32); ki = np.frombuffer((out / m["flies"]["kalshi"]["index"]).read_bytes(), dtype=np.int32) assert mi.tolist() == [0, 1, 2, 3, 6, 7] and m["flies"]["memecoin"]["n"] == 6 and ki.tolist() == [0, 1, 2, 3, 4, 5] and m["flies"]["kalshi"]["n"] == 6 mt = (out / "geometry_full.bin").stat().st_mtime_ns assert geometry.build_full_geometry(out, npz, tsv) == m and (out / "geometry_full.bin").stat().st_mtime_ns == mt assert geometry.build_geometry(out, npz, tsv)["n"] == 6 and (out / "geometry.bin").exists()