86 lines
2.9 KiB
Python
86 lines
2.9 KiB
Python
# hydra/regime/engine.py
|
|
import asyncio
|
|
import json
|
|
import time
|
|
from hydra.regime.detector import RegimeDetector
|
|
from hydra.logging.setup import get_logger
|
|
|
|
logger = get_logger(__name__)
|
|
|
|
_CANDLE_CHANNEL = "hydra:candle:new"
|
|
_INDICATOR_PREFIX = "hydra:indicator"
|
|
_REGIME_PREFIX = "hydra:regime"
|
|
|
|
|
|
class RegimeEngine:
|
|
def __init__(self, redis_client, detector: RegimeDetector):
|
|
self._redis = redis_client
|
|
self._detector = detector
|
|
|
|
async def _handle_event(
|
|
self, market: str, symbol: str, timeframe: str
|
|
) -> None:
|
|
try:
|
|
indicator_key = f"{_INDICATOR_PREFIX}:{market}:{symbol}:{timeframe}"
|
|
raw = self._redis.get(indicator_key)
|
|
if raw is None:
|
|
return
|
|
indicators = json.loads(raw)
|
|
close = float(indicators.get("close") or 0.0)
|
|
regime = self._detector.detect(indicators, close)
|
|
regime_key = f"{_REGIME_PREFIX}:{market}:{symbol}:{timeframe}"
|
|
await self._redis.set(regime_key, json.dumps({
|
|
"regime": regime,
|
|
"detected_at": int(time.time() * 1000),
|
|
}))
|
|
logger.debug("regime_cached", market=market, symbol=symbol,
|
|
tf=timeframe, regime=regime)
|
|
except Exception as e:
|
|
logger.warning("regime_error", market=market, symbol=symbol,
|
|
tf=timeframe, error=str(e))
|
|
|
|
async def cold_start(self) -> None:
|
|
keys = self._redis.keys(f"{_INDICATOR_PREFIX}:*")
|
|
logger.info("regime_cold_start", count=len(keys))
|
|
for key in keys:
|
|
parts = key.split(":")
|
|
if len(parts) < 5:
|
|
continue
|
|
market = parts[2]
|
|
symbol = ":".join(parts[3:-1])
|
|
timeframe = parts[-1]
|
|
await self._handle_event(market, symbol, timeframe)
|
|
|
|
async def run(self) -> None:
|
|
pubsub = self._redis.pubsub()
|
|
await pubsub.subscribe(_CANDLE_CHANNEL)
|
|
logger.info("regime_engine_subscribed", channel=_CANDLE_CHANNEL)
|
|
async for message in pubsub.listen():
|
|
if message["type"] != "message":
|
|
continue
|
|
try:
|
|
payload = json.loads(message["data"])
|
|
await self._handle_event(
|
|
payload["market"], payload["symbol"], payload["timeframe"],
|
|
)
|
|
except Exception as e:
|
|
logger.warning("regime_subscribe_error", error=str(e))
|
|
|
|
|
|
async def main() -> None:
|
|
import redis.asyncio as aioredis
|
|
from hydra.config.settings import get_settings
|
|
settings = get_settings()
|
|
r = aioredis.from_url(settings.redis_url, decode_responses=True)
|
|
detector = RegimeDetector()
|
|
engine = RegimeEngine(redis_client=r, detector=detector)
|
|
try:
|
|
await engine.cold_start()
|
|
await engine.run()
|
|
finally:
|
|
await r.aclose()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
asyncio.run(main())
|