122 lines
3.9 KiB
Python
122 lines
3.9 KiB
Python
"""In-memory market data manager with rolling OHLCV windows.
|
|
|
|
Maintains a per-ticker deque of recent bars and computes technical
|
|
indicators (SMA, RSI) on demand when building ``MarketSnapshot`` objects.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections import deque
|
|
from typing import Any
|
|
|
|
from shared.schemas.trading import MarketSnapshot, OHLCVBar
|
|
|
|
|
|
# Default rolling-window sizes
|
|
_DEFAULT_MAX_BARS = 100
|
|
_RSI_PERIOD = 14
|
|
|
|
|
|
class MarketDataManager:
|
|
"""Manages in-memory rolling windows of OHLCV bars per ticker.
|
|
|
|
Parameters
|
|
----------
|
|
max_bars:
|
|
Maximum number of bars to retain per ticker.
|
|
"""
|
|
|
|
def __init__(self, max_bars: int = _DEFAULT_MAX_BARS) -> None:
|
|
self.max_bars = max_bars
|
|
self._bars: dict[str, deque[OHLCVBar]] = {}
|
|
|
|
# ------------------------------------------------------------------
|
|
# Public API
|
|
# ------------------------------------------------------------------
|
|
|
|
def add_bar(self, ticker: str, bar_data: dict[str, Any] | OHLCVBar) -> None:
|
|
"""Append a bar to the rolling window for *ticker*.
|
|
|
|
``bar_data`` can be a dict (parsed from JSON) or an ``OHLCVBar``
|
|
instance.
|
|
"""
|
|
if isinstance(bar_data, dict):
|
|
bar = OHLCVBar.model_validate(bar_data)
|
|
else:
|
|
bar = bar_data
|
|
|
|
if ticker not in self._bars:
|
|
self._bars[ticker] = deque(maxlen=self.max_bars)
|
|
self._bars[ticker].append(bar)
|
|
|
|
def get_snapshot(self, ticker: str) -> MarketSnapshot | None:
|
|
"""Build a ``MarketSnapshot`` from the rolling window.
|
|
|
|
Returns ``None`` if no bars have been recorded for *ticker*.
|
|
"""
|
|
bars = self._bars.get(ticker)
|
|
if not bars:
|
|
return None
|
|
|
|
latest = bars[-1]
|
|
closes = [b.close for b in bars]
|
|
|
|
return MarketSnapshot(
|
|
ticker=ticker,
|
|
current_price=latest.close,
|
|
open=latest.open,
|
|
high=latest.high,
|
|
low=latest.low,
|
|
close=latest.close,
|
|
volume=latest.volume,
|
|
sma_20=self._compute_sma(closes, 20),
|
|
sma_50=self._compute_sma(closes, 50),
|
|
rsi=self._compute_rsi(closes, _RSI_PERIOD),
|
|
bars=[b.model_dump(mode="json") for b in bars],
|
|
)
|
|
|
|
def has_ticker(self, ticker: str) -> bool:
|
|
"""Return ``True`` if at least one bar exists for *ticker*."""
|
|
return ticker in self._bars and len(self._bars[ticker]) > 0
|
|
|
|
# ------------------------------------------------------------------
|
|
# Technical indicator helpers
|
|
# ------------------------------------------------------------------
|
|
|
|
@staticmethod
|
|
def _compute_sma(closes: list[float], period: int) -> float | None:
|
|
"""Compute the simple moving average over the last *period* closes.
|
|
|
|
Returns ``None`` if there are fewer than *period* data points.
|
|
"""
|
|
if len(closes) < period:
|
|
return None
|
|
return sum(closes[-period:]) / period
|
|
|
|
@staticmethod
|
|
def _compute_rsi(closes: list[float], period: int = 14) -> float | None:
|
|
"""Compute the standard RSI over the last *period+1* closes.
|
|
|
|
Uses the average-gain / average-loss method. Returns ``None`` if
|
|
there are not enough data points (need at least ``period + 1``
|
|
closes to compute ``period`` deltas).
|
|
"""
|
|
if len(closes) < period + 1:
|
|
return None
|
|
|
|
# Only use the most recent period+1 closes
|
|
relevant = closes[-(period + 1):]
|
|
deltas = [relevant[i + 1] - relevant[i] for i in range(len(relevant) - 1)]
|
|
|
|
gains = [d for d in deltas if d > 0]
|
|
losses = [-d for d in deltas if d < 0]
|
|
|
|
avg_gain = sum(gains) / period if gains else 0.0
|
|
avg_loss = sum(losses) / period if losses else 0.0
|
|
|
|
if avg_loss == 0:
|
|
return 100.0 # No losses -> RSI is 100
|
|
|
|
rs = avg_gain / avg_loss
|
|
rsi = 100.0 - (100.0 / (1.0 + rs))
|
|
return round(rsi, 4)
|