hamuna-quant-cli 0.1.12__tar.gz → 0.1.14__tar.gz

{hamuna_quant_cli-0.1.12 → hamuna_quant_cli-0.1.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hamuna-quant-cli
-Version: 0.1.12
+Version: 0.1.14
 Summary: Hamuna A 股回测 + 实盘统一 CLI (akquant 0.3.x). 替代 v1 自建 driver + QMT-style 策略规范.
 Author-email: Hamuna Team <team@hamuna.example>
 License: MIT

{hamuna_quant_cli-0.1.12 → hamuna_quant_cli-0.1.14}/hamuna_quant_cli/__init__.py

@@ -12,4 +12,4 @@ server (13-key metrics schema). 全部走 akquant 0.3.x 引擎.
 """
 from __future__ import annotations
 
-__version__ = "0.1.12"
+__version__ = "0.1.14"

{hamuna_quant_cli-0.1.12 → hamuna_quant_cli-0.1.14}/hamuna_quant_cli/__main__.py

@@ -598,7 +598,7 @@ def _bridge_kline(server: str, symbols: list[str], days: int) -> list[dict]:
     for sym in symbols:
         url = (
             f"{server}/data/history?security={urllib.parse.quote(sym)}"
-            f"&period=1d&count={days}&fq=None"
+            f"&period=1d&count={days}&fq=None&subscribe=false"
         )
         try:
             with urllib.request.urlopen(url, timeout=8) as resp:

{hamuna_quant_cli-0.1.12 → hamuna_quant_cli-0.1.14}/hamuna_quant_cli/live/qmt_market.py

@@ -28,6 +28,15 @@ akquant MarketGateway 接口:
             poll_interval 拉一次当日 bar, 若 OHLCV 任何字段变化就推 (盘中
             "今日累计" bar 持续更新直到收盘 — QMT 默认行为, 适合日线择时).
 
+Round 33 双源验证 (server 数据源):
+  dual_source="off"   : 单源 QMT (默认, paper 模式).
+  dual_source="verify": 双源 QMT + server 并行拉, 不一致 server 为主 + log warn.
+                        broker_live 默认开 (runner.py _live_safety_defaults).
+  dual_source="fallback": QMT 主, server 备; server 仅在 QMT 失败时启用.
+  server 走 /api/v1/cli/market/snapshot (容维 /RealTime TierNone 直连),
+  跟 backend /api/v1/market/bars 配套. 1m 路径 server 不支持物理表, CLI
+  自聚 (ServerMarketClient.OneMinuteAggregator).
+
 设计原则:
     - thin client: 翻译 + HTTP, 不存业务逻辑
     - 跟 broker 同 _HTTP / register / factory 套路 (requests.Session + Retry transient 自动重试)
@@ -42,9 +51,11 @@ __version__ = "0.1.0"
 # 共享 HTTP client — 跟 broker 模块同一份, 不重复实现
 # ============================================================
 from .qmt_broker import _HTTP, BrokerHTTPError, _emit_paper  # noqa: F401  re-used
+from .server_market_client import ServerMarketClient, OneMinuteAggregator
 
 import threading
 import time
+import json
 from typing import Any, Callable
 
 
@@ -76,6 +87,13 @@ def _make_market_gateway() -> Any:
             timeout: float = 5.0,
             symbols: list[str] | None = None,  # 启动时 auto-subscribe (来自 build_qmt_market 的 symbols)
             subscribe: bool = False,  # paper=False / broker_live=True — 透传给 /data/history
+            # Round 33: server 数据源 + 双源验证
+            server_base_url: str | None = None,  # None → 不开 server 源 (单源 QMT)
+            server_api_key: str | None = None,   # None → runtime.http_client._load_token() 自动读
+            server_timeout: float = 5.0,
+            dual_source: str = "off",  # "off" | "verify" | "fallback"
+            diff_threshold_close: float = 0.001,  # 0.1%
+            diff_threshold_volume: float = 0.05,   # 5%
         ) -> None:
             self._feed = feed
             self._http = _HTTP(base_url, timeout=timeout)
@@ -83,6 +101,18 @@ def _make_market_gateway() -> Any:
             self._bar_count = bar_count
             self._poll_interval = max(0.05, float(poll_interval))
             self._subscribe = bool(subscribe)
+            self._dual_source = dual_source if dual_source in ("off", "verify", "fallback") else "off"
+            self._diff_threshold_close = max(0.0, float(diff_threshold_close))
+            self._diff_threshold_volume = max(0.0, float(diff_threshold_volume))
+            # server 源: dual_source != "off" 才实例化 (避免无谓的 credentials.json 探测)
+            self._server: ServerMarketClient | None = None
+            self._server_aggr: dict[str, OneMinuteAggregator] = {}  # sym → 自聚 1m 桶 (Round 33 broker_live 1m 路径)
+            if self._dual_source != "off" and server_base_url is not None:
+                self._server = ServerMarketClient(
+                    base_url=server_base_url,
+                    api_key=server_api_key,
+                    timeout=server_timeout,
+                )
             # 启动时 auto-subscribe: build_qmt_market(symbols=...) 传来的就是 akquant run_live
             # instruments — 立即装订到 _subscribed, 不依赖 akquant forwarder (实测发现 forwarder
             # 在 functional mode 下安装时机晚于 strategy.subscribe, 错过首次订阅)
@@ -125,10 +155,16 @@ def _make_market_gateway() -> Any:
             if self._running:
                 return
             self._running = True
+            # Round 18.63 SSE push: bridge 主动推 bar/tick 走 /events/subscribe 长连接.
+            # warmup 仍走历史回填 (Round 26 优化, 不动); tick 通路先尝试 SSE, 失败
+            # 回退 polling. bar 也走 SSE 推 (新加), polling 仅 fallback.
             self._warmup_bars()
             self._thread = threading.Thread(target=self._poll_loop, daemon=True,
                                             name="qmt-market-poll")
             self._thread.start()
+            self._sse_thread = threading.Thread(target=self._sse_loop, daemon=True,
+                                               name="qmt-market-sse")
+            self._sse_thread.start()
 
         # ---- internal ----
 
@@ -202,6 +238,127 @@ def _make_market_gateway() -> Any:
                 elif sleep_for > 0:
                     time.sleep(sleep_for)
 
+        def _sse_loop(self) -> None:
+            """Round 18.63 SSE push: bridge /events/subscribe 长连接, 推 bar/tick 帧.
+            替代 polling 主路径. 断流 → 自动重连, 退避到 poll fallback.
+            """
+            backoff = 1.0
+            while self._running:
+                try:
+                    self._sse_consume()
+                    backoff = 1.0
+                except Exception as exc:  # noqa: BLE001 — SSE 异常不致命
+                    err_str = str(exc)[:200]
+                    print(
+                        f"[qmt-market] sse error: {type(exc).__name__}: {err_str}; "
+                        f"reconnect in {backoff:.1f}s",
+                        flush=True,
+                    )
+                    time.sleep(backoff)
+                    backoff = min(backoff * 2.0, 30.0)
+
+        def _sse_consume(self) -> None:
+            """一次 SSE 长连接: GET /events/subscribe, 按行解析 data: 帧."""
+            subs = sorted(self._subscribed)
+            if not subs:
+                time.sleep(1.0)
+                return
+            qmt_securities = [_to_qmt_symbol(s) for s in subs]
+            url = f"{self._http.base_url}/events/subscribe"
+            params = {"symbols": ",".join(qmt_securities), "period": self._period}
+            print(
+                f"[qmt-market] sse connect {url} symbols={len(subs)} "
+                f"period={self._period}",
+                flush=True,
+            )
+            # requests.Session + stream=True — SSE 长连接, 客户端按行读
+            resp = self._http._session.get(
+                url, params=params, stream=True,
+                headers={"Accept": "text/event-stream"},
+                timeout=(10.0, 3600.0),  # connect 10s, read 1h (SSE 永不主动断)
+            )
+            resp.raise_for_status()
+            current_event: str | None = None
+            current_data_lines: list[str] = []
+            for raw_line in resp.iter_lines(chunk_size=1, decode_unicode=True):
+                if not self._running:
+                    break
+                if raw_line is None:
+                    continue
+                line = raw_line.rstrip("\n").rstrip("\r")
+                if not line:
+                    # 空行 = 帧结束 → flush
+                    if current_data_lines:
+                        try:
+                            payload = json.loads("".join(current_data_lines))
+                            self._sse_dispatch(payload)
+                        except json.JSONDecodeError as exc:
+                            print(
+                                f"[qmt-market] sse frame json err: {exc}; "
+                                f"data={current_data_lines[:2]}",
+                                flush=True,
+                            )
+                        except Exception as exc:  # noqa: BLE001
+                            print(
+                                f"[qmt-market] sse dispatch err: {exc}",
+                                flush=True,
+                            )
+                        current_event = None
+                        current_data_lines = []
+                    continue
+                if line.startswith(":"):
+                    continue  # SSE 注释行
+                if line.startswith("event:"):
+                    current_event = line[len("event:"):].strip() or None
+                elif line.startswith("data:"):
+                    current_data_lines.append(line[len("data:"):].lstrip())
+                # 其他前缀 (id:, retry:) 忽略
+            resp.close()
+
+        def _sse_dispatch(self, payload: dict[str, Any]) -> None:
+            """SSE 帧分发: hello / tick / bar / ping. tick 推 feed; bar 推 feed."""
+            ftype = payload.get("type", "tick")
+            if ftype == "ping":
+                return
+            if ftype == "hello":
+                print(
+                    f"[qmt-market] sse hello symbols={payload.get('symbols')} "
+                    f"period={payload.get('period')}",
+                    flush=True,
+                )
+                return
+            if ftype == "bar":
+                # bridge 推单 sym 单 bar
+                sec = payload.get("security")
+                bar = payload.get("bar") or {}
+                period = payload.get("period", self._period)
+                if not sec or not bar:
+                    return
+                # 转 akquant 标准 symbol
+                std_sym = _from_qmt_symbol(sec) if ".X" in sec else sec
+                # bar 字段归一: bridge 给 {time, open, high, low, close, volume}
+                raw = dict(bar)
+                raw["symbol"] = std_sym
+                # 末根 sig 去重 (避免 bridge 重发同根)
+                sig = _bar_signature(raw)
+                if self._last_bar_signatures.get(std_sym) == sig:
+                    return
+                self._last_bar_signatures[std_sym] = sig
+                self._emit_bar(raw)
+                print(
+                    f"[qmt-market] sse bar {std_sym} t={bar.get('time')} "
+                    f"c={bar.get('close')} v={bar.get('volume')}",
+                    flush=True,
+                )
+                return
+            # 默认当 tick 帧
+            ticks = payload.get("ticks") or {}
+            for qmt_sym, tick in ticks.items():
+                std_sym = _from_qmt_symbol(qmt_sym) if ".X" in str(qmt_sym) else str(qmt_sym)
+                raw = dict(tick)
+                raw.setdefault("symbol", std_sym)
+                self._emit_tick(raw)
+
         def _poll_once(self) -> None:
             """一次 poll 拉 ticks + bars — 各自独立 try/except, 互不阻塞.
 
@@ -247,38 +404,149 @@ def _make_market_gateway() -> Any:
 
             响应 (无 envelope): {ticks: {sym: tick_dict}, qmt_codes: [...], source: '...'}
             ticks 内的 key 是 QMT 内部格式 (e.g. 600000.XSHG) — 转 6 位 canonical 跟 strategy 一致.
+
+            Round 33: 双源验证 (dual_source="verify") 时, 与 server 容维 /RealTime 并行拉,
+            diff lastPrice >0.1% → server 为主 + log [DIFF]. 任一源不可达 → fallback 单源.
             """
             securities_str = ",".join(_to_qmt_symbol(s) for s in symbols)
-            resp = self._http.get("/data/snapshot", {"securities": securities_str})
-            ticks_map = resp.get("ticks", {}) if isinstance(resp, dict) else {}
+            qmt_ticks_map: dict[str, dict[str, Any]] = {}
+            try:
+                resp = self._http.get("/data/snapshot", {"securities": securities_str})
+                ticks_map = resp.get("ticks", {}) if isinstance(resp, dict) else {}
+                if isinstance(ticks_map, dict):
+                    for qmt_sym, payload in ticks_map.items():
+                        if isinstance(payload, dict):
+                            qmt_ticks_map[qmt_sym] = payload
+            except Exception as e:  # noqa: BLE001
+                print(f"[qmt-market] QMT snapshot poll error: {type(e).__name__}: {e}",
+                      flush=True)
+
+            server_ticks_map: dict[str, dict[str, Any]] = {}
+            if self._dual_source != "off" and self._server is not None:
+                try:
+                    server_ticks_map = self._server.fetch_snapshot(symbols)
+                except ConnectionError as e:
+                    if self._dual_source == "fallback":
+                        # QMT 主, server 失败忽略
+                        pass
+                    else:
+                        print(f"[qmt-market] server snapshot poll FAIL (fallback to QMT): {e}",
+                              flush=True)
+
+            # 合并: QMT 主, server 校验
             ticks: list[dict[str, Any]] = []
-            if isinstance(ticks_map, dict):
-                for qmt_sym, payload in ticks_map.items():
-                    if not isinstance(payload, dict):
-                        continue
-                    tick = dict(payload)
-                    # QMT sym (e.g. 600000.XSHG) → akquant 标准 (600000.SH) 匹配 instruments
-                    std_sym = _from_qmt_symbol(qmt_sym)
-                    tick.setdefault("symbol", std_sym)
+            # 用 QMT key 集合作为权威 (QMT 决定 sym 在不在)
+            for qmt_sym, payload in qmt_ticks_map.items():
+                std_sym = _from_qmt_symbol(qmt_sym)
+                tick = dict(payload)
+                tick.setdefault("symbol", std_sym)
+                # diff: 与 server 同 sym 比 lastPrice
+                if std_sym in server_ticks_map:
+                    self._diff_tick(std_sym, tick, server_ticks_map[std_sym])
+                ticks.append(tick)
+
+            # server 有但 QMT 没的 — 补 (server 容维覆盖更广, 但 QMT 才有统一对齐 .XSHG/.XSHE 后缀)
+            for std_sym, srv_tick in server_ticks_map.items():
+                if std_sym not in {t.get("symbol") for t in ticks}:
+                    tick = dict(srv_tick)
+                    tick["symbol"] = std_sym
                     ticks.append(tick)
             return ticks
 
+        def _diff_tick(self, sym: str, qmt_tick: dict, srv_tick: dict) -> None:
+            """tick diff — 不一致 log warn. server 为主已经在 qmt_tick 里 (策略照常跑);
+            这里只 log, 不改 qmt_tick 字段值. 用户决策 'server 为主' 适用于不可调和场景
+            (server 拉到了 QMT 没拉到的 sym) — 价格不一致时 log warn 让 user 事后查."""
+            qmt_px = float(qmt_tick.get("lastPrice") or qmt_tick.get("price") or 0.0)
+            srv_px = float(srv_tick.get("lastPrice") or srv_tick.get("price") or 0.0)
+            if qmt_px <= 0 or srv_px <= 0:
+                return
+            ratio = abs(qmt_px - srv_px) / qmt_px
+            if ratio > self._diff_threshold_close:
+                print(
+                    f"[qmt-market][DIFF] tick {sym} close_qmt={qmt_px:.3f} "
+                    f"close_server={srv_px:.3f} ratio={ratio:.4f} "
+                    f"(threshold={self._diff_threshold_close:.4f})",
+                    flush=True,
+                )
+
         def _fetch_bars(self, symbol: str, count: int | None = None) -> list[dict[str, Any]]:
             """GET /data/history?security=...&period=1d&count=N[&subscribe=T/F] → list of bar dict (旧→新).
 
             subscribe: paper=False / broker_live=True (round 28+1 决策) — paper
             一次性拉够 N 根即可, broker_live 必须 True 让 QMT 实时推新 bar,
             避免 count=-1 + 空时间窗只返本地最新 1 条 snapshot 的问题.
+
+            Round 33 双源 (dual_source="verify"): QMT 历史 bar 为主, server
+            (容维 /StockBars 通过 backend /market/bars) 拉同样窗口. period=1m
+            backend 不支持物理表, server 端走 snapshot + 自聚 (period 不强制要求).
             """
             qmt_sym = _to_qmt_symbol(symbol)
             cnt = count if count is not None else self._bar_count
             params = {"security": qmt_sym, "period": self._period,
                       "count": str(cnt), "fq": "qfq"}
-            if self._subscribe:
-                params["subscribe"] = "true"
+            # Round 32: 显式带 subscribe, 不靠 bridge 默认 (已翻 True). paper 轮询纯历史
+            # → subscribe=false 防误开 QMT 订阅; broker_live → true (实时推新 bar).
+            params["subscribe"] = "true" if self._subscribe else "false"
             resp = self._http.get("/data/history", params)
             value = _unwrap_envelope(resp)
-            return _bars_from_history(value, symbol)
+            qmt_bars = _bars_from_history(value, symbol)
+
+            # Round 33 dual_source
+            if self._dual_source != "off" and self._server is not None and self._period != "1m":
+                try:
+                    server_bars_map = self._server.fetch_bars(
+                        [symbol], period=self._period, count=cnt
+                    )
+                    srv_bars = server_bars_map.get(symbol, [])
+                    if srv_bars and qmt_bars:
+                        self._diff_bars(symbol, qmt_bars, srv_bars)
+                    elif srv_bars and not qmt_bars:
+                        # QMT 空但 server 有 — server 为主 (用户决策: server 为主)
+                        print(
+                            f"[qmt-market][DIFF] bars {symbol} qmt=empty server={len(srv_bars)}; "
+                            f"using server (server 优先)",
+                            flush=True,
+                        )
+                        return srv_bars
+                except (ConnectionError, ValueError) as e:
+                    if self._dual_source == "fallback":
+                        pass
+                    else:
+                        print(
+                            f"[qmt-market] server bars poll FAIL (fallback to QMT): {e}",
+                            flush=True,
+                        )
+
+            return qmt_bars
+
+        def _diff_bars(self, sym: str, qmt_bars: list[dict], srv_bars: list[dict]) -> None:
+            """bar diff: 比最后一根 close + volume. 不一致 log warn."""
+            if not qmt_bars or not srv_bars:
+                return
+            q = qmt_bars[-1]
+            s = srv_bars[-1]
+            q_close = float(q.get("close") or 0.0)
+            s_close = float(s.get("close") or 0.0)
+            if q_close <= 0 or s_close <= 0:
+                return
+            close_ratio = abs(q_close - s_close) / q_close
+            if close_ratio > self._diff_threshold_close:
+                print(
+                    f"[qmt-market][DIFF] bar {sym} close_qmt={q_close:.3f} "
+                    f"close_server={s_close:.3f} ratio={close_ratio:.4f}",
+                    flush=True,
+                )
+            q_vol = float(q.get("volume") or 0.0)
+            s_vol = float(s.get("volume") or 0.0)
+            if q_vol > 0 and s_vol > 0:
+                vol_ratio = abs(q_vol - s_vol) / q_vol
+                if vol_ratio > self._diff_threshold_volume:
+                    print(
+                        f"[qmt-market][DIFF] bar {sym} vol_qmt={q_vol:.0f} "
+                        f"vol_server={s_vol:.0f} ratio={vol_ratio:.4f}",
+                        flush=True,
+                    )
 
     return QmtMarketGateway
 
@@ -480,6 +748,15 @@ def build_qmt_market(feed: Any, symbols: list[str], use_aggregator: bool, **kwar
                                             (paper=False, broker_live=True)
                                             透传方式: --gateway-options
                                             "market_subscribe=1" (或 True)
+      server_base_url   (default None)  — Round 33: server 数据源 base URL
+                                            (None → 不开 server 源)
+      server_api_key    (default None)  — Round 33: 显式 API key; None → 自动
+                                            从 ~/.hamuna/credentials.json 读
+      server_timeout    (default 5.0)   — Round 33: server HTTP 超时
+      dual_source       (default "off") — "off" | "verify" | "fallback"
+                                            broker_live 默认 "verify" (runner.py 配)
+      diff_threshold_close  (default 0.001) — close 差阈值 (0.1%)
+      diff_threshold_volume (default 0.05)  — volume 差阈值 (5%)
     """
     from akquant.gateway.protocols import GatewayBundle
 
@@ -491,6 +768,22 @@ def build_qmt_market(feed: Any, symbols: list[str], use_aggregator: bool, **kwar
     # market_subscribe: CLI 字符串 "1"/"true"/"yes" → True, 其它/缺失 → False
     subscribe_raw = kwargs.get("market_subscribe") or kwargs.get("subscribe") or ""
     subscribe = str(subscribe_raw).strip().lower() in ("1", "true", "yes", "on")
+    # Round 33 双源 kwargs
+    server_base_url = kwargs.get("server_base_url")
+    server_api_key = kwargs.get("server_api_key")
+    server_timeout = float(kwargs.get("server_timeout") or 5.0)
+    dual_source = str(kwargs.get("dual_source") or "off")
+    diff_threshold_close = float(kwargs.get("diff_threshold_close") or 0.001)
+    diff_threshold_volume = float(kwargs.get("diff_threshold_volume") or 0.05)
+    # Round 33: dual_source 启用且 server_base_url 未显式传 → 从 runtime.http_client
+    # 拿 server 地址 (env / server.json / 默认 localhost:8080). 默认 broker_live
+    # dual_source=verify 时这里自动接上 server — user 不用手动配 server_base_url.
+    if dual_source != "off" and not server_base_url:
+        try:
+            from ..runtime import http_client as _hc
+            server_base_url = _hc._resolve_server()
+        except Exception:  # noqa: BLE001 — credentials 缺失时静默退化为单源
+            pass
     QmtMarketGateway = _make_market_gateway()
     gw = QmtMarketGateway(
         feed=feed,  # akquant DataFeed — 主路径推 tick/bar 用
@@ -498,6 +791,12 @@ def build_qmt_market(feed: Any, symbols: list[str], use_aggregator: bool, **kwar
         poll_interval=poll, timeout=timeout,
         symbols=list(symbols or []),  # auto-subscribe (绕开 akquant forwarder 时序 bug)
         subscribe=subscribe,
+        server_base_url=server_base_url,
+        server_api_key=server_api_key,
+        server_timeout=server_timeout,
+        dual_source=dual_source,
+        diff_threshold_close=diff_threshold_close,
+        diff_threshold_volume=diff_threshold_volume,
     )
     return GatewayBundle(
         market_gateway=gw,
@@ -505,7 +804,8 @@ def build_qmt_market(feed: Any, symbols: list[str], use_aggregator: bool, **kwar
         trader_capabilities=None,
         metadata={"broker": "qmt_market", "bridge": "bullettrade_compat",
                   "period": period, "bar_count": bar_count, "poll_interval": poll,
-                  "subscribe": subscribe},
+                  "subscribe": subscribe,
+                  "dual_source": dual_source},
     )
 
 

{hamuna_quant_cli-0.1.12 → hamuna_quant_cli-0.1.14}/hamuna_quant_cli/live/runner.py

@@ -121,8 +121,10 @@ def _fetch_bridge_history(bridge_url: str, sym: str, period: str, count: int,
     if canonical.lower().startswith(("sh", "sz")):
         canonical = canonical[2:]
     params = {"security": canonical, "period": period, "count": str(count), "fq": "qfq"}
-    if subscribe:
-        params["subscribe"] = "true"
+    # Round 32: bridge_server subscribe 默认翻 True (qmt-docs 官方对齐) 后, 这里不能
+    # 省掉 query 靠默认 — 纯历史/paper 路径必须显式 subscribe=false 防误开 QMT 订阅
+    # (Round 27 300 只批量防卡护栏从 bridge 默认移到调用端显式 false).
+    params["subscribe"] = "true" if subscribe else "false"
     q = urlencode(params)
     url = f"{bridge_url.rstrip('/')}/data/history?{q}"
     try:
@@ -181,8 +183,8 @@ def _fetch_bridge_history_batch(bridge_url: str, symbols: list[str], period: str
         qmt_codes.append(c)
     params = {"securities": ",".join(qmt_codes),
               "period": period, "count": str(count), "fq": "qfq", "multi": "true"}
-    if subscribe:
-        params["subscribe"] = "true"
+    # Round 32: 同 _fetch_bridge_history — 显式带 subscribe, 不靠 bridge 默认 (已翻 True).
+    params["subscribe"] = "true" if subscribe else "false"
     q = urlencode(params)
     url = f"{bridge_url.rstrip('/')}/data/history?{q}"
     try:
@@ -614,6 +616,15 @@ def _live_safety_defaults(
             print("[info] broker_live 默认 duration=0 (永久运行); 如需限时显式传 --duration", flush=True)
             return "0"
         print(f"[warn] broker_live 使用显式 duration={duration} — 到期自动停止", flush=True)
+
+        # Round 33: broker_live 默认开 dual_source=verify (QMT + server 端双源验证).
+        # server_base_url 不显式传 → qmt_market 里 server=None → 退化为单源 QMT (旧路径).
+        # user 想开 server 验证 → --gateway-options "dual_source=verify,server_base_url=http://..."
+        # 或 env HAMUNA_SERVER 让 server_market_client 自动读.
+        if gateway_options.get("dual_source") is None:
+            gateway_options["dual_source"] = "verify"
+            print("[info] broker_live 默认 dual_source=verify (QMT+server 双源); "
+                  "传 dual_source=off 可关闭", flush=True)
     return duration
 
 

hamuna_quant_cli-0.1.14/hamuna_quant_cli/live/server_market_client.py

@@ -0,0 +1,311 @@
+"""hamuna_quant_cli.live.server_market_client — server 端实盘数据源 client.
+
+Round 33: 给 CLI broker_live 加一条 server 数据源 (本项目 backend), 跟 QMT
+并行拉同代码同期, 不一致以 server 为主 + log mismatch.
+
+设计原则:
+  - 复用 runtime.http_client._load_token() + _resolve_server() — 不另开 HTTP 层
+  - 走 /api/v1/cli/market/snapshot 路由 (Round 33 新增), 等价于
+    /api/v1/cli/proxy/data/realtime 但语义清晰
+  - 1m 物理表 backend 不支持 (用户决策), 1m 自聚: 多 tick 累积 60s 桶, 桶满 emit 1m bar
+  - 默认 dual_source=off (单源 QMT), broker_live 才开 verify — runner 默认值
+    在 runner.py 写, 这里保持中性
+  - fail loud 不静默: server 不可达时抛 ConnectionError, 上层 qmt_market 决定
+    降级策略 (verify 模式 → log warn + fallback QMT)
+
+不重复 / 复用:
+  - runtime.http_client.proxy_get — 已有 API Key 鉴权 GET, 直接调
+  - qmt_market._to_qmt_symbol — symbol 归一, 复用
+"""
+from __future__ import annotations
+
+import logging
+from collections import deque as _dq
+from typing import Any, Callable
+from urllib.error import HTTPError, URLError
+
+from ..runtime import http_client
+
+
+_log = logging.getLogger("hamuna.server_market")
+
+
+def _strip_code_suffix(code: str) -> str:
+    """600000.SH / 600000.SH / sh600000 → 600000.
+
+    后端 rongwei.NormalizeStockCode 同语义, 这里直接一份 — 不跨包依赖.
+    容维上游只接受裸 6 位.
+    """
+    s = code.strip().upper()
+    if s.endswith((".SH", ".SZ", ".BJ")):
+        s = s[:-3]
+    if s[:2] in ("SH", "SZ", "BJ") and len(s) == 8:
+        s = s[2:]
+    return s
+
+
+def _to_canonical_sym(code6: str) -> str:
+    """裸 6 位 → canonical "600000.SH" / "000001.SZ" / "830001.BJ" (按代码前缀).
+
+    前缀规则 (跟 qmt_broker._to_qmt_symbol 反向):
+      5/6/9 → SH (上海); 0/3/2 → SZ (深圳 A + 创业板); 8/4 → BJ (北证).
+      其它 → 默认 SZ. 兜底不当真, caller 看到反常 sym 应 log warn.
+    """
+    s = _strip_code_suffix(code6)
+    if not s or len(s) != 6 or not s.isdigit():
+        return f"{s}.SZ" if s else ""
+    head = s[0]
+    if head in ("5", "6", "9"):
+        return f"{s}.SH"
+    if head in ("0", "2", "3"):
+        return f"{s}.SZ"
+    if head in ("4", "8"):
+        return f"{s}.BJ"
+    return f"{s}.SZ"
+
+
+def _to_float(v: Any) -> float:
+    """容容错: int/float/str 数字 / 其它 → float. None / 非数字 → 0.0."""
+    if v is None:
+        return 0.0
+    if isinstance(v, (int, float)):
+        return float(v)
+    if isinstance(v, str):
+        try:
+            return float(v)
+        except (TypeError, ValueError):
+            return 0.0
+    return 0.0
+
+
+def _to_int(v: Any) -> int:
+    if v is None:
+        return 0
+    if isinstance(v, bool):
+        return int(v)
+    if isinstance(v, int):
+        return v
+    if isinstance(v, float):
+        return int(v)
+    if isinstance(v, str):
+        try:
+            return int(float(v))
+        except (TypeError, ValueError):
+            return 0
+    return 0
+
+
+class ServerMarketClient:
+    """后端 server 数据源 client.
+
+    主要能力:
+      - fetch_snapshot(symbols) → 容维 /RealTime tick (TierNone 不入磁盘缓存)
+      - fetch_bars(symbols, period, count) → backend /api/v1/market/bars (1d/5m/15m/30m)
+      - aggregate_1m_from_ticks(symbol) → 自聚 1m bar (用 tick deque + 桶边界)
+    """
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        timeout: float = 5.0,
+    ) -> None:
+        # ponytail: base_url/api_key 留 None 让 proxy_get 自己从 env + credentials.json 拿;
+        # 显式传值用于测试 mock. 不复制一份解析逻辑.
+        self._base_url_override = base_url
+        self._api_key_override = api_key
+        self._timeout = max(1.0, float(timeout))
+
+    def fetch_snapshot(self, symbols: list[str]) -> dict[str, dict[str, Any]]:
+        """容维 /RealTime tick snapshot (TierNone 直连).
+
+        DataValue 形态是 array, 每个元素字段是 F01V (code) / F07N (price) /
+        F08N (volume) / F03N-F06N (prevClose/open/high/low) — 见 docs/接口文档.md §4.1.
+        返回: {sym_canonical: tick_dict} — lastPrice/open/close/high/low/volume/amount/time.
+        symbols 入参接受带后缀或裸 6 位; 返回统一 canonical (按代码前缀补 SH/SZ/BJ 后缀).
+        """
+        if not symbols:
+            return {}
+        # 容维 StockCode 多值用逗号分隔; 归一裸 6 位避免后端二次 normalize
+        codes = [_strip_code_suffix(s) for s in symbols]
+        params = {"StockCode": ",".join(codes)}
+        try:
+            env = http_client.proxy_get("realtime", params, no_cache=True)
+        except (HTTPError, URLError) as e:
+            raise ConnectionError(
+                f"server /cli/market/snapshot 不可达: {type(e).__name__}: {e}"
+            ) from e
+        # env = {Result, Error, Message, DataValue: ...}
+        if not env.get("Result"):
+            raise ConnectionError(
+                f"server 返 Result=false: err={env.get('Error')} msg={env.get('Message')}"
+            )
+        data = env.get("DataValue")
+        out: dict[str, dict[str, Any]] = {}
+        if isinstance(data, list):
+            for item in data:
+                if not isinstance(item, dict):
+                    continue
+                # 容维 /RealTime 字段是 F01V (code) / F07N (price) / F08N (volume) /
+                # F03N (prevClose) / F04N (open) / F05N (high) / F06N (low) /
+                # F09N (amount). 见 docs/接口文档.md §4.1.
+                code = str(item.get("F01V") or "").strip()
+                if not code:
+                    continue
+                std_sym = _to_canonical_sym(code)
+                # 翻译成 qmt_broker/qmt_market 用的 tick dict shape, 跟 QMT
+                # /data/snapshot tick dict 兼容 — 双源 diff 时字段命名一致.
+                tick = {
+                    "symbol": std_sym,
+                    "code": code,
+                    "name": str(item.get("F02V") or ""),
+                    "lastPrice": _to_float(item.get("F07N")),
+                    "open": _to_float(item.get("F04N")),
+                    "high": _to_float(item.get("F05N")),
+                    "low": _to_float(item.get("F06N")),
+                    "close": _to_float(item.get("F07N")),  # 容维无独立 close 字段, 用 lastPrice
+                    "prevClose": _to_float(item.get("F03N")),
+                    "volume": _to_int(item.get("F08N")),
+                    "amount": _to_int(item.get("F09N")),
+                    "bidPrice": _to_float(item.get("F11V")),  # 卖五档字符串, 暂不解析
+                    "askPrice": _to_float(item.get("F10V")),
+                    "time": env.get("TradeTime"),  # HHMMSS
+                    "tradeDate": env.get("TradeDate"),  # YYYYMMDD
+                    "source": "rongwei_realtime",
+                }
+                out[std_sym] = tick
+        return out
+
+    def fetch_bars(
+        self,
+        symbols: list[str],
+        period: str,
+        count: int = 20,
+        fq: str = "qfq",
+    ) -> dict[str, list[dict[str, Any]]]:
+        """backend /api/v1/market/bars → {sym: [bar dict, ...]}.
+
+        支持 period ∈ {1d, 5m, 15m, 30m}; period=1m backend 不支持 → raise ValueError,
+        caller 走 fetch_snapshot 自聚.
+        返回 bars 字段标准化: open/high/low/close/volume/amount/time/symbol.
+        """
+        if period == "1m":
+            raise ValueError(
+                "backend 不支持 1m 物理表 (用户决策: 不加 1m 表); "
+                "走 fetch_snapshot + aggregate_1m_from_ticks 自聚"
+            )
+        if period not in ("1d", "5m", "15m", "30m"):
+            raise ValueError(f"unsupported period {period!r} for server fetch_bars")
+        if not symbols:
+            return {}
+        # backend /api/v1/market/bars 是单 symbol 端点 → 循环拉
+        out: dict[str, list[dict[str, Any]]] = {}
+        for sym in symbols:
+            stripped = _strip_code_suffix(sym)
+            params = {"period": period, "symbol": stripped, "count": str(count)}
+            try:
+                resp = http_client._http_get_json(
+                    "/api/v1/market/bars", params,
+                    base_url=self._base_url_override,
+                    api_key=self._api_key_override,
+                    timeout=self._timeout,
+                )
+            except (HTTPError, URLError) as e:
+                raise ConnectionError(
+                    f"server /market/bars 不可达: {type(e).__name__}: {e}"
+                ) from e
+            bars = resp.get("bars", []) if isinstance(resp, dict) else []
+            # 规范化: 每个 bar 加 symbol 字段
+            out[sym] = [
+                {
+                    **b,
+                    "symbol": sym,
+                    "datetime": b.get("time") or b.get("datetime"),
+                }
+                for b in bars
+                if isinstance(b, dict)
+            ]
+        return out
+
+
+# ============================================================
+# 1m 自聚: tick → 1m bar
+# ============================================================
+
+
+class OneMinuteAggregator:
+    """rolling 1m bar 自聚器.
+
+    用法: agg = OneMinuteAggregator(); emit = agg.add_tick(tick_ts_ns, last_price, volume)
+    桶边界对齐到 HH:MM:00 (00s); 跨桶 emit 上一桶 + 开新桶.
+
+    简单实现: 不分多 symbol (单 sym 用); 想要多 sym 各起一个实例.
+    """
+
+    def __init__(self) -> None:
+        self._bucket_minute_ns: int = 0  # 当前桶起点 (ns)
+        self._open: float = 0.0
+        self._high: float = 0.0
+        self._low: float = 0.0
+        self._close: float = 0.0
+        self._volume: float = 0.0
+        self._count: int = 0  # tick 计数 (用于空桶剔除)
+
+    def add_tick(self, ts_ns: int, price: float, volume: float) -> dict[str, Any] | None:
+        """追加一个 tick; 若跨分钟 → emit 上一桶 (或 None 表示空桶) + 开新桶.
+
+        返回: emit 出的 1m bar dict 或 None (空桶或首 tick).
+        """
+        # 桶起点 = ts_ns 对应的整分钟 (向下取整到 60_000_000_000 ns)
+        bucket_ns = (ts_ns // 60_000_000_000) * 60_000_000_000
+        emitted: dict[str, Any] | None = None
+        if self._bucket_minute_ns == 0:
+            # 第一个 tick — 开新桶
+            self._open_bucket(bucket_ns, price, volume)
+            return None
+        if bucket_ns > self._bucket_minute_ns:
+            # 跨分钟 — emit 上一桶 + 开新桶
+            if self._count > 0:
+                emitted = self._make_bar(self._bucket_minute_ns)
+            self._open_bucket(bucket_ns, price, volume)
+            return emitted
+        # 同桶内累积
+        if price > self._high:
+            self._high = price
+        if price < self._low or self._low == 0.0:
+            self._low = price
+        self._close = price
+        self._volume += max(0.0, volume)
+        self._count += 1
+        return None
+
+    def _open_bucket(self, bucket_ns: int, price: float, volume: float) -> None:
+        self._bucket_minute_ns = bucket_ns
+        self._open = price
+        self._high = price
+        self._low = price
+        self._close = price
+        self._volume = max(0.0, volume)
+        self._count = 1
+
+    def _make_bar(self, bucket_ns: int) -> dict[str, Any]:
+        """bucket_ns (UTC ns) → 1m bar dict.
+
+        time 字段给 HHMMSS int (akquant Tick 用 HHMMSS); A 股用本地 CST
+        (UTC+8) 时区, 把 UTC ns 加 8h 偏移后再取 HH/MM. 避免下午 16:00 UTC
+        桶被算成 "16 时" 而不是次日 00 时.
+        """
+        from datetime import datetime, timezone, timedelta
+        ts_utc = datetime.fromtimestamp(bucket_ns / 1e9, tz=timezone.utc)
+        ts_cst = ts_utc.astimezone(timezone(timedelta(hours=8)))
+        hh = ts_cst.hour
+        mm = ts_cst.minute
+        return {
+            "time": int(hh * 10000 + mm * 100),  # HHMM00
+            "open": self._open,
+            "high": self._high,
+            "low": self._low,
+            "close": self._close,
+            "volume": int(self._volume),
+            "ts_ns": bucket_ns,
+        }

{hamuna_quant_cli-0.1.12 → hamuna_quant_cli-0.1.14}/hamuna_quant_cli/runtime/cache.py

@@ -50,6 +50,23 @@ def cache_key(params: dict[str, Any]) -> str:
     return hashlib.sha256(raw.encode()).hexdigest()[:16]
 
 
+def make_key(endpoint: str, params: dict[str, Any] | None = None) -> str:
+    """Round 18.63+ 补: http_client.py:174 (qmt_market snapshot 路径) 调
+    cache.make_key(endpoint, params) 期望 (endpoint, params) 签名 — 0.1.13 之前
+    该方法不存在, 触发 AttributeError 让 live market broker 整个 SSE/snapshot
+    推送瘫痪. 实际语义 = endpoint + sorted params, 短小适合本地缓存键.
+
+    与 cache_key(params) 区别: cache_key 只 hash params (适配 multi-endpoint),
+    make_key 把 endpoint 当 prefix, 跟 0.1.13 之后的调用约定一致.
+    """
+    ep = (endpoint or "").strip("/")
+    if not params:
+        return ep
+    items = sorted((k, str(v)) for k, v in params.items() if v is not None)
+    suffix = "&".join(f"{k}={v}" for k, v in items)
+    return f"{ep}?{suffix}" if suffix else ep
+
+
 def is_fresh(path: Path, endpoint: str) -> bool:
     if not path.exists():
         return False

{hamuna_quant_cli-0.1.12 → hamuna_quant_cli-0.1.14}/hamuna_quant_cli/runtime/http_client.py

@@ -206,4 +206,36 @@ def proxy_post(endpoint: str, body: dict, *, no_cache: bool = False) -> dict:
     }, method='POST')
     with urlopen(req, timeout=30) as resp:
         raw = resp.read().decode('utf-8', errors='replace')
+    return json.loads(raw)
+
+
+def _http_get_json(
+    path: str,
+    params: dict | None = None,
+    *,
+    base_url: str | None = None,
+    api_key: str | None = None,
+    timeout: float = 30.0,
+) -> dict:
+    """任意 path 的 Bearer-auth JSON GET (不走 /proxy/data/<endpoint> 路径)。
+
+    给 Round 33 server_market_client 用: 拉 /api/v1/market/bars (非 /proxy/data/
+    旧路径)。不走本地缓存 (market/bars 已后端 1h TTL 缓存 + server_market_client
+    自己管 polling 节流)。
+
+    base_url/api_key 留 None → 走 _resolve_server() + _load_token()。显式传
+    用于测试 mock。
+    """
+    base = base_url if base_url else _resolve_server()
+    tok = api_key if api_key else _load_token()
+    qs = urlencode(params or {}, doseq=True) if params else ''
+    url = f'{base}{path}'
+    if qs:
+        url = f'{url}?{qs}'
+    req = Request(url, headers={
+        'Authorization': f'Bearer {tok}',
+        'Accept': 'application/json',
+    })
+    with urlopen(req, timeout=timeout) as resp:
+        raw = resp.read().decode('utf-8', errors='replace')
     return json.loads(raw)

{hamuna_quant_cli-0.1.12 → hamuna_quant_cli-0.1.14}/hamuna_quant_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hamuna-quant-cli
-Version: 0.1.12
+Version: 0.1.14
 Summary: Hamuna A 股回测 + 实盘统一 CLI (akquant 0.3.x). 替代 v1 自建 driver + QMT-style 策略规范.
 Author-email: Hamuna Team <team@hamuna.example>
 License: MIT

{hamuna_quant_cli-0.1.12 → hamuna_quant_cli-0.1.14}/hamuna_quant_cli.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ hamuna_quant_cli/live/loader.py
 hamuna_quant_cli/live/qmt_broker.py
 hamuna_quant_cli/live/qmt_market.py
 hamuna_quant_cli/live/runner.py
+hamuna_quant_cli/live/server_market_client.py
 hamuna_quant_cli/runtime/__init__.py
 hamuna_quant_cli/runtime/backtest.py
 hamuna_quant_cli/runtime/cache.py

{hamuna_quant_cli-0.1.12 → hamuna_quant_cli-0.1.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hamuna-quant-cli"
-version = "0.1.12"
+version = "0.1.14"
 description = "Hamuna A 股回测 + 实盘统一 CLI (akquant 0.3.x). 替代 v1 自建 driver + QMT-style 策略规范."
 readme = "hamuna_quant_cli/README.md"
 requires-python = ">=3.10"