2855e79af4
Kevin's signals are mid-long term (weeks/months) and he uploads almost
exclusively pre-market or evenings. Before this change, every such
signal hit RiskManager.outside_market_hours, got consumed off the
Redis stream, and was lost. End result: 71 emitted signals, 0 trades.
New behaviour: when RiskManager rejects with outside_market_hours,
push the signal into a Redis sorted-set keyed by next_market_open
(via Alpaca's clock API — handles weekends + holidays). A background
drain task polls the set every kevin_defer_drain_interval_s (60s);
any signal whose target <= now gets re-run through process_signal.
Safety:
- kevin_max_defer_hours (default 72h) caps signal staleness so we
don't trade on week-old views.
- Other RiskManager rejections (cooldown, kill-switch, drawdown
halt) fall through to the existing drop path.
- kevin_defer_outside_market_hours toggle defaults True; flip to
false for legacy behaviour.
Slack: new notify_deferred() emits "🕒 Meet Kevin: DEFERRED
NVDA until Mon 13:30 UTC (market closed; conviction 0.85)" instead
of the noisy outside_market_hours rejection spam.
Tests: 5 queue + 4 integration = 9 new, all 32 trade-executor tests
GREEN.
76 lines
2.7 KiB
Python
76 lines
2.7 KiB
Python
"""Defer signals that arrive outside US market hours, drain at next market open.
|
|
|
|
Kevin's signals are mid/long-term (weeks/months). A signal that lands at
|
|
Sunday 19:00 UTC should turn into a Monday-morning paper trade, not be
|
|
dropped on the floor. This queue holds (signal, target_submission_ts)
|
|
pairs in a Redis sorted-set keyed by target_submission_ts.
|
|
|
|
A background drain task in trade-executor's run() loop polls pop_due()
|
|
every ~60 s; signals whose target_submission_ts <= now are reprocessed
|
|
through the normal process_signal path.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import logging
|
|
from datetime import datetime, timezone
|
|
|
|
from redis.asyncio import Redis
|
|
|
|
from shared.schemas.trading import TradeSignal
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
DEFERRED_KEY = "kevin:deferred_signals"
|
|
|
|
|
|
class DeferredSignalQueue:
|
|
"""Redis-sorted-set wrapper. Score = target_submission_ts (epoch seconds).
|
|
Member = JSON of {"signal": <TradeSignal.model_dump>, "queued_at": <ISO>}.
|
|
"""
|
|
|
|
def __init__(self, redis: Redis) -> None:
|
|
self.redis = redis
|
|
|
|
async def defer(self, signal: TradeSignal, target_ts: datetime) -> None:
|
|
"""Add a signal to the queue, scheduled for re-submission at
|
|
``target_ts`` (usually the next market-open timestamp).
|
|
"""
|
|
member = json.dumps(
|
|
{
|
|
"signal": signal.model_dump(mode="json"),
|
|
"queued_at": datetime.now(timezone.utc).isoformat(),
|
|
}
|
|
)
|
|
await self.redis.zadd(DEFERRED_KEY, {member: target_ts.timestamp()})
|
|
|
|
async def pop_due(
|
|
self, now: datetime | None = None
|
|
) -> list[tuple[TradeSignal, datetime]]:
|
|
"""Atomically pop and return every signal whose target_ts <= now.
|
|
|
|
Returns: list of (TradeSignal, queued_at) pairs.
|
|
"""
|
|
now = now or datetime.now(timezone.utc)
|
|
cutoff = now.timestamp()
|
|
async with self.redis.pipeline(transaction=True) as pipe:
|
|
pipe.zrangebyscore(DEFERRED_KEY, min="-inf", max=cutoff)
|
|
pipe.zremrangebyscore(DEFERRED_KEY, min="-inf", max=cutoff)
|
|
members, _removed = await pipe.execute()
|
|
|
|
result: list[tuple[TradeSignal, datetime]] = []
|
|
for raw in members:
|
|
try:
|
|
if isinstance(raw, bytes):
|
|
raw = raw.decode("utf-8")
|
|
payload = json.loads(raw)
|
|
signal = TradeSignal.model_validate(payload["signal"])
|
|
queued_at = datetime.fromisoformat(payload["queued_at"])
|
|
result.append((signal, queued_at))
|
|
except Exception:
|
|
logger.exception("Failed to deserialize deferred signal: %s", raw)
|
|
return result
|
|
|
|
async def size(self) -> int:
|
|
return await self.redis.zcard(DEFERRED_KEY)
|