972 lines
42 KiB
Python
972 lines
42 KiB
Python
"""全局实时行情服务。
|
|
|
|
集中管理全市场行情拉取 + enriched 缓存，供盘中选股、自选股等所有模块复用。
|
|
|
|
架构:
|
|
- 后台线程轮询 TickFlow get_by_universes(["CN_Equity_A", "CN_Index"])
|
|
- 拉取行情 → 写 kline_daily (不复权) + 增量计算 enriched → 写盘 + 更新缓存
|
|
- _enriched_cache 是唯一的盘中数据源 (OHLCV + 全套技术指标)
|
|
- _live_agg_cache 是递推状态 (只加载一次, 盘中不变)
|
|
|
|
数据流 (每轮 ~15s):
|
|
1. API 拉取 → raw_records (临时变量)
|
|
2. raw_records → 写 kline_daily (不复权原始价格)
|
|
3. raw_records → 更新 _enriched_cache 的 OHLCV
|
|
4. 增量计算 enriched 指标 (~50ms)
|
|
5. 写 kline_daily_enriched + 替换 _enriched_cache
|
|
6. 通知 SSE
|
|
|
|
生命周期:
|
|
- 服务启动时读取 preferences，若 enabled 则自动启动线程
|
|
- 运行中可通过 API 切换开关
|
|
- 关闭时停止线程
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import threading
|
|
import time
|
|
from datetime import date, datetime, time as dt_time
|
|
|
|
import polars as pl
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class QuoteService:
|
|
"""全局实时行情服务 — 单例。"""
|
|
|
|
CORE_INDEX_SYMBOLS = ("000001.SH", "399001.SZ", "399006.SZ", "000680.SH")
|
|
|
|
# 档位 → 最小轮询间隔 (秒)
|
|
TIER_MIN_INTERVAL = {
|
|
"expert": 1.0,
|
|
"pro": 2.0,
|
|
"starter": 3.0,
|
|
"free": 6.0,
|
|
}
|
|
DEFAULT_INTERVAL = 10.0
|
|
MAX_INTERVAL = 60.0
|
|
|
|
def __init__(self) -> None:
|
|
self._lock = threading.Lock()
|
|
self._running = False
|
|
self._enabled = False # 全局开关 (持久化到 preferences)
|
|
self._interval = self.DEFAULT_INTERVAL
|
|
self._thread: threading.Thread | None = None
|
|
self._repo = None # 延迟注入, 避免循环导入
|
|
self._update_event = threading.Event() # SSE 通知: 行情更新后 set
|
|
self._alert_event = threading.Event() # SSE 通知: 有告警时 set
|
|
self._depth_update_event = threading.Event() # SSE 通知: depth 五档修正后 set (刷新连板梯队)
|
|
self._pending_alerts: list[dict] = [] # 待推送的告警
|
|
self._max_pending_alerts: int = 1000 # 背压上限: 超出丢弃最旧
|
|
# 复盘进度 SSE 通道: 定时复盘流式生成时, 把 meta/delta/done 事件推给开着页面的前端
|
|
self._review_event = threading.Event() # SSE 通知: 有复盘进度事件时 set
|
|
self._pending_review: list[str] = [] # 待推送的复盘事件(JSON 字符串)
|
|
self._max_pending_review: int = 200 # 背压上限: 超出丢弃最旧
|
|
self._strategy_monitor = None # 延迟注入
|
|
self._app_state = None # 延迟注入 (FastAPI app.state)
|
|
|
|
# 拉取元信息 (给 SSE / status 用)
|
|
self._fetch_time: float = 0.0 # perf_counter (用于计算 quote_age_ms)
|
|
self._fetch_ms: float = 0.0 # 拉取耗时 (毫秒)
|
|
self._fetched_at: float = 0.0 # 拉取完成的 Unix 时间戳 (毫秒)
|
|
self._symbol_count: int = 0
|
|
self._index_symbol_count: int = 0
|
|
self._etf_symbol_count: int = 0
|
|
self._index_quotes_cache: pl.DataFrame | None = None
|
|
|
|
# ================================================================
|
|
# 生命周期
|
|
# ================================================================
|
|
|
|
def start(self, interval: float = 0.0) -> None:
|
|
"""启动后台行情轮询线程。"""
|
|
if self._running:
|
|
return
|
|
if interval <= 0:
|
|
from app.services import preferences
|
|
interval = preferences.get_realtime_quote_interval()
|
|
self._interval = self._clamp_interval(interval)
|
|
self._running = True
|
|
self._enabled = True
|
|
self._thread = threading.Thread(target=self._poll_loop, daemon=True)
|
|
self._thread.start()
|
|
self._save_enabled(True)
|
|
logger.info("行情服务已启动, 轮询间隔 %.1fs", self._interval)
|
|
|
|
def stop(self) -> None:
|
|
"""停止后台行情轮询线程。"""
|
|
self._running = False
|
|
self._enabled = False
|
|
if self._thread:
|
|
self._thread.join(timeout=10)
|
|
self._thread = None
|
|
self._save_enabled(False)
|
|
logger.info("行情服务已停止")
|
|
|
|
def enable(self) -> bool:
|
|
"""开启自动行情 (不立即启动线程，等下一个交易时段)。
|
|
|
|
none 档无实时行情权限,拒绝开启并返回 False;
|
|
free 档开启自选股实时,starter+ 开启全市场实时。返回值表示是否真正开启。
|
|
"""
|
|
if not self.is_realtime_allowed():
|
|
logger.warning("实时行情开启被拒:当前档位(none)无实时行情权限")
|
|
return False
|
|
self._enabled = True
|
|
self._save_enabled(True)
|
|
if not self._running:
|
|
from app.services import preferences
|
|
self._interval = self._clamp_interval(preferences.get_realtime_quote_interval())
|
|
self._running = True
|
|
self._thread = threading.Thread(target=self._poll_loop, daemon=True)
|
|
self._thread.start()
|
|
logger.info("行情服务已启用, 轮询间隔 %.1fs", self._interval)
|
|
|
|
def disable(self) -> None:
|
|
"""关闭自动行情。"""
|
|
self.stop()
|
|
logger.info("行情服务已关闭")
|
|
|
|
def boot_check(self) -> None:
|
|
"""启动时检查 preferences，若 enabled 则自动启动。
|
|
|
|
none 档无实时行情权限:即使 preferences 标记为 enabled,
|
|
也不启动,并同步 preferences 为关闭(避免 UI 误显示已开启)。
|
|
"""
|
|
from app.services import preferences
|
|
if not self.is_realtime_allowed():
|
|
if preferences.get_realtime_quotes_enabled():
|
|
self._save_enabled(False)
|
|
logger.info("实时行情未启动:当前档位(none)无实时行情权限")
|
|
return
|
|
if preferences.get_realtime_quotes_enabled():
|
|
self.start()
|
|
|
|
def set_repo(self, repo) -> None:
|
|
"""注入 KlineRepository, 用于实时落盘。"""
|
|
self._repo = repo
|
|
|
|
def set_app_state(self, app_state) -> None:
|
|
"""注入 FastAPI app.state, 用于获取 strategy_monitor 等单例。"""
|
|
self._app_state = app_state
|
|
|
|
def set_interval(self, interval: float) -> float:
|
|
"""运行时更新轮询间隔（立即生效）。"""
|
|
clamped = self._clamp_interval(interval)
|
|
self._interval = clamped
|
|
from app.services import preferences
|
|
preferences.set_realtime_quote_interval(clamped)
|
|
logger.info("轮询间隔已更新为 %.1fs", clamped)
|
|
return clamped
|
|
|
|
def get_min_interval(self) -> float:
|
|
"""返回当前档位允许的最小间隔。"""
|
|
return self._tier_min_interval()
|
|
|
|
def wait_for_update(self, timeout: float = 30.0) -> bool:
|
|
"""阻塞等待下一次行情更新 (供 SSE 线程使用)。"""
|
|
self._update_event.clear()
|
|
return self._update_event.wait(timeout=timeout)
|
|
|
|
def wait_for_alert(self, timeout: float = 30.0) -> bool:
|
|
"""阻塞等待告警 (供 SSE 线程使用)。"""
|
|
self._alert_event.clear()
|
|
return self._alert_event.wait(timeout=timeout)
|
|
|
|
def notify_depth_updated(self) -> None:
|
|
"""五档盘口修正完成后调用: 通知 SSE 推送 depth_updated, 触发连板梯队刷新。
|
|
|
|
与行情/告警通道独立 — 只刷新连板梯队, 不连带刷新 watchlist 等。
|
|
"""
|
|
self._depth_update_event.set()
|
|
|
|
def wait_for_depth_update(self, timeout: float = 30.0) -> bool:
|
|
"""阻塞等待 depth 修正 (供 SSE 线程使用)。"""
|
|
self._depth_update_event.clear()
|
|
return self._depth_update_event.wait(timeout=timeout)
|
|
|
|
def pop_alerts(self) -> list[dict]:
|
|
"""取走所有待推送的告警 (线程安全)。"""
|
|
with self._lock:
|
|
alerts = self._pending_alerts
|
|
self._pending_alerts = []
|
|
return alerts
|
|
|
|
# ================================================================
|
|
# 复盘进度 SSE 通道 — 定时复盘流式生成时, 把事件实时推给前端
|
|
# ================================================================
|
|
def push_review_event(self, event_json: str) -> None:
|
|
"""追加一条复盘进度事件(JSON 字符串), 并唤醒 SSE generator。
|
|
|
|
事件格式与 recap_market_stream 的产出一致(meta/delta/error/done),
|
|
前端 reviewStore 直接消费。背压: 超过上限丢弃最旧(复盘流几百条 delta, 200 够用)。
|
|
"""
|
|
with self._lock:
|
|
self._pending_review.append(event_json)
|
|
if len(self._pending_review) > self._max_pending_review:
|
|
overflow = len(self._pending_review) - self._max_pending_review
|
|
self._pending_review = self._pending_review[overflow:]
|
|
self._review_event.set()
|
|
|
|
def wait_for_review(self, timeout: float = 30.0) -> bool:
|
|
"""阻塞等待复盘进度事件 (供 SSE 线程使用)。"""
|
|
self._review_event.clear()
|
|
return self._review_event.wait(timeout=timeout)
|
|
|
|
def pop_review_events(self) -> list[str]:
|
|
"""取走所有待推送的复盘事件 (线程安全)。"""
|
|
with self._lock:
|
|
events = self._pending_review
|
|
self._pending_review = []
|
|
return events
|
|
|
|
# ================================================================
|
|
# 档位感知间隔限制
|
|
# ================================================================
|
|
|
|
@staticmethod
|
|
def _current_tier() -> str:
|
|
"""获取当前档位名（小写）。"""
|
|
from app.tickflow.policy import tier_label
|
|
return tier_label().split()[0].split("+")[0].strip().lower()
|
|
|
|
@classmethod
|
|
def realtime_mode(cls) -> str:
|
|
"""当前实时行情模式: none / watchlist / full_market。"""
|
|
tier = cls._current_tier()
|
|
if tier == "none":
|
|
return "none"
|
|
if tier == "free":
|
|
return "watchlist"
|
|
return "full_market"
|
|
|
|
@classmethod
|
|
def is_realtime_allowed(cls) -> bool:
|
|
"""当前档位是否允许使用实时行情。"""
|
|
return cls.realtime_mode() != "none"
|
|
|
|
@classmethod
|
|
def _tier_min_interval(cls) -> float:
|
|
tier = cls._current_tier()
|
|
return cls.TIER_MIN_INTERVAL.get(tier, cls.DEFAULT_INTERVAL)
|
|
|
|
def _clamp_interval(self, interval: float) -> float:
|
|
return max(self._tier_min_interval(), min(self.MAX_INTERVAL, interval))
|
|
|
|
# ================================================================
|
|
# 行情数据访问
|
|
# ================================================================
|
|
|
|
def get_enriched_today(self) -> tuple[pl.DataFrame, date | None]:
|
|
"""返回今天 enriched 数据 + 日期 (线程安全)。
|
|
|
|
所有页面统一通过此方法获取实时行情 + 技术指标。
|
|
"""
|
|
if not self._repo:
|
|
return pl.DataFrame(), None
|
|
return self._repo.get_enriched_latest()
|
|
|
|
def get_quotes_compat(self) -> pl.DataFrame:
|
|
"""兼容接口: 返回行情 DataFrame (用于盘中选股等需要 last_price/prev_close 的场景)。
|
|
|
|
从 _enriched_cache 取 today 的数据, 只选行情基础列, 补上 last_price 别名。
|
|
不返回指标列, 避免 JOIN live_agg 时列名冲突。
|
|
"""
|
|
df, _ = self.get_enriched_today()
|
|
if df.is_empty():
|
|
return df
|
|
|
|
# 只取盘中选股需要的行情基础列
|
|
keep = [c for c in [
|
|
"symbol", "close", "open", "high", "low", "volume", "amount",
|
|
"prev_close", "change_pct", "change_amount", "amplitude", "turnover_rate",
|
|
] if c in df.columns]
|
|
df = df.select(keep)
|
|
|
|
# enriched 的 close 等价于 last_price
|
|
if "close" in df.columns and "last_price" not in df.columns:
|
|
df = df.with_columns(pl.col("close").alias("last_price"))
|
|
return df
|
|
|
|
def get_index_quotes(self, symbols: list[str] | None = None) -> pl.DataFrame:
|
|
"""返回实时指数行情缓存。不会触发 TickFlow 请求。"""
|
|
with self._lock:
|
|
df = self._index_quotes_cache.clone() if self._index_quotes_cache is not None else pl.DataFrame()
|
|
if df.is_empty():
|
|
return df
|
|
if symbols:
|
|
return df.filter(pl.col("symbol").is_in(symbols))
|
|
return df
|
|
|
|
def status(self) -> dict:
|
|
"""返回行情服务状态。"""
|
|
from app.services import preferences
|
|
age = (time.perf_counter() - self._fetch_time) * 1000 if self._fetch_time else -1
|
|
mode = self.realtime_mode()
|
|
return {
|
|
"enabled": self._enabled,
|
|
"running": self._running,
|
|
"mode": mode,
|
|
"realtime_allowed": mode != "none",
|
|
"watchlist_symbol_count": len(preferences.get_realtime_watchlist_symbols()),
|
|
"interval_s": self._interval,
|
|
"symbol_count": self._symbol_count,
|
|
"index_symbol_count": self._index_symbol_count,
|
|
"etf_symbol_count": self._etf_symbol_count,
|
|
"quote_age_ms": round(age, 0) if age >= 0 else None,
|
|
"is_trading_hours": self._is_trading_hours(),
|
|
"last_fetch_ms": round(self._fetched_at, 0) if self._fetched_at else None,
|
|
}
|
|
|
|
def refresh(self) -> dict:
|
|
"""手动触发一次行情拉取。"""
|
|
self._fetch_quotes()
|
|
return self.status()
|
|
|
|
# ================================================================
|
|
# 后台轮询
|
|
# ================================================================
|
|
|
|
def _poll_loop(self) -> None:
|
|
while self._running and self._enabled:
|
|
try:
|
|
if self._is_trading_hours():
|
|
self._fetch_quotes()
|
|
else:
|
|
logger.debug("非交易时段, 跳过行情轮询")
|
|
except Exception as e: # noqa: BLE001
|
|
logger.warning("行情轮询异常: %s", e)
|
|
|
|
waited = 0.0
|
|
while self._running and self._enabled and waited < self._interval:
|
|
time.sleep(0.5)
|
|
waited += 0.5
|
|
|
|
def _fetch_quotes(self) -> None:
|
|
"""按当前档位拉取行情。"""
|
|
if self.realtime_mode() == "watchlist":
|
|
self._fetch_watchlist_quotes()
|
|
return
|
|
self._fetch_full_market_quotes()
|
|
|
|
def _fetch_full_market_quotes(self) -> None:
|
|
"""拉取全市场行情 → 写 daily + 计算 enriched + 更新缓存。"""
|
|
from app.tickflow.client import get_paid_realtime_client
|
|
|
|
tf = get_paid_realtime_client()
|
|
if tf is None:
|
|
logger.warning("实时行情拉取失败:未配置付费服务器 API Key")
|
|
return
|
|
t0 = time.perf_counter()
|
|
now_ts = time.perf_counter()
|
|
|
|
try:
|
|
from app.services import preferences
|
|
all_index_symbols = set(self._repo.get_index_symbol_set()) if self._repo else set()
|
|
core_index_symbols = set(preferences.get_realtime_index_symbols() or self.CORE_INDEX_SYMBOLS)
|
|
all_index_symbols.update(core_index_symbols)
|
|
all_etf_symbols = set()
|
|
if self._repo:
|
|
etf_inst = self._repo.get_etf_instruments()
|
|
if not etf_inst.is_empty() and "symbol" in etf_inst.columns:
|
|
all_etf_symbols = set(etf_inst["symbol"].cast(pl.Utf8).to_list())
|
|
|
|
universes: list[str] = []
|
|
if preferences.get_realtime_pull_stock():
|
|
universes.append("CN_Equity_A")
|
|
if preferences.get_realtime_pull_etf() and all_etf_symbols:
|
|
universes.append("CN_ETF")
|
|
if preferences.get_realtime_pull_index() and preferences.get_realtime_index_mode() == "all":
|
|
universes.append("CN_Index")
|
|
|
|
resp = []
|
|
if universes:
|
|
resp.extend(tf.quotes.get_by_universes(universes=universes) or [])
|
|
if preferences.get_realtime_pull_index() and preferences.get_realtime_index_mode() == "core":
|
|
resp.extend(tf.quotes.get(symbols=sorted(core_index_symbols)) or [])
|
|
except Exception as e: # noqa: BLE001
|
|
logger.warning("行情拉取失败: %s", e)
|
|
return
|
|
|
|
if not resp:
|
|
logger.warning("行情数据为空")
|
|
return
|
|
|
|
# ---- 解析 API 响应 (临时变量, 用完丢弃) ----
|
|
records = []
|
|
for q in resp:
|
|
ext = q.get("ext") or {}
|
|
last_price = q.get("last_price")
|
|
prev_close = q.get("prev_close")
|
|
change_amount = ext.get("change_amount")
|
|
change_pct = ext.get("change_pct")
|
|
if change_amount is None and last_price is not None and prev_close is not None:
|
|
change_amount = float(last_price) - float(prev_close)
|
|
if change_pct is None and change_amount is not None and prev_close not in (None, 0):
|
|
change_pct = float(change_amount) / float(prev_close) * 100
|
|
records.append({
|
|
"symbol": q.get("symbol"),
|
|
"name": q.get("name") or ext.get("name"),
|
|
"last_price": last_price,
|
|
"prev_close": prev_close,
|
|
"open": q.get("open"),
|
|
"high": q.get("high"),
|
|
"low": q.get("low"),
|
|
"volume": q.get("volume"),
|
|
"amount": q.get("amount"),
|
|
"change_pct": change_pct,
|
|
"change_amount": change_amount,
|
|
"amplitude": ext.get("amplitude"),
|
|
"turnover_rate": ext.get("turnover_rate"),
|
|
"timestamp": q.get("timestamp"),
|
|
"session": q.get("session"),
|
|
})
|
|
|
|
index_records = [r for r in records if r.get("symbol") in all_index_symbols]
|
|
etf_records = [r for r in records if r.get("symbol") in all_etf_symbols]
|
|
stock_records = [
|
|
r for r in records
|
|
if r.get("symbol") not in all_index_symbols and r.get("symbol") not in all_etf_symbols
|
|
]
|
|
|
|
fetch_ms = (time.perf_counter() - t0) * 1000
|
|
fetched_at = time.time() * 1000
|
|
|
|
# ---- 更新元信息 ----
|
|
with self._lock:
|
|
self._fetch_time = now_ts
|
|
self._fetch_ms = fetch_ms
|
|
self._fetched_at = fetched_at
|
|
self._symbol_count = len(stock_records)
|
|
self._index_symbol_count = len(index_records)
|
|
self._etf_symbol_count = len(etf_records)
|
|
self._index_quotes_cache = self._build_index_quotes(index_records)
|
|
|
|
logger.info("行情刷新: %d 只股票, %d 只ETF, %d 只指数, 耗时 %.0fms", len(stock_records), len(etf_records), len(index_records), fetch_ms)
|
|
|
|
# ---- 写 kline_daily (不复权原始价格, 只有 OHLCV) ----
|
|
daily_df = self._build_daily(stock_records)
|
|
if not daily_df.is_empty() and self._repo:
|
|
try:
|
|
self._repo.flush_live_daily(daily_df)
|
|
except Exception as e: # noqa: BLE001
|
|
logger.warning("日K写盘失败: %s", e)
|
|
|
|
etf_daily_df = self._build_daily(etf_records)
|
|
if not etf_daily_df.is_empty() and self._repo:
|
|
try:
|
|
self._repo.flush_live_daily_asset("etf", etf_daily_df)
|
|
except Exception as e: # noqa: BLE001
|
|
logger.warning("ETF 日K写盘失败: %s", e)
|
|
|
|
# ---- 构建 API 直接值的补充表 (不写 daily, 只用于 enriched 计算) ----
|
|
quote_extra = self._build_quote_extra(stock_records)
|
|
etf_quote_extra = self._build_quote_extra(etf_records)
|
|
|
|
# ---- 增量计算 enriched + 写盘 + 更新缓存 ----
|
|
if not daily_df.is_empty() and self._repo:
|
|
self._flush_live_enriched(daily_df, quote_extra, asset_type="stock")
|
|
if not etf_daily_df.is_empty() and self._repo:
|
|
self._flush_live_enriched(etf_daily_df, etf_quote_extra, asset_type="etf")
|
|
|
|
# ---- 通知 SSE ----
|
|
self._update_event.set()
|
|
|
|
# ---- 策略监控 + 告警评估 ----
|
|
self._evaluate_monitors(daily_df, quote_extra)
|
|
|
|
def _fetch_watchlist_quotes(self) -> None:
|
|
"""Free 档自选股实时: 只拉取最多 5 个 symbols。"""
|
|
from app.services import preferences
|
|
from app.tickflow.client import get_paid_realtime_client
|
|
|
|
symbols = preferences.get_realtime_watchlist_symbols()
|
|
if not symbols:
|
|
logger.info("自选实时未配置标的, 跳过行情拉取")
|
|
return
|
|
|
|
tf = get_paid_realtime_client()
|
|
if tf is None:
|
|
logger.warning("自选实时拉取失败:未配置付费服务器 API Key")
|
|
return
|
|
|
|
t0 = time.perf_counter()
|
|
now_ts = time.perf_counter()
|
|
try:
|
|
resp = tf.quotes.get(symbols=symbols) or []
|
|
except Exception as e: # noqa: BLE001
|
|
logger.warning("自选实时拉取失败: %s", e)
|
|
return
|
|
|
|
if not resp:
|
|
logger.warning("自选实时行情数据为空")
|
|
return
|
|
|
|
records = []
|
|
for q in resp:
|
|
ext = q.get("ext") or {}
|
|
last_price = q.get("last_price")
|
|
prev_close = q.get("prev_close")
|
|
change_amount = ext.get("change_amount")
|
|
change_pct = ext.get("change_pct")
|
|
if change_amount is None and last_price is not None and prev_close is not None:
|
|
change_amount = float(last_price) - float(prev_close)
|
|
if change_pct is None and change_amount is not None and prev_close not in (None, 0):
|
|
change_pct = float(change_amount) / float(prev_close) * 100
|
|
records.append({
|
|
"symbol": q.get("symbol"),
|
|
"name": q.get("name") or ext.get("name"),
|
|
"last_price": last_price,
|
|
"prev_close": prev_close,
|
|
"open": q.get("open"),
|
|
"high": q.get("high"),
|
|
"low": q.get("low"),
|
|
"volume": q.get("volume"),
|
|
"amount": q.get("amount"),
|
|
"change_pct": change_pct,
|
|
"change_amount": change_amount,
|
|
"amplitude": ext.get("amplitude"),
|
|
"turnover_rate": ext.get("turnover_rate"),
|
|
"timestamp": q.get("timestamp"),
|
|
"session": q.get("session"),
|
|
})
|
|
|
|
fetch_ms = (time.perf_counter() - t0) * 1000
|
|
fetched_at = time.time() * 1000
|
|
with self._lock:
|
|
self._fetch_time = now_ts
|
|
self._fetch_ms = fetch_ms
|
|
self._fetched_at = fetched_at
|
|
self._symbol_count = len(records)
|
|
self._index_symbol_count = 0
|
|
self._etf_symbol_count = 0
|
|
self._index_quotes_cache = None
|
|
|
|
logger.info("自选实时刷新: %d 只股票, 耗时 %.0fms", len(records), fetch_ms)
|
|
|
|
daily_df = self._build_daily(records)
|
|
quote_extra = self._build_quote_extra(records)
|
|
if not daily_df.is_empty() and self._repo:
|
|
try:
|
|
self._repo.merge_live_daily_asset("stock", daily_df)
|
|
except Exception as e: # noqa: BLE001
|
|
logger.warning("自选实时日K写盘失败: %s", e)
|
|
self._flush_live_enriched(daily_df, quote_extra, asset_type="stock", merge=True)
|
|
|
|
self._update_event.set()
|
|
self._evaluate_monitors(daily_df, quote_extra)
|
|
|
|
# ================================================================
|
|
# 工具
|
|
# ================================================================
|
|
|
|
@staticmethod
|
|
def _build_daily(records: list[dict]) -> pl.DataFrame:
|
|
"""将 API records 转为日K格式 DataFrame (只有 OHLCV, 写 kline_daily 用)。"""
|
|
if not records:
|
|
return pl.DataFrame()
|
|
df = pl.DataFrame(records)
|
|
cols_map = {
|
|
"symbol": "symbol",
|
|
"last_price": "close",
|
|
"open": "open",
|
|
"high": "high",
|
|
"low": "low",
|
|
"volume": "volume",
|
|
"amount": "amount",
|
|
}
|
|
select_exprs = []
|
|
for src, dst in cols_map.items():
|
|
if src in df.columns:
|
|
select_exprs.append(pl.col(src).alias(dst))
|
|
if not select_exprs:
|
|
return pl.DataFrame()
|
|
result = df.select(select_exprs).with_columns(
|
|
pl.lit(date.today()).cast(pl.Date).alias("date"),
|
|
)
|
|
# 修复: API 在非交易时段可能返回 open/high/low=0 或 null,
|
|
# 导致蜡烛从 0 开始。用 close 填充这些异常值。
|
|
for col in ("open", "high", "low"):
|
|
if col in result.columns:
|
|
result = result.with_columns(
|
|
pl.when((pl.col(col) == 0) | pl.col(col).is_null())
|
|
.then(pl.col("close"))
|
|
.otherwise(pl.col(col))
|
|
.alias(col)
|
|
)
|
|
return result
|
|
|
|
@staticmethod
|
|
def _build_quote_extra(records: list[dict]) -> pl.DataFrame:
|
|
"""构建 API 直接提供的补充字段 (不写 daily, 只传给 enriched 计算)。
|
|
|
|
包含: prev_close, change_pct, change_amount, amplitude, turnover_rate。
|
|
"""
|
|
if not records:
|
|
return pl.DataFrame()
|
|
df = pl.DataFrame(records)
|
|
keep = [c for c in [
|
|
"symbol", "prev_close", "change_pct", "change_amount",
|
|
"amplitude", "turnover_rate",
|
|
] if c in df.columns]
|
|
if not keep or "symbol" not in keep:
|
|
return pl.DataFrame()
|
|
return df.select(keep)
|
|
|
|
@staticmethod
|
|
def _build_index_quotes(records: list[dict]) -> pl.DataFrame:
|
|
"""构建指数实时行情缓存，不落股票 parquet。
|
|
|
|
注意: API 返回的 change_pct/amplitude 是小数 (0.0366 = 3.66%),
|
|
统一转成百分比输出, 与 _fallback_index_quotes_from_daily 口径一致
|
|
(前端指数侧不×100, 直接 toFixed(2)% 展示)。
|
|
"""
|
|
if not records:
|
|
return pl.DataFrame()
|
|
df = pl.DataFrame(records)
|
|
keep = [c for c in [
|
|
"symbol", "name", "last_price", "prev_close", "open", "high", "low",
|
|
"volume", "amount", "change_pct", "change_amount", "amplitude", "timestamp", "session",
|
|
] if c in df.columns]
|
|
if not keep or "symbol" not in keep:
|
|
return pl.DataFrame()
|
|
df = df.select(keep)
|
|
# change_pct / amplitude: 小数 → 百分比 (统一指数展示口径)
|
|
for col in ("change_pct", "amplitude"):
|
|
if col in df.columns:
|
|
df = df.with_columns((pl.col(col).cast(pl.Float64) * 100).alias(col))
|
|
if "last_price" in df.columns and "close" not in df.columns:
|
|
df = df.with_columns(pl.col("last_price").alias("close"))
|
|
return df
|
|
|
|
@staticmethod
|
|
def _is_trading_hours() -> bool:
|
|
now = datetime.now()
|
|
t = now.time()
|
|
morning = dt_time(9, 15) <= t <= dt_time(11, 35)
|
|
afternoon = dt_time(12, 55) <= t <= dt_time(15, 5)
|
|
return now.weekday() < 5 and (morning or afternoon)
|
|
|
|
@staticmethod
|
|
def _save_enabled(enabled: bool) -> None:
|
|
from app.services import preferences
|
|
preferences.save({"realtime_quotes_enabled": enabled})
|
|
|
|
# ================================================================
|
|
# 策略监控
|
|
# ================================================================
|
|
|
|
def _evaluate_monitors(self, daily_df: pl.DataFrame, quote_extra: pl.DataFrame | None) -> None:
|
|
"""行情更新后评估统一监控规则引擎,并刷新策略结果缓存。"""
|
|
try:
|
|
# 获取 enriched 数据 (刚算好的)
|
|
enriched_today, enriched_date = self.get_enriched_today()
|
|
if enriched_today.is_empty():
|
|
return
|
|
|
|
all_alerts: list[dict] = []
|
|
rule_events: list[dict] = []
|
|
engine = None
|
|
|
|
# 通用监控规则评估 (统一引擎: signal/price/market/strategy)
|
|
if self._app_state:
|
|
engine = getattr(self._app_state, "monitor_engine", None)
|
|
if engine and engine.rule_count > 0:
|
|
# 预构建 symbol → name 映射 (enriched 已 drop name 列, 引擎触发时回填用)
|
|
try:
|
|
inst_df = self._app_state.repo.get_instruments()
|
|
if not inst_df.is_empty() and "symbol" in inst_df.columns and "name" in inst_df.columns:
|
|
engine.set_name_map({
|
|
row["symbol"]: row["name"]
|
|
for row in inst_df.select(["symbol", "name"]).iter_rows(named=True)
|
|
if row.get("name")
|
|
})
|
|
except Exception as e: # noqa: BLE001
|
|
logger.debug("name_map 构建失败 (不影响监控): %s", e)
|
|
# 连板梯队封单监控: 有 ladder 规则时, 从 depth_service 注入封单量到 enriched
|
|
eval_df = enriched_today
|
|
if engine.has_rule_type("ladder"):
|
|
eval_df = self._inject_sealed_vol(enriched_today, enriched_date)
|
|
rule_events = engine.evaluate(eval_df)
|
|
if rule_events:
|
|
# 落盘到 alerts.jsonl
|
|
try:
|
|
from app.services import alert_store
|
|
alert_store.append_many(
|
|
self._app_state.repo.store.data_dir, rule_events,
|
|
)
|
|
except Exception as e: # noqa: BLE001
|
|
logger.warning("告警落盘失败: %s", e)
|
|
# 转为 SSE 推送格式 (兼容旧 alert schema)
|
|
for ev in rule_events:
|
|
all_alerts.append({
|
|
"source": ev["source"],
|
|
"type": ev["type"],
|
|
"rule_id": ev.get("rule_id"),
|
|
"strategy_id": ev.get("rule_id") if ev["source"] == "strategy" else None,
|
|
"symbol": ev["symbol"],
|
|
"name": ev["name"],
|
|
"message": ev["message"],
|
|
"price": ev["price"],
|
|
"change_pct": ev["change_pct"],
|
|
"signals": ev["signals"],
|
|
"severity": ev.get("severity", "info"),
|
|
"conditions": ev.get("conditions") or [],
|
|
"logic": ev.get("logic") or "and",
|
|
})
|
|
|
|
# 策略页实时回显: 不写文件 (实时行情每轮更新 enriched, 写文件会被 read_cache
|
|
# 的 mtime 校验判过期, 反复读不到)。监控引擎本轮已算出的结果存在内存
|
|
# (latest_strategy_results), 由 /api/screener/cached 端点直接叠加读取。
|
|
|
|
# 推入待推送队列 + 通知 SSE (含背压保护)
|
|
if all_alerts:
|
|
with self._lock:
|
|
self._pending_alerts.extend(all_alerts)
|
|
# 背压: 超出上限丢弃最旧
|
|
if len(self._pending_alerts) > self._max_pending_alerts:
|
|
overflow = len(self._pending_alerts) - self._max_pending_alerts
|
|
self._pending_alerts = self._pending_alerts[overflow:]
|
|
self._alert_event.set()
|
|
logger.info("监控评估完成: %d 条通知", len(all_alerts))
|
|
|
|
# 系统通知 (可选通道, 由 preferences 开关控制)。
|
|
# cooldown 去重已在 MonitorRuleEngine 做过, 这里只负责转发。
|
|
self._maybe_send_system_notifications(all_alerts)
|
|
|
|
# Webhook 推送 (飞书等外部 IM, 由规则 webhook_enabled 开关控制)。
|
|
# 紧随系统通知, 同样静默降级不阻断主流程。
|
|
if rule_events:
|
|
self._maybe_send_webhook(rule_events, engine)
|
|
|
|
except Exception as e: # noqa: BLE001
|
|
logger.warning("监控评估失败: %s", e)
|
|
|
|
def _inject_sealed_vol(self, enriched_today: pl.DataFrame, enriched_date) -> pl.DataFrame:
|
|
"""从 depth_service 取封单量, 作为临时列 _sealed_vol 注入 enriched 副本。
|
|
|
|
涨停封单(买一量) + 跌停封单(卖一量)合并, 供 ladder 规则评估。
|
|
depth 未就绪时返回原 df (不注入, ladder 规则安全降级不触发)。
|
|
"""
|
|
try:
|
|
depth_svc = getattr(self._app_state, "depth_service", None)
|
|
if not depth_svc:
|
|
return enriched_today
|
|
# enriched_date 可能是 date 或字符串, 统一为 date
|
|
from datetime import date as date_cls
|
|
target_date = enriched_date if isinstance(enriched_date, date_cls) else date_cls.fromisoformat(str(enriched_date))
|
|
# 取涨停 + 跌停封单, 合并 {symbol: vol}
|
|
up_map = depth_svc.get_sealed_map(target_date, is_down=False)
|
|
down_map = depth_svc.get_sealed_map(target_date, is_down=True)
|
|
sealed: dict[str, int] = {}
|
|
for m in (up_map, down_map):
|
|
for sym, info in m.items():
|
|
vol = (info or {}).get("vol")
|
|
if vol and vol > 0:
|
|
sealed[sym] = vol # 后者覆盖前者 (同 symbol 不可能在涨跌停都封单)
|
|
if not sealed:
|
|
return enriched_today
|
|
# 构造 (symbol, _sealed_vol) DataFrame, join 到 enriched 副本
|
|
sealed_df = pl.DataFrame({
|
|
"symbol": list(sealed.keys()),
|
|
"_sealed_vol": list(sealed.values()),
|
|
})
|
|
# 若已有残留列先移除 (避免重复 join 报错)
|
|
df = enriched_today.drop("_sealed_vol") if "_sealed_vol" in enriched_today.columns else enriched_today
|
|
return df.join(sealed_df, on="symbol", how="left")
|
|
except Exception as e: # noqa: BLE001
|
|
logger.debug("封单注入失败 (ladder 规则将不触发): %s", e)
|
|
return enriched_today
|
|
|
|
def _maybe_send_webhook(self, rule_events: list[dict], engine) -> None:
|
|
"""把告警通过 Webhook 推送到外部 IM (由规则 webhook_enabled 开关控制)。
|
|
|
|
- 全局飞书 URL 未配置: 直接返回
|
|
- 仅推送 webhook_enabled=True 的规则触发的告警
|
|
- 失败静默, 不阻断主流程
|
|
- 去重: 复用 MonitorRuleEngine 的 cooldown, 此处不重复去重
|
|
|
|
注意: 用 rule_events (含 rule_id) 而非重建后的 all_alerts,
|
|
以便反查引擎规则判断是否启用推送。
|
|
"""
|
|
try:
|
|
from app.services import preferences
|
|
from app.services import webhook_adapter
|
|
|
|
url = preferences.get_feishu_webhook_url()
|
|
if not url:
|
|
return
|
|
secret = preferences.get_feishu_webhook_secret()
|
|
|
|
# 反查规则, 过滤出启用推送的事件
|
|
source_labels = {
|
|
"strategy": "策略", "signal": "信号",
|
|
"price": "价格", "market": "异动",
|
|
}
|
|
rules = engine.rules if engine is not None else {}
|
|
pushed = 0
|
|
for ev in rule_events:
|
|
rule = rules.get(ev.get("rule_id"))
|
|
if not rule or not rule.get("webhook_enabled"):
|
|
continue
|
|
source = ev.get("source", "")
|
|
source_label = source_labels.get(source, source or "通知")
|
|
symbol = ev.get("symbol") or ""
|
|
name = ev.get("name") or ""
|
|
message = ev.get("message") or ""
|
|
title = f"TickFlow · {source_label}"
|
|
body = f"{symbol} {name} {message}".strip() if symbol else (message or name)
|
|
if webhook_adapter.send_feishu(url, title, body, secret):
|
|
pushed += 1
|
|
if pushed:
|
|
logger.info("飞书 Webhook 推送: %d 条", pushed)
|
|
except Exception as e: # noqa: BLE001
|
|
logger.debug("Webhook 推送异常 (不影响告警主流程): %s", e)
|
|
|
|
def _maybe_send_system_notifications(self, all_alerts: list[dict]) -> None:
|
|
"""把告警转发到操作系统通知中心 (由 preferences 开关控制)。
|
|
|
|
- 开关关闭: 直接返回
|
|
- 开关开启: 逐条发系统通知; 失败静默, 不阻断主流程
|
|
- 去重: 复用 MonitorRuleEngine 的 cooldown, 此处不重复去重
|
|
- 批量策略事件 (symbol="") 聚合为一条通知, 避免刷屏
|
|
"""
|
|
try:
|
|
from app.services import preferences
|
|
from app.services import notify_adapter
|
|
|
|
if not preferences.get_system_notify_enabled():
|
|
return
|
|
|
|
for ev in all_alerts:
|
|
# 通知标题: 用 source 分类 (策略/信号/价格/异动)
|
|
source = ev.get("source", "")
|
|
source_label = {
|
|
"strategy": "策略", "signal": "信号",
|
|
"price": "价格", "market": "异动",
|
|
}.get(source, source or "通知")
|
|
|
|
name = ev.get("name") or ""
|
|
symbol = ev.get("symbol") or ""
|
|
message = ev.get("message") or ""
|
|
|
|
# 正文: 优先用现成 message, 拼上 symbol/name 让用户一眼定位
|
|
if symbol:
|
|
body = f"{symbol} {name} {message}".strip()
|
|
else:
|
|
body = message or name
|
|
|
|
title = f"TickFlow · {source_label}"
|
|
notify_adapter.notify(title, body)
|
|
except Exception as e: # noqa: BLE001
|
|
logger.debug("系统通知发送异常 (不影响告警主流程): %s", e)
|
|
|
|
@staticmethod
|
|
def _get_strategy_monitor():
|
|
"""获取 StrategyMonitorService — 不再使用, 改用 _app_state 注入。"""
|
|
return None
|
|
|
|
# ================================================================
|
|
# enriched 增量计算
|
|
# ================================================================
|
|
|
|
def _flush_live_enriched(self, daily_df: pl.DataFrame, quote_extra: pl.DataFrame = None, asset_type: str = "stock", merge: bool = False) -> None:
|
|
"""增量计算今天的 enriched: 用昨天的递推状态 + 今天 OHLCV → 只算今天 5500 行。
|
|
|
|
quote_extra: API 直接提供的补充字段 (prev_close, change_pct 等),
|
|
不写 daily, 直接传给 compute_enriched_today 避免重复计算。
|
|
"""
|
|
try:
|
|
today = date.today()
|
|
t0 = time.perf_counter()
|
|
|
|
# ---- 尝试增量路径 ----
|
|
live_agg = self._repo.get_live_agg() if asset_type == "stock" else pl.DataFrame()
|
|
prev_enriched, prev_date = (
|
|
self._repo.get_enriched_latest()
|
|
if asset_type == "stock"
|
|
else self._repo.get_enriched_latest_asset(asset_type)
|
|
)
|
|
|
|
use_incremental = (
|
|
asset_type == "stock"
|
|
and not live_agg.is_empty()
|
|
and not prev_enriched.is_empty()
|
|
and prev_date is not None
|
|
)
|
|
|
|
if use_incremental:
|
|
from app.indicators.pipeline import compute_enriched_today
|
|
instruments = self._repo.get_instruments()
|
|
# 将 API 直接提供的补充字段 JOIN 到 daily_df
|
|
today_ohlcv = daily_df
|
|
if quote_extra is not None and not quote_extra.is_empty():
|
|
today_ohlcv = daily_df.join(quote_extra, on="symbol", how="left")
|
|
enriched_today = compute_enriched_today(
|
|
live_agg=live_agg,
|
|
prev_enriched=prev_enriched,
|
|
today_ohlcv=today_ohlcv,
|
|
instruments=instruments,
|
|
)
|
|
if enriched_today.is_empty():
|
|
logger.warning("增量计算结果为空, 回退到全量计算")
|
|
use_incremental = False
|
|
|
|
# ---- 全量回退路径 ----
|
|
if not use_incremental:
|
|
from datetime import timedelta
|
|
from app.indicators.pipeline import compute_enriched
|
|
|
|
logger.info("enriched 全量计算 (live_agg=%s, 上次日期=%s)",
|
|
"ok" if not live_agg.is_empty() else "空", prev_date)
|
|
|
|
cutoff = today - timedelta(days=90)
|
|
table = "kline_etf_daily" if asset_type == "etf" else "kline_daily"
|
|
daily_glob = str(self._repo.store.data_dir / table / "**" / "*.parquet")
|
|
ohlcv_cols = ["symbol", "date", "open", "high", "low", "close", "volume", "amount"]
|
|
hist_df = (
|
|
pl.scan_parquet(daily_glob)
|
|
.filter(pl.col("date") >= cutoff)
|
|
.sort(["symbol", "date"])
|
|
.collect()
|
|
)
|
|
if hist_df.is_empty():
|
|
return
|
|
|
|
hist_cols = [c for c in ohlcv_cols if c in hist_df.columns]
|
|
hist_df = hist_df.select(hist_cols).filter(pl.col("date") != today)
|
|
daily_ohlcv = daily_df.select([c for c in ohlcv_cols if c in daily_df.columns])
|
|
full_df = pl.concat([hist_df, daily_ohlcv], how="diagonal_relaxed")
|
|
full_df = full_df.sort(["symbol", "date"])
|
|
|
|
factor_dir = "adj_factor_etf" if asset_type == "etf" else "adj_factor"
|
|
factor_path = self._repo.store.data_dir / factor_dir / "all.parquet"
|
|
factors = pl.DataFrame()
|
|
if factor_path.exists():
|
|
try:
|
|
factors = pl.read_parquet(factor_path)
|
|
except Exception:
|
|
pass
|
|
instruments = self._repo.get_instruments() if asset_type == "stock" else None
|
|
|
|
enriched_full = compute_enriched(full_df, factors=factors, instruments=instruments)
|
|
enriched_today = enriched_full.filter(pl.col("date") == today)
|
|
|
|
if enriched_today.is_empty():
|
|
return
|
|
|
|
# ---- 写盘 + 更新缓存 ----
|
|
if merge:
|
|
self._repo.merge_live_enriched_asset(asset_type, enriched_today)
|
|
else:
|
|
self._repo.flush_live_enriched_asset(asset_type, enriched_today)
|
|
|
|
elapsed = time.perf_counter() - t0
|
|
mode_label = "增量" if use_incremental else "全量"
|
|
logger.info("enriched %s: %d 只, %s, 耗时 %.0fms",
|
|
mode_label, len(enriched_today), today, elapsed * 1000)
|
|
except Exception as e: # noqa: BLE001
|
|
logger.warning("enriched 计算失败: %s", e)
|