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

hamuna_quant_cli/runtime/discipline.py

@@ -0,0 +1,560 @@
+"""strategy_cli.discipline (v2) — akquant API 静态审查.
+
+v1 discipline.py 检查 QMT-style (passorder / handlebar / m_strRemark / quickTrade / is_last_bar / init+ContextInfo 形参).
+v2 改检查 akquant 0.3.x 风格, 共 8 条 rule:
+  - 必继承 akquant.Strategy 或 (Strategy) 或 (HamunaStrategy) — HamunaStrategy 是 v2 推荐基类
+    (自身继承 akquant.Strategy, 默认 no-op compute_factors/filter_symbols, 见 base_strategy.py)
+  - 文件编码 # coding: utf-8 (v1 走 QMT 的 GBK, v2 走 UTF-8)
+  - 无 QMT globals (passorder / set_basket / get_basket / m_strRemark / quickTrade /
+    is_last_bar / subscribe_quote / run_time / after_init / XtQuantTrader / xttrader / xtdata / ContextInfo)
+  - 不混 def handlebar(...) (QMT 形态) — v2 走 akquant def on_bar(self, bar: Bar)
+  - 不混 def init(ContextInfo) (QMT 形态) — v2 走 akquant def __init__(self)
+  - bar.<field> 不取 bar.time / bar.date (akquant 0.3.x REPR ALIAS, getattr 返 None;
+    真实字段是 bar.timestamp, int ns) — 实战踩过的 bug
+  - Round 1 (0.3.x 加速原语): 同 (count, sym) 多次 get_history 不同字段应合并 get_history_multi
+  - Round 1 (0.3.x 强制): __init__ 形参含 universe 走老注入风格应改 ListParam 内联字段
+
+调用方: __main__.py cmd_run 在 backtest.run 之前 source = strategy.py.read_text()
+        然后 check_discipline(source, cfg) → 若 list 非空, abort 退出码 3.
+"""
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+
+
+@dataclass
+class DisciplineError:
+    rule: str            # 短代码 (e.g. "bar_field_alias_trap")
+    line: int            # 触发处行号 (1-indexed)
+    msg: str             # 人读错误信息
+
+    def __str__(self) -> str:
+        return f'ERROR: rule={self.rule} line={self.line} {self.msg}'
+
+
+# QMT 残留标识符 (出现即报 — v2 走 akquant, 任何 QMT-specific 调用都该走 v1)
+_QMT_GLOBALS: dict[str, str] = {
+    'passorder':              'QMT 报单函数 (akquant 用 self.buy / self.sell)',
+    'set_basket':             'QMT 组合函数 (akquant 用 self 内部状态)',
+    'get_basket':             'QMT 组合函数 (akquant 用 self.get_position)',
+    'm_strRemark':            'QMT 订单字段 (akquant 不支持, 改 remark=...)',
+    'quickTrade':             'QMT subscribe_quote 参数 (akquant on_bar 自动)',
+    'is_last_bar':            'QMT handlebar gate (akquant daily 全是 last-bar)',
+    'subscribe_quote':        'QMT tick 订阅 (akquant 0.3.x on_bar 一次性)',
+    'run_time':               'QMT 定时器 (akquant enable_timer 但 API 不同)',
+    'after_init':             'QMT 初始化回调 (akquant 用 on_start / __init__ 子类)',
+    'XtQuantTrader':          'QMT native API class (v2 不引入)',
+    'XtQuantTraderCallback':  'QMT native API callback',
+    'xttrader':               'QMT native API module',
+    'xtdata':                 'QMT native API module',
+    'ContextInfo':            'QMT 编辑器形参 (akquant 用 self + bar)',
+}
+
+
+# ---- Rule 1: 文件编码 UTF-8 ------
+def _rule_coding_utf8(source: str) -> list[DisciplineError]:
+    """检测文件顶部是否有 # coding: gbk / cp936 — v2 走 akquant, UTF-8 是契约."""
+    errs: list[DisciplineError] = []
+    for i, line in enumerate(source.splitlines()[:3], 1):
+        stripped = line.strip().lower()
+        if not (stripped.startswith('# -*- coding:') or stripped.startswith('# coding:')):
+            continue
+        if stripped.startswith('# -*- coding:'):
+            enc = stripped.split(':', 1)[1].strip().rstrip(' -*-').strip()
+        else:
+            enc = stripped.split(':', 1)[1].strip()
+        if enc not in ('utf-8', 'utf8'):
+            errs.append(DisciplineError(
+                rule='coding_not_utf8',
+                line=i,
+                msg=f'文件编码 = {enc!r}; v2 走 akquant, UTF-8 是契约 (QMT 旧 GBK 策略需先转码)',
+            ))
+        return errs
+    return errs
+
+
+# ---- Rule 2: 必继承 akquant.Strategy / HamunaStrategy ------
+def _rule_akquant_strategy_subclass(tree: ast.Module) -> list[DisciplineError]:
+    """必须有一个 class Foo(akquant.Strategy) / class Foo(Strategy) /
+    class Foo(HamunaStrategy) (后者从 strategy_cli.references.base_strategy 导入,
+    HamunaStrategy 自身继承 akquant.Strategy, v2 skill 推荐基类)."""
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ClassDef):
+            continue
+        for base in node.bases:
+            bname = None
+            if isinstance(base, ast.Attribute):
+                bname = base.attr
+            elif isinstance(base, ast.Name):
+                bname = base.id
+            if bname in ('Strategy', 'HamunaStrategy'):
+                return []
+    return [DisciplineError(
+        rule='missing_akquant_strategy_subclass',
+        line=1,
+        msg='未找到 `class Xxx(akquant.Strategy)` / `class Xxx(Strategy)` / '
+            '`class Xxx(HamunaStrategy)` 子类; v2 策略必须继承 akquant.Strategy 或 HamunaStrategy',
+    )]
+
+
+# ---- Rule 3: 无 QMT globals ------
+def _rule_no_qmt_globals(tree: ast.Module) -> list[DisciplineError]:
+    """扫描所有 Name / Attribute / Import, 命中 QMT 标识符即报."""
+    errs: list[DisciplineError] = []
+    seen: set[str] = set()  # 防同一标识符多行刷屏
+
+    def _check(ident: str, line: int) -> None:
+        if ident in _QMT_GLOBALS and ident not in seen:
+            seen.add(ident)
+            errs.append(DisciplineError(
+                rule='qmt_global_leaked',
+                line=line,
+                msg=f'QMT 标识符 {ident!r}: {_QMT_GLOBALS[ident]}',
+            ))
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Name):
+            _check(node.id, node.lineno)
+        elif isinstance(node, ast.Attribute):
+            _check(node.attr, node.lineno)
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                _check(alias.name.split('.')[0], node.lineno)
+        elif isinstance(node, ast.ImportFrom):
+            if node.module:
+                _check(node.module.split('.')[0], node.lineno)
+            for alias in node.names:
+                _check(alias.name, node.lineno)
+    return errs
+
+
+# ---- Rule 4: 不混 def handlebar(...) (QMT 形态) ------
+def _rule_no_handlebar(tree: ast.Module) -> list[DisciplineError]:
+    """v2 走 akquant on_bar(bar); def handlebar(...) 是 QMT 形态, 报错."""
+    errs: list[DisciplineError] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.FunctionDef):
+            continue
+        if node.name == 'handlebar':
+            errs.append(DisciplineError(
+                rule='handlebar_not_akquant',
+                line=node.lineno,
+                msg='def handlebar(...) 是 QMT 形态; v2 走 akquant, 用 def on_bar(self, bar: Bar): ...',
+            ))
+    return errs
+
+
+# ---- Rule 5: 不混 def init(ContextInfo) ------
+def _rule_no_init_contextinfo(tree: ast.Module) -> list[DisciplineError]:
+    """QMT 形态 init(ContextInfo) vs akquant 形态 __init__(self) — 不混用."""
+    errs: list[DisciplineError] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.FunctionDef):
+            continue
+        if node.name != 'init':
+            continue
+        if not node.args.args:
+            continue
+        first = node.args.args[0].arg
+        if first == 'ContextInfo':
+            errs.append(DisciplineError(
+                rule='init_contextinfo_form',
+                line=node.lineno,
+                msg='def init(ContextInfo) 是 QMT 形态; v2 走 akquant, '
+                    '用 __init__(self) + self.subscribe + warmup_period',
+            ))
+    return errs
+
+
+# ---- Rule 6: bar.time / bar.date 是 akquant 0.3.x REPR ALIAS (实战踩过) ------
+def _rule_bar_field_uses_timestamp(tree: ast.Module) -> list[DisciplineError]:
+    """akquant 0.3.x Bar 字段名陷阱: bar.time / bar.date 是 REPR ALIAS, getattr 返 None.
+    检 on_bar 体内 bar.<field> 访问, 不允许 bar.time / bar.date 取日期.
+    真实字段是 bar.timestamp (int ns), 自定义 date 字段若存在也被拦 — 避免混用.
+    """
+    errs: list[DisciplineError] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        if node.name != 'on_bar':
+            continue
+        for child in ast.walk(node):
+            if not isinstance(child, ast.Attribute):
+                continue
+            if not isinstance(child.value, ast.Name):
+                continue
+            if child.value.id == 'bar' and child.attr in ('time', 'date'):
+                errs.append(DisciplineError(
+                    rule='bar_field_alias_trap',
+                    line=child.lineno,
+                    msg=f'bar.{child.attr} 是 akquant 0.3.x REPR ALIAS, getattr 返 None — '
+                        f'用 bar.timestamp (int ns) 转 datetime.fromtimestamp(ts/1e9).date()',
+                ))
+    return errs
+
+
+
+
+# ---- Rule 7 (Round 1): 0.3.x 起 get_history 多次应改 get_history_multi -----
+def _rule_get_history_batched(tree: ast.Module) -> list[DisciplineError]:
+    """akquant 0.3.x 提供 `self.get_history_multi(count, sym, fields=...)`, 一次 FFI 拉多字段.
+
+    检 on_bar / on_timer 体内 self.get_history(...) 调用, 同一 (sym, count) 出现 >= 2 个
+    不同 field → 报建议合并为 get_history_multi. 单字段 / 多 sym 是正常的, 不报.
+
+    ponytail: 启发式, 只看字面 call, 不追变量 (e.g. sym = bar.symbol; c1 = self.get_history(n, sym, "close")
+    + c2 = self.get_history(n, sym, "volume") -> 报). 实测 false-positive 极低 (罕有人写多 sym 但同 (n,sym,field)).
+    """
+    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
+        # 收集 (count, sym) -> {field}
+        calls: dict[tuple, set] = {}
+        for child in ast.walk(node):
+            if not isinstance(child, ast.Call):
+                continue
+            func = child.func
+            if not (isinstance(func, ast.Attribute) and isinstance(func.value, ast.Name)):
+                continue
+            if func.value.id != "self" or func.attr != "get_history":
+                continue
+            args = child.args
+            if len(args) < 3:
+                continue
+            count_key = ast.dump(args[0])
+            sym_key = ast.dump(args[1])
+            field_key = ast.dump(args[2])
+            k = (count_key, sym_key)
+            calls.setdefault(k, set()).add(field_key)
+        for (_ck, _sk), fields in calls.items():
+            if len(fields) >= 2:
+                errs.append(DisciplineError(
+                    rule="get_history_not_batched",
+                    line=node.lineno,
+                    msg=(f"{node.name} 体内同一 (count, sym) 多次 self.get_history(... field=...) "
+                          f"(字段数 {len(fields)}); akquant 0.3.x 提供 self.get_history_multi(count, sym, "
+                          f"fields=('close', 'volume', ...)) 一次 FFI 拉多字段 - 跨 sym N 调用时省 "
+                          f"50~80% FFI 跨越"),
+                ))
+    return errs
+
+
+# ---- Rule 8 (Round 1): 0.3.x 起 universe 必须走 ParamModel 风格 -----
+def _rule_universe_param_style(tree: ast.Module) -> list[DisciplineError]:
+    """akquant 0.3.x 弃用 `__init__(self, universe=None)` 注入风格, 必须用:
+
+        class S(Strategy):
+            universe: list = ListParam(default=[])
+
+    检策略类的 __init__ 是否收 `universe` 形参; 若收 -> 报迁移提示 (0.3 strict 拒收).
+
+    ponytail: 仅警告 (severity=warn), 不强制 abort - 因为 0.3 也允许 0.2 老写法
+    (engine 调 __init__ 时 TypeError + warning 不会 fail backtest); 但 runner 检测
+    不到 universe 字段, 不会注入 -> 静默 0 trades. 显式报让用户立即感知.
+    """
+    errs: list[DisciplineError] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ClassDef):
+            continue
+        is_strat = False
+        for base in node.bases:
+            base_str = ast.unparse(base) if hasattr(ast, "unparse") else ""
+            if "Strategy" in base_str:
+                is_strat = True
+                break
+        if not is_strat:
+            continue
+        for child in node.body:
+            if isinstance(child, ast.FunctionDef) and child.name == "__init__":
+                for arg in child.args.args:
+                    if arg.arg == "universe":
+                        errs.append(DisciplineError(
+                            rule="universe_init_style_deprecated",
+                            line=child.lineno,
+                            msg=(f"{node.name}.__init__ 形参含 `universe` - akquant 0.3.x 严格拒收 "
+                                 f"老风格 (TypeError); 改 `universe: list = ListParam(default=[])` "
+                                 f"类字段, 读 `self.params.universe`, runner 自动注入"),
+                        ))
+                        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 之前调."""
+    try:
+        tree = ast.parse(source)
+    except SyntaxError as e:
+        return [DisciplineError(
+            rule='syntax_error',
+            line=e.lineno or 1,
+            msg=f'parse failed: {e.msg}',
+        )]
+
+    errs: list[DisciplineError] = []
+    errs += _rule_coding_utf8(source)
+    errs += _rule_akquant_strategy_subclass(tree)
+    errs += _rule_no_qmt_globals(tree)
+    errs += _rule_no_handlebar(tree)
+    errs += _rule_no_init_contextinfo(tree)
+    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
+
+
+def _selfcheck() -> None:
+    """v2 discipline._selfcheck: 跑一份合规 + 一份违规, 4 个 buy-and-hold 策略.
+
+    合规: class BuyHold(Strategy): on_bar(self, bar): self.buy(bar.symbol, 100)
+    违规: def handlebar(bar): passorder(...)  → 报 qmt_global_leaked + handlebar_not_akquant
+    """
+    good = '''
+from akquant import Strategy
+
+class BuyHold(Strategy):
+    warmup_period = 1
+    def on_bar(self, bar):
+        if self.get_position(bar.symbol) == 0:
+            self.buy(bar.symbol, 100)
+'''
+    errs = check_discipline(good, {})
+    assert not errs, f'合规策略不应被拦: {errs}'
+    print(f'OK: 合规策略 0 违规')
+
+    bad = '''# coding: gbk
+def init(ContextInfo):
+    pass
+
+def handlebar(ContextInfo):
+    passorder(23, 1101, '600000.SH', 0, 0, 100, 0, '', 'remark')
+    quickTrade = 2
+'''
+    errs = check_discipline(bad, {})
+    rules = {e.rule for e in errs}
+    assert 'coding_not_utf8' in rules, f'应拦 GBK: {errs}'
+    assert 'qmt_global_leaked' in rules, f'应拦 QMT globals: {errs}'
+    assert 'init_contextinfo_form' in rules, f'应拦 init(ContextInfo): {errs}'
+    assert 'handlebar_not_akquant' in rules, f'应拦 handlebar: {errs}'
+    assert 'missing_akquant_strategy_subclass' in rules, f'应拦无 Strategy: {errs}'
+    print(f'OK: 违规策略拦 {len(errs)} 条 (rules={sorted(rules)})')
+
+    # bar.time 陷阱
+    bad_time = '''
+from akquant import Strategy
+class MyStrat(Strategy):
+    def on_bar(self, bar):
+        d = bar.time   # 实际 attr 是 timestamp
+'''
+    errs = check_discipline(bad_time, {})
+    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()