powerquant-cli 0.2.6__py3-none-any.whl

quant_core/app/trading_runtime/replay/market_runtime_service.py

@@ -0,0 +1,573 @@
+"""
+Market Runtime Service - 市场数据按市场时间流动（② Runtime 能力）
+
+两种事件源，同一个 MarketEvent 契约：
+
+    Historical Replay: 本地库 → ReplayMarketEventSource → MarketEvent
+    Live Stream:       Provider  → LiveMarketEventSource   → MarketEvent
+
+Strategy / Backtest 只消费事件流，不感知自己是回测还是实盘。
+
+边界：Runtime 只负责事件产生与时间推进；Order/Fill/Portfolio/指标归 backtest 域。
+"""
+
+import asyncio
+import heapq
+from collections.abc import AsyncIterator, Iterator
+from datetime import UTC, date, datetime, time
+from zoneinfo import ZoneInfo
+
+from quant_core.app.data.constants import (
+    SESSION_BREAK_END_TIME,
+    SESSION_BREAK_START_TIME,
+    SESSION_CLOSE_TIME,
+    SESSION_OPEN_TIME,
+    SESSION_PRE_OPEN_TIME,
+    BarFrequency,
+    Exchange,
+    MarketEventType,
+    MarketStreamMode,
+)
+from quant_core.app.data.exceptions import MarketDataNotSyncedException
+from quant_core.app.data.interface.market_event_source import IMarketEventSource
+from quant_core.app.data.interface.market_runtime_repository import IMarketRuntimeRepository
+from quant_core.app.data.schema.corporate_action_schema import (
+    CorporateActionEventPayload,
+    CorporateActionPhase,
+    CorporateActionResponse,
+)
+from quant_core.app.data.schema.event_schema import (
+    PRE_SESSION_STAGES,
+    BarEvent,
+    CoarseBarExecutionContext,
+    CorporateActionEvent,
+    MarketEvent,
+    MarketStreamRequest,
+    MarketTimeSlice,
+    TradingSessionEvent,
+    TradingSessionStage,
+    bar_to_bar_event,
+    daily_state_snapshot_to_event,
+    market_event_order_key,
+    trading_session_to_event,
+)
+from quant_core.app.data.schema.exchange_state_schema import (
+    ExchangePhase,
+    exchange_state_snapshot_to_event,
+    exchange_state_to_event,
+)
+from quant_core.app.data.schema.market_schema import BarResponse
+from quant_core.app.data.service.calendar_coverage_service import build_calendar_coverage
+from quant_core.app.trading_runtime.replay.daily_state_expand import DailyFact, expand_daily_state
+
+# Session 事件只在日内频率回放中产生；日线及以上以「日」为粒度，无日内时段语义
+_INTRADAY_FREQUENCIES = {
+    BarFrequency.M1,
+    BarFrequency.M5,
+    BarFrequency.M15,
+    BarFrequency.M30,
+    BarFrequency.H1,
+}
+# Session 五阶段（通用阶段 → 各市场具体时刻；A股见 constants SESSION_*_TIME）
+_SESSION_STAGES: tuple[tuple[TradingSessionStage, str], ...] = (
+    (MarketEventType.SESSION_PRE_OPEN, SESSION_PRE_OPEN_TIME),
+    (MarketEventType.SESSION_OPEN, SESSION_OPEN_TIME),
+    (MarketEventType.SESSION_BREAK_START, SESSION_BREAK_START_TIME),
+    (MarketEventType.SESSION_BREAK_END, SESSION_BREAK_END_TIME),
+    (MarketEventType.SESSION_CLOSE, SESSION_CLOSE_TIME),
+)
+_MARKET_TZ = ZoneInfo("Asia/Shanghai")
+# Session 阶段 → 交易所运行 phase（T4R；增量事件与 Session 边界同点同源）
+_STAGE_TO_PHASE: dict[TradingSessionStage, ExchangePhase] = {
+    MarketEventType.SESSION_PRE_OPEN: ExchangePhase.PRE_OPEN,
+    MarketEventType.SESSION_OPEN: ExchangePhase.OPEN,
+    MarketEventType.SESSION_BREAK_START: ExchangePhase.BREAK,
+    MarketEventType.SESSION_BREAK_END: ExchangePhase.OPEN,
+    MarketEventType.SESSION_CLOSE: ExchangePhase.CLOSED,
+}
+
+
+def _phase_at_time(hhmm: str) -> ExchangePhase:
+    """确定性 A 股日内时段规则（HH:MM 字典序即时序）：bounded 起点 phase 基线
+
+    - <09:15 CLOSED（凌晨/早盘前：禁止以 PRE_OPEN capability 接受新订单）；
+    - 09:15–09:30 PRE_OPEN（开盘集合竞价）；09:30–11:30 OPEN；
+    - 11:30–13:00 BREAK（午休）；13:00–15:00 OPEN；>=15:00 CLOSED。
+    """
+    if hhmm < SESSION_PRE_OPEN_TIME:
+        return ExchangePhase.CLOSED
+    if hhmm < SESSION_OPEN_TIME:
+        return ExchangePhase.PRE_OPEN
+    if hhmm < SESSION_BREAK_START_TIME:
+        return ExchangePhase.OPEN
+    if hhmm < SESSION_BREAK_END_TIME:
+        return ExchangePhase.BREAK
+    if hhmm < SESSION_CLOSE_TIME:
+        return ExchangePhase.OPEN
+    return ExchangePhase.CLOSED
+
+
+def _make_slice(slice_time: datetime, batch: list[MarketEvent], coarse: bool) -> MarketTimeSlice:
+    """粗粒度开盘决策片和 Bar 撮合片均携带有界交易所资格。"""
+    context = None
+    if coarse:
+        bar_exchanges = sorted(
+            {
+                _exchange_of(e.payload.instrument_id)
+                for e in batch
+                if e.event_type is MarketEventType.BAR and isinstance(e, BarEvent)
+            }
+            | {
+                e.payload.exchange
+                for e in batch
+                if e.event_type is MarketEventType.SESSION_OPEN
+                and isinstance(e, TradingSessionEvent)
+            }
+        )
+        if bar_exchanges:
+            context = CoarseBarExecutionContext(
+                decision_time=slice_time,
+                eligible_exchanges=tuple(bar_exchanges),
+                reason=(
+                    "coarse_bar_decision_point"
+                    if any(e.event_type is MarketEventType.BAR for e in batch)
+                    else "coarse_open_decision_point"
+                ),
+            )
+    return MarketTimeSlice(event_time=slice_time, events=batch, execution_context=context)
+
+
+class ReplayMarketEventSource:
+    """历史重放事件源：多标的 Bar + 各交易所 Trading Session → 全局时间归并
+
+    归并语义（确定性，与 instrument_ids 输入顺序无关）：
+    - Bar 按标的字典序作为独立归并流（heapq.merge，同 key 时先到者优先）；
+    - 每个涉及的 Exchange 分别基于 TradingCalendar 生成 Session 事件，
+      按边界优先级分两路参与归并：OPEN/RESUME 类（PRE_OPEN/OPEN/BREAK_END）
+      在同 event_time 市场事实前，BREAK/CLOSE 类（BREAK_START/CLOSE）在后；
+    - event_time 全局单调不减，sequence 在整条流上严格递增（归并后统一编号）；
+    - 同一精确 event_time 的事件可经 stream_slices() 形成 MarketTimeSlice，
+      与 stream() 复用同一份归并实现。
+
+    Strategy 只认 event_time，禁止用 received_at。
+    """
+
+    def __init__(self, repository: IMarketRuntimeRepository):
+        self.repository = repository
+
+    async def stream(self, request: MarketStreamRequest) -> AsyncIterator[MarketEvent]:
+        """原子事件流（全局时间归并，sequence 严格递增）"""
+        async for event in self._stream_merged(request):
+            yield event
+
+    async def stream_slices(self, request: MarketStreamRequest) -> AsyncIterator[MarketTimeSlice]:
+        """时间片流：复用同一份全局归并，按精确 event_time 增量分组（不整体物化）
+
+        R2 finding 3（方案 A）：粗粒度（日线及以上）片携带显式
+        CoarseBarExecutionContext（模拟决策/撮合资格）；日内片恒为 None。
+        ExchangeState 事实与执行资格由此彻底分离。
+        """
+        coarse = request.frequency not in _INTRADAY_FREQUENCIES
+        slice_time: datetime | None = None
+        batch: list[MarketEvent] = []
+        async for event in self._stream_merged(request):
+            if slice_time is not None and event.event_time != slice_time:
+                yield _make_slice(slice_time, batch, coarse)
+                batch = []
+            slice_time = event.event_time
+            batch.append(event)
+        if batch:
+            assert slice_time is not None
+            yield _make_slice(slice_time, batch, coarse)
+
+    async def _stream_merged(self, request: MarketStreamRequest) -> AsyncIterator[MarketEvent]:
+        if request.start is None or request.end is None:
+            raise ValueError("replay 模式必须指定 start/end")
+        received_at = datetime.now(UTC)
+        # 归并流顺序 = market_event_order_key 规范序（R1 契约）：
+        # (event_time, 边界优先级, 标的/交易所 tie-break, 事件类型)。
+        # 生产侧在进入 MarketTimeSlice 之前就产出规范序，sequence 按该序编号
+        # 严格递增；切片内重排因此是幂等 no-op，stream 与 stream_slices
+        # 的逐事件业务顺序完全一致。
+        if request.frequency in _INTRADAY_FREQUENCIES:
+            # 每交易所查询一次完整日历基线（R1 契约）：Session 与 Snapshot
+            # 共享同一份 open days，不完整日历结构化失败，绝不分别查询后不一致
+            calendars: dict[str, list[date]] = {
+                exchange: await self._open_days_with_full_coverage(
+                    exchange,
+                    request.start.astimezone(_MARKET_TZ).date(),
+                    request.end.astimezone(_MARKET_TZ).date(),
+                )
+                for exchange in sorted(_exchanges_from_instrument_ids(request.instrument_ids))
+            }
+            pre_sessions, post_sessions = self._session_events(request, calendars)
+            ex_snapshots, ex_pre, ex_post = self._exchange_state_events(request, calendars)
+            pre_sessions = pre_sessions + ex_pre
+            post_sessions = post_sessions + ex_post
+        else:
+            # 日线及以上：无日内 Session 语义，但必须提供完整日历基线
+            # （日级事实快照消费同一份 open days，CalendarCoverage 统一判定）
+            calendars = {
+                exchange: await self._open_days_with_full_coverage(
+                    exchange,
+                    request.start.astimezone(_MARKET_TZ).date(),
+                    request.end.astimezone(_MARKET_TZ).date(),
+                )
+                for exchange in sorted(_exchanges_from_instrument_ids(request.instrument_ids))
+            }
+            # 日级 Bar 只在收盘可见；开盘 Session 是真实日历边界，
+            # 给策略提供不含当日 Bar 的事前决策点，而不伪造交易所状态事实。
+            received_at = datetime.now(UTC)
+            pre_sessions = [
+                trading_session_to_event(
+                    exchange,
+                    MarketEventType.SESSION_OPEN,
+                    datetime(day.year, day.month, day.day, 9, 30, tzinfo=_MARKET_TZ).astimezone(
+                        UTC
+                    ),
+                    0,
+                    "replay",
+                    received_at,
+                )
+                for exchange, days in sorted(calendars.items())
+                for day in days
+                if request.coarse_open_decisions
+                if request.start
+                <= datetime(day.year, day.month, day.day, 9, 30, tzinfo=_MARKET_TZ).astimezone(UTC)
+                <= request.end
+            ]
+            post_sessions = []
+            ex_snapshots: list[MarketEvent] = []  # 日线及以上：无交易所事件（方案 A）
+        bar_streams: list[Iterator[MarketEvent]] = []
+        fact_events: list[MarketEvent] = []
+        for instrument_id in sorted(set(request.instrument_ids)):
+            snapshot_events: list[MarketEvent] = []
+            has_facts = False
+            snapshot_events, has_facts = await self._daily_snapshot_events(
+                instrument_id,
+                request,
+                received_at,
+                calendars[_exchange_of(instrument_id)],
+            )
+            bars = await self.repository.list_bars(
+                instrument_id, request.frequency.value, request.start, request.end, limit=1000000
+            )
+            if not bars and not has_facts:
+                # 无 Bar 且区间内无任何官方事实行：真正未同步，结构化失败
+                # （不伪装成功，也不用日历-derived UNKNOWN 快照冒充数据）；
+                # 仅有官方停牌事实（纯停牌区间无 Bar）是合法回放
+                raise MarketDataNotSyncedException(
+                    f"回放数据未同步（{instrument_id} {request.frequency.value}），请先 sync bars"
+                )
+            if bars:
+                bar_streams.append(
+                    iter(
+                        bar_to_bar_event(BarResponse.model_validate(b), 0, "replay", received_at)
+                        for b in bars
+                    )
+                )
+            fact_events.extend(snapshot_events)
+        # R2 finding 3（方案 A）：日线及以上片不再生成任何交易所事件——
+        # 15:00 的真实投影是 CLOSED，粗粒度撮合资格由时间片
+        # execution_context（CoarseBarExecutionContext）显式表达，
+        # 禁止伪造 Snapshot(OPEN) 混淆市场事实与模拟撮合资格。
+        fact_events.extend(ex_snapshots)
+        fact_events.extend(await self._corporate_action_events(request, received_at))
+        fact_events.sort(key=market_event_order_key)
+        pre_sessions.sort(key=market_event_order_key)
+        post_sessions.sort(key=market_event_order_key)
+        merged = heapq.merge(
+            iter(pre_sessions),
+            iter(fact_events),
+            *bar_streams,
+            iter(post_sessions),
+            key=market_event_order_key,
+        )
+        for sequence, event in enumerate(merged):
+            event.sequence = sequence
+            yield event
+            if request.speed > 0:
+                await asyncio.sleep(0)  # 限速模式让出事件循环，按speed等待由调用方控制
+
+    async def _corporate_action_events(
+        self, request: MarketStreamRequest, received_at: datetime
+    ) -> list[MarketEvent]:
+        """把本地公司行动事实展开为三阶段事件。
+
+        record 在收盘后固化权益；ex/pay 在开盘前依次生效。刻意使用不同时间，
+        保证同日除权且派息时，应收先建立、现金后到账，不依赖输入行顺序。
+        """
+        assert request.start is not None and request.end is not None
+        actions = await self.repository.list_corporate_actions(
+            sorted(set(request.instrument_ids)),
+            request.start.astimezone(_MARKET_TZ).date(),
+            request.end.astimezone(_MARKET_TZ).date(),
+        )
+        events: list[MarketEvent] = []
+        phase_times = (
+            (CorporateActionPhase.RECORD, time(15, 0)),
+            (CorporateActionPhase.EX_DATE, time(9, 20)),
+            (CorporateActionPhase.LISTING_DATE, time(9, 25)),
+            (CorporateActionPhase.PAY_DATE, time(9, 26)),
+        )
+        for row in actions:
+            action = CorporateActionResponse.model_validate(row)
+            dates = {
+                CorporateActionPhase.RECORD: action.record_date,
+                CorporateActionPhase.EX_DATE: action.ex_date,
+                CorporateActionPhase.PAY_DATE: action.pay_date,
+                CorporateActionPhase.LISTING_DATE: action.listing_date,
+            }
+            for phase, effective_time in phase_times:
+                effective_date = dates[phase]
+                if effective_date is None:
+                    continue
+                event_time = datetime.combine(
+                    effective_date, effective_time, tzinfo=_MARKET_TZ
+                ).astimezone(UTC)
+                if request.start <= event_time <= request.end:
+                    events.append(
+                        CorporateActionEvent(
+                            event_time=event_time,
+                            received_at=received_at,
+                            sequence=0,
+                            source="replay",
+                            payload=CorporateActionEventPayload(action=action, phase=phase),
+                        )
+                    )
+        return events
+
+    async def _open_days_with_full_coverage(
+        self, exchange: str, start_d: date, end_d: date
+    ) -> list[date]:
+        """完整日历基线（R1 契约）：请求涉及的每个本地自然日都必须有日历行
+
+        「返回行非空」不代表日历已完整同步；缺任何一天 → 结构化失败
+        （无法区分「休市」与「日历缺失」，禁止静默当作非交易日跳过）。
+        返回区间内 open days（升序）。
+        """
+        days = await self.repository.list_calendar_days(exchange, start_d, end_d, only_open=False)
+        coverage = build_calendar_coverage(exchange, start_d, end_d, days)
+        coverage.require_complete()
+        return list(coverage.open_days)
+
+    async def _daily_snapshot_events(
+        self,
+        instrument_id: str,
+        request: MarketStreamRequest,
+        received_at: datetime,
+        open_days: list[date],
+    ) -> tuple[list[MarketEvent], bool]:
+        """日级官方事实 → 每交易日一条完整 DailyStateSnapshotEvent（T1/T3 契约）
+
+        事件时间取当日 SESSION_OPEN（A股 09:30）：与当日首根 Bar 同片，符合
+        MarketTimeSlice「同片同标的快照/Bar 各一条」契约。
+        - 覆盖区间内每个交易日（TradingCalendar open days）：
+          有事实行 → 按官方事实展开；无事实行 → 显式 UNKNOWN 快照
+          （跨日重置基线，不依赖「事件缺席」；价格限制随快照显式清除）；
+        - bounded replay 初始化（R1 契约）：request.start 晚于当日开盘时，
+          快照以窗口起点 max(开盘, start) 作为生效时间注入——当日官方事实
+          必须先于首根被消费的 Bar 生效，不允许让 Resolver 从 UNKNOWN 起步；
+          不使用未来信息、不反查 Provider、不从 Bar 推断，且 event_time
+          不早于 request.start（无时间倒退）、保持请求闭区间；
+        - 交易日历由调用方传入完整基线（每交易所一次查询，Session 共享）；
+        - Bar 流与 Runtime 因果顺序零修改：快照只作为附加事实流入切片。
+        """
+        assert request.start is not None and request.end is not None
+        start_d = request.start.astimezone(_MARKET_TZ).date()
+        end_d = request.end.astimezone(_MARKET_TZ).date()
+        facts = {
+            f.trade_date: f
+            for f in await self.repository.list_daily_facts(instrument_id, start_d, end_d)
+        }
+        events: list[MarketEvent] = []
+        hour, minute = (int(x) for x in SESSION_OPEN_TIME.split(":"))
+        for day in open_days:
+            f = facts.get(day)
+            expanded = expand_daily_state(
+                None
+                if f is None
+                else DailyFact(
+                    trade_date=f.trade_date,
+                    suspension_status=f.suspension_status,
+                    limit_up=f.limit_up,
+                    limit_dn=f.limit_dn,
+                    extra=getattr(f, "extra", None),
+                )
+            )
+            day_open = datetime(
+                day.year,
+                day.month,
+                day.day,
+                hour,
+                minute,
+                tzinfo=_MARKET_TZ,
+            ).astimezone(UTC)
+            # bounded replay 初始化：窗口起点晚于开盘 → 快照推迟到窗口起点生效
+            event_time = max(day_open, request.start)
+            if not (request.start <= event_time <= request.end):
+                continue
+            events.append(
+                daily_state_snapshot_to_event(
+                    instrument_id,
+                    expanded.trading_state,
+                    event_time,
+                    expanded.limit_up if expanded.has_price_limit else None,
+                    expanded.limit_dn if expanded.has_price_limit else None,
+                    0,
+                    "replay",
+                    received_at,
+                )
+            )
+        return events, bool(facts)
+
+    def _session_events(
+        self, request: MarketStreamRequest, calendars: dict[str, list[date]]
+    ) -> tuple[list[MarketEvent], list[MarketEvent]]:
+        """基于共享日历基线为每个涉及 Exchange 生成 Session 事件
+
+        calendars 由 _stream_merged 以「每交易所一次完整覆盖查询」构建，
+        Session 与 Snapshot 消费同一份 open days（R1 契约）。
+        返回 (前置边界列表, 后置边界列表)。
+        """
+        assert request.start is not None and request.end is not None
+        pre: list[MarketEvent] = []
+        post: list[MarketEvent] = []
+        received_at = datetime.now(UTC)
+        for exchange, open_days in sorted(calendars.items()):
+            for day in open_days:
+                for stage, hhmm in _SESSION_STAGES:
+                    hour, minute = int(hhmm[:2]), int(hhmm[3:])
+                    event_time = datetime(
+                        day.year,
+                        day.month,
+                        day.day,
+                        hour,
+                        minute,
+                        tzinfo=_MARKET_TZ,
+                    ).astimezone(UTC)
+                    if request.start <= event_time <= request.end:
+                        event = trading_session_to_event(
+                            exchange, stage, event_time, 0, "replay", received_at
+                        )
+                        (pre if stage in PRE_SESSION_STAGES else post).append(event)
+        sort_key = lambda e: (e.event_time, e.payload.exchange)  # noqa: E731
+        pre.sort(key=sort_key)
+        post.sort(key=sort_key)
+        return pre, post
+
+    def _exchange_state_events(
+        self, request: MarketStreamRequest, calendars: dict[str, list[date]]
+    ) -> tuple[list[MarketEvent], list[MarketEvent], list[MarketEvent]]:
+        """交易所运行状态事实（T4R）：(Snapshot 基线, 前置边界增量, 后置边界增量)
+
+        - Snapshot 在 request.start 为每交易所建立 bounded replay 起点的完整
+          状态基线：开市日按确定性 A 股时段规则（_phase_at_time）推导，
+          非开市日 CLOSED。不伪造「request.start 发生状态转换」——窗口内
+          没有对应 Session 边界就没有增量事件；
+        - 增量 Event 与 Session 边界同点同源生成（_STAGE_TO_PHASE 映射），
+          排序优先级由 market_event_order_key 按目标 phase 继承边界层；
+        - 日历基线与 Session/DailySnapshot 共享（每交易所一次查询）。
+        """
+        assert request.start is not None and request.end is not None
+        snapshots: list[MarketEvent] = []
+        pre: list[MarketEvent] = []
+        post: list[MarketEvent] = []
+        received_at = datetime.now(UTC)
+        start_local = request.start.astimezone(_MARKET_TZ)
+        open_day_sets = {exchange: set(days) for exchange, days in calendars.items()}
+        for exchange in sorted(calendars):
+            baseline_phase = (
+                ExchangePhase.CLOSED
+                if start_local.date() not in open_day_sets[exchange]
+                else _phase_at_time(start_local.strftime("%H:%M"))
+            )
+            snapshots.append(
+                exchange_state_snapshot_to_event(
+                    exchange, baseline_phase, request.start, 0, "replay", received_at
+                )
+            )
+        for exchange, open_days in sorted(calendars.items()):
+            for day in open_days:
+                for stage, hhmm in _SESSION_STAGES:
+                    hour, minute = int(hhmm[:2]), int(hhmm[3:])
+                    event_time = datetime(
+                        day.year, day.month, day.day, hour, minute, tzinfo=_MARKET_TZ
+                    ).astimezone(UTC)
+                    if request.start <= event_time <= request.end:
+                        event = exchange_state_to_event(
+                            exchange,
+                            _STAGE_TO_PHASE[stage],
+                            event_time,
+                            0,
+                            "replay",
+                            received_at,
+                        )
+                        (pre if stage in PRE_SESSION_STAGES else post).append(event)
+        return snapshots, pre, post
+
+
+def _exchange_of(instrument_id: str) -> str:
+    """单标的 Canonical ID（CN.XSHE.000001）→ 交易所段（非法 ID 显式失败）"""
+    parts = instrument_id.split(".")
+    if len(parts) != 3 or parts[1] not in Exchange.__members__:
+        raise ValueError(f"非法 Canonical instrument_id: {instrument_id}")
+    return parts[1]
+
+
+def _exchanges_from_instrument_ids(instrument_ids: list[str]) -> set[str]:
+    """从 Canonical instrument_id（CN.XSHE.000001）提取涉及的交易所；推断不出默认 XSHG"""
+    exchanges = {
+        parts[1]
+        for instrument_id in instrument_ids
+        if len(parts := instrument_id.split(".")) == 3 and parts[1] in Exchange.__members__
+    }
+    return exchanges or {Exchange.XSHG.value}
+
+
+def _daterange(start_d: date, end_d: date) -> list[date]:
+    """闭区间内全部本地自然日（完整日历覆盖检查的基准）"""
+    return [date.fromordinal(o) for o in range(start_d.toordinal(), end_d.toordinal() + 1)]
+
+
+class LiveMarketEventSource:
+    """实时事件源：Provider 最新快照轮询包装为事件流（V1 轮询形态）"""
+
+    def __init__(self, provider):
+        self.provider = provider
+
+    async def stream(self, request: MarketStreamRequest) -> AsyncIterator[MarketEvent]:
+        sequence = 0
+        while True:
+            quotes = await self.provider.get_spot_quotes()
+            now = datetime.now(UTC)
+            for q in quotes:
+                if request.instrument_ids and q.instrument_id not in request.instrument_ids:
+                    continue
+                # V1 快照以 bar 事件形态发布；tick 事件属未来 Level-2
+                event = MarketEvent(
+                    event_type=MarketEventType.BAR,
+                    event_time=q.timestamp,
+                    received_at=now,
+                    sequence=sequence,
+                    source="live",
+                    payload=q.model_dump(mode="json"),
+                )
+                yield event
+                sequence += 1
+            await asyncio.sleep(3.0 if request.speed <= 0 else 3.0 / request.speed)
+
+
+class MarketRuntimeService:
+    """市场运行时 Service：按模式把请求路由到对应事件源"""
+
+    def __init__(
+        self,
+        replay_source: IMarketEventSource,
+        live_source: IMarketEventSource,
+    ):
+        self._sources = {MarketStreamMode.REPLAY: replay_source, MarketStreamMode.LIVE: live_source}
+
+    def stream(self, request: MarketStreamRequest) -> AsyncIterator[MarketEvent]:
+        """获取市场事件流（Live 与 Replay 的统一入口）"""
+        return self._sources[request.mode].stream(request)