hamuna-quant-cli 0.1.0.dev93__py3-none-any.whl

hamuna_quant_cli/live/qmt_market.py

@@ -0,0 +1,448 @@
+"""hamuna_qmt_market — akquant 自定义 **行情** gateway, 走 bridge_server HTTP API.
+
+跟 hamuna_qmt_broker 平行 — 那个管账户/委托/成交/下单/撤单 (5 类交易 endpoint),
+本模块管 snapshot (tick) + history (bar) (2 类行情 endpoint). 两者共用 bridge_server
+同一个 helper 进程, 但 MarketGateway 必须独立 (akquant run_live 要求 market_broker
+跟 trader_broker 分家 — broker=qmt 只给交易通道).
+
+调用方式 (run_live 之前先 import 触发 register):
+    import hamuna_qmt_market  # noqa: F401
+    run_live(market_broker="qmt_market", trader_broker="qmt", ...,
+             qmt_base_url="http://127.0.0.1:9000",
+             qmt_account_id="8888888888", qmt_paper=1)
+
+bridge_server 端点:
+    GET /data/snapshot?securities=<sym1>,<sym2>,...  → 全推实时 tick (QMT get_full_tick)
+    GET /data/history?security=<sym>&period=<p>&count=<n>&fq=<fwd/back/None>
+                                                   → 历史 K 线 (QMT get_market_data_ex)
+    GET /health                                       → 探活
+
+akquant MarketGateway 接口:
+    connect / disconnect / subscribe / unsubscribe / on_bar / on_tick / start
+
+行情推送语义:
+    on_tick: 每个 poll_interval (默认 30s, 用户决策 ≥30s 限流保护) 对每个 subscribed symbol 调一次
+             /data/snapshot, 把 tick dict 原样推 callback (QMT 字段: lastPrice,
+             open/close/high/low/volume/amount, datetime, ...).
+    on_bar:  warmup 阶段 backfill count 根历史 bar (period=1d) 一次性推; 之后每
+            poll_interval 拉一次当日 bar, 若 OHLCV 任何字段变化就推 (盘中
+            "今日累计" bar 持续更新直到收盘 — QMT 默认行为, 适合日线择时).
+
+设计原则:
+    - thin client: 翻译 + HTTP, 不存业务逻辑
+    - 跟 broker 同 _HTTP / register / factory 套路, 不引入新依赖
+    - paper 模式: 不下单, 行情全真 (snapshot/history 都是只读) — paper e2e 仍能验
+      真桥 7 个端点 (5 交易 + 2 行情)
+"""
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+# ============================================================
+# 共享 HTTP client — 跟 broker 模块同一份, 不重复实现
+# ============================================================
+from .qmt_broker import _HTTP, BrokerHTTPError, _emit_paper  # noqa: F401  re-used
+
+import threading
+import time
+from typing import Any, Callable
+
+
+# ============================================================
+# MarketGateway 工厂 — 跟 broker 同 closure pattern
+# ============================================================
+def _make_market_gateway() -> Any:
+    """构造 QmtMarketGateway 类. 延迟到第一次调用时再 import akquant.
+
+    返回的类继承 akquant.gateway.protocols.MarketGateway. 命名上不显式继承 —
+    duck check 由 akquant run_live 通过 `isinstance(gw, MarketGateway)` 验证,
+    我们直接走显式继承避免 magic.
+
+    数据流: bridge_server /data/snapshot + /data/history → QmtMarketGateway 解析 →
+    akquant DataFeed (`feed.add_tick(Bar/Tick)`) → akquant engine 读 feed → strategy hook.
+    MarketGateway 协议暴露的 `on_tick`/`on_bar` 是兼容接口, akquant 实际不调用 —
+    它通过 DataFeed 中转. 这里保留这两个 setter 让 broker-level e2e 能直接挂 callback 验证.
+    """
+    from akquant.gateway.protocols import MarketGateway
+
+    class QmtMarketGateway(MarketGateway):
+        def __init__(
+            self,
+            feed: Any = None,  # akquant DataFeed — 主路径用这个推
+            base_url: str = "http://127.0.0.1:9000",
+            period: str = "1d",
+            bar_count: int = 20,
+            poll_interval: float = 30.0,  # 默认 30s/帧 (≈2/min) — 用户决策: 不打 QMT 限流; 想更快自己 CLI 透传
+            timeout: float = 5.0,
+            symbols: list[str] | None = None,  # 启动时 auto-subscribe (来自 build_qmt_market 的 symbols)
+        ) -> None:
+            self._feed = feed
+            self._http = _HTTP(base_url, timeout=timeout)
+            self._period = period
+            self._bar_count = bar_count
+            self._poll_interval = max(0.05, float(poll_interval))
+            # 启动时 auto-subscribe: build_qmt_market(symbols=...) 传来的就是 akquant run_live
+            # instruments — 立即装订到 _subscribed, 不依赖 akquant forwarder (实测发现 forwarder
+            # 在 functional mode 下安装时机晚于 strategy.subscribe, 错过首次订阅)
+            self._subscribed: list[str] = [s for s in (symbols or []) if s]
+            self._bar_callback: Callable[[dict[str, Any]], None] | None = None
+            self._tick_callback: Callable[[dict[str, Any]], None] | None = None
+            self._running = False
+            self._thread: threading.Thread | None = None
+            self._last_bar_signatures: dict[str, tuple] = {}
+
+        def connect(self) -> None:
+            health = self._http.get("/health", {})
+            if not isinstance(health, dict) or health.get("ready") is not True:
+                raise BrokerHTTPError(f"bridge /health 未 ready: {health}")
+
+        def disconnect(self) -> None:
+            self._running = False
+            if self._thread is not None:
+                self._thread.join(timeout=2.0)
+                self._thread = None
+
+        def subscribe(self, symbols) -> None:
+            for s in symbols:
+                if s not in self._subscribed:
+                    self._subscribed.append(s)
+
+        def unsubscribe(self, symbols) -> None:
+            removed = set(symbols)
+            self._subscribed = [s for s in self._subscribed if s not in removed]
+            for s in removed:
+                self._last_bar_signatures.pop(s, None)
+
+        def on_bar(self, callback: Callable[[dict[str, Any]], None]) -> None:
+            self._bar_callback = callback
+
+        def on_tick(self, callback: Callable[[dict[str, Any]], None]) -> None:
+            self._tick_callback = callback
+
+        def start(self) -> None:
+            if self._running:
+                return
+            self._running = True
+            self._warmup_bars()
+            self._thread = threading.Thread(target=self._poll_loop, daemon=True,
+                                            name="qmt-market-poll")
+            self._thread.start()
+
+        # ---- internal ----
+
+        def _emit_tick(self, raw: dict[str, Any]) -> None:
+            symbol = raw.get("symbol", "")
+            tick_obj = _to_tick_obj(raw)
+            if self._feed is not None:
+                self._feed.add_tick(tick_obj)
+            if self._tick_callback:
+                self._tick_callback(raw)
+
+        def _emit_bar(self, raw: dict[str, Any]) -> None:
+            bar_obj = _to_bar_obj(raw)
+            if self._feed is not None:
+                self._feed.add_bar(bar_obj)
+            if self._bar_callback:
+                self._bar_callback(raw)
+
+        def _warmup_bars(self) -> None:
+            # warmup 期每个 sym 拉 1 次 history — bridge_server 1/min 限流保护下做指数退避
+            backoff = 1.0
+            for sym in list(self._subscribed):
+                while True:
+                    try:
+                        bars = self._fetch_bars(sym)
+                        for bar in bars:
+                            self._emit_bar(bar)
+                        if bars:
+                            self._last_bar_signatures[sym] = _bar_signature(bars[-1])
+                        backoff = 1.0
+                        break  # 成功 → 下一个 sym
+                    except Exception as e:  # noqa: BLE001
+                        err_str = str(e)
+                        print(f"[qmt-market] warmup error {sym}: {err_str}", flush=True)
+                        if "429" in err_str or "Too much connections" in err_str:
+                            time.sleep(backoff)
+                            backoff = min(backoff * 2.0, 60.0)
+                            continue
+                        raise  # 非 429 错误立即 raise, 不静默吞
+
+        def _poll_loop(self) -> None:
+            backoff = 1.0  # 429 触发时指数退避 (cap 60s, 留 2x 安全余量 vs 30s poll)
+            while self._running:
+                t0 = time.monotonic()
+                rate_limited = False
+                try:
+                    self._poll_once()
+                    backoff = 1.0  # 成功 — 重置
+                except Exception as e:  # noqa: BLE001 — polling 不能让线程死
+                    err_str = str(e)
+                    print(f"[qmt-market] poll error: {type(e).__name__}: {err_str}", flush=True)
+                    if "429" in err_str or "Too much connections" in err_str:
+                        rate_limited = True
+                elapsed = time.monotonic() - t0
+                sleep_for = max(0.0, self._poll_interval - elapsed)
+                if rate_limited:
+                    time.sleep(backoff)
+                    backoff = min(backoff * 2.0, 60.0)
+                elif sleep_for > 0:
+                    time.sleep(sleep_for)
+
+        def _poll_once(self) -> None:
+            subs = list(self._subscribed)
+            if not subs:
+                return
+            ticks = self._fetch_ticks(subs)
+            for t in ticks:
+                self._emit_tick(t)
+            for sym in subs:
+                bars = self._fetch_bars(sym, count=1)
+                if not bars:
+                    continue
+                last = bars[-1]
+                sig = _bar_signature(last)
+                if self._last_bar_signatures.get(sym) != sig:
+                    self._last_bar_signatures[sym] = sig
+                    self._emit_bar(last)
+
+        def _fetch_ticks(self, symbols: list[str]) -> list[dict[str, Any]]:
+            """GET /data/snapshot?securities=sym1,sym2 → list of tick dict.
+
+            响应 (无 envelope): {ticks: {sym: tick_dict}, qmt_codes: [...], source: '...'}
+            ticks 内的 key 是 QMT 内部格式 (e.g. 600000.XSHG) — 转 6 位 canonical 跟 strategy 一致.
+            """
+            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 {}
+            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) → canonical 6 位 (e.g. 600000)
+                    bare = qmt_sym.split(".")[0] if "." in qmt_sym else qmt_sym
+                    tick.setdefault("symbol", bare)
+                    ticks.append(tick)
+            return ticks
+
+        def _fetch_bars(self, symbol: str, count: int | None = None) -> list[dict[str, Any]]:
+            """GET /data/history?security=...&period=1d&count=N → list of bar dict (旧→新)."""
+            qmt_sym = _to_qmt_symbol(symbol)
+            cnt = count if count is not None else self._bar_count
+            resp = self._http.get("/data/history", {
+                "security": qmt_sym, "period": self._period,
+                "count": str(cnt), "fq": "None",
+            })
+            value = _unwrap_envelope(resp)
+            return _bars_from_history(value, symbol)
+
+    return QmtMarketGateway
+
+
+# ============================================================
+# helpers — bridge_server envelope + symbol/bar 适配
+# ============================================================
+def _to_qmt_symbol(symbol: str) -> str:
+    """akquant 习惯 sh600000 (前缀小写) → bridge_server 接 6 位 canonical (600000).
+
+    接受 sh/sz 前缀或纯 6 位,统一返 6 位 uppercase (e.g. sh600000 → "600000").
+    bridge_server 对 sh/sz 前缀不识别 (snapshot 返回 qmt_codes 但 ticks={}),
+    必须 strip 掉前缀才能拿到真 tick / bar.
+    """
+    s = symbol.strip()
+    if len(s) >= 7 and s[:2].lower() in ("sh", "sz"):
+        return s[2:].upper()
+    return s.upper()
+
+
+def _unwrap_envelope(resp: dict[str, Any]) -> Any:
+    """bridge_server envelope {ok, value, request_id, ...} → 业务数据 value 字段.
+
+    行情端点 (/data/snapshot, /data/history) **不走 envelope** — 直接返业务 dict,
+    envelope 是交易端点 (/account, /positions, /place_order ...) 的格式. 这里
+    兼容两种: 有 envelope 返 value, 没 envelope 原样返.
+    """
+    if not isinstance(resp, dict):
+        return resp
+    if resp.get("ok") is False:
+        raise BrokerHTTPError(f"bridge 返回 ok=false: {resp.get('code')}: {resp.get('message')}")
+    return resp.get("value", resp)
+
+
+def _bar_signature(bar: dict[str, Any]) -> tuple:
+    """bar OHLCV 摘要 — 推 on_bar 去重用."""
+    return (
+        bar.get("open"), bar.get("high"), bar.get("low"),
+        bar.get("close"), bar.get("volume"), bar.get("amount"),
+        bar.get("datetime") or bar.get("date") or bar.get("time"),
+    )
+
+
+# 解析时间字段 — QMT tick `time` 是 epoch ms, bar `time`/`stime` 是日期字符串 + epoch ms.
+def _parse_bar_timestamp_ns(bar: dict[str, Any]) -> int:
+    """bar dict → timestamp (纳秒). 优先级: time (epoch ms) > stime ('YYYYMMDD')."""
+    t = bar.get("time")
+    if isinstance(t, (int, float)) and t > 0:
+        return int(t * 1_000_000)  # ms → ns
+    stime = bar.get("stime")
+    if isinstance(stime, str) and len(stime) == 8 and stime.isdigit():
+        # '20260811' → 当日 00:00 (本地) epoch ns (用 09:30 开盘更准但要时区配置, 简化为 0:00)
+        from datetime import datetime, timezone, timedelta
+        dt = datetime.strptime(stime, "%Y%m%d").replace(tzinfo=timezone(timedelta(hours=8)))
+        return int(dt.timestamp() * 1_000_000_000)
+    return 0
+
+
+def _parse_tick_timestamp_ns(tick: dict[str, Any]) -> int:
+    """tick dict → timestamp (纳秒). QMT `time` 是 epoch ms."""
+    t = tick.get("time")
+    if isinstance(t, (int, float)) and t > 0:
+        return int(t * 1_000_000)  # ms → ns
+    return 0
+
+
+def _to_bar_obj(raw: dict[str, Any]):
+    """raw bar dict → akquant Bar 构造."""
+    from akquant import Bar
+    return Bar(
+        timestamp=_parse_bar_timestamp_ns(raw),
+        open=float(raw.get("open") or 0.0),
+        high=float(raw.get("high") or 0.0),
+        low=float(raw.get("low") or 0.0),
+        close=float(raw.get("close") or 0.0),
+        volume=float(raw.get("volume") or 0.0),
+        symbol=str(raw.get("symbol") or ""),
+    )
+
+
+def _to_tick_obj(raw: dict[str, Any]):
+    """raw tick dict → akquant Tick 构造. QMT lastPrice → price, volume 字段."""
+    from akquant import Tick
+    return Tick(
+        timestamp=_parse_tick_timestamp_ns(raw),
+        symbol=str(raw.get("symbol") or ""),
+        price=float(raw.get("lastPrice") or raw.get("price") or 0.0),
+        volume=float(raw.get("volume") or 0.0),
+    )
+
+
+# QMT DataFrame JSON 序列化的标准 columns (amount, close, high, low, open, ...)
+# 见 bridge_server `/data/history` `dtype=dataframe` 响应.
+_QMT_HISTORY_COLUMNS = ("amount", "close", "high", "low", "open", "openInterest",
+                        "preClose", "settelementPrice", "stime", "suspendFlag",
+                        "time", "volume")
+
+
+def _bars_from_history(value: Any, symbol: str) -> list[dict[str, Any]]:
+    """bridge_server /data/history 响应 (无 envelope) → list of OHLCV bar dict.
+
+    形态 A (QMT DataFrame JSON, 当前默认): {dtype: 'dataframe', columns: [...], records: [[...]]}
+        records[i] 与 columns[i] 一一对应, 转 dict 后附加 datetime (stime/time).
+    形态 B (旧 envelope 内 bars list): {"bars": [{...}, ...]}
+    形态 C (裸 list of dict): [{...}, ...]
+    """
+    if not value:
+        return []
+    if isinstance(value, list):
+        return [{**b, "symbol": symbol} for b in value if isinstance(b, dict)]
+    if isinstance(value, dict):
+        # 形态 A: QMT DataFrame JSON
+        if value.get("dtype") == "dataframe" and "records" in value:
+            cols = value.get("columns") or _QMT_HISTORY_COLUMNS
+            recs = value.get("records") or []
+            bars: list[dict[str, Any]] = []
+            for rec in recs:
+                if not isinstance(rec, list):
+                    continue
+                bar = {col: rec[i] for i, col in enumerate(cols) if i < len(rec)}
+                bar["symbol"] = symbol
+                # datetime: 优先 stime (YYYYMMDD), 回退 time (epoch ms)
+                bar["datetime"] = bar.get("stime") or bar.get("time")
+                bars.append(bar)
+            return bars
+        # 形态 B
+        if "bars" in value and isinstance(value["bars"], list):
+            return [{**b, "symbol": symbol} for b in value["bars"] if isinstance(b, dict)]
+        # 形态 A 旧版: dict-of-list (key=sym 或 single-key dict)
+        target = value.get(symbol) or value.get(_to_qmt_symbol(symbol))
+        if target is None and len(value) == 1:
+            target = next(iter(value.values()))
+        if isinstance(target, dict):
+            dates = target.get("datetime") or target.get("date") or target.get("time") or []
+            n = len(dates)
+            if n == 0:
+                return []
+            return [
+                {
+                    "symbol": symbol,
+                    "datetime": dates[i] if i < len(dates) else None,
+                    "open": _at(target.get("open"), i),
+                    "high": _at(target.get("high"), i),
+                    "low": _at(target.get("low"), i),
+                    "close": _at(target.get("close"), i),
+                    "volume": _at(target.get("volume"), i),
+                    "amount": _at(target.get("amount"), i),
+                }
+                for i in range(n)
+            ]
+    return []
+
+
+def _at(seq: Any, i: int) -> Any:
+    """list-like 安全取第 i 个; 标量直接返."""
+    if isinstance(seq, list):
+        return seq[i] if i < len(seq) else None
+    if hasattr(seq, "__getitem__") and not isinstance(seq, (str, bytes)):
+        try:
+            return seq[i]
+        except (IndexError, KeyError, TypeError):
+            return None
+    return seq
+
+
+# ============================================================
+# builder + register
+# ============================================================
+def build_qmt_market(feed: Any, symbols: list[str], use_aggregator: bool, **kwargs: Any) -> Any:
+    """akquant run_live(market_broker="qmt_market", ...) 的 builder 入口.
+
+    kwargs:
+      qmt_base_url      (default "http://127.0.0.1:9000")
+      market_period     (default "1d")  — bar 周期 (QMT period: 1d/5m/1m/...)
+      market_bar_count  (default 20)    — warmup 拉几根
+      market_poll       (default 30.0)  — 轮询秒数 (用户决策 2026-08-18: ≥30s)
+      market_timeout    (default 5.0)   — HTTP 超时
+    """
+    from akquant.gateway.protocols import GatewayBundle
+
+    base_url = kwargs.get("qmt_base_url") or kwargs.get("base_url") or "http://127.0.0.1:9000"
+    period = kwargs.get("market_period") or kwargs.get("period") or "1d"
+    bar_count = int(kwargs.get("market_bar_count") or kwargs.get("bar_count") or 20)
+    poll = float(kwargs.get("market_poll") or kwargs.get("poll_interval") or 30.0)
+    timeout = float(kwargs.get("market_timeout") or kwargs.get("timeout") or 30.0)  # ponytail: 跟 _HTTP.timeout 默认 30s 保持一致 (caller 显式传 timeout=5.0 会盖过这里默认, 但 build_qmt_market 不传 timeout 时必须 30s 才治网络抖动)
+    QmtMarketGateway = _make_market_gateway()
+    gw = QmtMarketGateway(
+        feed=feed,  # akquant DataFeed — 主路径推 tick/bar 用
+        base_url=base_url, period=period, bar_count=bar_count,
+        poll_interval=poll, timeout=timeout,
+        symbols=list(symbols or []),  # auto-subscribe (绕开 akquant forwarder 时序 bug)
+    )
+    return GatewayBundle(
+        market_gateway=gw,
+        trader_gateway=None,  # market-only builder, 不含 trader
+        trader_capabilities=None,
+        metadata={"broker": "qmt_market", "bridge": "bullettrade_compat",
+                  "period": period, "bar_count": bar_count, "poll_interval": poll},
+    )
+
+
+def _safe_register() -> None:
+    try:
+        from akquant.gateway import register_broker
+        register_broker("qmt_market", build_qmt_market)
+    except ImportError:
+        pass
+
+
+_safe_register()