foxclaw 0.1.0 → 0.1.2

package/python/bench/chaos.py

@@ -0,0 +1,142 @@
+"""
+混沌故障注入（Chaos Engineering）· 数字产物
+
+补足 bench 三件套的「故障维度」:
+  · concurrency.py —— 共享库并发写(无故障)
+  · load_test.py    —— HTTP 高并发负载(无故障)
+  · chaos.py(本文件) —— 故障注入:LLM 空响应/异常/fallback/断路器,验证降级语义 + 恢复
+
+验证 ModelRouter(所有 Agent 的 LLM 唯一咽喉)在故障下的三件事:
+  1. 降级语义正确:空响应/全失败**不伪装成功**(对齐 base.py §二「真相优先」);
+  2. fallback 链:主 provider 故障 → 自动回退到已配的次 provider;
+  3. 断路器:故障 provider 进冷却、成功解冻(惊群防护),系统可恢复。
+
+离线:不联网、不碰真实 Key,纯 monkeypatch 注入故障。
+用法:HF_HUB_OFFLINE=1 python bench/chaos.py
+"""
+import os
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+# 关闭联网触发(chaos 只测 LLM 咽喉,不触发搜索)
+import foxclaw.core.web_search as ws  # noqa: E402
+ws.needs_search = lambda q: False
+
+from foxclaw.core.model_router import ModelRouter, PROVIDER_ENV  # noqa: E402
+
+_SYS = "你是 Foxclaw 助手。"
+_MSG = [{"role": "user", "content": "用一句话总结量子计算"}]
+
+
+def _make_router(primary="deepseek", fallback=None):
+    """构造一个走真实路径(非 stub)的 router,并把 _client 设成非 None,
+    以便 monkeypatch _call_provider 注入故障。fallback 指定次 provider 并伪造其 key。"""
+    if fallback:
+        os.environ[PROVIDER_ENV[fallback]] = "chaos-test-key"
+    r = ModelRouter(provider=primary)
+    r._client = object()                     # 使 is_stub == False
+    r._clients[primary] = object()
+    if fallback:
+        r._clients[fallback] = object()
+    return r
+
+
+def _boom(provider, client, model, system, messages, max_tokens, images=None):
+    raise RuntimeError("chaos: upstream timeout")
+
+
+def case1_empty_response():
+    """[1] 空响应故障:provider 返回空串 → degraded + 显式失败文案,不伪装成功。"""
+    r = _make_router("deepseek")
+    r._call_provider = lambda *a, **k: ("", None)
+    out = r.complete(_SYS, _MSG)
+    ok = ("【模型返回为空】" in out) and r.is_degraded()
+    return ok, ("degraded=" + str(r.is_degraded())), out[:40]
+
+
+def case2_call_failure():
+    """[2] 调用异常故障:LLM 抛异常 → 全部失败文案 + degraded,绝不拼接 stub 成功文案。"""
+    r = _make_router("deepseek")
+    r._call_provider = _boom
+    out = r.complete(_SYS, _MSG)
+    ok = ("【全部模型失败】" in out) and r.is_degraded() and ("已完成" not in out)
+    return ok, ("degraded=" + str(r.is_degraded()) + " 伪装成功=" + str("已完成" in out)), out[:40]
+
+
+def case3_fallback_chain():
+    """[3] fallback 链:主 provider 抛异常 → 自动回退到已配次 provider 并记录原因。"""
+    r = _make_router("deepseek", fallback="openai")
+    calls = []
+
+    def _flaky(provider, client, model, system, messages, max_tokens, images=None):
+        calls.append(provider)
+        if provider == "deepseek":
+            raise RuntimeError("chaos: deepseek down")
+        return "openai 兜底回复", None
+
+    r._call_provider = _flaky
+    out = r.complete(_SYS, _MSG)
+    ok = (out == "openai 兜底回复") and (calls[-1] == "openai") and bool(r.fallback_reason)
+    return ok, ("调用顺序=" + str(calls) + " 回退原因=" + r.fallback_reason), out[:40]
+
+
+def case4_circuit_breaker():
+    """[4] 断路器:provider 失败后进入冷却,立即重试被跳过(不再紧密重试)。"""
+    r = _make_router("deepseek")
+    r._call_provider = _boom
+    r.complete(_SYS, _MSG)                    # 第一次失败 → 进入 cooldown
+    cooled = "deepseek" in r._cooldown
+    t0 = time.perf_counter()
+    r.complete(_SYS, _MSG)                    # 第二次:cooldown 未过期 → 直接跳过,不等超时
+    fast = (time.perf_counter() - t0) < 0.5   # 跳过热 provider,应远快于真实超时
+    ok = cooled and fast and r.is_degraded()
+    return ok, (f"冷却中={cooled} 跳过耗时={((time.perf_counter()-t0)*1000):.0f}ms"), "断路器生效"
+
+
+def case5_recovery():
+    """[5] 恢复:故障清除(cooldown 过期/成功)后,同一 provider 恢复正常服务。"""
+    r = _make_router("deepseek")
+    r._call_provider = _boom
+    r.complete(_SYS, _MSG)
+    assert "deepseek" in r._cooldown           # 先确认在冷却
+    r._cooldown["deepseek"] = 0                # 模拟冷却过期
+    r._call_provider = lambda *a, **k: ("恢复后的正常回复", None)
+    out = r.complete(_SYS, _MSG)
+    # 注:degraded 是「曾降级」的累积运维标志(不因恢复清零),恢复语义看「解冻 + 成功返回」。
+    ok = (out == "恢复后的正常回复") and ("deepseek" not in r._cooldown)
+    return ok, ("解冻=" + str("deepseek" not in r._cooldown)), out[:40]
+
+
+def main():
+    cases = [
+        ("空响应 → degraded(不伪装成功)", case1_empty_response),
+        ("调用异常 → 全部失败(不拼接 stub)", case2_call_failure),
+        ("fallback 链(主失败→次兜底)", case3_fallback_chain),
+        ("断路器(失败进冷却·重试跳过)", case4_circuit_breaker),
+        ("恢复(冷却过期→正常服务)", case5_recovery),
+    ]
+    print("=" * 64)
+    print("Foxclaw · 混沌故障注入(ModelRouter 咽喉)")
+    print("=" * 64)
+    n_ok = 0
+    for name, fn in cases:
+        try:
+            ok, detail, sample = fn()
+            n_ok += 1 if ok else 0
+            print(f"\n[{name}]")
+            print(f"  {'✓ 通过' if ok else '✗ 失败'}  {detail}")
+            print(f"  输出样例: {sample}…")
+        except Exception as e:
+            print(f"\n[{name}]\n  ✗ 异常: {type(e).__name__}: {e}")
+    print("\n" + "=" * 64)
+    print(f"结论: {n_ok}/{len(cases)} 混沌用例通过 — "
+          f"{'✓ 故障下降级语义正确、fallback/断路器/恢复均生效' if n_ok == len(cases) else '✗ 存在故障处理缺口'}")
+    print("=" * 64)
+    return 0 if n_ok == len(cases) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/python/bench/concurrency.py

@@ -0,0 +1,103 @@
+"""
+M2 · 并发压测（数字产物）
+
+回答路线图 M2 的量化问题:
+  · 并行 fork-join 相对顺序,墙钟省多少?(latency)
+  · 共享库(ThoughtChain/ProcessManager/SystemBus/HMR)在多线程并发写下的吞吐,
+    以及 `database is locked` 计数(应为 0)。
+
+离线:不联网、LLM 用带固定延迟的 stub。
+用法:HF_HUB_OFFLINE=1 python bench/concurrency.py
+"""
+import asyncio
+import sys
+import tempfile
+import threading
+import time
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import foxclaw.core.web_search as ws
+ws.needs_search = lambda q: False
+
+from foxclaw import Foxclaw
+from foxclaw.core.thought_chain import ThoughtNode
+
+SLEEP = 0.4
+PAR_TASK = "同时查今天的日程、分析本月理财、总结这篇论文"
+SEQ_TASK = "先查今天的日程然后分析本月理财然后总结这篇论文"
+
+
+def _slow(system, messages, max_tokens=2048, agent_id=""):
+    time.sleep(SLEEP)
+    return "已处理"
+
+
+def bench_latency(os_):
+    print("\n[1] 并行 fork-join vs 顺序（每个子任务 LLM stub 固定 " f"{SLEEP*1000:.0f}ms）")
+    r = asyncio.run(os_.supervisor.run_task(PAR_TASK))
+    par = r["plan"]["wall_ms"]
+    t0 = time.perf_counter()
+    asyncio.run(os_.supervisor.run_task(SEQ_TASK))
+    seq = (time.perf_counter() - t0) * 1000
+    print(f"    顺序墙钟 : {seq:8.0f} ms")
+    print(f"    并行墙钟 : {par:8.0f} ms")
+    print(f"    加速比   : {seq/par:8.2f}×   （3 子任务跨 3 个 Agent）")
+
+
+def bench_concurrency(os_, threads=12, per_thread=20):
+    print(f"\n[2] 共享库并发写压测（{threads} 线程 × {per_thread} 轮）")
+    tc, pm, bus, hmr = (os_.thought_chain, os_.process_manager,
+                        os_.system_bus, os_.hmr)
+    locked = {"n": 0}
+    errors = []
+    lk = threading.Lock()
+
+    def worker(k):
+        for i in range(per_thread):
+            try:
+                node = ThoughtNode.create(session_id=f"b{k}", agent_id="bench",
+                                          type="reasoning", content=f"n{k}_{i}", conf=0.9)
+                tc.add_node(node); tc.update_harness(node.id, "PASS")
+                p = pm.create(f"t{k}_{i}", agent_id=f"a{k}", schedule={"priority": 1})
+                pm.mark_running(p.process_id); pm.mark_completed(p.process_id)
+                bus.publish("bench.evt", {"k": k, "i": i})
+                hmr.ingest(f"记忆{k}_{i}", type="concept", agent_id=f"a{k}", title=f"m{k}_{i}")
+            except Exception as e:
+                msg = repr(e)
+                if "database is locked" in msg:
+                    with lk:
+                        locked["n"] += 1
+                with lk:
+                    errors.append(msg)
+
+    total = threads * per_thread
+    t0 = time.perf_counter()
+    ts = [threading.Thread(target=worker, args=(k,)) for k in range(threads)]
+    for t in ts: t.start()
+    for t in ts: t.join()
+    dur = time.perf_counter() - t0
+
+    with tc._conn() as c:
+        nodes = c.execute("SELECT COUNT(*) FROM thought_nodes WHERE agent_id='bench'"
+                          ).fetchone()[0]
+    print(f"    总写入组   : {total}  （每组 = 1 审计节点 + 1 进程流转 + 1 事件 + 1 记忆）")
+    print(f"    耗时       : {dur*1000:8.0f} ms   吞吐 {total/dur:8.0f} 组/s")
+    print(f"    审计落库   : {nodes} / {total}   {'✓ 不丢' if nodes >= total else '✗ 丢失'}")
+    print(f"    database is locked 次数 : {locked['n']}   {'✓' if locked['n']==0 else '✗'}")
+    print(f"    其它异常   : {len(errors)}   {'✓ 无' if not errors else errors[:1]}")
+
+
+def main():
+    os_ = Foxclaw(data_dir=tempfile.mkdtemp())
+    os_.router.complete = _slow
+    print("=" * 60)
+    print("Foxclaw · M2 并发压测")
+    print("=" * 60)
+    bench_latency(os_)
+    bench_concurrency(os_)
+    print("\n" + "=" * 60)
+
+
+if __name__ == "__main__":
+    main()

package/python/bench/e2e_real_models.py

@@ -0,0 +1,95 @@
+"""
+真实多模型 E2E 冒烟（非 stub）· 数字产物
+
+回答步骤 10「真实多模型 E2E」:逐个探测已配 Key 的 provider,各跑一条**真实**最小消息,
+验证「非 stub、非降级、有真实输出」,产出量化报告。
+
+opt-in:只对有真实 Key 的 provider 打真模型(要联网、会消耗额度);一个 Key 都没配则
+优雅跳过(exit 0)——CI/离线环境绝不误判失败。
+
+用法:
+  python bench/e2e_real_models.py            # 只测当前环境已配 Key 的 provider
+  FOXCLAW_E2E_SKIP_PROVIDER=google python ...  # 跳过某 provider(如无 SDK/额度)
+"""
+import os
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import foxclaw.core.web_search as ws  # noqa: E402
+ws.needs_search = lambda q: False
+
+from foxclaw.core.model_router import ModelRouter  # noqa: E402
+
+_SYS = "你是 Foxclaw 助手。"
+_MSG = [{"role": "user", "content": "请只回复两个字：你好"}]
+_MAX_TOKENS = 64
+# stub/故障 的特征文案(出现即视为"非真实成功")
+_BAD_MARKERS = ("【未执行】", "【模型返回为空】", "【全部模型失败】", "【模型流式中断】", "STUB")
+
+
+def _smoke(provider: str) -> dict:
+    """对一个 provider 跑一条真实最小消息,返回观测结果。"""
+    t0 = time.perf_counter()
+    r = ModelRouter(provider=provider)
+    info = r.info()
+    if not info.get("client_ready"):
+        return {"provider": provider, "ok": False, "lat_ms": 0,
+                "output": "", "reason": "client 未就绪(SDK 缺失或无 Key): " +
+                                         (info.get("fallback_reason") or "未知")}
+    try:
+        out = r.complete(_SYS, _MSG, max_tokens=_MAX_TOKENS, agent_id="bench")
+        lat = (time.perf_counter() - t0) * 1000
+    except Exception as e:
+        return {"provider": provider, "ok": False, "lat_ms": (time.perf_counter() - t0) * 1000,
+                "output": "", "reason": f"调用异常: {type(e).__name__}: {e}"}
+
+    degraded = r.take_call_degraded()
+    bad = any(m in out for m in _BAD_MARKERS)
+    ok = bool(out) and not degraded and not bad
+    reason = ""
+    if degraded:
+        reason = "本次调用降级(degraded)"
+    elif bad:
+        reason = "输出含降级/失败文案"
+    return {"provider": provider, "ok": ok, "lat_ms": lat, "output": out, "reason": reason}
+
+
+def main():
+    skip = {s.strip().lower() for s in os.environ.get("FOXCLAW_E2E_SKIP_PROVIDER", "").split(",")
+            if s.strip()}
+    configured = [p["provider"] for p in ModelRouter.available_providers()
+                  if p["configured"] and p["provider"] not in skip]
+
+    print("=" * 64)
+    print("Foxclaw · 真实多模型 E2E 冒烟(非 stub)")
+    print("=" * 64)
+
+    if not configured:
+        print("未检测到任何已配置 Key 的 provider(见 .env.example)。")
+        print("结论: 跳过(无真实模型可测)——离线/无额度环境属预期,非失败。")
+        print("=" * 64)
+        return 0
+
+    print(f"检测到 {len(configured)} 个 provider: {', '.join(configured)}\n")
+    n_ok = 0
+    for p in configured:
+        r = _smoke(p)
+        mark = "✓" if r["ok"] else "✗"
+        n_ok += 1 if r["ok"] else 0
+        sample = (r["output"].strip().replace("\n", " ")[:36]) if r["output"] else "(空)"
+        print(f"[{mark}] {p:12s}  {r['lat_ms']:7.0f} ms  → {sample}")
+        if r["reason"]:
+            print(f"     原因: {r['reason']}")
+
+    print("\n" + "=" * 64)
+    print(f"结论: {n_ok}/{len(configured)} 个真实模型冒烟通过 — "
+          f"{'✓ 多模型真实链路可用' if n_ok == len(configured) else '✗ 有 provider 未通过(见上)'}")
+    print("=" * 64)
+    return 0 if n_ok == len(configured) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/python/bench/llm_retry_test.py

@@ -0,0 +1,248 @@
+"""
+bench/llm_retry_test.py
+C 阶段 _retry_llm helper 单元测试。
+
+覆盖:
+  1. 正常调用 1 次成功
+  2. 429 抛 1 次后成功
+  3. 429 抛 max_retries 次后 raise
+  4. 非 retryable 异常立即 raise
+  5. Retry-After header 优先于 backoff
+  6. 5xx 也 retry
+  7. ConnectionError / Timeout retry
+  8. 指数退避 (backoff 1→2→4) + max_delay 上限
+  9. openai RateLimitError (name 含 RateLimit) 也 retry
+"""
+import os, sys, time
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'vendor'))
+from hkc.hkc_kde.extractor import Extractor
+
+
+# ── Mock 异常类型 ────────────────────────────────────
+
+class FakeResponse:
+    def __init__(self, headers=None):
+        self.headers = headers or {}
+
+
+class Fake429Error(Exception):
+    def __init__(self, msg="rate limited", retry_after=None):
+        super().__init__(msg)
+        self.status_code = 429
+        self.headers = {"Retry-After": str(retry_after)} if retry_after else {}
+
+
+class Fake5xxError(Exception):
+    def __init__(self, msg="server error", status=500):
+        super().__init__(msg)
+        self.status_code = status
+
+
+class FakeTimeoutError(TimeoutError):
+    def __init__(self, msg="timed out"):
+        super().__init__(msg)
+        self.status_code = None
+
+
+class FakeConnError(ConnectionError):
+    pass
+
+
+class FakeRateLimitName(Exception):
+    """模拟 openai.RateLimitError(type name 含 'RateLimit',无 status_code)"""
+    def __init__(self, msg="rate"):
+        super().__init__(msg)
+        # 不设 status_code;靠 type name 'RateLimit' 识别
+
+
+class FakeValueError(Exception):
+    """非 retryable"""
+    def __init__(self, msg="bad request"):
+        super().__init__(msg)
+        self.status_code = 400
+
+
+# ── 测试实例化 ───────────────────────────────────────
+# KnowledgeExtractor __init__ 不调 LLM,只是记 provider/model 配置
+# _retry_llm 是 instance method,任意实例都能调
+ext = Extractor(provider="mock", model="mock-model")
+
+
+def make_func(side_effects):
+    """side_effects: 异常类或值,依次抛出,最后返回 'ok' 或 raise"""
+    call_count = [0]
+    sleeps = []
+
+    def _func(*args, **kwargs):
+        i = call_count[0]
+        call_count[0] += 1
+        if i < len(side_effects):
+            item = side_effects[i]
+            if isinstance(item, Exception):
+                raise item
+            return item
+        return "ok"
+
+    return _func, call_count, sleeps
+
+
+def patch_sleep():
+    """monkey-patch time.sleep 不真睡,记录时长"""
+    import hkc.hkc_kde.extractor as ex
+    original = ex.time.sleep
+    sleeps = []
+    def fake_sleep(s):
+        sleeps.append(s)
+    ex.time.sleep = fake_sleep
+    return ex, original, sleeps
+
+
+def restore_sleep(ex, original):
+    ex.time.sleep = original
+
+
+def t1_ok():
+    """1. 正常调用 1 次成功"""
+    func, calls, _ = make_func(["ok"])
+    r = ext._retry_llm(func, max_retries=3, base_delay=0.01)
+    assert r == "ok" and calls[0] == 1
+    print("  1. ok 1 次成功: PASS")
+
+
+def t2_429_retry_success():
+    """2. 429 抛 1 次后成功"""
+    func, calls, _ = make_func([Fake429Error(), "ok"])
+    ex, original, sleeps = patch_sleep()
+    try:
+        r = ext._retry_llm(func, max_retries=3, base_delay=0.01, max_delay=0.1)
+        assert r == "ok" and calls[0] == 2
+        assert len(sleeps) == 1 and sleeps[0] == 0.01
+        print("  2. 429 1 次后成功 + sleep 0.01: PASS")
+    finally:
+        restore_sleep(ex, original)
+
+
+def t3_429_exhaust():
+    """3. 429 抛 max_retries+1 次后 raise"""
+    func, calls, _ = make_func([Fake429Error()] * 5)
+    ex, original, sleeps = patch_sleep()
+    try:
+        try:
+            ext._retry_llm(func, max_retries=3, base_delay=0.001, max_delay=0.01)
+            assert False, "应该 raise"
+        except Fake429Error:
+            pass
+        assert calls[0] == 4  # 1 + 3 retries
+        assert len(sleeps) == 3  # 3 次 retry 才 sleep
+        print("  3. 429 4 次后 raise (1+3 retry): PASS, calls={}, sleeps={}".format(calls[0], sleeps))
+    finally:
+        restore_sleep(ex, original)
+
+
+def t4_non_retryable():
+    """4. 非 retryable (400) 立即 raise"""
+    func, calls, _ = make_func([FakeValueError()])
+    ex, original, sleeps = patch_sleep()
+    try:
+        try:
+            ext._retry_llm(func, max_retries=3, base_delay=0.01)
+            assert False, "应该 raise"
+        except FakeValueError:
+            pass
+        assert calls[0] == 1
+        assert len(sleeps) == 0
+        print("  4. 400 立即 raise 不 sleep: PASS")
+    finally:
+        restore_sleep(ex, original)
+
+
+def t5_retry_after():
+    """5. Retry-After header 优先于 backoff"""
+    func, calls, _ = make_func([Fake429Error(retry_after=0.05), "ok"])
+    ex, original, sleeps = patch_sleep()
+    try:
+        r = ext._retry_llm(func, max_retries=3, base_delay=1.0, max_delay=10.0)
+        assert r == "ok"
+        assert len(sleeps) == 1
+        assert sleeps[0] == 0.05, f"expected 0.05, got {sleeps[0]}"
+        print("  5. Retry-After=0.05 优先 backoff=1.0: PASS, slept={}".format(sleeps))
+    finally:
+        restore_sleep(ex, original)
+
+
+def t6_5xx():
+    """6. 5xx (500) retry"""
+    func, calls, _ = make_func([Fake5xxError(status=500), Fake5xxError(status=503), "ok"])
+    ex, original, sleeps = patch_sleep()
+    try:
+        r = ext._retry_llm(func, max_retries=3, base_delay=0.01, max_delay=0.1)
+        assert r == "ok" and calls[0] == 3
+        assert sleeps == [0.01, 0.02]
+        print("  6. 5xx 500+503 后成功: PASS, sleeps={}".format(sleeps))
+    finally:
+        restore_sleep(ex, original)
+
+
+def t7_conn_timeout():
+    """7. ConnectionError / Timeout retry"""
+    for cls, name in [(FakeConnError, "ConnectionError"), (FakeTimeoutError, "Timeout")]:
+        func, calls, _ = make_func([cls(), "ok"])
+        ex, original, sleeps = patch_sleep()
+        try:
+            r = ext._retry_llm(func, max_retries=3, base_delay=0.01)
+            assert r == "ok" and calls[0] == 2
+            assert len(sleeps) == 1
+            print("  7. {} retry: PASS".format(name))
+        finally:
+            restore_sleep(ex, original)
+
+
+def t8_backoff():
+    """8. 指数退避 1→2→4 + max_delay 上限"""
+    func, calls, _ = make_func([Fake429Error()] * 4)
+    ex, original, sleeps = patch_sleep()
+    try:
+        try:
+            ext._retry_llm(func, max_retries=3, base_delay=1.0, max_delay=3.0)
+        except Fake429Error:
+            pass
+        # 3 次 retry:sleeps = [1, 2, 3] (4 cap at max_delay=3)
+        assert sleeps == [1.0, 2.0, 3.0], f"expected [1,2,3], got {sleeps}"
+        print("  8. 退避 1→2→3 (max_delay cap): PASS, sleeps={}".format(sleeps))
+    finally:
+        restore_sleep(ex, original)
+
+
+def t9_rate_limit_name():
+    """9. type name 含 'RateLimit' (openai.RateLimitError 风格) 也 retry"""
+    func, calls, _ = make_func([FakeRateLimitName(), "ok"])
+    ex, original, sleeps = patch_sleep()
+    try:
+        r = ext._retry_llm(func, max_retries=3, base_delay=0.01)
+        assert r == "ok" and calls[0] == 2
+        print("  9. RateLimit class name → retry: PASS")
+    finally:
+        restore_sleep(ex, original)
+
+
+def main():
+    print("=" * 60)
+    print("C 阶段 _retry_llm helper 单元测试 (9 项)")
+    print("=" * 60)
+    t1_ok()
+    t2_429_retry_success()
+    t3_429_exhaust()
+    t4_non_retryable()
+    t5_retry_after()
+    t6_5xx()
+    t7_conn_timeout()
+    t8_backoff()
+    t9_rate_limit_name()
+    print("=" * 60)
+    print("全部 9 项 PASS")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()