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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hamuna-quant-cli
-Version: 0.1.11
+Version: 0.1.12
 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.11 → hamuna_quant_cli-0.1.12}/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.11"
+__version__ = "0.1.12"

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

@@ -332,9 +332,8 @@ def cmd_commit(args) -> int:
     bundle = 4 文件 (strategy + result + config + params). multipart params 字段
     = 整个 params.json 内容 (ADR-0025, desktop 实盘配置源).
 
-    Round 18.62 P0-1: 新增 step 1.5 replay diff gate — `--replay-result` 必填,
-    与 `--result` 算 sharpe diff, 超阈值 (HAMUNA_REPLAY_GATE_PCT 缺省 0.20) → exit 5.
-    server `UpdateStrategyResult` handler 二次校验防绕过.
+    Round 18.63: replay gate (P0-1) 移除 (用户决策) — 上传不再要求 replay_result,
+    `--replay-result` / `--skip-replay-gate` 参数已删.
 
     Round 18.62 P1-1: 新增 step 1.4 version bump — `GET /strategies/{id}` 拿
     `latest_version` (无 → "0.0.0"); 默认 patch 自动 bump (`0.0.0 → 0.0.1`),
@@ -345,7 +344,6 @@ def cmd_commit(args) -> int:
     from .runtime.server_client import ServerError
     import io
     import json
-    import os
     import re
     import tarfile
 
@@ -367,16 +365,6 @@ def cmd_commit(args) -> int:
     if params_path and not params_path.exists():
         print(f"params.json 不存在: {params_path} (--params 可选)", file=sys.stderr)
         return 2
-    # Round 18.62 P0-1: replay_result.json 必填 (除非 --skip-replay-gate qa 通道).
-    replay_path = Path(args.replay_result) if args.replay_result else None
-    if not args.skip_replay_gate:
-        if replay_path is None:
-            print("ERROR: P0-1: 必须传 --replay-result, 先跑 live run --broker replay 拿 metrics "
-                  "(或 --skip-replay-gate qa 通道)", file=sys.stderr)
-            return 2
-        if not replay_path.exists():
-            print(f"replay_result.json 不存在: {args.replay_result}", file=sys.stderr)
-            return 2
 
     # ----- Round 18.62 P1-1 step 1.4: version bump -----
     # cli 先 GET /strategies/{id} 拿 latest_version (无 → "0.0.0"); 默认 patch 自动 bump,
@@ -407,7 +395,7 @@ def cmd_commit(args) -> int:
     bundle_out = Path(args.bundle_out) if args.bundle_out else Path(f"runs/{sid}/bundle.tar.gz")
     bundle_out.parent.mkdir(parents=True, exist_ok=True)
 
-    print("=== Step 1/3: 打包 bundle (strategy + result + config + params + replay + version) ===",
+    print("=== Step 1/3: 打包 bundle (strategy + result + config + params + version) ===",
           file=sys.stderr)
     with tarfile.open(bundle_out, "w:gz") as tar:
         tar.add(strategy_path, arcname=strategy_path.name)
@@ -416,9 +404,6 @@ def cmd_commit(args) -> int:
             tar.add(cfg_path, arcname=cfg_path.name)
         if params_path:
             tar.add(params_path, arcname=params_path.name)
-        # Round 18.62 P0-1: replay_result.json 也打进去, 方便回溯 / 审计.
-        if replay_path:
-            tar.add(replay_path, arcname=replay_path.name)
         # Round 18.62 P1-1: version.json 内存写, audit 用 (server 不读, 仅本地回溯).
         ver_bytes = json.dumps({"version": new_version}, ensure_ascii=False).encode("utf-8")
         ver_info = tarfile.TarInfo(name="version.json")
@@ -426,40 +411,7 @@ def cmd_commit(args) -> int:
         tar.addfile(ver_info, io.BytesIO(ver_bytes))
     print(f"  ✓ bundle = {bundle_out} ({bundle_out.stat().st_size} bytes)", file=sys.stderr)
 
-    # ----- Round 18.62 P0-1 step 1.5: replay diff gate -----
-    # 必在 step 2 (PUT) 之前 — gate fail 后 step 2-3 都不跑, 不留半上传状态.
-    replay_metrics: dict | None = None
-    if not args.skip_replay_gate:
-        try:
-            bt = json.loads(result_path.read_text(encoding="utf-8"))
-            rp = json.loads(replay_path.read_text(encoding="utf-8"))  # type: ignore[union-attr]
-        except json.JSONDecodeError as e:
-            print(f"  ✗ result/replay JSON 解析失败: {e}", file=sys.stderr)
-            return 2
-        bt_sharpe = float(bt.get("metrics", {}).get("sharpe", 0.0))
-        rp_sharpe = float(rp.get("metrics", {}).get("sharpe", 0.0))
-        diff_pct = abs(rp_sharpe - bt_sharpe) / max(abs(bt_sharpe), 0.01)
-        try:
-            threshold = float(os.environ.get("HAMUNA_REPLAY_GATE_PCT", "0.20"))
-        except ValueError:
-            threshold = 0.20
-        if diff_pct > threshold:
-            print(f"ERROR: replay gate diff={diff_pct:.2%} > {threshold:.0%} "
-                  f"(backtest.sharpe={bt_sharpe:.4f} vs replay.sharpe={rp_sharpe:.4f})",
-                  file=sys.stderr)
-            return 5
-        replay_metrics = {
-            "sharpe": rp_sharpe,
-            "total_return": float(rp.get("metrics", {}).get("total_return", 0.0)),
-            "win_rate": float(rp.get("metrics", {}).get("win_rate", 0.0)),
-            "trades": len(rp.get("trades", [])),
-            "diff_pct": diff_pct,
-            "run_at": (rp.get("period") or {}).get("end"),
-        }
-        print(f"  ✓ replay gate pass (diff={diff_pct:.2%} <= {threshold:.0%}, "
-              f"replay.sharpe={rp_sharpe:.4f})", file=sys.stderr)
-
-    print("=== Step 2/3: PUT /strategies/:id/result (metrics + replay_metrics + version) ===",
+    print("=== Step 2/3: PUT /strategies/:id/result (metrics + version) ===",
           file=sys.stderr)
     try:
         result = json.loads(result_path.read_text(encoding="utf-8"))
@@ -468,7 +420,7 @@ def cmd_commit(args) -> int:
         return 2
     try:
         resp = runtime.server_client.upload_backtest_result(
-            sid, result, replay_metrics=replay_metrics, version=new_version,
+            sid, result, version=new_version,
         )
     except runtime.server_client.ServerError as e:
         print(f"  ✗ 上传 metrics 失败: {e}", file=sys.stderr)
@@ -1036,12 +988,6 @@ def build_parser() -> argparse.ArgumentParser:
     cm.add_argument("strategy_id", help="server 端 strategy_id")
     cm.add_argument("--strategy", help="akquant strategy .py 路径 (默认 <id>.py)")
     cm.add_argument("--result", required=True, help="metrics result.json 路径")
-    # Round 18.62 P0-1: replay gate. --replay-result 必填 (除非 --skip-replay-gate).
-    cm.add_argument("--replay-result", default=None,
-                    help="replay_result.json 路径 (P0-1 必填; 先跑 live run --broker replay 拿 metrics, "
-                         "或 --skip-replay-gate 跳过)")
-    cm.add_argument("--skip-replay-gate", action="store_true",
-                    help="[qa 临时] 跳过 replay diff gate (非 dev 默认)")
     # Round 18.62 P1-1: version bump. 默认 patch 自动 (从 server latest_version +0.0.1),
     # 显式 --major / --minor opt-in. 互斥.
     cm.add_argument("--major", action="store_true",

{hamuna_quant_cli-0.1.11 → hamuna_quant_cli-0.1.12}/hamuna_quant_cli/akquant_runner.py

@@ -46,63 +46,23 @@ class StrategyParamsError(RuntimeError):
 
 # ---- strategy loader (沿 driver._load_strategy 模式, 但导 Strategy 类不导 handlebar) ----
 def _with_backtest_timer_rebalance(cls: type) -> type:
-    """回测端周五 schedule + on_timer 注入 — 与实盘 replay 同触发路径.
-
-    Round 18.32: 之前回测横截面策略走 `on_cross_section`, 实盘 replay 走
-    `on_timer` (runner 外部日历注入 schedule) — 两端路径不同, 可比性差 (实盘丢
-    07-03 批 / 因子一次性 vs 逐 bar 演进). 本 wrapper 让**回测也走 on_timer**:
-
-    - `on_start` 时 `_trading_days` 未注入 (engine.py:3107 on_start 在 :3502 注入
-      之前), `self.trading_days` 恒空 — 所以**延迟到首个 on_bar** 再注册.
-    - 首个 bar 时从 `self.trading_days` 筛周五, 逐周注册 `schedule(周五14:55, 'rebalance')`
-      → 引擎按 bar 边界触发 `on_timer('rebalance')`, ctx.current_time 即该周五.
-    - 策略已定义 on_timer 处理 'rebalance' → 与实盘完全同路径; 未定义 → base no-op, 无害.
-    - 只包有 on_timer 的策略 (无 on_timer 时 on_cross_section 仍是唯一回测调仓钩子,
-      注入 schedule 白费且可能引发无预期 on_timer 调用).
-
-    ponytail: 与 live 端 `_with_live_history_depth` 互补 — live 用外部日历注入
-    (replay bars / bridge 历史), 回测用引擎 trading_days. 两端最终都注册
-    `schedule(周五14:55, 'rebalance')` → `on_timer`, 真正同机制.
-    """
-    import datetime as _dt
+    """回测端 on_cross_section 调仓路径 — 与实盘 schedule_daily+on_timer 配对.
+
+    Round 24 真相修正 (前 Round 18.32 wrapper 声称 schedule+on_timer 注入, 但
+    `akquant.collect_cross_section_timer_entries` 只查 strategy 上
+    `_trading_day_cross_section_timestamps` 字段, 完全不消费 `strategy_scheduler`
+    里的 _schedule 注册 — 实测 0 trade). 真触发路径只有 on_cross_section.
 
-    if cls is None or "on_timer" not in getattr(cls, "__dict__", {}):
+    本 wrapper 改为: 不再吞 on_cross_section, 让策略层的 on_cross_section 自由
+    处理调仓 (用户策略层用 weekday/dedup 判定周频, Round 24 DIR-003 同型).
+    策略层若无 on_cross_section, 不 wrap (直接返回 cls, 让 engine 走 on_cross_section
+    默认 no-op, 不影响).
+    """
+    if cls is None or "on_cross_section" not in getattr(cls, "__dict__", {}):
         return cls
-    from akquant.strategy_scheduler import schedule as _schedule
 
     class _BacktestTimerRebalance(cls):
-        _bt_timer_registered = False
-
-        def on_bar(self, bar) -> Any:
-            ret_val = super().on_bar(bar)
-            if not type(self)._bt_timer_registered:
-                type(self)._bt_timer_registered = True
-                try:
-                    fridays = [ts for ts in self.trading_days if ts.weekday() == 4]
-                    for ts in fridays:
-                        _schedule(self, ts.replace(hour=14, minute=55), "rebalance")
-                    print(
-                        f"[info] 回测周五 schedule+on_timer 注入: {len(fridays)} 个 "
-                        f"({[ts.strftime('%m-%d') for ts in fridays]})",
-                        file=sys.stderr,
-                    )
-                except Exception as e:  # noqa: BLE001 — 注入失败不崩, 回测走原路径
-                    print(
-                        f"[warn] 回测周五 schedule 注入失败: {e}",
-                        file=sys.stderr,
-                    )
-            return ret_val
-
-        def on_cross_section(self, trading_date, timestamp) -> Any:
-            """吞掉 on_cross_section — schedule 定时器已接管调仓 (Round 18.32).
-
-            策略类同时有 on_cross_section (回测旧路径) 和 on_timer (实盘新路径) 时,
-            同一个周五**两个钩子都会触发** → 重复下单 (实测: 07-06 批 20→22 trades,
-            000006/000035 各重复买一次). 本 wrapper 把 on_cross_section 变 no-op,
-            让回测统一走 schedule+on_timer, 与实盘完全同路径. 若策略没有
-            on_cross_section, 本方法不干扰 (未重写 → 走父类 no-op, 同样无害).
-            """
-            return None
+        pass
 
     _BacktestTimerRebalance.__name__ = cls.__name__
     _BacktestTimerRebalance.__qualname__ = cls.__qualname__

{hamuna_quant_cli-0.1.11 → hamuna_quant_cli-0.1.12}/hamuna_quant_cli/akquant_schema_adapter.py

@@ -8,12 +8,13 @@
 一致 (B 重写不动数值层). 迁移原因: v2 skill 未来独立分发, 不依赖仓根.
 
 字段映射 (15 metrics):
-  total_return ← r.metrics.total_return_pct / 100
-  annual_return ← r.metrics.annual_return_pct / 100  (akquant 直接给)
+  total_return ← r.metrics.total_return_pct / 100          (% → ratio)
+  annual_return ← r.metrics.annualized_return (0.3.52, 小数)
+                 或 r.metrics.annual_return_pct / 100      (0.3.41 legacy, %)
   sharpe ← r.metrics.sharpe_ratio
   max_drawdown ← r.metrics.max_drawdown_pct / 100
   volatility ← 自算 (np.std(daily_ret) * sqrt(252), 沿 metrics.py:63)
-  win_rate ← r.metrics.win_rate
+  win_rate ← r.metrics.win_rate / 100                      (% → 0~1; 0 平仓 → None)
   profit_loss_ratio ← 自算 from trades_df (FIFO pair, 沿 metrics.py:104)
   avg_holding_period ← 自算 calendar days (沿 metrics.py:155)
   benchmark_total_return ← NaN (akquant 单策略无自动基准, 见 bench_20260813_201349.json)
@@ -24,6 +25,11 @@
   profit_factor ← 自算 from trades_df (沿 metrics.py:192)
   annual_volatility ← alias of volatility
 
+> ⚠ 0.3.41 → 0.3.52 键名漂移 (2026-09-02 真回测校准):
+>   `annual_return_pct` → `annualized_return` (且单位从 % 变为小数);
+>   `final_value` → `end_market_value`; `win_rate` 两版都是 %, 需 /100.
+>   读取统一走 `_metric(obj, _METRIC_ALIASES[i])`, 两版兼容.
+
 equity_curve: r.equity_curve() Series → [{date:'YYYYMMDD', nav: float}, ...]
   首日补 initial_capital (driver.py:103-106 同款)
 
@@ -37,7 +43,8 @@ monthly_bars / monthly_metrics: 自算 (沿 metrics.py:242+)
 
 initial_capital / final_capital / avg_holding_period / suggestions:
   - initial_capital = cfg['init_capital']
-  - final_capital = r.metrics.final_value (若 akquant 给) 或 equity_curve 末点
+  - final_capital = r.metrics.end_market_value (0.3.52) / final_value (0.3.41),
+                    或 equity_curve 末点 (fallback)
   - avg_holding_period = metrics 内同名字段
   - suggestions = [] (Phase B 最小化; driver._suggestions 不复用)
 
@@ -97,6 +104,36 @@ def _safe_get(obj: Any, key: str, default: float = float('nan')) -> float:
     return f
 
 
+# akquant 0.3.41 → 0.3.52 键名漂移 (2026-09-02 真回测校准):
+#   0.3.41 用 `annual_return_pct` (%, /100) / `final_value`;
+#   0.3.52 改为 `annualized_return` (小数, 直接取) / `end_market_value`.
+# `win_rate` 两个版本都是 % (有平仓时 70.0 = 70%), Hamuna 契约要 0~1 → /100.
+_METRIC_ALIASES: list[tuple[tuple[str, float], ...]] = [
+    # (候选键名, 换算 scale) — 键存在即取, scale 对齐 Hamuna ratio 契约
+    (('total_return_pct', 1.0 / 100.0),),                                  # % → ratio
+    (('annualized_return', 1.0), ('annual_return_pct', 1.0 / 100.0)),      # 0.3.52 小数 | 0.3.41 %
+    (('sharpe_ratio', 1.0),),
+    (('max_drawdown_pct', 1.0 / 100.0),),                                  # % → ratio
+    (('win_rate', 1.0 / 100.0),),                                          # % → ratio (0~1)
+    (('end_market_value', 1.0), ('final_value', 1.0)),                     # 0.3.52 | 0.3.41
+]
+
+
+def _metric(obj: Any, aliases: tuple[tuple[str, float], ...],
+            default: float = float('nan')) -> float:
+    """按候选键名读取 metric, 兼容版本键名漂移.
+
+    aliases: ((键名, scale), ...) 按优先序; 取第一个在 obj 上真实存在的键,
+    返回值 = 原值 × scale. 全部缺失 → default (NaN). 与 _safe_get 的
+    "missing 与 0.0 不混淆" 语义一致 (float 转换失败/NaN/Inf 也返回 default).
+    """
+    for key, scale in aliases:
+        v = _safe_get(obj, key, default=float('nan'))
+        if not math.isnan(v):
+            return v * scale
+    return default
+
+
 def _nan() -> float:
     return float('nan')
 
@@ -206,13 +243,19 @@ def to_hamuna_result(akquant_r: Any, cfg: dict) -> dict:
     equity_curve = _to_daily(eq_curve, initial_capital)
     nav_values = [p['nav'] for p in equity_curve]
 
-    # 15 metrics
+    # 15 metrics — 键名走 `_metric` 别名 (0.3.41/0.3.52 兼容, 见 _METRIC_ALIASES)
     m = getattr(akquant_r, 'metrics', None)
-    total_return = _safe_get(m, 'total_return_pct', 0.0) / 100.0 if m else _nan()
-    annual_return = _safe_get(m, 'annual_return_pct', _nan()) / 100.0 if m else _nan()
-    sharpe = _safe_get(m, 'sharpe_ratio', _nan()) if m else _nan()
-    mdd = _safe_get(m, 'max_drawdown_pct', _nan()) / 100.0 if m else _nan()
-    win_rate = _safe_get(m, 'win_rate', _nan()) if m else _nan()
+    total_return = _metric(m, _METRIC_ALIASES[0], 0.0) if m else _nan()
+    annual_return = _metric(m, _METRIC_ALIASES[1]) if m else _nan()
+    sharpe = _metric(m, _METRIC_ALIASES[2]) if m else _nan()
+    mdd = _metric(m, _METRIC_ALIASES[3]) if m else _nan()
+    win_rate = _metric(m, _METRIC_ALIASES[4]) if m else _nan()
+    # 0 closed pair (trades_df 空) 时 AKQuant metrics.win_rate 为 0.0, 但 Hamuna 契约
+    # 要 None (backtest-result.md: 0 trades → win_rate=None). trades_df 才是 closed
+    # pair 源 (executions_df 含 buy-only 流水, 不能用来判"有无已平仓交易").
+    closed_pair_empty = trades_df is None or trades_df.empty
+    if closed_pair_empty:
+        win_rate = _nan()
     # 自算
     volatility = _volatility(nav_values) if nav_values else 0.0
     sortino = _sortino(nav_values) if nav_values else 0.0
@@ -247,8 +290,8 @@ def to_hamuna_result(akquant_r: Any, cfg: dict) -> dict:
     monthly_bars = _monthly_bars(equity_curve)
     monthly_metrics = _monthly_metrics(equity_curve)
 
-    # final_capital
-    final_capital = _safe_get(m, 'final_value', float('nan')) if m else _nan()
+    # final_capital: end_market_value (0.3.52) / final_value (0.3.41) → fallback equity 末点
+    final_capital = _metric(m, _METRIC_ALIASES[5], float('nan')) if m else _nan()
     if math.isnan(final_capital) and equity_curve:
         final_capital = equity_curve[-1]['nav']
     final_capital = None if isinstance(final_capital, float) and math.isnan(final_capital) else final_capital
@@ -434,14 +477,29 @@ def _json_safe(o: Any) -> Any:
     场景: akquant orders_df 等原始曲面的 limit_price/stop_price 常见 NaN
     (市价单/未触发单). 直接进 result 会让后端 json.loads 崩.
     Round 18.16 真数据验证抓到的真实泄漏 (Round 3 NaN 待办真载体).
+    Round 18.62+ 实测补漏: DataFrame.to_dict 会把 DatetimeIndex/时间列转成
+    pandas.Timestamp / datetime — json.dumps 抛 TypeError, 一并转 ISO 字符串.
     """
-    import math
+    import datetime as _dt
     if isinstance(o, float):
         return None if (math.isnan(o) or math.isinf(o)) else o
     if isinstance(o, dict):
         return {k: _json_safe(v) for k, v in o.items()}
     if isinstance(o, list):
         return [_json_safe(x) for x in o]
+    # pandas.Timestamp 是 datetime 子类 → 先判 Timestamp 再判 datetime, 顺序无所谓
+    if isinstance(o, _dt.datetime):
+        return o.isoformat()
+    if isinstance(o, _dt.date):
+        return o.isoformat()
+    if isinstance(o, _dt.timedelta):
+        # orders_df.duration = exit - entry (timedelta) — JSON 无原生类型, 转秒
+        return o.total_seconds()
+    if hasattr(o, 'isoformat'):  # 兜底: np.datetime64 等
+        try:
+            return o.isoformat()
+        except Exception:  # noqa: BLE001
+            pass
     return o
 
 
@@ -475,12 +533,19 @@ def _selfcheck() -> None:
             "设置 HAMUNA_SELFTEST=1 显式启用."
         )
     class _MockMetrics:
+        """0.3.52 真实键 (2026-09-02 实测校准):
+        - total_return_pct = % (5.0 表示 5%) → ratio 0.05
+        - annualized_return = 小数 (0.12 表示 12%), 无 annual_return_pct
+        - max_drawdown_pct = % (8.0 表示 8%) → ratio 0.08
+        - win_rate = % (60.0 表示 60%) → ratio 0.6; 无 closed pair 时为 0.0
+        - end_market_value (金额), 无 final_value
+        """
         total_return_pct = 5.0
-        annual_return_pct = 12.0
+        annualized_return = 0.12
         sharpe_ratio = 1.2
         max_drawdown_pct = 8.0
-        win_rate = 0.6
-        final_value = 1_050_000.0
+        win_rate = 60.0
+        end_market_value = 1_050_000.0
 
     class _MockEquityCurve:
         def __init__(self):
@@ -509,6 +574,9 @@ def _selfcheck() -> None:
         # NaN 泄漏回归: orders_df 的 limit_price 常态 NaN (市价单), 必须被 _json_safe 清掉
         orders_df = [{'symbol': '600000.SH', 'limit_price': float('nan'),
                       'stop_price': float('nan'), 'filled': 100}]
+        # Timestamp 泄漏回归 (Round 18.62+ 实测): exposure_df 的 date 列 to_dict
+        # 后是 pandas.Timestamp, json.dumps 会 TypeError — 必须转 ISO 字符串.
+        exposure_df = [{'date': pd.Timestamp('2024-01-05'), 'gross': 1.2}]
 
     cfg = {
         'backtest_start': '20240101',
@@ -521,6 +589,14 @@ def _selfcheck() -> None:
     # 15 metrics
     assert set(result['metrics'].keys()) == HAMUNA_METRICS_15, (
         f'metrics key 缺/多: {set(result["metrics"].keys()) ^ HAMUNA_METRICS_15}')
+    # 单位转换断言 (0.3.52 键名/单位校准, 2026-09-02):
+    # total_return_pct=5.0(%) → 0.05; annualized_return=0.12(小数) → 0.12;
+    # max_drawdown_pct=8.0(%) → 0.08; win_rate=60.0(%) → 0.6.
+    mt = result['metrics']
+    assert abs(mt['total_return'] - 0.05) < 1e-9, mt['total_return']
+    assert abs(mt['annual_return'] - 0.12) < 1e-9, mt['annual_return']
+    assert abs(mt['max_drawdown'] - 0.08) < 1e-9, mt['max_drawdown']
+    assert abs(mt['win_rate'] - 0.6) < 1e-9, mt['win_rate']
     # 13 顶层 key (driver.py:113-128: metrics/equity_curve/benchmark_curve/trades/universe/
     # period/params/monthly_bars/monthly_metrics/initial_capital/final_capital/avg_holding_period/suggestions)
     expected_top = {'metrics', 'equity_curve', 'benchmark_curve', 'trades', 'universe',
@@ -543,10 +619,30 @@ def _selfcheck() -> None:
     odf = result['params']['_akquant_extra']['orders_df']
     assert odf[0]['limit_price'] is None, f'limit_price 应 None, got {odf[0]["limit_price"]!r}'
     assert odf[0]['stop_price'] is None
+    # Timestamp 泄漏回归 (Round 18.62+): 时间值必须转 ISO 字符串, 否则 json.dumps TypeError
+    edf = result['params']['_akquant_extra']['exposure_df']
+    assert edf[0]['date'] == '2024-01-05T00:00:00', f'Timestamp 应转 ISO, got {edf[0]["date"]!r}'
     import json
-    json.dumps(result)  # strict JSON 序列化 — NaN 会 raise ValueError
+    json.dumps(result)  # strict JSON 序列化 — NaN 会 raise ValueError, Timestamp 会 TypeError
     print('OK: akquant_schema_adapter 15 metrics + 13 顶层 key + 7 trades fields + NaN 清理 全对齐')
 
+    # 0.3.41 legacy 键兼容 (annual_return_pct=12.0 % → 0.12; final_value=1050000):
+    class _LegacyMetrics:
+        total_return_pct = 5.0
+        annual_return_pct = 12.0
+        sharpe_ratio = 1.2
+        max_drawdown_pct = 8.0
+        win_rate = 60.0
+        final_value = 1_050_000.0
+
+    class _LegacyResult(_MockResult):
+        metrics = _LegacyMetrics()
+
+    legacy = to_hamuna_result(_LegacyResult(), cfg)
+    assert abs(legacy['metrics']['annual_return'] - 0.12) < 1e-9, legacy['metrics']['annual_return']
+    assert legacy['final_capital'] == 1_050_000.0, legacy['final_capital']
+    print('OK: 0.3.41 legacy 键 (annual_return_pct / final_value) 兼容')
+
 
 if __name__ == '__main__':
     _selfcheck()

{hamuna_quant_cli-0.1.11 → hamuna_quant_cli-0.1.12}/hamuna_quant_cli/live/qmt_broker.py

@@ -66,6 +66,7 @@ def _import_akquant_gateway():
 # (transient failure 自动重试; 4xx/业务错误不重试)
 # ============================================================
 import json
+import time
 from typing import Any
 
 import requests
@@ -383,6 +384,19 @@ def _make_trader_gateway():
             if order_id:
                 self.record_broker_order(order_id, req.client_order_id)
             # 即便 order_id 空 (bridge 的 submit_unknown), 也返回它拿到的 ref, 让上层知道.
+            if not order_id:
+                # Round 26 修复: bridge passorder_return=0 时 order_id/order_ref 都空,
+                # 但 bridge 已经把 qmt_user_order_id 写到了 QMT m_strRemark (Round 27 后
+                # bridge 会主动 poll 找真 order_id 并写到响应里). 此处 fallback:
+                #   1) qmt_user_order_id 优先 (bridge 内的稳定 key, 跨重启也保留)
+                #   2) passorder_return 兜底 (xtquant passorder 返回值, 0/正整数都允许)
+                # 任一非空都 record_broker_order, 让 akquant _sync_order_id_mapping
+                # (line 2072 of akquant/_runner.py) 不会因 broker_order_id 空而跳过.
+                fallback_id = (str(data.get("qmt_user_order_id") or "")
+                               or str(data.get("passorder_return") or ""))
+                if fallback_id and fallback_id not in ("0", "0.0"):
+                    self.record_broker_order(fallback_id, req.client_order_id)
+                    return fallback_id
             return order_id or str(data.get("passorder_return") or "")
 
         # ----- 撤单 -----
@@ -511,6 +525,92 @@ def _make_trader_gateway():
             except BrokerHTTPError:
                 return False
 
+        # ----- Round 26 补齐: akquant Protocol sync_* 方法 -----
+        # akquant BrokerRecovery (live/_runner.py:1800) 每 30s 调 sync_open_orders /
+        # sync_today_trades, 期望返回 UnifiedOrderSnapshot / UnifiedTrade 列表.
+        # qmt 路径默认 TraderGatewayBase.sync_* 返 [], 导致 on_order/on_trade 永远
+        # 收不到回报 (Round 26 0 trade 主因之一). 这里 override 走 query_* + 反查表.
+        #
+        # Round 28+ — bridge ensure_cache 同步阻塞老问题 cascade:
+        #   bridge _QMT_EXECUTOR 4 线程被 download_history_data 占满 → /orders HTTP hang
+        #   → sync_open_orders 每 30s 触发 query_order 累积 5s×N → on_order 永远收不到.
+        # Fix: TTL local cache (30s 内复用, 不重复 HTTP) + HTTP 失败返 last known good
+        # (不抛, 降级). 配合 bridge ensure_cache 异步化 (Round 28+ 改动 #1).
+        _sync_cache_ttl: float = 30.0
+        _sync_orders_cache: tuple = (0.0, [])  # (monotonic_ts, result_list)
+        _sync_trades_cache: tuple = (0.0, [])
+
+        def sync_open_orders(self):  # type: ignore[override]
+            """调 query_order per known broker_order_id, 聚合未完成订单.
+
+            Round 28+: TTL cache + 失败降级返 last known good.
+
+            已知 broker_order_id 来源:
+              1) self._client_id_by_broker (record_broker_order 写入, TraderGatewayBase)
+              2) self._broker_to_client_order_ids (akquant 内部维护)
+            任一找不到的 fallback 调 query_order(client_order_id=client_oid).
+            """
+            if not self._connected:
+                return []
+            # Round 28+: TTL cache — 30s 内复用避免 bridge hang 时重复 HTTP
+            now = time.monotonic()
+            ts, cached = self._sync_orders_cache
+            if cached and (now - ts) < self._sync_cache_ttl:
+                return cached
+            ak = _import_akquant_gateway()
+            UnifiedOrderSnapshot = ak["UnifiedOrderSnapshot"]
+            known_ids: set[str] = set()
+            client_map = getattr(self, "_client_id_by_broker", {})
+            known_ids.update(str(k) for k in client_map.keys() if k)
+            snapshots: list = []
+            seen: set[str] = set()
+            any_success = False
+            for bid in known_ids:
+                if not bid or bid in seen:
+                    continue
+                seen.add(bid)
+                try:
+                    snap = self.query_order(bid)
+                    if snap is not None:
+                        snapshots.append(snap)
+                        any_success = True
+                except Exception as e:  # noqa: BLE001
+                    print(f"[qmt-broker] sync_open_orders {bid} error: "
+                          f"{type(e).__name__}: {e}", flush=True)
+            # Round 28+: 全失败且有 cache → 降级返 cache (桥 hang 时不抛, 保 fire 不死)
+            if not any_success and cached:
+                print(f"[qmt-broker] sync_open_orders 全失败, 降级返 cache "
+                      f"({len(cached)} 条, age={now - ts:.1f}s)", flush=True)
+                return cached
+            # 成功 → 更新 cache
+            self._sync_orders_cache = (now, snapshots)
+            return snapshots
+
+        def sync_today_trades(self):  # type: ignore[override]
+            """调 query_trades (无 since) 拉当日所有成交, 30s 周期.
+
+            Round 28+: TTL cache + 失败降级.
+            """
+            if not self._connected:
+                return []
+            now = time.monotonic()
+            ts, cached = self._sync_trades_cache
+            if cached and (now - ts) < self._sync_cache_ttl:
+                return cached
+            try:
+                result = self.query_trades(since=None)
+                self._sync_trades_cache = (now, list(result))
+                return result
+            except Exception as e:  # noqa: BLE001
+                if cached:
+                    print(f"[qmt-broker] sync_today_trades HTTP 失败, 降级返 cache "
+                          f"({len(cached)} 条, age={now - ts:.1f}s): "
+                          f"{type(e).__name__}: {e}", flush=True)
+                    return cached
+                print(f"[qmt-broker] sync_today_trades error: "
+                      f"{type(e).__name__}: {e}", flush=True)
+                return []
+
     return QmtTraderGateway
 
 

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

@@ -13,7 +13,7 @@
 
 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>
+    GET /data/history?security=<sym>&period=<p>&count=<n>&fq=<fwd/back/qfq/None>
                                                    → 历史 K 线 (QMT get_market_data_ex)
     GET /health                                       → 探活
 
@@ -75,12 +75,14 @@ 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
         ) -> 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))
+            self._subscribe = bool(subscribe)
             # 启动时 auto-subscribe: build_qmt_market(symbols=...) 传来的就是 akquant run_live
             # instruments — 立即装订到 _subscribed, 不依赖 akquant forwarder (实测发现 forwarder
             # 在 functional mode 下安装时机晚于 strategy.subscribe, 错过首次订阅)
@@ -152,7 +154,19 @@ def _make_market_gateway() -> Any:
                 while True:
                     try:
                         bars = self._fetch_bars(sym)
-                        for bar in bars:
+                        # Round 26 诊断: 区分 warmup bar (历史回填) vs live bar (新生成)
+                        # 避免 warmup 期间 emit 跟 live 期间 emit 混在一起 (debug 时方便定位).
+                        print(f"[qmt-market] warmup {sym}: 拉 {len(bars)} 根 "
+                              f"(period={self._period}, bar_count={self._bar_count})",
+                              flush=True)
+                        for i, bar in enumerate(bars):
+                            if i < 3 or i == len(bars) - 1:
+                                # 只打印头 3 + 末 1 根, 避免刷屏
+                                print(f"[qmt-market] warmup {sym} bar[{i}] "
+                                      f"time={bar.get('time')} "
+                                      f"close={bar.get('close')} "
+                                      f"volume={bar.get('volume')}",
+                                      flush=True)
                             self._emit_bar(bar)
                         if bars:
                             self._last_bar_signatures[sym] = _bar_signature(bars[-1])
@@ -189,21 +203,44 @@ def _make_market_gateway() -> Any:
                     time.sleep(sleep_for)
 
         def _poll_once(self) -> None:
+            """一次 poll 拉 ticks + bars — 各自独立 try/except, 互不阻塞.
+
+            Round 26 Bug 修: 原版 _fetch_ticks 抛异常 → 整个 _poll_once 退出,
+            bar 拉取永远不到; snapshot timeout 一次 → bar 推送永久缺失.
+            改版: ticks / bars 各自 try, 异常只 print + continue, 不中断对方.
+            """
             subs = list(self._subscribed)
             if not subs:
                 return
-            ticks = self._fetch_ticks(subs)
-            for t in ticks:
-                self._emit_tick(t)
+            # ticks: 独立 try — snapshot timeout 不应阻止 bar 拉取
+            try:
+                ticks = self._fetch_ticks(subs)
+                for t in ticks:
+                    self._emit_tick(t)
+            except Exception as e:  # noqa: BLE001
+                print(f"[qmt-market] ticks poll error: {type(e).__name__}: {e}",
+                      flush=True)
+            # bars: 独立 try — 单只 sym 失败不影响其它
             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)
+                try:
+                    bars = self._fetch_bars(sym, count=1)
+                    # Round 29+4 诊断: 看 _fetch_bars 实际返几个 bar + 是不是真的空
+                    if not bars:
+                        print(f"[qmt-market] bars poll {sym}: 0 bars (QMT 数据未到?)",
+                              flush=True)
+                        continue
+                    last = bars[-1]
+                    sig = _bar_signature(last)
+                    prev = self._last_bar_signatures.get(sym)
+                    if prev != sig:
+                        self._last_bar_signatures[sym] = sig
+                        self._emit_bar(last)
+                        print(f"[qmt-market] bar emit {sym} time={last.get('time')} "
+                              f"close={last.get('close')} sig_changed={prev is None}",
+                              flush=True)
+                except Exception as e:  # noqa: BLE001
+                    print(f"[qmt-market] bars poll error {sym}: "
+                          f"{type(e).__name__}: {e}", flush=True)
 
         def _fetch_ticks(self, symbols: list[str]) -> list[dict[str, Any]]:
             """GET /data/snapshot?securities=sym1,sym2 → list of tick dict.
@@ -227,13 +264,19 @@ def _make_market_gateway() -> Any:
             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 (旧→新)."""
+            """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 的问题.
+            """
             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",
-            })
+            params = {"security": qmt_sym, "period": self._period,
+                      "count": str(cnt), "fq": "qfq"}
+            if self._subscribe:
+                params["subscribe"] = "true"
+            resp = self._http.get("/data/history", params)
             value = _unwrap_envelope(resp)
             return _bars_from_history(value, symbol)
 
@@ -284,11 +327,18 @@ def _unwrap_envelope(resp: dict[str, Any]) -> Any:
 
 
 def _bar_signature(bar: dict[str, Any]) -> tuple:
-    """bar OHLCV 摘要 — 推 on_bar 去重用."""
+    """bar 摘要 — 推 on_bar 去重用.
+
+    Round 26 修复: 加 `time` (epoch ms, QMT 全推) 进 tuple. 之前只用
+    OHLCV + datetime (YYYYMMDD 字符串), 当 1m/5m 等高频 bar 在同一
+    'date' 字符串内 + 早盘 OHLCV 不变时 (e.g. 日线 fallback), signature
+    永不变化 → 不 emit. 加 time 字段后即使 OHLCV 不变, 只要 bar 是新的
+    (time 不同), 就能 detect.
+    """
     return (
+        bar.get("time"),  # epoch ms (Round 26 加: 高频 bar 时间戳)
         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"),
     )
 
 
@@ -426,6 +476,10 @@ 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)
+                                            透传方式: --gateway-options
+                                            "market_subscribe=1" (或 True)
     """
     from akquant.gateway.protocols import GatewayBundle
 
@@ -434,19 +488,24 @@ 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")
     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)
+        subscribe=subscribe,
     )
     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},
+                  "period": period, "bar_count": bar_count, "poll_interval": poll,
+                  "subscribe": subscribe},
     )
 
 

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

@@ -39,12 +39,80 @@ def parse_kv_pairs(raw: str | None) -> dict[str, str]:
     return out
 
 
+# Round 19+2 — market_period 自动从策略 params 推断 (CLI 显式 > 策略 params > 默认 1d).
+# IntParam 0=auto/1d / 1=1d / 2=5m / 3=1m. cli 直读 self.params.market_period, 无 ast/无推断策略.
+_MARKET_PERIOD_MAP = {0: "1d", 1: "1d", 2: "5m", 3: "1m"}
+
+
+_CLI_PERIOD_ALIASES = {"1d", "1m", "5m", "1w", "1mon", "tick"}
+
+
+def _resolve_market_period(
+    spec: StrategySpec, gateway_options: dict[str, str],
+    params: dict | None,
+) -> str | None:
+    """决定 driver market_period:
+      1) CLI --gateway-options 显式 market_period → 翻译或透传
+         - 数字字符串 "0"/"1"/"2"/"3" 走 _MARKET_PERIOD_MAP (跟 IntParam 兼容)
+         - period 别名 "1d"/"1m"/"5m"/"1w"/"1mon" 原样透传
+      2) 策略 self.params.market_period (skill 在 .py 生成) → 映射
+      3) params.json strategy_params.market_period → 同上 (运行时覆盖)
+      4) 默认 "1d" (向后兼容)
+
+    返回 None 表示 CLI 已显式 period 别名, 不需要再 inject (兼容旧契约).
+    """
+    if "market_period" in gateway_options:
+        cli_value = str(gateway_options["market_period"]).strip()
+        # 数字字符串 (IntParam 0/1/2/3) → 翻译成 period 别名
+        if cli_value in {"0", "1", "2", "3"}:
+            mapped = _MARKET_PERIOD_MAP[int(cli_value)]
+            print(
+                f"[info] CLI market_period 数字 {cli_value} → {mapped} "
+                f"(_MARKET_PERIOD_MAP 翻译)",
+                flush=True,
+            )
+            return mapped
+        # period 别名 → 原样透传 (注入到 gateway_options 防止下游错读)
+        if cli_value in _CLI_PERIOD_ALIASES:
+            gateway_options["market_period"] = cli_value
+            return None  # CLI 已显式 period 别名, 跳过自动推断
+        # 其它非法值 — 不静默 fallback, 报错给用户
+        raise LiveRunError(
+            f"--gateway-options market_period={cli_value!r} 非法. "
+            f"接受 IntParam 数字 0/1/2/3 或 period 别名 "
+            f"{sorted(_CLI_PERIOD_ALIASES)}"
+        )
+    # 优先级 2: 策略 inline params (无 ast, 实例化读 params)
+    if spec.mode == "class" and spec.strategy_cls is not None:
+        try:
+            inst = spec.strategy_cls()
+            mp = int(getattr(inst.params, "market_period", 1))
+            mapped = _MARKET_PERIOD_MAP.get(mp, "1d")
+            print(
+                f"[info] market_period 自动推断: {mapped} "
+                f"(params.market_period={mp}, 策略 inline 默认)",
+                flush=True,
+            )
+            return mapped
+        except Exception as e:  # noqa: BLE001
+            print(
+                f"[warn] market_period 推断失败 ({type(e).__name__}: {e}), "
+                f"fallback '1d'",
+                flush=True,
+            )
+    return "1d"  # 默认
+
+
 def _fetch_bridge_history(bridge_url: str, sym: str, period: str, count: int,
-                          timeout: float = 30.0) -> list[dict[str, Any]]:
-    """GET /data/history?security=<sym>&period=<p>&count=<n>&fq=None → list of bar dict (旧→新).
+                          timeout: float = 30.0, subscribe: bool = False) -> list[dict[str, Any]]:
+    """GET /data/history?security=<sym>&period=<p>&count=<n>&fq=qfq[&subscribe=T/F] → list of bar dict (旧→新).
 
     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 的问题.
     """
     from urllib.parse import urlencode
     from urllib.request import urlopen, Request
@@ -52,9 +120,10 @@ def _fetch_bridge_history(bridge_url: str, sym: str, period: str, count: int,
     canonical = sym.split(".")[0]
     if canonical.lower().startswith(("sh", "sz")):
         canonical = canonical[2:]
-    q = urlencode({
-        "security": canonical, "period": period, "count": str(count), "fq": "None",
-    })
+    params = {"security": canonical, "period": period, "count": str(count), "fq": "qfq"}
+    if subscribe:
+        params["subscribe"] = "true"
+    q = urlencode(params)
     url = f"{bridge_url.rstrip('/')}/data/history?{q}"
     try:
         with urlopen(Request(url), timeout=timeout) as resp:
@@ -91,11 +160,14 @@ def _fetch_bridge_history(bridge_url: str, sym: str, period: str, count: int,
 
 
 def _fetch_bridge_history_batch(bridge_url: str, symbols: list[str], period: str = "1d",
-                                  count: int = 30, timeout: float = 45.0) -> dict[str, list[dict[str, Any]]]:
+                                  count: int = 30, timeout: float = 45.0,
+                                  subscribe: bool = False) -> dict[str, list[dict[str, Any]]]:
     """GET /data/history?securities=...&multi=true → {sym: [bar dict]} 批量获取.
 
     优先使用 bridge_server 的批量 multi 接口 (一次 HTTP 拉多只), 大幅减少
     逐只 HTTP 开销 (300 只从 ~27s 降到 ~1s). 失败时返回 {} 让调用方回退逐只.
+
+    subscribe 语义同 _fetch_bridge_history (paper=False, broker_live=True).
     """
     from urllib.parse import urlencode
     from urllib.request import urlopen, Request
@@ -107,10 +179,11 @@ def _fetch_bridge_history_batch(bridge_url: str, symbols: list[str], period: str
         if c.lower().startswith(("sh", "sz")):
             c = c[2:]
         qmt_codes.append(c)
-    q = urlencode({
-        "securities": ",".join(qmt_codes),
-        "period": period, "count": str(count), "fq": "None", "multi": "true",
-    })
+    params = {"securities": ",".join(qmt_codes),
+              "period": period, "count": str(count), "fq": "qfq", "multi": "true"}
+    if subscribe:
+        params["subscribe"] = "true"
+    q = urlencode(params)
     url = f"{bridge_url.rstrip('/')}/data/history?{q}"
     try:
         with urlopen(Request(url), timeout=timeout) as resp:
@@ -140,7 +213,8 @@ _BATCH_CHUNK_SIZE = 50
 def _fetch_live_factors(bridge_url: str, universe: list[str], period: str = "1d",
                         count: int = 30, timeout: float = 45.0,
                         chunk_size: int = _BATCH_CHUNK_SIZE,
-                        max_workers: int | None = None) -> dict[str, Any]:
+                        max_workers: int | None = None,
+                        subscribe: bool = False) -> dict[str, Any]:
     """实盘 startup: 拉 N sym × N bar 历史, 拼成 {sym: DataFrame} 喂 compute_factors.
 
     实盘只支持日线 (1d) — QMT 5m/1m/tick 走 market_broker=qmt_market 的实时 tick,
@@ -151,6 +225,9 @@ def _fetch_live_factors(bridge_url: str, universe: list[str], period: str = "1d"
       2. 每片用批量 multi 接口 (一次 HTTP 拉 ≤50 只)
       3. 多片 ThreadPoolExecutor 并发执行 (默认 min(32, 片数))
       4. 单只失败的片回退逐只 (兼容旧 bridge_server)
+
+    subscribe 透传给 _fetch_bridge_history / _fetch_bridge_history_batch —
+    paper=False, broker_live=True (run_live 内 mode→subscribe 映射).
     """
     import pandas as _pd
     from concurrent.futures import ThreadPoolExecutor, as_completed
@@ -173,7 +250,8 @@ def _fetch_live_factors(bridge_url: str, universe: list[str], period: str = "1d"
     def _fetch_chunk(chunk: list[str]) -> dict[str, _pd.DataFrame]:
         """拉一片: 批量优先, 失败逐只. 批量返回的裸码 key 会归一化到标准 symbol."""
         out: dict[str, _pd.DataFrame] = {}
-        batch = _fetch_bridge_history_batch(bridge_url, chunk, period, count, timeout=timeout)
+        batch = _fetch_bridge_history_batch(bridge_url, chunk, period, count,
+                                            timeout=timeout, subscribe=subscribe)
         if batch:
             # 归一化批量返回的 key (裸码 → 标准), 并只保留本片请求的
             wanted = set(chunk)
@@ -186,7 +264,8 @@ def _fetch_live_factors(bridge_url: str, universe: list[str], period: str = "1d"
         else:
             missing = chunk
         for sym in missing:
-            bars = _fetch_bridge_history(bridge_url, sym, period, count, timeout=timeout)
+            bars = _fetch_bridge_history(bridge_url, sym, period, count,
+                                         timeout=timeout, subscribe=subscribe)
             out[sym] = _pd.DataFrame(bars) if bars else                 _pd.DataFrame(columns=["open", "high", "low", "close", "volume", "amount"])
         return out
 
@@ -205,7 +284,8 @@ def _fetch_live_factors(bridge_url: str, universe: list[str], period: str = "1d"
                 chunk = futures[fut]
                 for sym in chunk:
                     try:
-                        bars = _fetch_bridge_history(bridge_url, sym, period, count, timeout=timeout)
+                        bars = _fetch_bridge_history(bridge_url, sym, period, count,
+                                                     timeout=timeout, subscribe=subscribe)
                         factors[sym] = _pd.DataFrame(bars) if bars else                             _pd.DataFrame(columns=["open", "high", "low", "close", "volume", "amount"])
                     except Exception:
                         factors[sym] = _pd.DataFrame(columns=["open", "high", "low", "close", "volume", "amount"])
@@ -354,11 +434,19 @@ def _with_live_history_depth(
         def on_start(self) -> _Any:
             ret_val = super().on_start()
             try:
-                for day in fridays:
+                # Round 25+ 修复: calendar 是 bridge 历史 (count=30 默认, 全过去日期) —
+                # 若不过滤 today, akquant scheduler 启动期会一次性回放所有过去 schedule,
+                # 导致 on_timer FIRED 在启动瞬间触发 (实测 b95upfgju 12:13:55 rebalance),
+                # 错把启动当 14:55 调仓时机. 过滤 day >= today 让 wrapper 只注未来/今日.
+                today_str = _dt.date.today().strftime("%Y-%m-%d")
+                future_fridays = [d for d in fridays if d >= today_str]
+                for day in future_fridays:
                     y, m, d = day.split("-")
                     _schedule(self, _dt.datetime(int(y), int(m), int(d), 14, 55), "rebalance")
                 print(
-                    f"[info] 周五 14:55 重排定时器注入: {len(fridays)} 个 ({fridays})",
+                    f"[info] 周五 14:55 重排定时器注入: {len(future_fridays)} 个 "
+                    f"(过去 {len(fridays) - len(future_fridays)} 个已跳过, "
+                    f"未来 {future_fridays})",
                     flush=True,
                 )
             except Exception as e:  # noqa: BLE001 — 定时器失败不应让 on_start 崩
@@ -561,6 +649,10 @@ def run_live(
     """
     gateway_options = parse_kv_pairs(gateway_options_raw)
     duration = _live_safety_defaults(mode, broker, gateway_options, duration)
+    # Round 19+2 — market_period 自动从策略 params 推断 (CLI 显式覆盖最高优先级).
+    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
@@ -664,6 +756,38 @@ def run_live(
                     "如不需要预计算因子, 走 functional mode 兼容路径."
                 )
 
+            # Round 25+ 修复: 交易日历 (周五 14:55 重排定时器) 必须在 wants_precompute
+            # 分支外独立拉 — 策略层 schedule_daily("15:00", "trigger") 周末也会触发,
+            # 真周五重排需要从 bridge 真实历史抽交易日历 (跳过周末/节假日). 之前逻辑把
+            # _fetch_live_factors 放在 wants_precompute else 分支内, 无 compute_factors
+            # 策略直接跳过 → 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
+
             if not wants_precompute:
                 print(
                     f"[info] class mode 无 compute_factors/filter_symbols — 跳过预计算, "
@@ -675,25 +799,7 @@ def run_live(
                 if hasattr(strat_inst, "compute_factors"):
                     # 实盘 startup: 拉 N sym × N bar 历史, 拼 {sym: DataFrame} 喂 compute_factors
                     # qmt: bridge /data/history; replay: 本地 prebuilt bars (paper trading).
-                    try:
-                        if has_replay_data:
-                            raw_factors = replay_bars_df
-                        else:
-                            raw_factors = _fetch_live_factors(qmt_base_url, symbols)
-                        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"实盘拉历史失败: {type(e).__name__}: {e} "
-                            f"(用户原话: 出错直接报错停止, 不走 mock 兜底)"
-                        ) from e
+                    # raw_factors / rebalance_calendar 已在上面分支统一拉, 此处复用.
                     try:
                         factors = strat_inst.compute_factors(raw_factors) or {}
                     except Exception as e:
@@ -791,45 +897,4 @@ def run_live(
           f"market_broker={market_broker or '<single>'} "
           f"symbols={symbols or '<all>'} duration={duration}", flush=True)
     print(f"[info] gateway_options={gateway_options}", flush=True)
-    _akquant_run_live(**kwargs)
-
-    # ===== Round 18.62 P0-1: replay metrics 产出 =====
-    # live run 跑完后, 拿同一份 bars + strategy_cls 跑一次 mini-backtest 拿 metrics,
-    # 落 runs/{strategy_id}/replay_result.json (跟 cmd_run 同 13-key schema, to_hamuna_result).
-    # 用途: commiter cmd_commit --replay-result 拿此文件 vs 回测 result.json 算 sharpe diff.
-    # 仅 broker=replay 时跑 (其他 broker 真盘无意义, 也没 bars 数据).
-    if broker == "replay" and spec.mode == "class" and spec.strategy_cls is not None:
-        try:
-            from akquant import run_backtest as _akquant_run_backtest  # noqa: F401
-            from ..akquant_schema_adapter import to_hamuna_result
-            from datetime import datetime as _dt
-            # strategy_id 来自 run_live kwargs 顶层 (Round 18.42+ commiter 必传);
-            # 若没有 (裸 live run 调) 退到 /tmp/replay_result.json, 不污染 runs/.
-            strategy_id = kwargs.get("strategy_id") or "adhoc"
-            out_dir = Path("runs") / strategy_id
-            out_dir.mkdir(parents=True, exist_ok=True)
-            out_path = out_dir / "replay_result.json"
-            # 用 replay_bars_df + strategy_cls 跑 mini-backtest. 同一份数据 → 可比.
-            mini_kwargs = dict(kwargs)
-            mini_kwargs.pop("live", None)  # 防混入 live flag
-            # to_hamuna_result 需 akquant BacktestResult 对象; mini-backtest 走同一 strategy_cls
-            # + 同一份 bars, 拿 metrics 对象 → to_hamuna_result 落 13-key schema.
-            bt_result = _akquant_run_backtest(
-                strategy_cls=spec.strategy_cls,
-                bars=replay_bars_df,
-                initial_cash=initial_cash or 100000.0,
-            )
-            cfg = {"period": {"start": str(replay_bars_df['date'].min())[:10] if hasattr(replay_bars_df, 'columns') else "",
-                                "end": str(_dt.now().date())}}
-            result_dict = to_hamuna_result(bt_result, cfg)
-            out_path.write_text(json.dumps(result_dict, indent=2, ensure_ascii=False), encoding="utf-8")
-            m = result_dict.get("metrics", {})
-            print(f"[info] replay metrics: sharpe={m.get('sharpe'):.3f} "
-                  f"total_return={m.get('total_return', 0):.2%} trades={len(result_dict.get('trades', []))} "
-                  f"→ {out_path}", flush=True)
-        except ImportError:
-            # akquant 未装 / to_hamuna_result 不可用 — 跳过, 不阻塞 live run
-            print("[warn] P0-1: akquant / to_hamuna_result 未装, 跳过 replay metrics 产出", flush=True)
-        except Exception as e:
-            # mini-backtest 失败不致命 — live run 已成功, 只 warn
-            print(f"[warn] P0-1: replay metrics 产出失败 ({type(e).__name__}: {e}), 跳过", flush=True)
+    _akquant_run_live(**kwargs)

{hamuna_quant_cli-0.1.11 → hamuna_quant_cli-0.1.12}/hamuna_quant_cli/runtime/server_client.py

@@ -72,25 +72,20 @@ def _api_call(method: str, path: str, body: dict | None = None) -> dict:
     return envelope
 
 
-def upload_backtest_result(strategy_id: str, result: dict, replay_metrics: dict | None = None, version: str | None = None) -> dict:
-    """PUT /api/v1/strategies/{id}/result → 上传 BacktestResult-shape dict + 可选 replay_metrics + version.
+def upload_backtest_result(strategy_id: str, result: dict, version: str | None = None) -> dict:
+    """PUT /api/v1/strategies/{id}/result → 上传 BacktestResult-shape dict + version.
 
     兼容 akquant_runner.run_akquant_backtest() 输出 (13 顶层 key + metrics 子 dict 15 key + ...),
     先做轻清洗: NaN/Inf → None (json 标准不允许), 后传给 server.
 
-    Round 18.62 P0-1: replay_metrics (Sharpe/TotalReturn/WinRate/Trades/DiffPct/RunAt) —
-    跟 result 平级, server handler 二次校验 diff 防绕过. None 时不传该 key (老调用方不破).
     Round 18.62 P1-1: version (X.Y.Z semver) — cli 默认 patch 自动 bump (cmd_commit step 1.4
     拿 server latest_version 算新 version), server handler 二次校验 semver 格式 + 严格递增.
     老调用方 (无 version kwarg) → 不传该 key → server 422 (P1-1 强校验).
+    Round 18.63: replay_metrics / P0-1 gate 移除 (用户决策) — 上传不再需要 replay.
     """
     payload = _sanitize_for_json(result)
-    # P1-1 P0-1.1 ponytail: 无条件 wrap `{"result": ...}` 让 server 解析形状一致
-    # (即使 replay_metrics=None / version=None 也要 wrap, 防止 server handler 422 invalid shape).
-    # 此改动在 P1-1 同步实施, P0-1 Case F 已知问题修复.
+    # 无条件 wrap `{"result": ...}` 让 server 解析形状一致.
     body: dict = {"result": payload}
-    if replay_metrics is not None:
-        body["replay_metrics"] = _sanitize_for_json(replay_metrics)
     if version is not None:
         body["version"] = version
     return _api_call('PUT', f'/api/v1/strategies/{strategy_id}/result', body)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hamuna-quant-cli
-Version: 0.1.11
+Version: 0.1.12
 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.11 → hamuna_quant_cli-0.1.12}/pyproject.toml

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