hamuna-quant-cli 0.1.23__tar.gz → 0.1.25__tar.gz

{hamuna_quant_cli-0.1.23 → hamuna_quant_cli-0.1.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hamuna-quant-cli
-Version: 0.1.23
+Version: 0.1.25
 Summary: Hamuna A 股回测 + 实盘统一 CLI (akquant 0.3.x). 替代 v1 自建 driver + QMT-style 策略规范.
 Author-email: Hamuna Team <team@hamuna.example>
 License: MIT
@@ -130,11 +130,8 @@ hamuna_quant_cli upload --name "v2_smoke" --config /tmp/c.json --code /tmp/s.py
 ```bash
 # 1) 写策略 (同上)
 
-# 2) paper 模式 (smoke, 不连真实 broker)
-hamuna_quant_cli live run /tmp/s.py \
-    --mode paper --broker replay --symbols sh600000,sz600036 --duration 30s
-
-# 3) qmt 实盘 (需配 broker=qmt + market_broker=qmt_market + gateway_options)
+# 2) qmt 实盘 (需配 broker=qmt + market_broker=qmt_market + gateway_options)
+#    Round 18.63.18: paper 模式已删 — 模拟由 QMT 客户端原生「模拟信号模式」承担
 hamuna_quant_cli live run /tmp/s.py \
     --mode broker_live --broker qmt --market-broker qmt_market \
     --symbols sh600000,sz600036 \

{hamuna_quant_cli-0.1.23 → hamuna_quant_cli-0.1.25}/hamuna_quant_cli/README.md

@@ -91,11 +91,8 @@ hamuna_quant_cli upload --name "v2_smoke" --config /tmp/c.json --code /tmp/s.py
 ```bash
 # 1) 写策略 (同上)
 
-# 2) paper 模式 (smoke, 不连真实 broker)
-hamuna_quant_cli live run /tmp/s.py \
-    --mode paper --broker replay --symbols sh600000,sz600036 --duration 30s
-
-# 3) qmt 实盘 (需配 broker=qmt + market_broker=qmt_market + gateway_options)
+# 2) qmt 实盘 (需配 broker=qmt + market_broker=qmt_market + gateway_options)
+#    Round 18.63.18: paper 模式已删 — 模拟由 QMT 客户端原生「模拟信号模式」承担
 hamuna_quant_cli live run /tmp/s.py \
     --mode broker_live --broker qmt --market-broker qmt_market \
     --symbols sh600000,sz600036 \

{hamuna_quant_cli-0.1.23 → hamuna_quant_cli-0.1.25}/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.23"
+__version__ = "0.1.25"

{hamuna_quant_cli-0.1.23 → hamuna_quant_cli-0.1.25}/hamuna_quant_cli/__main__.py

@@ -9,7 +9,7 @@ Usage:
     hamuna_quant_cli qmt-translate <strategy.py> <cfg.json>
     hamuna_quant_cli commit <strategy_id> --strategy ... --result ... --config ... --params ...
     hamuna_quant_cli dataset {list|fetch|manifest}
-    hamuna_quant_cli live run <strategy.py> --mode paper --broker qmt ...
+    hamuna_quant_cli live run <strategy.py> --mode broker_live --broker qmt ...
 
 PYTHONPATH: 不需要 (pip install hamuna-quant-cli 后全局可用).
 """
@@ -909,7 +909,6 @@ def cmd_live_run(args) -> int:
             log_level=args.log_level,
             log_file=args.log_file,
             market_broker=args.market_broker,
-            replay_days=args.replay_days,
             params=sp if isinstance(sp, dict) else None,
         )
     except LiveRunError as e:
@@ -1048,10 +1047,10 @@ def build_parser() -> argparse.ArgumentParser:
     live_sub = live_p.add_subparsers(dest="subcmd", required=True)
     run_p = live_sub.add_parser("run", help="运行一个 strategy.py")
     run_p.add_argument("strategy", type=Path, help="strategy.py 路径")
-    run_p.add_argument("--mode", choices=["paper", "broker_live"], default="paper",
-                       help="trading_mode (default: paper)")
-    run_p.add_argument("--broker", default="replay",
-                       help="broker 名称: ctp / qmf / replay / qmt (default: replay)")
+    run_p.add_argument("--mode", choices=["broker_live"], default="broker_live",
+                       help="trading_mode (Round 18.63.18: 仅 broker_live, paper 已删)")
+    run_p.add_argument("--broker", default="qmt",
+                       help="broker 名称: qmt / 自定义 (replay 已删)")
     run_p.add_argument("--market-broker", default=None,
                        help="独立行情 broker (e.g. qmt_market)")
     run_p.add_argument("--symbols", default=None,
@@ -1064,9 +1063,6 @@ def build_parser() -> argparse.ArgumentParser:
                        help="strategy.py 里的类名")
     run_p.add_argument("--gateway-options", default=None,
                        help="k=v 字典, 透传给 run_live")
-    run_p.add_argument("--replay-days", type=int, default=30,
-                       help="broker=replay 时取最近 N 天真实日线 (默认 30; "
-                            "策略 warmup 超窗口需加大, e.g. 90)")
     run_p.add_argument("--initial-cash", type=float, default=None)
     run_p.add_argument("--log-level", default="INFO",
                        choices=["DEBUG", "INFO", "WARNING", "ERROR"])

{hamuna_quant_cli-0.1.23 → hamuna_quant_cli-0.1.25}/hamuna_quant_cli/live/qmt_broker.py

@@ -84,11 +84,6 @@ class BrokerHTTPError(RuntimeError):
     """bridge_server 返回 ok=False 或 HTTP 状态非 2xx."""
 
 
-def _emit_paper(msg: str) -> None:
-    """paper 模式日志 — flush=True 保证 akquant 拉日志实时看到, 不被缓冲."""
-    print(f"[PAPER] {msg}", flush=True)
-
-
 class _HTTP:
     def __init__(self, base_url: str, timeout: float = 30.0) -> None:  # ponytail: 默认 30s 容忍 TCP connect 偶发超时 — ceiling = qmt_market.poll_interval (30s), 再高就盖过 poll cycle; Retry 自动重试已覆盖偶发抖动 (urllib3.Retry, 见 _RETRY_*)
         self.base_url = base_url.rstrip("/")
@@ -267,12 +262,9 @@ def _make_trader_gateway():
             account_id: str = "",
             account_type: str = "stock",
             timeout: float = 5.0,
-            paper: bool = True,
         ) -> None:
-            """
-            paper: 默认 True — 安全默认, paper 模式下 place_order / cancel_order
-                   不发真 HTTP, 走本地 mock. 显式真下单必须 paper=False.
-            """
+            """Round 18.63.18: paper 参数已删 — QMT 客户端原生模拟信号模式,
+            CLI 永远发真 passorder (模拟由 QMT GUI 切)."""
             super().__init__()
             ak = _import_akquant_gateway()
             self._BrokerCapability = ak["BrokerCapability"]
@@ -281,13 +273,6 @@ def _make_trader_gateway():
             self._account_id = account_id
             self._account_type = account_type
             self._connected = False
-            self._paper = paper
-            self._paper_order_seq = 0  # 仅 paper 模式用, mock 订单号递增
-            if paper:
-                _emit_paper(
-                    f"qmt broker paper 模式启动 — account={account_id} "
-                    f"place_order / cancel_order 不发真 HTTP, mock 返 PAPER-NNNNNN"
-                )
 
         # ----- 生命周期 -----
         def connect(self) -> None:
@@ -352,16 +337,8 @@ def _make_trader_gateway():
         def place_order(self, req):  # type: ignore[override]
             if not self._connected:
                 raise BrokerHTTPError("place_order: 未 connect, 先调 start()/connect()")
-            # paper 模式: 不发真 HTTP, mock 返 PAPER-NNNNNN — e2e 验证不真下单
-            if self._paper:
-                self._paper_order_seq += 1
-                order_id = f"PAPER-{self._paper_order_seq:06d}"
-                self.record_broker_order(order_id, req.client_order_id)
-                _emit_paper(
-                    f"place_order 跳过真下单: symbol={req.symbol} side={req.side} "
-                    f"qty={req.quantity} price={req.price} → mock order_id={order_id}"
-                )
-                return order_id
+            # Round 18.63.18: paper mock 路径已删 — QMT 客户端原生模拟信号模式
+            # (GUI 手动切), CLI 永远发真 passorder, 模拟由 QMT 侧承担.
             ak = _import_akquant_gateway()
             side = str(req.side).upper()
             # bridge 的 amount 字段 — QMT 用 int, 但 akquant quantity 是 float, 截断到 int.
@@ -417,9 +394,6 @@ def _make_trader_gateway():
         def cancel_order(self, broker_order_id: str) -> None:
             if not self._connected:
                 raise BrokerHTTPError("cancel_order: 未 connect")
-            if self._paper:
-                _emit_paper(f"cancel_order 跳过真撤单: broker_order_id={broker_order_id}")
-                return
             self._http.post("/cancel_order", {
                 "account_id": self._account_id,
                 "account_type": self._account_type,
@@ -644,13 +618,14 @@ def build_qmt(
       qmt_account_id   (必填)
       qmt_account_type (default "stock")
       qmt_timeout      (default 5.0 秒)
-      qmt_paper        (default "1"=paper; 显式真下单设 "0" — 默认安全)
+
+    Round 18.63.18 (用户拍板): qmt_paper 已删 — QMT 客户端原生模拟信号模式,
+    CLI 永远发真 passorder, 模拟由 QMT GUI 切.
     """
     base_url = kwargs.get("qmt_base_url") or kwargs.get("base_url") or "http://127.0.0.1:9000"
     account_id = kwargs.get("qmt_account_id") or kwargs.get("account_id") or ""
     account_type = kwargs.get("qmt_account_type") or kwargs.get("account_type") or "stock"
     timeout = float(kwargs.get("qmt_timeout") or kwargs.get("timeout") or 30.0)  # ponytail: 跟 _HTTP.timeout 默认 30s 保持一致 (caller 显式传 timeout=5.0 会盖过这里默认, 但 build_qmt 不传 timeout 时必须 30s 才治网络抖动)
-    paper = _qmt_paper_default(kwargs.get("qmt_paper"))
     if not account_id:
         raise ValueError(
             "hamuna_qmt_broker: 缺少 qmt_account_id — 透传给 run_live(..., qmt_account_id='...')"
@@ -659,27 +634,16 @@ def build_qmt(
     QmtTraderGateway = _make_trader_gateway()
     trader = QmtTraderGateway(
         base_url=base_url, account_id=account_id, account_type=account_type,
-        timeout=timeout, paper=paper,
+        timeout=timeout,
     )
     return ak["GatewayBundle"](
         market_gateway=None,  # 行情走 akquant DataFeed (无 push)
         trader_gateway=trader,
         trader_capabilities=trader.get_capabilities(),
-        metadata={"broker": "qmt", "bridge": "bullettrade_compat", "paper": paper},
+        metadata={"broker": "qmt", "bridge": "bullettrade_compat"},
     )
 
 
-def _qmt_paper_default(v: Any) -> bool:
-    """CLI 字符串 → paper bool. 默认 True (安全).
-    显式 "0"/"false"/"no"/"off" → False (真下单); 其它 (含 None/""/"1"/"true") → True (paper)."""
-    if v is None or v == "":
-        return True
-    s = str(v).strip().lower()
-    if s in ("0", "false", "no", "off"):
-        return False
-    return True
-
-
 # 注册 (side-effect import). akquant 未装时不抛 — 让 --help 仍能跑.
 def _safe_register() -> None:
     try:
@@ -690,176 +654,3 @@ def _safe_register() -> None:
 
 
 _safe_register()
-
-
-# ============================================================
-# self-check — 不依赖 akquant, 起本地 mock bridge_server, 验证 HTTP shape
-# ============================================================
-if __name__ == "__main__":
-    import threading
-    from http.server import BaseHTTPRequestHandler, HTTPServer
-
-    class _MockBridge(BaseHTTPRequestHandler):
-        def log_message(self, fmt, *args):
-            pass  # 静音
-
-        def _read_json(self):
-            length = int(self.headers.get("Content-Length") or 0)
-            return json.loads(self.rfile.read(length).decode("utf-8")) if length else {}
-
-        def _send(self, code, payload):
-            body = json.dumps(payload).encode("utf-8")
-            self.send_response(code)
-            self.send_header("Content-Type", "application/json")
-            self.send_header("Content-Length", str(len(body)))
-            self.end_headers()
-            self.wfile.write(body)
-
-        def do_GET(self):
-            if self.path.startswith("/health"):
-                self._send(200, {"ok": True, "value": {"status": "ok"}})
-                return
-            if self.path.startswith("/orders"):
-                self._send(200, {"ok": True, "value": {"orders": [{
-                    "order_id": "ORD1", "security": "600000.SH", "raw_status": 6,
-                    "filled": 100, "price": 10.5, "amount": 100,
-                    "qmt_user_order_id": "coid1",
-                }]}})
-                return
-            if self.path.startswith("/trades"):
-                self._send(200, {"ok": True, "value": {"trades": [{
-                    "trade_id": "TRD1", "order_id": "ORD1", "security": "600000.SH",
-                    "amount": 100, "price": 10.5, "side": "BUY",
-                    "qmt_user_order_id": "coid1",
-                }]}})
-                return
-            if self.path.startswith("/flaky"):
-                # transient retry 验证: 前 _RETRY_TOTAL 次返 503, 之后 200.
-                # 计数器放 server (handler 每请求新实例, 放 self 会每次清零 → 永不 200)
-                n = getattr(self.server, "_flaky_n", 0)
-                if n < _RETRY_TOTAL:
-                    self.server._flaky_n = n + 1
-                    self._send(503, {"ok": False, "code": "TRY_AGAIN"})
-                    return
-                self._send(200, {"ok": True, "value": {"attempts": n + 1}})
-                return
-            self._send(404, {"ok": False, "code": "NOT_FOUND"})
-
-        def do_POST(self):
-            data = self._read_json()
-            if "/set_account" in self.path:
-                # Round 18.63.12: connect() 先 POST /set_account 设全局账户 —
-                # mock 同步返回 ok, 否则 paper 模式 connect 抛异常.
-                self._send(200, {"ok": True, "value": {
-                    "account_id": data.get("account_id"),
-                    "account_type": data.get("account_type") or "stock",
-                }})
-                return
-            if "/account" in self.path:
-                self._send(200, {"ok": True, "value": {
-                    "account_id": data.get("account_id"), "account_type": "stock",
-                    "available_cash": 50000.0, "cash": 100000.0, "total_value": 150000.0,
-                }})
-                return
-            if "/positions" in self.path:
-                self._send(200, {"ok": True, "value": {"positions": [{
-                    "security": "600000.SH", "amount": 100, "closeable_amount": 100,
-                    "avg_cost": 10.0,
-                }]}})
-                return
-            if "/place_order" in self.path:
-                self._send(200, {"ok": True, "value": {
-                    "order_id": "ORD2", "order_ref": "ORD2", "security": "600000.SH",
-                    "side": data.get("side"), "amount": data.get("amount"),
-                    "price": data.get("price"),
-                }})
-                return
-            if "/cancel_order" in self.path:
-                self._send(200, {"ok": True, "value": {"cancelled": True}})
-                return
-            self._send(404, {"ok": False, "code": "NOT_FOUND"})
-
-    server = HTTPServer(("127.0.0.1", 0), _MockBridge)
-    port = server.server_address[1]
-    threading.Thread(target=server.serve_forever, daemon=True).start()
-    print(f"[self-check] mock bridge_server at http://127.0.0.1:{port}")
-
-    # 1. symbol 映射 (无 akquant 依赖)
-    assert _to_qmt_symbol("sh600000") == "600000.SH"
-    assert _to_qmt_symbol("600000.XSHG") == "600000.SH"
-    assert _to_qmt_symbol("sz000001") == "000001.SZ"
-    assert _to_qmt_symbol("000001.XSHE") == "000001.SZ"
-    assert _from_qmt_symbol("600000.XSHG") == "600000.SH"
-    assert _from_qmt_symbol("600000.SH") == "600000.SH"
-    assert _from_qmt_symbol("000001.XSHE") == "000001.SZ"
-    assert _from_qmt_symbol("000001.SZ") == "000001.SZ"
-    print("[self-check] OK symbol 映射")
-
-    # 2. HTTP client — 6 个 endpoint shape 验证
-    http = _HTTP(f"http://127.0.0.1:{port}", timeout=2.0)
-    acct = http.post("/account", {"account_id": "ACCT", "account_type": "stock"})
-    assert acct["available_cash"] == 50000.0, acct
-    pos = http.post("/positions", {"account_id": "ACCT"})
-    assert pos["positions"][0]["security"] == "600000.SH", pos
-    order = http.post("/place_order", {
-        "account_id": "ACCT", "security": "600000.SH", "side": "BUY",
-        "amount": 100, "price": 10.0,
-    })
-    assert order["order_id"] == "ORD2", order
-    http.post("/cancel_order", {"account_id": "ACCT", "order_id": "ORD2"})
-    orders = http.get("/orders", {"account_id": "ACCT", "order_id": "ORD1"})
-    assert orders["orders"][0]["raw_status"] == 6
-    trades = http.get("/trades", {"account_id": "ACCT"})
-    assert trades["trades"][0]["trade_id"] == "TRD1"
-    print("[self-check] OK HTTP client shape")
-
-    # 2.5 retry — /flaky 前 pending 次 503, Retry 自动重试后 200 (返回 attempts=total+1)
-    flaky = http.get("/flaky", {"account_id": "ACCT"})
-    assert isinstance(flaky, dict) and flaky.get("attempts") == _RETRY_TOTAL + 1, flaky
-    print("[self-check] OK transient retry (503 自动重试后成功)")
-
-    # 3. akquant 协议 — 检查 TraderGatewayBase 子类化 + 方法齐
-    try:
-        ak = _import_akquant_gateway()
-    except ImportError as e:
-        print(f"[self-check] akquant 未装 ({e.__cause__ or e}) — 跳过协议层验证")
-    else:
-        QmtTraderGateway = _make_trader_gateway()
-        # 实例化 (不连, 只查 shape). paper=False 让 e2e 走真 HTTP place_order 路径.
-        gw = QmtTraderGateway(
-            base_url=f"http://127.0.0.1:{port}", account_id="ACCT", account_type="stock",
-            timeout=2.0, paper=False,
-        )
-        for name in (
-            "connect", "disconnect", "start", "place_order", "cancel_order",
-            "query_order", "query_trades", "query_account", "query_positions",
-            "get_capabilities", "heartbeat", "on_order", "on_trade",
-            "on_execution_report", "record_broker_order", "client_order_id_for",
-        ):
-            assert hasattr(gw, name), f"missing {name}"
-        cap = gw.get_capabilities()
-        assert cap.broker_name == "qmt"
-        assert "qmt_bridge" in cap.features
-        print("[self-check] OK akquant 协议点齐 (TraderGatewayBase 子类)")
-        # 4. e2e: 真实 connect / place / cancel / query
-        gw.connect()
-        a = gw.query_account()
-        assert a.account_id == "ACCT" and a.available_cash == 50000.0, a
-        ps = gw.query_positions()
-        assert len(ps) == 1 and ps[0].symbol == "600000.SH", ps
-        oid = gw.place_order(ak["UnifiedOrderRequest"](
-            client_order_id="coid-test", symbol="600000.XSHG", side="buy",
-            quantity=100, price=10.0, order_type="Limit",
-        ))
-        assert oid == "ORD2", oid
-        gw.cancel_order(oid)
-        snap = gw.query_order("ORD1")
-        # raw_status=6 → Filled, 但 query_order 不一定拿到 coid 反查 (mock 返回 ORD1 没在 record 里)
-        # 测试 record_broker_order + 反查
-        gw.record_broker_order("ORD1", "coid-test")
-        snap2 = gw.query_order("ORD1")
-        assert snap2 is not None and snap2.symbol == "600000.SH", snap2
-        print("[self-check] OK e2e connect→place→cancel→query")
-
-    server.shutdown()
-    print("[self-check] ALL PASSED")

{hamuna_quant_cli-0.1.23 → hamuna_quant_cli-0.1.25}/hamuna_quant_cli/live/qmt_market.py

@@ -9,7 +9,7 @@
     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)
+             qmt_account_id="8888888888")
 
 bridge_server 端点:
     GET /data/snapshot?securities=<sym1>,<sym2>,...  → 全推实时 tick (QMT get_full_tick)
@@ -29,7 +29,7 @@ akquant MarketGateway 接口:
             "今日累计" bar 持续更新直到收盘 — QMT 默认行为, 适合日线择时).
 
 Round 33 双源验证 (server 数据源):
-  dual_source="off"   : 单源 QMT (默认, paper 模式).
+  dual_source="off"   : 单源 QMT (默认).
   dual_source="verify": 双源 QMT + server 并行拉, 不一致 server 为主 + log warn.
                         broker_live 默认开 (runner.py _live_safety_defaults).
   dual_source="fallback": QMT 主, server 备; server 仅在 QMT 失败时启用.
@@ -40,8 +40,6 @@ Round 33 双源验证 (server 数据源):
 设计原则:
     - thin client: 翻译 + HTTP, 不存业务逻辑
     - 跟 broker 同 _HTTP / register / factory 套路 (requests.Session + Retry transient 自动重试)
-    - paper 模式: 不下单, 行情全真 (snapshot/history 都是只读) — paper e2e 仍能验
-      真桥 7 个端点 (5 交易 + 2 行情)
 """
 from __future__ import annotations
 
@@ -50,7 +48,7 @@ __version__ = "0.1.0"
 # ============================================================
 # 共享 HTTP client — 跟 broker 模块同一份, 不重复实现
 # ============================================================
-from .qmt_broker import _HTTP, BrokerHTTPError, _emit_paper  # noqa: F401  re-used
+from .qmt_broker import _HTTP, BrokerHTTPError  # noqa: F401  re-used
 from .server_market_client import ServerMarketClient, OneMinuteAggregator
 
 import threading
@@ -86,7 +84,7 @@ def _make_market_gateway() -> Any:
             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)
-            subscribe: bool = False,  # paper=False / broker_live=True — 透传给 /data/history
+            subscribe: bool = True,  # Round 18.63.18: paper 已删, 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() 自动读
@@ -484,9 +482,8 @@ def _make_market_gateway() -> Any:
         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 的问题.
+            subscribe: Round 18.63.18 paper 已删 — broker_live 恒 True 让 QMT
+            实时推新 bar, 避免 count=-1 + 空时间窗只返本地最新 1 条 snapshot 的问题.
 
             Round 33 双源 (dual_source="verify"): QMT 历史 bar 为主, server
             (容维 /StockBars 通过 backend /market/bars) 拉同样窗口. period=1m
@@ -496,8 +493,8 @@ def _make_market_gateway() -> Any:
             cnt = count if count is not None else self._bar_count
             params = {"security": qmt_sym, "period": self._period,
                       "count": str(cnt), "fq": "qfq"}
-            # Round 32: 显式带 subscribe, 不靠 bridge 默认 (已翻 True). paper 轮询纯历史
-            # → subscribe=false 防误开 QMT 订阅; broker_live → true (实时推新 bar).
+            # Round 32: 显式带 subscribe, 不靠 bridge 默认 (已翻 True). broker_live
+            # → true (实时推新 bar); 显式 market_subscribe=0 可关 (纯历史拉取).
             params["subscribe"] = "true" if self._subscribe else "false"
             resp = self._http.get("/data/history", params)
             value = _unwrap_envelope(resp)
@@ -784,10 +781,11 @@ def build_qmt_market(feed: Any, symbols: list[str], use_aggregator: bool, **kwar
       market_bar_count  (default 20)    — warmup 拉几根
       market_poll       (default 30.0)  — 轮询秒数 (用户决策 2026-08-18: ≥30s)
       market_timeout    (default 5.0)   — HTTP 超时
-      market_subscribe  (default False) — /data/history subscribe= 参数
-                                            (paper=False, broker_live=True)
+      market_subscribe  (default True)  — /data/history subscribe= 参数
+                                            (Round 18.63.18: paper 已删, broker_live
+                                            恒 True; 显式 "0"/"false" 可关纯历史拉取)
                                             透传方式: --gateway-options
-                                            "market_subscribe=1" (或 True)
+                                            "market_subscribe=0" (关)
       server_base_url   (default None)  — Round 33: server 数据源 base URL
                                             (None → 不开 server 源)
       server_api_key    (default None)  — Round 33: 显式 API key; None → 自动
@@ -805,9 +803,10 @@ def build_qmt_market(feed: Any, symbols: list[str], use_aggregator: bool, **kwar
     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 才治网络抖动)
-    # 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")
+    # market_subscribe: Round 18.63.18 paper 已删, broker_live 恒 True (实时推新 bar);
+    # 显式 "0"/"false"/"no"/"off" 可关闭 (纯历史拉取, 防误开 QMT 订阅).
+    subscribe_raw = kwargs.get("market_subscribe") or kwargs.get("subscribe") or "1"
+    subscribe = not str(subscribe_raw).strip().lower() in ("0", "false", "no", "off", "")
     # Round 33 双源 kwargs
     server_base_url = kwargs.get("server_base_url")
     server_api_key = kwargs.get("server_api_key")

{hamuna_quant_cli-0.1.23 → hamuna_quant_cli-0.1.25}/hamuna_quant_cli/live/runner.py

@@ -9,7 +9,6 @@
 from __future__ import annotations
 
 import sys
-import json  # Round 18.62 P0-1: replay metrics 落盘
 from pathlib import Path
 from typing import Any
 
@@ -133,9 +132,8 @@ def _fetch_bridge_history(bridge_url: str, sym: str, period: str, count: int,
     bridge 不通 / 超时 / 非 200 直接 raise LiveRunError, 不静默退化 (用户原话:
     策略出错直接报错停止, 不走 mock 兜底).
 
-    subscribe: paper=False / broker_live=True — paper 不需要实时订阅 (一次性拉够
-    N 根 bar 即可), broker_live 需要开 subscribe=True 让 QMT 实时推新 bar, 避免
-    count=-1 + start/end 全空时只返回本地最新 1 条 snapshot 的问题.
+    subscribe: broker_live 恒 True (Round 18.63.18: paper 已删) — 让 QMT 实时
+    推新 bar, 避免 count=-1 + start/end 全空时只返回本地最新 1 条 snapshot 的问题.
     """
     from urllib.parse import urlencode
     from urllib.request import urlopen, Request
@@ -145,7 +143,7 @@ def _fetch_bridge_history(bridge_url: str, sym: str, period: str, count: int,
         canonical = canonical[2:]
     params = {"security": canonical, "period": period, "count": str(count), "fq": "qfq"}
     # Round 32: bridge_server subscribe 默认翻 True (qmt-docs 官方对齐) 后, 这里不能
-    # 省掉 query 靠默认 — 纯历史/paper 路径必须显式 subscribe=false 防误开 QMT 订阅
+    # 省掉 query 靠默认 — 显式带 subscribe 防误开/误关 QMT 订阅
     # (Round 27 300 只批量防卡护栏从 bridge 默认移到调用端显式 false).
     params["subscribe"] = "true" if subscribe else "false"
     q = urlencode(params)
@@ -192,7 +190,7 @@ def _fetch_bridge_history_batch(bridge_url: str, symbols: list[str], period: str
     优先使用 bridge_server 的批量 multi 接口 (一次 HTTP 拉多只), 大幅减少
     逐只 HTTP 开销 (300 只从 ~27s 降到 ~1s). 失败时返回 {} 让调用方回退逐只.
 
-    subscribe 语义同 _fetch_bridge_history (paper=False, broker_live=True).
+    subscribe 语义同 _fetch_bridge_history (broker_live 恒 True, Round 18.63.18).
     """
     from urllib.parse import urlencode
     from urllib.request import urlopen, Request
@@ -252,7 +250,7 @@ def _fetch_live_factors(bridge_url: str, universe: list[str], period: str = "1d"
       4. 单只失败的片回退逐只 (兼容旧 bridge_server)
 
     subscribe 透传给 _fetch_bridge_history / _fetch_bridge_history_batch —
-    paper=False, broker_live=True (run_live 内 mode→subscribe 映射).
+    broker_live 恒 True (Round 18.63.18: paper 已删).
     """
     import pandas as _pd
     from concurrent.futures import ThreadPoolExecutor, as_completed
@@ -317,16 +315,15 @@ def _fetch_live_factors(bridge_url: str, universe: list[str], period: str = "1d"
     return factors
 
 
-def _build_instruments(symbols: list[str] | None, normalize: bool = False) -> list[Any] | None:
+def _build_instruments(symbols: list[str] | None) -> list[Any] | None:
     """symbols 列表 → akquant.Instrument 列表. None → None (全市场, 让策略自行 subscribe).
 
-    normalize=True: 裸码 → 带后缀 (replay 数据来自 prebuilt, stockCode 是 '600000.SH'
-    形态, instrument symbol 必须一致才匹配 ReplayMarketGateway 的订阅过滤).
-
     Round 18.59: 按 6 位代码前缀推断 AssetType — akquant 0.3.x AssetType 枚举没 ETF 也没 Bond,
     510/511/512/515/159 (沪/深 ETF) → Fund; 113/127/128 (可转债) → Fund; 其他 6 位 → Stock.
     之前硬写 AssetType.Stock 让 351 个 ETF 被 broker 内部按 asset_type 分流时丢弃 → universe=[].
     ponytail: akquant 0.4.x 若新增 AssetType.ETF / AssetType.Bond 则此映射需重审.
+
+    Round 18.63.18: normalize 参数已删 (曾用于 replay prebuilt 裸码归一, replay 已删).
     """
     if not symbols:
         return None
@@ -336,14 +333,8 @@ def _build_instruments(symbols: list[str] | None, normalize: bool = False) -> li
     _ETF_PREFIXES = ("510", "511", "512", "515", "159")
     _BOND_PREFIXES = ("113", "127", "128")  # 可转债 (沪 113 / 深 127 / 沪 128)
 
-    def _sym(s: str) -> str:
-        if normalize:
-            from ..akquant_schema_adapter import normalize_symbol
-            return normalize_symbol(s)
-        return s
-
     def _asset_type(bare: str) -> Any:
-        # _sym 后可能是 6 位裸码或 600000.SH 形态 — 都按前 3 位判
+        # 6 位裸码或 600000.SH 形态 — 都按前 3 位判
         code6 = bare.split(".")[0][-6:] if "." in bare else bare[-6:]
         if not (len(code6) == 6 and code6.isdigit()):
             return AssetType.Stock  # 非法 6 位 fallback, 不阻塞启动
@@ -354,38 +345,7 @@ def _build_instruments(symbols: list[str] | None, normalize: bool = False) -> li
             return AssetType.Fund
         return AssetType.Stock
 
-    return [Instrument(symbol=_sym(s), asset_type=_asset_type(_sym(s))) for s in symbols if s.strip()]
-
-
-def _recent_real_bars(symbols: list[str], days: int = 30) -> tuple[Any, str]:
-    """最近 N 天真实日线 → replay bars DataFrame (akquant dataframe_to_bars 格式).
-
-    数据源 = 本地 prebuilt bundle (真实历史, 与回测同源; bundle 覆盖到最新交易日).
-    返 (df, src): df 列 = date/open/high/low/close/volume/symbol + "股票代码" (多标的
-    识别必需, dataframe_to_bars normalize.py 只认这个列名).
-
-    Raises:
-        LiveRunError: 无 --symbols / 数据不可达 (提示先 dataset fetch).
-    """
-    from datetime import datetime, timedelta
-
-    from ..prebuilt_resolver import resolve
-
-    if not symbols:
-        raise LiveRunError(
-            "broker=replay 需要 --symbols 限定回放标的 (从本地 prebuilt 取最近真实数据)"
-        )
-    end = datetime.now().strftime("%Y%m%d")
-    start = (datetime.now() - timedelta(days=days)).strftime("%Y%m%d")
-    df, src = resolve(symbols, start, end)
-    if df is None or len(df) == 0:
-        raise LiveRunError(
-            f"最近 {days} 天无 bar 数据 (universe={symbols}, {start}~{end}, src={src}). "
-            f"先 `hamuna_quant_cli dataset fetch --symbols {','.join(symbols)}` 下载 prebuilt"
-        )
-    out = df.copy()
-    out["股票代码"] = out["symbol"]
-    return out, src
+    return [Instrument(symbol=s, asset_type=_asset_type(s)) for s in symbols if s.strip()]
 
 
 def configure_logging(level: str, log_file: Path | None) -> None:
@@ -417,7 +377,7 @@ def _with_live_history_depth(
     wrapper 在 on_start 里按日历注册周五 14:55 的 schedule() 定时器 (payload
     'rebalance') — 这正是 akquant live 缺的横截面周频触发:live 不注入
     _trading_days (on_cross_section 静默死) 且 schedule_daily 堕入真实墙钟
-    (replay 死), 手动 schedule() 绝对 ts 是唯一通路 (2026-08-27 探针实测触发).
+    (replay 已删 18.63.18), 手动 schedule() 绝对 ts 是唯一通路 (2026-08-27 探针实测触发).
 
     params: 用户实盘参数 (params.json strategy_params) — 作构造 kwargs 注入.
     live 端 _build_strategy_instance 是 `cls()` 无参实例化, 用户参数经
@@ -562,14 +522,13 @@ def _friday_date_strings(calendar: list[str] | None) -> list[str]:
 def _calendar_from_df(df: Any, symbols: list[str] | None = None) -> list[str] | None:
     """从实盘 startup 拉到的历史数据提取真实交易日列表 (YYYY-MM-DD 去重排序).
 
-    兼容两种 raw_factors 形态:
-    - replay: 单 bars_df (列含 date/时间)
+    形态 (Round 18.63.18: replay 已删, 只剩 bridge):
     - bridge: {sym: DataFrame} dict (列名 bridge 透传, 可能 date/stime/time/datetime)
 
     返回 None 表示无可用日期列 (跳过日历注入). 日期列探测优先级
     date > datetime > stime > time. bridge /data/history 的 bar 无 date 列,
     stime 是 'YYYYMMDD' 字符串 (真机实测 2026-08-28), time 是毫秒时间戳 —
-    time 必须 unit='ms' 解析, 否则 to_datetime 默认 ns 单位得 1970-01-01 垃圾日 (Round 18.23 replay 路径的坑).
+    time 必须 unit='ms' 解析, 否则 to_datetime 默认 ns 单位得 1970-01-01 垃圾日 (Round 18.23 的坑).
     """
     import datetime as _dt
     import pandas as _pd
@@ -620,20 +579,21 @@ def _live_safety_defaults(
     gateway_options: dict[str, str],
     duration: str,
 ) -> str:
-    """P0-1/P0-2 实盘安全默认: broker_live+qmt 强制真实下单 + 永久运行.
+    """P0-2 实盘安全默认: broker_live+qmt 永久运行 + dual_source 验证.
 
-    原地改 gateway_options (注入 qmt_paper=0 或报错), 返回修正后的 duration.
+    Round 18.63.18 (用户拍板): 去掉 qmt_paper mock 下单路径 — QMT 客户端原生
+    有「模拟信号模式」(GUI 手动切), CLI 永远发真 passorder, 模拟由 QMT 侧承担.
+    返回修正后的 duration.
     """
     if mode == "broker_live" and broker == "qmt":
-        paper_val = gateway_options.get("qmt_paper")
-        if paper_val is None:
-            gateway_options["qmt_paper"] = "0"
-            print("[info] broker_live 未显式 qmt_paper → 强制 0 (真实下单)", flush=True)
-        elif str(paper_val).strip().lower() in ("1", "true", "yes", "on"):
-            raise LiveRunError(
-                "broker_live + qmt_paper=1 矛盾: 真实盘模式不能 paper 下单. "
-                "要去掉 qmt_paper=1 或改用 --mode paper."
-            )
+        # 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)
 
         if duration in ("1h", "0", "0s", "0m", "0h", ""):
             # Round 18.63.14: "0"/"1h" = 永久运行. 之前返回 "0" 会被 akquant
@@ -644,15 +604,6 @@ def _live_safety_defaults(
             print("[info] broker_live 默认 duration=0 (永久运行); 如需限时显式传 --duration", flush=True)
             return ""
         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
 
 
@@ -668,14 +619,13 @@ def run_live(
     log_level: str,
     log_file: Path | None,
     market_broker: str | None,
-    replay_days: int = 30,
     params: dict | None = None,
 ) -> None:
     """翻译 + 转发到 akquant.run_live.
 
     spec:        loader 加载出的 StrategySpec (class 或 functional)
-    mode:        "paper" / "broker_live"
-    broker:      "ctp" / "qmf" / "replay" / 自定义 broker 名字
+    mode:        "broker_live" (Round 18.63.18: paper 已删 — QMT 原生模拟信号模式)
+    broker:      "qmt" / 自定义 broker 名字 (replay 已删)
     market_broker: 独立行情 broker id (e.g. "qmt_market"); None=单 broker
                    当 market_broker 设了, akquant 要求 trader_broker 也设 (二者成对, broker 字段被忽略).
                    我们固定配对: market_broker="qmt_market" + trader_broker="qmt".
@@ -692,43 +642,13 @@ def run_live(
     resolved_mp = _resolve_market_period(spec, gateway_options, params)
     if resolved_mp is not None:
         gateway_options["market_period"] = resolved_mp
-    # replay broker 的 bars 数据 — 供 v2 architecture compute_factors 复用
-    replay_bars_df = None
-    # 真实交易日历 (YYYY-MM-DD, 从 bars_df / bridge 历史提取) — 注入 strategy wrapper
+    # 真实交易日历 (YYYY-MM-DD, 从 bridge 历史提取) — 注入 strategy wrapper
     # 做周五 14:55 重排定时器 (Round 18.22: live 无 _trading_days, schedule_daily 墙钟死)
     rebalance_calendar: list[str] | None = None
 
-    # replay broker 必须配 trading_mode="paper" — 提前给出清晰错误, 而不是让 akquant 在深处抛
-    if broker == "replay" and mode == "broker_live":
-        raise LiveRunError(
-            "broker=replay + trading_mode=broker_live 不兼容 — replay 只有行情, "
-            "无交易通道, 用 broker_live 会抛 ValueError. 改用 mode=paper 或换 broker."
-        )
-
-    # broker=replay → 自动注入最近 N 天真实数据 (本地 prebuilt), paper 撮合走引擎.
-    # bounded_event_total 让回放完自动停, 不依赖 --duration 墙钟.
-    if broker == "replay":
-        bars_df, replay_src = _recent_real_bars(symbols, days=replay_days)
-        replay_bars_df = bars_df  # 供 v2 architecture compute_factors 复用
-        instruments = _build_instruments(sorted(bars_df["symbol"].unique()), normalize=True)
-        gateway_options["bars"] = bars_df
-        print(
-            f"[info] replay 数据: {replay_src} · {len(bars_df)} bars · "
-            f"{sorted(bars_df['symbol'].unique())} (最近 {replay_days} 天)",
-            flush=True,
-        )
-        if len(bars_df) < 60:
-            print(
-                f"[warn] bars < 60 — 有 warmup 的策略可能全程不触发 on_bar (0 交易). "
-                f"可加 --replay-days 扩大窗口 (e.g. --replay-days 180)",
-                flush=True,
-            )
-    else:
-        instruments = _build_instruments(symbols)
-        # run_live 始终要求至少 1 个 instrument (不是可选) — 不传 --symbols 时
-        # 用占位 sh600000, paper 模式 broker=qmt 不真下单, smoke 能跑通.
-        if not instruments:
-            instruments = _build_instruments(["sh600000"])
+    # Round 18.63.18 (用户拍板): broker=replay 本地回放已删 — QMT 客户端原生
+    # 模拟信号模式承担"无真盘验证", CLI live run 只走 broker_live+qmt 真下单.
+    instruments = _build_instruments(symbols)
     configure_logging(log_level, log_file)
 
     # broker="qmt" → import 触发 register_broker("qmt", ...), 校验 qmt_account_id 必填.
@@ -771,10 +691,7 @@ def run_live(
     # functional mode / 无 bridge_url 跳过 (兼容老策略).
     if spec.mode == "class" and spec.strategy_cls is not None:
         qmt_base_url = gateway_options.get("qmt_base_url")
-        # replay (paper trading) 用本地 bars 数据; qmt 用 bridge /data/history.
-        # 两者都走 compute_factors / filter_symbols (v2 architecture).
-        has_replay_data = replay_bars_df is not None
-        if qmt_base_url or has_replay_data:
+        if qmt_base_url:
             try:
                 strat_inst = spec.strategy_cls()
             except Exception as e:
@@ -802,30 +719,24 @@ def run_live(
             # 策略直接跳过 → calendar=[] → fridays=[] → 0 个周五百排定时器 (实测 bn9d2aa9u).
             rebalance_calendar: list[str] | None = None
             raw_factors: dict[str, Any] = {}  # 兜底初值: 下面 if 不走时空 dict
-            if qmt_base_url or has_replay_data:
-                try:
-                    if has_replay_data:
-                        raw_factors = replay_bars_df
-                    else:
-                        # paper=False / broker_live=True — paper 不需要实时订阅, broker_live
-                        # 必须 True 才能让 QMT 实时推新 bar (避免 count=-1 + 空时间窗只返
-                        # 本地最新 1 条 snapshot 的问题). qmt_market.go live_mode 同语义.
-                        raw_factors = _fetch_live_factors(qmt_base_url, symbols,
-                                                          subscribe=(mode == "broker_live"))
-                    rebalance_calendar = _calendar_from_df(raw_factors, symbols)
-                    if rebalance_calendar:
-                        print(
-                            f"[info] 交易日历注入: {len(rebalance_calendar)} days, "
-                            f"{len(_friday_date_strings(rebalance_calendar))} 周五 → 14:55 重排定时器",
-                            flush=True,
-                        )
-                except LiveRunError:
-                    raise
-                except Exception as e:
-                    raise LiveRunError(
-                        f"实盘拉历史失败 (rebalance_calendar): {type(e).__name__}: {e} "
-                        f"(用户原话: 出错直接报错停止, 不走 mock 兜底)"
-                    ) from e
+            try:
+                # broker_live 必须 subscribe=True 才能让 QMT 实时推新 bar
+                # (避免 count=-1 + 空时间窗只返本地最新 1 条 snapshot 的问题).
+                raw_factors = _fetch_live_factors(qmt_base_url, symbols, subscribe=True)
+                rebalance_calendar = _calendar_from_df(raw_factors, symbols)
+                if rebalance_calendar:
+                    print(
+                        f"[info] 交易日历注入: {len(rebalance_calendar)} days, "
+                        f"{len(_friday_date_strings(rebalance_calendar))} 周五 → 14:55 重排定时器",
+                        flush=True,
+                    )
+            except LiveRunError:
+                raise
+            except Exception as e:
+                raise LiveRunError(
+                    f"实盘拉历史失败 (rebalance_calendar): {type(e).__name__}: {e} "
+                    f"(用户原话: 出错直接报错停止, 不走 mock 兜底)"
+                ) from e
 
             if not wants_precompute:
                 print(
@@ -837,7 +748,7 @@ def run_live(
                 factors: dict[str, Any] = {}
                 if hasattr(strat_inst, "compute_factors"):
                     # 实盘 startup: 拉 N sym × N bar 历史, 拼 {sym: DataFrame} 喂 compute_factors
-                    # qmt: bridge /data/history; replay: 本地 prebuilt bars (paper trading).
+                    # qmt: bridge /data/history (Round 18.63.18: replay 已删).
                     # raw_factors / rebalance_calendar 已在上面分支统一拉, 此处复用.
                     try:
                         factors = strat_inst.compute_factors(raw_factors) or {}
@@ -882,7 +793,7 @@ def run_live(
                 instruments = _build_instruments(filtered)
         else:
             print(
-                "[info] class mode 无 qmt_base_url / replay bars; 跳过 compute_factors / filter_symbols",
+                "[info] class mode 无 qmt_base_url; 跳过 compute_factors / filter_symbols",
                 flush=True,
             )
     elif spec.mode == "functional":

{hamuna_quant_cli-0.1.23 → hamuna_quant_cli-0.1.25}/hamuna_quant_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hamuna-quant-cli
-Version: 0.1.23
+Version: 0.1.25
 Summary: Hamuna A 股回测 + 实盘统一 CLI (akquant 0.3.x). 替代 v1 自建 driver + QMT-style 策略规范.
 Author-email: Hamuna Team <team@hamuna.example>
 License: MIT
@@ -130,11 +130,8 @@ hamuna_quant_cli upload --name "v2_smoke" --config /tmp/c.json --code /tmp/s.py
 ```bash
 # 1) 写策略 (同上)
 
-# 2) paper 模式 (smoke, 不连真实 broker)
-hamuna_quant_cli live run /tmp/s.py \
-    --mode paper --broker replay --symbols sh600000,sz600036 --duration 30s
-
-# 3) qmt 实盘 (需配 broker=qmt + market_broker=qmt_market + gateway_options)
+# 2) qmt 实盘 (需配 broker=qmt + market_broker=qmt_market + gateway_options)
+#    Round 18.63.18: paper 模式已删 — 模拟由 QMT 客户端原生「模拟信号模式」承担
 hamuna_quant_cli live run /tmp/s.py \
     --mode broker_live --broker qmt --market-broker qmt_market \
     --symbols sh600000,sz600036 \

{hamuna_quant_cli-0.1.23 → hamuna_quant_cli-0.1.25}/pyproject.toml

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

hamuna_quant_cli-0.1.25/tests/test_live_safety.py

@@ -0,0 +1,42 @@
+"""P0-2 实盘安全默认测试 (2026-08; Round 18.63.18 更新).
+
+验证 hamuna_quant_cli.live.runner._live_safety_defaults:
+  - broker_live + qmt + duration=1h (CLI 默认) → 改为 "" (永久)
+  - broker_live + qmt + 显式 duration=2h → 保留 2h
+  - broker_live + qmt → 默认注入 dual_source=verify
+  - Round 18.63.18 (用户拍板): qmt_paper 已删 — QMT 客户端原生模拟信号模式,
+    CLI 永远发真 passorder. 不再强制/拒绝 qmt_paper, gateway_options 里出现
+    该键也不做任何处理 (build_qmt 忽略未知 kwargs).
+"""
+import sys
+from pathlib import Path
+
+# 确保能 import 到 hamuna_quant_cli (仓库根)
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT))
+
+from hamuna_quant_cli.live.runner import _live_safety_defaults  # noqa: E402
+
+def test_broker_live_qmt_default_duration_permanent():
+    opts = {}
+    duration = _live_safety_defaults("broker_live", "qmt", opts, "1h")
+    assert duration == "", "broker_live 默认 duration=1h 应改为 '' (永久运行)"
+    assert opts.get("dual_source") == "verify", "broker_live+qmt 默认开双源验证"
+
+def test_broker_live_qmt_explicit_duration_preserved():
+    opts = {}
+    duration = _live_safety_defaults("broker_live", "qmt", opts, "2h")
+    assert duration == "2h", "显式 duration 应保留"
+
+def test_broker_live_qmt_paper_key_ignored():
+    # Round 18.63.18: qmt_paper 概念已删, 出现也不报错 (QMT 原生模拟信号模式)
+    opts = {"qmt_paper": "1"}
+    duration = _live_safety_defaults("broker_live", "qmt", opts, "1h")
+    assert duration == ""
+    assert opts.get("dual_source") == "verify"
+
+def test_other_mode_untouched():
+    opts = {}
+    duration = _live_safety_defaults("broker_live", "other", opts, "1h")
+    assert opts == {}, "非 qmt broker 不应注入 dual_source"
+    assert duration == "1h"

hamuna_quant_cli-0.1.23/tests/test_live_safety.py

@@ -1,52 +0,0 @@
-"""P0-1/P0-2 实盘安全默认测试 (2026-08).
-
-验证 hamuna_quant_cli.live.runner._live_safety_defaults:
-  - broker_live + qmt + 未显式 qmt_paper → 强制注入 "0" (真实下单)
-  - broker_live + qmt + 显式 qmt_paper=1 → LiveRunError
-  - broker_live + qmt + duration=1h (CLI 默认) → 改为 "0" (永久)
-  - broker_live + qmt + 显式 duration=2h → 保留 2h
-  - paper / 非 qmt → 不改 gateway_options, duration 原样
-"""
-import sys
-from pathlib import Path
-
-# 确保能 import 到 hamuna_quant_cli (仓库根)
-ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(ROOT))
-
-from hamuna_quant_cli.live.runner import LiveRunError, _live_safety_defaults  # noqa: E402
-
-
-def test_broker_live_qmt_injects_real_trading():
-    opts = {}
-    duration = _live_safety_defaults("broker_live", "qmt", opts, "1h")
-    assert opts["qmt_paper"] == "0", "broker_live+qmt 必须强制真实下单"
-    assert duration == "0", "broker_live 默认 duration=1h 应改为 0 (永久)"
-
-
-def test_broker_live_qmt_explicit_paper_raises():
-    import pytest
-    opts = {"qmt_paper": "1"}
-    with pytest.raises(LiveRunError, match="qmt_paper=1"):
-        _live_safety_defaults("broker_live", "qmt", opts, "1h")
-
-
-def test_broker_live_qmt_explicit_duration_preserved():
-    opts = {}
-    duration = _live_safety_defaults("broker_live", "qmt", opts, "2h")
-    assert opts["qmt_paper"] == "0"
-    assert duration == "2h", "显式 duration 应保留"
-
-
-def test_paper_mode_untouched():
-    opts = {}
-    duration = _live_safety_defaults("paper", "qmt", opts, "1h")
-    assert opts == {}, "paper 模式不应注入 qmt_paper"
-    assert duration == "1h"
-
-
-def test_broker_live_non_qmt_untouched():
-    opts = {}
-    duration = _live_safety_defaults("broker_live", "replay", opts, "1h")
-    assert opts == {}, "非 qmt broker 不应注入"
-    assert duration == "1h"