hamuna-quant-cli 0.1.0.dev93__tar.gz → 0.1.1__tar.gz

{hamuna_quant_cli-0.1.0.dev93 → hamuna_quant_cli-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hamuna-quant-cli
-Version: 0.1.0.dev93
+Version: 0.1.1
 Summary: Hamuna A 股回测 + 实盘统一 CLI (akquant 0.3.x). 替代 v1 自建 driver + QMT-style 策略规范.
 Author-email: Hamuna Team <team@hamuna.example>
 License: MIT
@@ -25,6 +25,8 @@ Requires-Dist: numpy>=1.23
 Requires-Dist: pyarrow>=10
 Requires-Dist: pyyaml>=6
 Requires-Dist: requests>=2.28
+Requires-Dist: boto3>=1.34
+Requires-Dist: cryptography>=41
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
 Requires-Dist: pytest-cov>=4; extra == "dev"

{hamuna_quant_cli-0.1.0.dev93 → hamuna_quant_cli-0.1.1}/hamuna_quant_cli/__init__.py

@@ -14,4 +14,4 @@ from __future__ import annotations
 
 # 版本号由 scripts/bump_version.py 每次 build 自动更新 (基于 git 提交数).
 # 格式: 0.1.0.dev<git提交数> (PEP 440). 手动改这里会被下一次 build 覆盖.
-__version__ = "0.1.0.dev93"
+__version__ = "0.1.1"

{hamuna_quant_cli-0.1.0.dev93 → hamuna_quant_cli-0.1.1}/hamuna_quant_cli/__main__.py

@@ -800,6 +800,9 @@ def cmd_live_run(args) -> int:
         return 3
     try:
         symbols = [s.strip() for s in args.symbols.split(",")] if args.symbols else None
+        params = json.loads(Path(args.params).read_text(encoding="utf-8")) if args.params else None
+        # 只取 strategy_params 段 (schema 顶层: backtest / strategy_params / risk_config / meta)
+        sp = (params or {}).get("strategy_params")
         run_live(
             spec,
             mode=args.mode,
@@ -812,6 +815,7 @@ def cmd_live_run(args) -> int:
             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:
         print(f"[error] live run 失败: {e}", file=sys.stderr)
@@ -950,6 +954,8 @@ def build_parser() -> argparse.ArgumentParser:
                        help="独立行情 broker (e.g. qmt_market)")
     run_p.add_argument("--symbols", default=None,
                        help="标的列表, 逗号分隔")
+    run_p.add_argument("--params", default=None,
+                       help="params.json 路径 (固定 schema, strategy_params 段作策略构造参数)")
     run_p.add_argument("--duration", default="1h",
                        help="运行时长 (akquant 解析)")
     run_p.add_argument("--class-name", default="Strategy",

{hamuna_quant_cli-0.1.0.dev93 → hamuna_quant_cli-0.1.1}/hamuna_quant_cli/akquant_data_adapter.py

@@ -124,7 +124,9 @@ def load_prebuilt_to_akquant(universe: Iterable[str], start: str, end: str,
             f'prebuilt 缺 OHLCV 列 {missing} (R2: schema 不兼容). 实际列: {list(df.columns)[:10]}...')
     for c in _DROP_COLS:
         df = df.drop(columns=[c], errors='ignore')
-    df['date'] = pd.to_datetime(df['date'].astype(str), format='%Y%m%d')
+    # time 字段兼容 8 位 (YYYYMMDD, 个股) / 14 位 (YYYYMMDDHHMMSS, ETF/可转债) / ISO (YYYY-MM-DD)
+    _date_str = df['date'].astype(str).str[:10].str.replace('-', '', regex=False)
+    df['date'] = pd.to_datetime(_date_str, format='%Y%m%d')
     df = df[['date', 'open', 'high', 'low', 'close', 'volume', 'symbol']]
     return df.reset_index(drop=True)
 

{hamuna_quant_cli-0.1.0.dev93 → hamuna_quant_cli-0.1.1}/hamuna_quant_cli/akquant_runner.py

@@ -203,14 +203,24 @@ def run_akquant_backtest(strategy_path: str, cfg: dict) -> dict:
         't_plus_one': bool(cfg.get('t_plus_one', True)),
         'show_progress': False,
     }
-    # universe 注入 (Q1: 多标/横截面策略必需):
-    #   - 0.3.x 新 API: strategy 用 `universe = ListParam(default=[])` 类字段, runner 通过
-    #     `strategy_params={'universe': universe}` 注入 (引擎走 .params.universe).
-    #   - 0.2.x 旧 API: strategy `__init__(self, universe=None)`, runner 通过 kwargs 注入.
-    #     **0.3.x 严格拒收** (raise TypeError), 所以检测到旧风格时只能跳过, 让用户迁移.
-    if _strategy_accepts_universe_param(strat_cls):
-        kwargs['strategy_params'] = {'universe': universe}
-    # 不再 fallback 到 0.2 旧路径 — 见上方注释; 旧 strategy 走 0.3 必须先迁移到 ParamModel.
+    # strategy_params 注入 (0.3.x ParamModel 字段):
+    #   - universe: 多标/横截面策略必需, cfg['universe']/['pool'] 归一化后注入.
+    #   - exclude_symbols: 策略声明 `exclude_symbols = ListParam(default=[])` 时,
+    #     cfg['exclude_symbols'] (裸码 list) 归一化后并列注入. 策略在 on_bar 里
+    #     拿 self.params.exclude_symbols 和 bar.symbol 比对 (两者同带后缀形态).
+    #     只有策略声明该字段才注入 — 未声明注入 = engine strict 模式 unknown key 崩溃.
+    #     ponytail: 回测侧 exclude_symbols 仅来自 cfg; 实盘 QMT「排除已持仓」需策略在
+    #     on_bar 里自己调 broker query_positions() (runner 不透传持仓, 那是动态状态).
+    accepted_fields = _strategy_param_fields(strat_cls)
+    strategy_params: dict[str, Any] = {}
+    if 'universe' in accepted_fields:
+        strategy_params['universe'] = universe
+    if 'exclude_symbols' in accepted_fields:
+        exclude_codes = cfg.get('exclude_symbols') or []
+        strategy_params['exclude_symbols'] = [
+            normalize_symbol(s) for s in exclude_codes]
+    if strategy_params:
+        kwargs['strategy_params'] = strategy_params
 
     # ===== 0.3.x 加速原语 (自动启用, strategy 不用改) =====
     # 1) history_depth — 推断: scan __init__ 默认值 + warmup_period + cfg['history_depth']
@@ -393,34 +403,44 @@ def _akquant_supports_commission_policy() -> bool:
     return _akquant_kwarg_supported('commission_policy')
 
 
-def _strategy_accepts_universe_param(strat_cls: type) -> bool:
-    """检测 strategy 是否声明 `universe` 为 0.3.x 的 ParamModel 字段.
+def _strategy_param_fields(strat_cls: type) -> set[str]:
+    """返回 strategy 声明的 0.3.x ParamModel 字段名集合.
 
-    0.3.x: `universe: list = ListParam(default=[])` 类字段, 通过 strategy_params 注入.
-    0.2.x: `__init__(self, universe=None)` — 0.3.x 严格拒收 (TypeError), 这里返 False 跳过.
+    0.3.x: `universe: list = ListParam(default=[])` 类字段 → model_fields.
+    0.2.x: `__init__(self, universe=None)` — 无 model_fields, 返空集 (runner 跳过注入).
 
-    ponytail: 仅检测 'universe' 字段. 其它字段 (lots/fast/slow 等) 走 ParamModel 自身规则,
-    runner 不替用户策略注入; grid/WFO 子命令会单独处理.
+    空集 = 策略没用 ParamModel (老 __init__ 风格), 不是「豁免」— 0.3.x 严格拒收.
     """
     try:
-        # pydantic-based ParamModel: 实例化后 inst.params.<name> 存在
         with warnings.catch_warnings():
             warnings.simplefilter('ignore')  # 0.3.x 对老 __init__ 形参的 UserWarning
             inst = strat_cls()
         if not hasattr(inst, 'params'):
-            return False
+            return set()
         params_obj = getattr(inst, 'params')
-        # pydantic v2: model_fields 是 dict[str, FieldInfo]
-        fields = getattr(params_obj, 'model_fields', None)
-        if fields and 'universe' in fields:
-            return True
-        # pydantic v1 fallback
-        fields_v1 = getattr(params_obj, '__fields__', None)
-        if fields_v1 and 'universe' in fields_v1:
-            return True
-        return False
+        fields = getattr(params_obj, 'model_fields', None)  # pydantic v2
+        if fields:
+            return set(fields)
+        fields_v1 = getattr(params_obj, '__fields__', None)  # pydantic v1 fallback
+        if fields_v1:
+            return set(fields_v1)
+        return set()
     except Exception:  # noqa: BLE001
-        return False
+        return set()
+
+
+def _strategy_accepts_universe_param(strat_cls: type) -> bool:
+    """检测 strategy 是否声明 `universe` 为 0.3.x 的 ParamModel 字段."""
+    return 'universe' in _strategy_param_fields(strat_cls)
+
+
+def _strategy_accepts_exclude_symbols_param(strat_cls: type) -> bool:
+    """检测 strategy 是否声明 `exclude_symbols` 为 0.3.x 的 ParamModel 字段.
+
+    仅当策略显式声明才注入 — 未声明字段注入会在 strict_strategy_params=True 下
+    被 engine 判 unknown key → TypeError (用户 2026-08-25 实际踩过).
+    """
+    return 'exclude_symbols' in _strategy_param_fields(strat_cls)
 
 
 def _selfcheck() -> None:
@@ -537,6 +557,47 @@ class UsesUniverse(Strategy):
                 'UsesUniverse (ListParam) 应 _strategy_accepts_universe_param=True')
             print(f'OK: universe 注入路径生效 (0.3 ParamModel → strategy_params; 旧 __init__ 风格跳过)')
 
+            # ===== exclude_symbols 注入 (2026-08-25, 用户实战踩坑): =====
+            # 仅当策略声明 `exclude_symbols = ListParam(...)` 才注入; 未声明注入 =
+            # engine strict 模式 unknown key → TypeError. 注入值归一化为带后缀形态.
+            strat4 = Path(tmp) / 'uses_exclude.py'
+            strat4.write_text('''
+from akquant import Strategy, ListParam
+
+class UsesExclude(Strategy):
+    """0.3.x 新 ParamModel 风格: universe + exclude_symbols 双字段."""
+    universe = ListParam(item_type=str, default=[])
+    exclude_symbols = ListParam(item_type=str, default=[])
+    def on_bar(self, bar):
+        pass
+''', encoding='utf-8')
+            captured.clear()
+            _akq.run_backtest = _capture
+            try:
+                cfg_ex = {**cfg, 'exclude_symbols': ['600036']}
+                _ = run_akquant_backtest(strat4, cfg_ex)
+                assert captured.get('strategy_params') == {
+                    'universe': ['600000.SH'],
+                    'exclude_symbols': ['600036.SH'],
+                }, f'UsesExclude 注入错 (应归一化为带后缀): {captured.get("strategy_params")}'
+            finally:
+                _akq.run_backtest = _orig_run
+            # MACross (无 ParamModel) 不应注入 exclude_symbols — strict 模式会崩
+            captured.clear()
+            _akq.run_backtest = _capture
+            try:
+                _ = run_akquant_backtest(strat_path, cfg_ex)   # MACross 走 0.2 __init__ 风格
+                assert 'strategy_params' not in captured, (
+                    f'MACross 不应注入 exclude_symbols: {captured.get("strategy_params")}')
+            finally:
+                _akq.run_backtest = _orig_run
+            _uses_excl = _load_akquant_strategy(strat4)
+            assert _strategy_accepts_exclude_symbols_param(_uses_excl), (
+                'UsesExclude (ListParam) 应 _strategy_accepts_exclude_symbols_param=True')
+            assert not _strategy_accepts_exclude_symbols_param(_macross_cls), (
+                'MACross (无 exclude_symbols 字段) 应 False')
+            print('OK: exclude_symbols 注入 (仅声明注入 + 归一化带后缀 + 未声明跳过)')
+
             # ===== Round 1: history_depth 推断 + 0.3 kwarg 探测 ——
             # 1) history_depth 推断: 用 MACross(fast=3, slow=5, ...), 预期 max(3,5)+10=15
             #    (注意: 这里 fast=3 / slow=5 是 selfcheck 里写死的, 不是 user 默认)

{hamuna_quant_cli-0.1.0.dev93 → hamuna_quant_cli-0.1.1}/hamuna_quant_cli/live/qmt_market.py

@@ -220,9 +220,9 @@ def _make_market_gateway() -> Any:
                     if not isinstance(payload, dict):
                         continue
                     tick = dict(payload)
-                    # QMT sym (e.g. 600000.XSHG) → canonical 6 位 (e.g. 600000)
-                    bare = qmt_sym.split(".")[0] if "." in qmt_sym else qmt_sym
-                    tick.setdefault("symbol", bare)
+                    # QMT sym (e.g. 600000.XSHG) → akquant 标准 (600000.SH) 匹配 instruments
+                    std_sym = _from_qmt_symbol(qmt_sym)
+                    tick.setdefault("symbol", std_sym)
                     ticks.append(tick)
             return ticks
 
@@ -256,6 +256,19 @@ def _to_qmt_symbol(symbol: str) -> str:
     return s.upper()
 
 
+def _from_qmt_symbol(symbol: str) -> str:
+    """QMT 内部 symbol (600000.XSHG / 000001.XSHE / 830001.XBJE) → akquant 标准
+    (600000.SH / 000001.SZ / 830001.BJ). 与 instruments 的 symbol 匹配, 否则
+    on_tick/on_bar 回调因 symbol 不匹配收不到.
+    """
+    s = str(symbol).strip()
+    if "." not in s:
+        return s
+    code, _, ex = s.partition(".")
+    ex_map = {"XSHG": "SH", "XSHE": "SZ", "XBJE": "BJ", "SH": "SH", "SZ": "SZ", "BJ": "BJ"}
+    return f"{code}.{ex_map.get(ex.upper(), ex.upper())}"
+
+
 def _unwrap_envelope(resp: dict[str, Any]) -> Any:
     """bridge_server envelope {ok, value, request_id, ...} → 业务数据 value 字段.
 

{hamuna_quant_cli-0.1.0.dev93 → hamuna_quant_cli-0.1.1}/hamuna_quant_cli/live/runner.py

@@ -75,28 +75,139 @@ def _fetch_bridge_history(bridge_url: str, sym: str, period: str, count: int,
     # envelope {ok, value} 或裸 dict — 兼容两种
     if isinstance(payload, dict) and "value" in payload:
         payload = payload["value"]
+    # QMT bridge 常见 dataframe 形态: {dtype: "dataframe", columns: [...], records: [[...], ...]}
+    # 转成 list[dict] 供上层 DataFrame 消费.
+    if isinstance(payload, dict) and payload.get("dtype") == "dataframe":
+        cols = payload.get("columns") or []
+        recs = payload.get("records") or []
+        payload = [dict(zip(cols, row)) for row in recs]
     if not isinstance(payload, list):
         raise LiveRunError(
-            f"bridge /data/history 响应 shape 异常 ({sym}): 期望 list[bar], 实得 {type(payload).__name__}"
-        ) from e
+            f"bridge /data/history 响应 shape 异常 ({sym}): 期望 list[bar] 或 dataframe dict, "
+            f"实得 {type(payload).__name__}"
+        )
     return payload
 
 
+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]]]:
+    """GET /data/history?securities=...&multi=true → {sym: [bar dict]} 批量获取.
+
+    优先使用 bridge_server 的批量 multi 接口 (一次 HTTP 拉多只), 大幅减少
+    逐只 HTTP 开销 (300 只从 ~27s 降到 ~1s). 失败时返回 {} 让调用方回退逐只.
+    """
+    from urllib.parse import urlencode
+    from urllib.request import urlopen, Request
+    import json as _json
+    # 裸码 (bridge 不识别 .SH/.SZ 后缀)
+    qmt_codes = []
+    for sym in symbols:
+        c = sym.split(".")[0]
+        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",
+    })
+    url = f"{bridge_url.rstrip('/')}/data/history?{q}"
+    try:
+        with urlopen(Request(url), timeout=timeout) as resp:
+            if resp.status != 200:
+                return {}
+            raw = resp.read().decode("utf-8", errors="replace")
+        payload = _json.loads(raw)
+    except Exception:
+        return {}
+    # envelope {ok, value}
+    if isinstance(payload, dict) and "value" in payload:
+        payload = payload["value"]
+    # multi 结构: {dtype: "multi", symbols: {sym: dataframe}}
+    if isinstance(payload, dict) and payload.get("dtype") == "multi":
+        out: dict[str, list[dict[str, Any]]] = {}
+        for sym, df_payload in (payload.get("symbols") or {}).items():
+            cols = df_payload.get("columns") or []
+            recs = df_payload.get("records") or []
+            out[sym] = [dict(zip(cols, row)) for row in recs]
+        return out
+    return {}
+
+
+# 分片并发批量拉取: 每片最多 50 只标的 (避免单次 HTTP 过大 + 并发提速)
+_BATCH_CHUNK_SIZE = 50
+
 def _fetch_live_factors(bridge_url: str, universe: list[str], period: str = "1d",
-                        count: int = 60, timeout: float = 30.0) -> dict[str, Any]:
+                        count: int = 30, timeout: float = 45.0,
+                        chunk_size: int = _BATCH_CHUNK_SIZE,
+                        max_workers: int | None = None) -> dict[str, Any]:
     """实盘 startup: 拉 N sym × N bar 历史, 拼成 {sym: DataFrame} 喂 compute_factors.
 
     实盘只支持日线 (1d) — QMT 5m/1m/tick 走 market_broker=qmt_market 的实时 tick,
     不在 compute_factors 启动期预计算范围.
+
+    策略:
+      1. 大量标的按每片最多 chunk_size (默认 50) 分片
+      2. 每片用批量 multi 接口 (一次 HTTP 拉 ≤50 只)
+      3. 多片 ThreadPoolExecutor 并发执行 (默认 min(32, 片数))
+      4. 单只失败的片回退逐只 (兼容旧 bridge_server)
     """
     import pandas as _pd
-    factors: dict[str, _pd.DataFrame] = {}
-    for sym in universe:
-        bars = _fetch_bridge_history(bridge_url, sym, period, count, timeout=timeout)
-        if not bars:
-            factors[sym] = _pd.DataFrame(columns=["open", "high", "low", "close", "volume", "amount"])
+    from concurrent.futures import ThreadPoolExecutor, as_completed
+
+    if not universe:
+        return {}
+
+    # 分片: 每片最多 chunk_size
+    chunks = [universe[i:i + chunk_size] for i in range(0, len(universe), chunk_size)]
+    if max_workers is None:
+        max_workers = min(32, len(chunks))
+
+    def _norm_sym(sym: str) -> str:
+        """裸码 → 标准 symbol (批量返回可能是 000001 而非 000001.SZ)."""
+        s = str(sym)
+        if "." not in s and len(s) == 6 and s.isdigit():
+            return f"{s}.SH" if s.startswith(("6", "9")) else f"{s}.SZ"
+        return s
+
+    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)
+        if batch:
+            # 归一化批量返回的 key (裸码 → 标准), 并只保留本片请求的
+            wanted = set(chunk)
+            for sym, bars in batch.items():
+                std = _norm_sym(sym)
+                if std in wanted and std not in out:
+                    out[std] = _pd.DataFrame(bars) if bars else                         _pd.DataFrame(columns=["open", "high", "low", "close", "volume", "amount"])
+            # 批量可能漏掉部分 (返回不足), 漏的逐只补
+            missing = [s for s in chunk if s not in out]
         else:
-            factors[sym] = _pd.DataFrame(bars)
+            missing = chunk
+        for sym in missing:
+            bars = _fetch_bridge_history(bridge_url, sym, period, count, timeout=timeout)
+            out[sym] = _pd.DataFrame(bars) if bars else                 _pd.DataFrame(columns=["open", "high", "low", "close", "volume", "amount"])
+        return out
+
+    factors: dict[str, _pd.DataFrame] = {}
+    if len(chunks) == 1:
+        factors.update(_fetch_chunk(chunks[0]))
+        return factors
+
+    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+        futures = {pool.submit(_fetch_chunk, c): c for c in chunks}
+        for fut in as_completed(futures):
+            try:
+                factors.update(fut.result())
+            except Exception as e:
+                # 片内失败: 逐只兜底 (不阻塞整体)
+                chunk = futures[fut]
+                for sym in chunk:
+                    try:
+                        bars = _fetch_bridge_history(bridge_url, sym, period, count, timeout=timeout)
+                        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"])
     return factors
 
 
@@ -168,17 +279,30 @@ def configure_logging(level: str, log_file: Path | None) -> None:
     akquant.configure_logging(LogConfig(**cfg_kwargs))
 
 
-def _with_live_history_depth(cls: type) -> type:
+def _with_live_history_depth(cls: type, params: dict | None = None) -> type:
     """class mode 注入 set_history_depth — live 引擎不像回测 (engine.py:4637) 那样
     自动开 history tracking, 策略 on_bar 里 get_history 直接抛
     "History tracking is not enabled" (2026-08-19 实测). depth 取策略 on_start 设的
     warmup_period, 未设默认 120.
 
+    params: 用户实盘参数 (params.json strategy_params) — 作构造 kwargs 注入.
+    live 端 _build_strategy_instance 是 `cls()` 无参实例化, 不传的话 Strategy.__new__
+    走 `model_cls()` 空模型, 用户配置的参数不生效 (2026-08-25 实测缺口).
+    注入必须盖 `__new__`: Strategy 的参数入口在 __new__ 末尾 `model_cls(**kwargs)`,
+    盖 __init__ 传 kwargs 不回灌给已结束的 __new__ (无参构造时 params 丢失).
+
     ponytail: 只包 class mode; functional mode 用户自己管 get_history (ctx 侧).
     """
     from typing import Any as _Any
 
     class _Wrapped(cls):
+        _user_params: dict = params or {}
+
+        def __new__(cls, *a: _Any, **kw: _Any) -> _Any:
+            merged = dict(cls._user_params)
+            merged.update(kw)
+            return super().__new__(cls, *a, **merged)
+
         def on_start(self) -> _Any:
             ret = super().on_start()
             depth = getattr(self, "warmup_period", None) or 120
@@ -234,6 +358,7 @@ def run_live(
     log_file: Path | None,
     market_broker: str | None,
     replay_days: int = 30,
+    params: dict | None = None,
 ) -> None:
     """翻译 + 转发到 akquant.run_live.
 
@@ -247,9 +372,13 @@ def run_live(
     duration:    字符串 ("30s" / "1h" / "2d"), akquant 自己解析
     gateway_options_raw:  CLI 字符串, parse 成 dict 后透传
     initial_cash: 回传给 run_live (None = akquant 默认)
+    params:      params.json 的 strategy_params (用户实盘配置) — 校验后作构造
+                 kwargs 注入策略. None = 用策略代码内默认值.
     """
     gateway_options = parse_kv_pairs(gateway_options_raw)
     duration = _live_safety_defaults(mode, broker, gateway_options, duration)
+    # replay broker 的 bars 数据 — 供 v2 architecture compute_factors 复用
+    replay_bars_df = None
 
     # replay broker 必须配 trading_mode="paper" — 提前给出清晰错误, 而不是让 akquant 在深处抛
     if broker == "replay" and mode == "broker_live":
@@ -262,6 +391,7 @@ def run_live(
     # 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(
@@ -323,7 +453,10 @@ 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")
-        if 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:
             try:
                 strat_inst = spec.strategy_cls()
             except Exception as e:
@@ -354,8 +487,12 @@ 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).
                     try:
-                        raw_factors = _fetch_live_factors(qmt_base_url, symbols)
+                        if has_replay_data:
+                            raw_factors = replay_bars_df
+                        else:
+                            raw_factors = _fetch_live_factors(qmt_base_url, symbols)
                     except LiveRunError:
                         raise
                     except Exception as e:
@@ -406,7 +543,7 @@ def run_live(
                 instruments = _build_instruments(filtered)
         else:
             print(
-                "[info] class mode 但无 qmt_base_url (gateway_options); 跳过 compute_factors / filter_symbols",
+                "[info] class mode 无 qmt_base_url / replay bars; 跳过 compute_factors / filter_symbols",
                 flush=True,
             )
     elif spec.mode == "functional":
@@ -434,7 +571,19 @@ def run_live(
 
     # class mode vs functional mode — run_live 入参不同
     if spec.mode == "class":
-        kwargs["strategy_cls"] = _with_live_history_depth(spec.strategy_cls)
+        # params.json 用户配置 → 校验 (未知字段/越界抛 LiveRunError) + 注入构造 kwargs.
+        # live 端 _build_strategy_instance 是 `cls()` 无参实例化, 必须在包装类里把
+        # params 传进 __new__ → ParamModel(**kwargs) 才生效 (2026-08-25 实测缺口).
+        sp = None
+        if params:
+            try:
+                from akquant import validate_strategy_params
+                sp = validate_strategy_params(spec.strategy_cls, params)
+            except Exception as e:
+                raise LiveRunError(
+                    f"params.json 校验失败 (strategy_params 与 IntParam/ListParam 字段不符): {e}"
+                ) from e
+        kwargs["strategy_cls"] = _with_live_history_depth(spec.strategy_cls, sp)
     else:
         cbs = spec.callbacks or {}
         kwargs["strategy_cls"] = cbs["on_bar"]

{hamuna_quant_cli-0.1.0.dev93 → hamuna_quant_cli-0.1.1}/hamuna_quant_cli/runtime/discipline.py

@@ -283,6 +283,175 @@ def _rule_universe_param_style(tree: ast.Module) -> list[DisciplineError]:
                         break
     return errs
 
+# ---- Rule 9: 指标规范 — 已有指标用 akquant.talib, 自定义指标向量化 -----
+# 常见手写指标模式 (有 akquant.talib 内置替代):
+#   closes[-n:].mean() / pd.rolling(n).mean()  → talib.SMA
+#   closes[-n:].std() / pd.rolling(n).std()     → talib.STDDEV
+#   np.mean(closes[-n:]) / np.std(closes[-n:])  → talib.SMA/STDDEV
+_HANDROLLED_INDICATOR_PATTERNS = [
+    # (匹配 AST 特征, 提示信息)
+    ("rolling", "手写 rolling().mean()/std() 指标 - 用 akquant.talib.SMA/STDDEV"),
+    ("mean_slice", "手写 closes[-n:].mean() - 用 akquant.talib.SMA"),
+    ("std_slice", "手写 closes[-n:].std() - 用 akquant.talib.STDDEV"),
+]
+
+
+def _rule_indicator_uses_builtin(tree: ast.Module) -> list[DisciplineError]:
+    """指标规范: 已有指标必须用 akquant.talib, 禁止手写; 自定义指标必须向量化.
+
+    拦:
+      1. `.rolling(...)` 手写滚动指标 (有 talib 替代)
+      2. `closes[-n:].mean()` / `.std()` 手写切片统计 (有 talib 替代)
+      3. `for i in range(len(...))` 逐根 Python 循环算指标
+
+    不拦: 自定义指标用向量化 rolling/cumsum/shift 且无 talib 替代 (正常).
+    """
+    errs: list[DisciplineError] = []
+    for node in ast.walk(tree):
+        # 1) .rolling( 调用 (手写滚动指标)
+        if isinstance(node, ast.Call):
+            func = node.func
+            if isinstance(func, ast.Attribute) and func.attr == "rolling":
+                errs.append(DisciplineError(
+                    rule="indicator_not_using_builtin",
+                    line=node.lineno,
+                    msg="手写 .rolling() 滚动指标 - akquant.talib 有内置 (SMA/STDDEV/BBANDS 等), "
+                        "用 `talib.SMA(closes, n, as_series=True)` 替代 (Rust 加速, 见 references/indicators.md)",
+                ))
+            # 2) mean/std 切片 (closes[-n:].mean())
+            if isinstance(func, ast.Attribute) and func.attr in ("mean", "std"):
+                # 调用者是 Subscript (closes[-n:]) → 手写切片统计
+                if isinstance(node.func.value, ast.Subscript):
+                    errs.append(DisciplineError(
+                        rule="indicator_not_using_builtin",
+                        line=node.lineno,
+                        msg=f"手写切片 .{func.attr}() - 用 akquant.talib."
+                            f"{'SMA' if func.attr == 'mean' else 'STDDEV'}(closes, n, as_series=True) 替代",
+                    ))
+        # 3) 逐根 Python 循环算指标 (for i in range(len(closes)))
+        if isinstance(node, ast.For):
+            # 循环变量是 range(len(...)) → 疑似逐根算
+            iter_node = node.iter
+            if (isinstance(iter_node, ast.Call)
+                    and isinstance(iter_node.func, ast.Name)
+                    and iter_node.func.id == "range"):
+                # 粗略: range(len( 出现即提示 (可能是合法循环, 但指标计算场景多为逐根)
+                # 仅在循环体内有下标访问 closes[i] 时更可能是指标
+                has_subscript = any(
+                    isinstance(c, ast.Subscript) and isinstance(c.value, ast.Name)
+                    for c in ast.walk(node)
+                )
+                if has_subscript:
+                    errs.append(DisciplineError(
+                        rule="indicator_not_using_builtin",
+                        line=node.lineno,
+                        msg="逐根 Python 循环算指标 (for i in range(len(closes))) - 必须向量化 "
+                            "(rolling/cumsum/shift) + akquant.talib 原语组合, 见 references/indicators.md",
+                    ))
+    return errs
+
+
+# ---- Rule 10 (2026-08-25 用户实战踩坑 + 实测): get_history 返回值必须做 NaN 完整性检查 ----
+def _rule_get_history_nan_guard(tree: ast.Module) -> list[DisciplineError]:
+    """akquant 0.3.x `get_history(N, sym, field)` 返回**固定长度 N** 的 ndarray, 历史不足时
+    用 **NaN 填充** (实测: warmup_period=3 + get_history(20) → len=20 但前 17 个是 NaN).
+    因此 `len(closes) < N: return` guard **无效** (len 恒等于 N) — 必须检查 NaN 才算数.
+
+    拦: on_bar / on_timer / on_cross_section 体内, get_history 结果被当有效数据用
+        (调 .mean() / .std() / 下标切片 / 进排序), 但同一作用域内**没有**对该变量的
+        NaN 完整性检查 (`np.isnan(...)` / `.isna()` / `np.isfinite(...)` / `!= arr`).
+
+    不拦: 结果被 NaN 检查保护过 / 只赋不读 / 单字段直接透传 (e.g. bar 字段直用).
+
+    ponytail: AST 启发式, 检测同一函数体内是否存在对目标变量的 nan 检查调用.
+    误报极低 — 正常策略对 get_history 结果做计算前必有 warmup guard 或 NaN 检查.
+    """
+    errs: list[DisciplineError] = []
+    target_funcs = {"on_bar", "on_timer", "on_cross_section"}
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        if node.name not in target_funcs:
+            continue
+        # 收集 get_history 赋值: var -> 是否被 NaN 检查保护
+        assigned: dict[str, list[ast.Assign | ast.AnnAssign]] = {}
+        for child in ast.walk(node):
+            if not isinstance(child, (ast.Assign, ast.AnnAssign)):
+                continue
+            target = child.targets[0] if isinstance(child, ast.Assign) else child.target
+            if not isinstance(target, ast.Name):
+                continue
+            val = child.value
+            if not isinstance(val, ast.Call):
+                continue
+            func = val.func
+            if not (isinstance(func, ast.Attribute) and isinstance(func.value, ast.Name)
+                    and func.value.id == "self" and func.attr == "get_history"):
+                continue
+            assigned.setdefault(target.id, []).append(child)
+        if not assigned:
+            continue
+        # 收集函数体内对每个 var 的 NaN 检查
+        protected: set[str] = set()
+        for child in ast.walk(node):
+            if isinstance(child, ast.Call):
+                func = child.func
+                # np.isnan(x) / x.isna() / np.isfinite(x) / x != x
+                if isinstance(func, ast.Attribute) and func.attr in ("isna", "isnan", "isfinite"):
+                    for a in child.args:
+                        if isinstance(a, ast.Name) and a.id in assigned:
+                            protected.add(a.id)
+                if isinstance(func, ast.Name) and func.id in ("isnan", "isfinite"):
+                    for a in child.args:
+                        if isinstance(a, ast.Name) and a.id in assigned:
+                            protected.add(a.id)
+                # x != x (NaN 自比较惯用法)
+                for c in ast.walk(child):
+                    if isinstance(c, ast.Compare) and isinstance(c.ops[0], ast.NotEq):
+                        for comp in c.comparators:
+                            if isinstance(comp, ast.Name) and comp.id in assigned:
+                                protected.add(comp.id)
+        # 检测 get_history 结果被当有效数据用但未保护
+        for var_name, assigns in assigned.items():
+            if var_name in protected:
+                continue
+            # 找这个 var 被消费的地方: .mean() / .std() / [slice] / np.mean(x) / sorted(x)
+            consumed = False
+            for c in ast.walk(node):
+                if isinstance(c, ast.Call):
+                    cf = c.func
+                    # 形态 A: closes.mean() / closes.std()  (attr 调自身)
+                    if isinstance(cf, ast.Attribute) and isinstance(cf.value, ast.Name):
+                        if cf.value.id == var_name and cf.attr in ("mean", "std", "min", "max", "sum", "iloc", "tolist"):
+                            consumed = True
+                            break
+                    # 形态 B: np.mean(closes) / sorted(closes)  (var 作参数)
+                    if any(isinstance(a, ast.Name) and a.id == var_name for a in c.args):
+                        # 排除把 var 传给 isna/isfinite 类检查 (那是保护, 不是消费)
+                        fn_name = ""
+                        if isinstance(cf, ast.Name):
+                            fn_name = cf.id
+                        elif isinstance(cf, ast.Attribute):
+                            fn_name = cf.attr
+                        if fn_name not in ("isna", "isnan", "isfinite", "all", "any", "len"):
+                            consumed = True
+                            break
+                if isinstance(c, ast.Subscript) and isinstance(c.value, ast.Name) and c.value.id == var_name:
+                    consumed = True
+                    break
+            if consumed:
+                errs.append(DisciplineError(
+                    rule="get_history_nan_guard",
+                    line=assigns[0].lineno,
+                    msg=(f"{node.name} 内 `{var_name} = self.get_history(...)` 结果被当有效数据用 "
+                         f"(mean/std/切片/排序), 但无 NaN 完整性检查. akquant 0.3.x get_history "
+                         f"返固定长度 N, 历史不足时 NaN 填充 (len<N guard 无效!) — "
+                         f"先 `if np.isnan({var_name}).any(): return` 或 `valid = "
+                         f"{var_name}[~np.isnan({var_name})]`"),
+                ))
+    return errs
+
+
 # ---- 聚合入口 ------
 def check_discipline(source: str, config: dict) -> list[DisciplineError]:
     """返 0~N 条 DisciplineError; 空 list = 通过. cmd_run 在 backtest.run 之前调."""
@@ -304,6 +473,8 @@ def check_discipline(source: str, config: dict) -> list[DisciplineError]:
     errs += _rule_bar_field_uses_timestamp(tree)
     errs += _rule_get_history_batched(tree)
     errs += _rule_universe_param_style(tree)
+    errs += _rule_indicator_uses_builtin(tree)
+    errs += _rule_get_history_nan_guard(tree)
     return errs
 
 
@@ -354,6 +525,36 @@ class MyStrat(Strategy):
     assert any(e.rule == 'bar_field_alias_trap' for e in errs), f'应拦 bar.time: {errs}'
     print(f'OK: bar.time 陷阱拦住')
 
+    # Rule 10: get_history 返回值无 NaN 检查被当有效数据用 → 拦
+    bad_nan = '''
+from akquant import Strategy
+import numpy as np
+class MyStrat(Strategy):
+    warmup_period = 21
+    def on_bar(self, bar):
+        closes = self.get_history(20, bar.symbol, 'close')
+        fast_ma = np.mean(closes)   # NaN 填充时静默 NaN
+'''
+    errs = check_discipline(bad_nan, {})
+    assert any(e.rule == 'get_history_nan_guard' for e in errs), f'应拦 NaN guard: {errs}'
+    print(f'OK: get_history NaN guard 拦 (结果被 mean 用但无检查)')
+
+    # 有 NaN 检查 → 放行
+    good_nan = '''
+from akquant import Strategy
+import numpy as np
+class MyStrat(Strategy):
+    warmup_period = 21
+    def on_bar(self, bar):
+        closes = self.get_history(20, bar.symbol, 'close')
+        if np.isnan(closes).any():
+            return
+        fast_ma = np.mean(closes)
+'''
+    errs = check_discipline(good_nan, {})
+    assert not any(e.rule == 'get_history_nan_guard' for e in errs), f'有 NaN 检查应放行: {errs}'
+    print(f'OK: NaN guard 放行 (有 np.isnan 检查)')
+
 
 if __name__ == '__main__':
     _selfcheck()

hamuna_quant_cli-0.1.1/hamuna_quant_cli/scripts/server.json

@@ -0,0 +1,4 @@
+{
+  "api_base": "https://sapi.ai.z-compute.cn",
+  "_comment": "部署配置层 — 后端 API 端点。环境变量 HAMUNA_SERVER 可覆盖。"
+}

{hamuna_quant_cli-0.1.0.dev93 → hamuna_quant_cli-0.1.1}/hamuna_quant_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hamuna-quant-cli
-Version: 0.1.0.dev93
+Version: 0.1.1
 Summary: Hamuna A 股回测 + 实盘统一 CLI (akquant 0.3.x). 替代 v1 自建 driver + QMT-style 策略规范.
 Author-email: Hamuna Team <team@hamuna.example>
 License: MIT
@@ -25,6 +25,8 @@ Requires-Dist: numpy>=1.23
 Requires-Dist: pyarrow>=10
 Requires-Dist: pyyaml>=6
 Requires-Dist: requests>=2.28
+Requires-Dist: boto3>=1.34
+Requires-Dist: cryptography>=41
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
 Requires-Dist: pytest-cov>=4; extra == "dev"

{hamuna_quant_cli-0.1.0.dev93 → hamuna_quant_cli-0.1.1}/hamuna_quant_cli.egg-info/requires.txt

@@ -4,6 +4,8 @@ numpy>=1.23
 pyarrow>=10
 pyyaml>=6
 requests>=2.28
+boto3>=1.34
+cryptography>=41
 
 [backtest-extra]
 matplotlib>=3.7

{hamuna_quant_cli-0.1.0.dev93 → hamuna_quant_cli-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hamuna-quant-cli"
-version = "0.1.0.dev93"
+version = "0.1.1"
 description = "Hamuna A 股回测 + 实盘统一 CLI (akquant 0.3.x). 替代 v1 自建 driver + QMT-style 策略规范."
 readme = "hamuna_quant_cli/README.md"
 requires-python = ">=3.10"
@@ -32,6 +32,8 @@ dependencies = [
     "pyarrow>=10",
     "pyyaml>=6",
     "requests>=2.28",
+    "boto3>=1.34",
+    "cryptography>=41",
 ]
 
 [project.optional-dependencies]

hamuna_quant_cli-0.1.0.dev93/hamuna_quant_cli/scripts/server.json

@@ -1,4 +0,0 @@
-{
-  "api_base": "http://localhost:8080",
-  "_comment": "部署配置层 — Round 14 注入方式: pip install hamuna-quant-cli 后, http_client.py 自动按优先级 1) HAMUNA_SERVER env 2) HAMUNA_SERVER_JSON env 3) ./scripts/server.json 4) <包根>/scripts/server.json (本文件) 5) ./server.json 6) 默认 localhost:8080 解析. 部署方只需改这一个文件 + 重装包即可切 server."
-}