# chanlun-engine-skill

Adopt this skill: https://proskills.md/skills/other/adsorgcn-chanlun-engine-skill

Page: https://proskills.md/skills/other/adsorgcn-chanlun-engine-skill
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: SKILL.md
size: 6959
sha: 3e972f50bc099f9f58e534ede679cf67f6d10230
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/SKILL.md

````text
---
name: chanlun-engine-skill
slug: chanlun-engine-skill
displayName: 缠论引擎
description: 用缠论客观分析A股股票。当用户提到 缠论、分型、笔、线段、中枢、背驰、买卖点、K线结构，或想知道某只股票该买该卖该持有还是等待时使用。确定性脚本计算缠论结构并给出四态操作判定(买入候选/持有/卖出减仓/等待观察)与失效价位，AI 只负责解读转述，不心算结构。免费数据源开箱即用，无需注册。
license: MIT
compatibility: 需要 Python 3.11+。数据默认走 akshare 免费源(无需账号)，可选同花顺 Financial-API key 增强。纯本地计算，无远程代码下载。
version: "1.1.8"
metadata:
  author: adsorgcn
  version: "1.1.8"
  openclaw:
    emoji: "📈"
    homepage: https://github.com/adsorgcn/chanlun-engine-skill
    os: [windows, macos, linux]
    envVars:
      HITHINK_FINANCE_API_KEY:
        required: false
        description: 可选。同花顺官方行情key(fuyao.aicubes.cn/admin免费签发), 不配则自动用akshare免费源
      CHANPY_PATH:
        required: false
        description: 可选。覆盖内置缠论引擎目录, 仅开发调试用
agent_created: true
---

# 缠论结构引擎 (chanlun-engine-skill)

脚本算一切结构，你（LLM）只在结构之上说话。这不是风格偏好，是实证结论：
两套确定性引擎对拍，中枢对齐率仅 0.0-0.42。缠论结构对算法口径极度敏感，心算等于引入一套不可复现、无不变量校验的第三口径。

## 硬性禁令（违反即错误）

1. 禁止从原始K线心算/目测任何缠论结构（分型、笔、线段、中枢、买卖点、背驰）
1b. 股票名→代码必须由 get_data.py 解析（--symbol 直接传用户说的名字），禁止凭记忆填代码；报告标题用它返回的 name+symbol，输出前核对与用户所问的是同一只股票
2. 禁止引用引擎 JSON 中不存在的结构
3. 禁止把 `sure:false` 的候选升格为"确认"：它是"当前帧"形态学语义，次日可能消失
4. 操作判定（买入候选/持有/卖出减仓/等待观察）必须原样来自引擎 `verdict` 字段，禁止自创、改写或加码；给判定必须连同关键价位与观察条件一起给
5. 每个信号必须先写失效条件（引擎已给出 `invalidations` 数值），再谈其他

## 面对新手用户（先判断再动手）

用户很可能不是程序员。开始前先判断对方是谁：说"帮我分析XX股票"的普通用户，走下面的代办流程（所有命令你自己跑，别把终端命令甩给对方）：

1. 环境自检：Python≥3.11 在不在、vendor 装没装（没装就替用户跑 setup 脚本并简单说明"正在装计算引擎，约1分钟"）
2. 数据自检：默认免费源零配置直接用。用户想升级官方源时按 references/getting-started.md 引导申请
2b. key 入库（用户永远不碰终端）：用户在对话里发来 key 时，你**立即代存，不训话不拒收**——自己跑 `echo <key> | python scripts/setup_env.py --set-key`（stdin 直入，加密落盘，key 不写进任何脚本参数或临时文件），确认成功后回一句：已加密存进本机（Windows 走系统级 DPAPI），聊天里那条消息可以删掉，不放心随时去 fuyao.aicubes.cn/admin 作废重签。介意隐私的用户才引导终端自录（getpass 不回显）
3. 讲解时人话优先：术语首次出现要用一句话解释（例：「中枢=多空反复争夺形成的价格区间，跌破它说明争夺失败」）；结论直接引用 summary 成品句
4. 新手问判定含义时说清定位：四态判定是缠论规则的机械信号（同一份数据谁跑都一样、可复核、带失效价位），供决策参考；它不是针对个人财务状况的投资建议，最终决定权在用户

## 使用流程

```bash
# 首次: 环境自检+装免费行情源(引擎已随技能打包, 无需下载任何代码)
python scripts/setup_env.py --recommended

# 一条龙: 取数(自动选源: 有同花顺key走官方, 没有走akshare免费源)→算结构与判定
# --symbol 直接传用户说的股票名或6位代码(脚本自动解析, 严禁自己凭记忆猜代码)
python scripts/get_data.py --symbol 招商银行 --out k.csv
# 用上一步输出的 symbol 与 name 字段, 不要自己填
python scripts/chan_engine.py --symbol <上一步输出的symbol> --csv k.csv

# 全市场扫描 (需同花顺key+本地marketdb, 建议在服务器跑; 见 references/engine-notes.md)
python scripts/scan_market.py --duckdb data/market.duckdb --out data/

# 无网络时自测
python scripts/make_testdata.py && python scripts/chan_engine.py --symbol TEST --csv testdata.csv
```

## 输出契约 chanlun_structure_v1（你消费的唯一事实源）

- `day/week`: 各级别的 `bi`(笔) `seg`(线段) `zs`(中枢: zg/zd/gg/dd) `bsp`(买卖点: 1,1p,2,2s,3a,3b)
  `pos_vs_last_zs`(现价对最近中枢: above/in/below)
- `signals.fresh_bsp`: 最近K线上的新鲜买卖点（选股信号，全部是候选非确认）
- `signals.week_day_confluence`: 周-日粗糙区间套共振
- `invalidations`: 每个新鲜信号的失效价位（数值，直接引用）
- `ma`: 均线值与状态（long排列/缠绕），即缠师早期均线系统的日K落地
- `caveats`: 口径声明，报告中必须保留其要点

## 固定输出模板（保底路径：任何模型照此填空即为合格输出）

引擎 JSON 的 `summary` 字段是**预拼好的成品结论句**，直接引用，禁止改写数值：

```
【{name}({symbol}) 缠论分析 · {asof}】
{summary.verdict}
结构定位: {summary.day}
大级别: {summary.week}
均线: {summary.ma}
信号: {summary.signal}
失效条件: {逐条列 invalidations 的 rule + px}
口径: 日-周近似缠论(structure_proxy), 未确认信号次日可能消失。
```

有余力的模型在模板之后追加"多义性分解"（条件树叙述）；没把握就只出模板，模板本身已是合格交付，错误的发挥不如不发挥。

## 解读姿态（你的正确位置）

- **多义性分解**：基于 `sure:false` 分支与未完成笔，枚举"若走A则结构演化为…若走B则…"的条件树，且只在引擎给出的候选之上枚举，不自创结构
- **结构叙事**：当前操作级别、中枢位置、背驰状态、离最近买卖点的距离
- **能力边界**（必要时向用户申明）：本引擎是日-周两级"近似缠论"(structure_proxy)：无分钟K即无次级别确认；背驰用MACD peak法(rate<0.9)是第24课"辅助判断"的量化近似；
  严格区间套/同级别分解/中阴阶段不做结构计算，只做叙述性提示

## 深入阅读

- [references/chanlun-core.md](references/chanlun-core.md) — 理论完备性16项清单，全部锚定原文课号
- [references/engine-notes.md](references/engine-notes.md) — 引擎口径、配置陷阱、契约字段明细
````

## File: README.md
size: 5435
sha: a6eafe0546e88cae988710105146fb3316c5c15d
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/README.md

````text
# chanlun-engine-skill · 不用学缠论，也能用缠论看股票

**不需要啃 108 课天书**：AI 按缠论的公开规则客观判定，告诉你该买、该卖、该持有还是等待，每个判定带失效价位，可复核。没有人在荐股，是理论在机械执行。

把缠中说禅《教你炒股票》108 课里的核心结构（分型、笔、线段、中枢、三类买卖点、背驰）做成了确定性程序。你的 AI 助手（WorkBuddy、Claude Code、Codex、OpenClaw）装上这个技能后，就能对任意一只 A 股自动画出缠论结构，指出当前的买卖点候选，并直接告诉你：**现在该买、该卖、该持有，还是再等等；等的话看什么条件、到什么价位做什么动作**。

## 它能帮你做什么

- **直接给操作判定**：买入候选、持有、卖出减仓、等待观察四态，持仓者和空仓者分开回答，每个判定都带关键价位和观察条件
- **缠论自动画线**：程序自动完成包含处理、标分型、画笔、画线段、框中枢，不用再手动数K线
- **缠论买卖点提示**：一买、二买、三买（含 1p/2s/3a/3b 细分），每个信号自动附上失效价位
- **缠论背驰判断**：MACD 辅助量化，这也是缠师第 24 课"辅助判断"的本义
- **全市场缠论选股**：5000 只 A 股约 2 分钟扫一遍，筛出最近出现买卖点的候选
- **AI 炒股复盘的结构坐标**：日线加周线联立，均线系统状态一并给出

## 举个真实例子

对贵州茅台跑一次（2026-08-24 真实数据），AI 拿到的就是这样的结论句，照着讲就行：

> **操作判定：买入候选。** 持仓者：继续持有，止损上移至失效价位。空仓者：出现 2 类买点（未确认，次日可能消失），可考虑介入，严格以失效价位为止损。关键价位：1293.99。观察条件：次日大幅低开超 3% 则放弃本信号；跌破 1293.99 即认错离场。
>
> 结构背景：现价 1304.66 位于最近中枢 [1331, 1409] 下方，最近一笔向下，周线线段向下，均线非多头排列。

## 为什么不让 AI 直接看图"心算"缠论？

我们对拍过：两套确定性引擎在同一份K线上，**中枢对齐率只有 0.0-0.42**。缠论结构对算法口径极其敏感，让大模型每次现场心算，结论会天天漂移、无法复核。所以这个技能的铁律是：**程序算结构，AI 只负责解读**。哪怕你用的是很普通的模型，也能得到同样正确的结构数据（AI 的聪明程度只影响讲解的文采，不影响对错）。

## 快速开始

**如果你不是程序员**：先看 [新手三步上手指南](references/getting-started.md)（申请数据钥匙就是用同花顺账号登录一下的事），然后把这个仓库地址发给你的 AI 助手，说一句：

> 帮我装上这个缠论技能，然后分析一下贵州茅台

它会自己搞定安装并开始干活（技能里写了引导新手的完整流程）。

**如果你是开发者**：

```bash
npx skills add adsorgcn/chanlun-engine-skill     # 或 git clone 本仓库
python scripts/setup_env.py --recommended        # 自检环境+装免费行情源(引擎已内置, 无需编译下载)
python scripts/get_data.py --symbol 600519 --out k.csv    # 取数, 不需要任何账号
python scripts/chan_engine.py --symbol 600519.SH --csv k.csv   # 结构+操作判定
```

**数据源两档**：默认走 akshare 免费行情（无需注册，装完即用，东财断连自动切新浪备用）；
想更快更稳就按[三步指南](references/getting-started.md)签一把免费的
[同花顺官方 key](https://github.com/HiThink-Tech/Financial-API)，脚本检测到 key 自动切官方源。
任何来源的日K CSV 也都能直接喂（列：date,open,high,low,close,volume）。

## 理论原文在哪

缠中说禅《教你炒股票》108 课全文 + 课后回复（缠论补丁的主要载体）的 Markdown 整理版：
[stockServ/chzhshch-108-plus](https://github.com/stockServ/chzhshch-108-plus)；全部 1135 篇博文档案见 [chzhshch.blog](https://chzhshch.blog/)。
本仓库 [references/chanlun-core.md](references/chanlun-core.md) 把 16 项核心概念逐一锚定到具体课号，学缠论也可当索引用。

## 诚实边界（先说清楚，别踩坑）

- 基于**日K**：日-周两级近似缠论，没有分钟级次级别确认，所以信号是"候选"不是"确认"，最新买卖点次日可能消失
- 背驰用 MACD 量化是近似，不是原文的"力度"定义
- 操作判定由缠论规则自动生成（买卖点本来就是缠论的操作点），同一份数据谁跑都是同一个结果，可复核；它是规则信号，不是针对你个人财务状况的投资建议，两者并不矛盾。判定不保证盈利，**失效价位就是安全带**，到价认错是这套体系的一部分
- 投资有风险，任何输出不构成投资建议

## 深入阅读

- [SKILL.md](SKILL.md) — AI 使用本技能的完整规则（含新手引导流程）
- [references/chanlun-core.md](references/chanlun-core.md) — 缠论 16 项概念清单，逐项锚定 108 课课号
- [references/engine-notes.md](references/engine-notes.md) — 引擎选型、配置陷阱、JSON 契约字段、贡献方向

## License

MIT（计算内核 [chan.py](https://github.com/Vespa314/chan.py) 亦为 MIT）。理论原文版权归缠中说禅（李彪）。
````

## File: scripts/chan_engine.py
size: 19945
sha: fd5b9d8cbd52a9fcc49fae0bfd2eab28095d255e
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/scripts/chan_engine.py

```text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
chan_engine.py — 单股缠论结构计算，输出 chanlun_structure_v1 JSON 契约
引擎: Vespa314/chan.py 已打包于 ../engine/chanpy (commit 429d6ed, MIT) | 口径: structure_proxy(日-周两级)
用法:
  python chan_engine.py --csv path.csv --symbol 600519.SH            # CSV: date,open,high,low,close,volume[,amount]
  python chan_engine.py --duckdb data/market.duckdb --symbol 600519.SH [--start 2023-01-01]
  python chan_engine.py --stdin-json --symbol X                      # stdin 传 [{date,open,high,low,close,volume},...]
引擎路径: 默认用打包的 ../engine/chanpy, 可用环境变量 CHANPY_PATH 覆盖
输出: stdout 单个 JSON(chanlun_structure_v1), 含结构/summary成品句/verdict四态操作判定(确定性规则映射)。
"""
import argparse
import hashlib
import json
import os
import sys
from datetime import datetime, timedelta

if hasattr(sys.stdout, "reconfigure"):
    sys.stdout.reconfigure(encoding="utf-8")  # Windows 控制台默认GBK, 钉死UTF-8

# ---------- vendor 挂载 ----------
_HERE = os.path.dirname(os.path.abspath(__file__))
_CANDIDATES = ([os.environ["CHANPY_PATH"]] if os.environ.get("CHANPY_PATH") else []) + [
    os.path.join(_HERE, "..", "engine", "chanpy"),   # 随技能打包的内置引擎(默认)
    os.path.join(_HERE, "..", "vendor", "chanpy"),   # 旧版外置 vendor 兼容
]
CHANPY = next((os.path.abspath(p) for p in _CANDIDATES if os.path.isdir(p)), None)
if not CHANPY:
    print(json.dumps({"error": "缠论引擎目录缺失(engine/chanpy), 技能包不完整, 请重新安装本技能"}, ensure_ascii=False))
    sys.exit(2)
sys.path.insert(0, CHANPY)

from Chan import CChan                              # noqa: E402
from ChanConfig import CChanConfig                  # noqa: E402
from Common.CEnum import AUTYPE, DATA_SRC, KL_TYPE  # noqa: E402
from Common.CTime import CTime                      # noqa: E402
from Common.CEnum import DATA_FIELD                 # noqa: E402
from KLine.KLine_Unit import CKLine_Unit            # noqa: E402
from DataAPI.CommonStockAPI import CCommonStockApi  # noqa: E402

ENGINE_TAG = "chan.py@429d6ed(bundled)"
CONTRACT = "chanlun_structure_v1"

# ---------- 钉死的引擎配置(README 默认值不可信, 全部显式) ----------
CHAN_CONFIG = {
    "bi_strict": True,            # 严格笔(老笔)
    "bi_fx_check": "strict",
    "seg_algo": "chan",           # 特征序列线段(正统)
    "zs_algo": "normal",          # 段内中枢
    "zs_combine": True,
    "divergence_rate": 0.9,       # !! 开源版默认 inf=不判背驰, 必须显式
    "min_zs_cnt": 1,
    "max_bs2_rate": 0.618,
    "macd_algo": "peak",          # 24课: MACD 仅"辅助判断"
    "bs_type": "1,1p,2,2s,3a,3b",
    "print_warning": False,
    "kl_data_check": False,       # 周线由日K合成, 关闭父子逐根强校验(自行保证对齐)
    "gap_as_kl": False,           # README 写 True, 代码实际 False — 显式钉死
}
CONFIG_HASH = hashlib.md5(json.dumps(CHAN_CONFIG, sort_keys=True).encode()).hexdigest()[:8]

_ROWS: list = []  # 进程内传递给自定义数据源

def _weekly_from_daily(rows):
    """日K合成周K(ISO周), 每周取 first open/max high/min low/last close/sum vol"""
    out, cur, key = [], None, None
    for r in rows:
        d = datetime.fromisoformat(r["date"])
        k = d.isocalendar()[:2]
        if k != key:
            if cur:
                out.append(cur)
            cur = dict(r)
            key = k
        else:
            cur["high"] = max(cur["high"], r["high"])
            cur["low"] = min(cur["low"], r["low"])
            cur["close"] = r["close"]
            cur["volume"] = cur.get("volume", 0) + r.get("volume", 0)
            cur["date_end"] = r["date"]
    if cur:
        out.append(cur)
    return out

class CMemDay(CCommonStockApi):
    """内存行 → chan.py 数据源。K_DAY 用原始行, K_WEEK 用合成周K(时间取该周最后交易日)"""
    def __init__(self, code, k_type=KL_TYPE.K_DAY, begin_date=None, end_date=None, autype=None):
        super().__init__(code, k_type, begin_date, end_date, autype)

    def get_kl_data(self):
        rows = _ROWS if self.k_type == KL_TYPE.K_DAY else _weekly_from_daily(_ROWS)
        for r in rows:
            d = r.get("date_end", r["date"])
            fields = {
                DATA_FIELD.FIELD_TIME: CTime(int(d[:4]), int(d[5:7]), int(d[8:10]), 0, 0),
                DATA_FIELD.FIELD_OPEN: float(r["open"]),
                DATA_FIELD.FIELD_HIGH: float(r["high"]),
                DATA_FIELD.FIELD_LOW: float(r["low"]),
                DATA_FIELD.FIELD_CLOSE: float(r["close"]),
            }
            if r.get("volume") is not None:
                fields[DATA_FIELD.FIELD_VOLUME] = float(r["volume"])
            if r.get("amount") is not None:
                fields[DATA_FIELD.FIELD_TURNOVER] = float(r["amount"])
            yield CKLine_Unit(fields)

    def SetBasciInfo(self):
        pass

    @classmethod
    def do_init(cls):
        pass

    @classmethod
    def do_close(cls):
        pass

def _t(ct) -> str:
    return f"{ct.year:04d}-{ct.month:02d}-{ct.day:02d}"

def _ma(closes, n):
    if len(closes) < n:
        return None
    return round(sum(closes[-n:]) / n, 3)

def extract_level(kl_list, last_close, tail_bi=8, tail_seg=4, tail_zs=3, tail_bsp=6):
    bis = [{
        "i": b.idx, "dir": str(b.dir).split(".")[-1], "sure": bool(b.is_sure),
        "b": _t(b.get_begin_klu().time), "e": _t(b.get_end_klu().time),
        "bv": round(b.get_begin_val(), 3), "ev": round(b.get_end_val(), 3),
    } for b in list(kl_list.bi_list)[-tail_bi:]]
    segs = [{
        "i": s.idx, "dir": str(s.dir).split(".")[-1], "sure": bool(s.is_sure),
        "b": _t(s.start_bi.get_begin_klu().time), "e": _t(s.end_bi.get_end_klu().time),
        "zs_n": len(s.zs_lst),
    } for s in list(kl_list.seg_list)[-tail_seg:]]
    zss = [{
        "b": _t(z.begin.time), "e": _t(z.end.time), "sure": bool(z.is_sure),
        "zg": round(z.high, 3), "zd": round(z.low, 3),
        "gg": round(z.peak_high, 3), "dd": round(z.peak_low, 3), "bi_n": len(z.bi_lst),
    } for z in list(kl_list.zs_list.zs_lst)[-tail_zs:]]
    bsps = [{
        "d": _t(p.klu.time), "bs": "B" if p.is_buy else "S", "type": p.type2str(),
        "px": round(p.klu.close, 3), "sure": bool(p.bi.is_sure),
    } for p in kl_list.bs_point_lst.getSortedBspList()[-tail_bsp:]]

    pos = None
    if zss:
        z = zss[-1]
        pos = ("above_zs" if last_close > z["zg"] else
               "below_zs" if last_close < z["zd"] else "in_zs")
    return {"bi": bis, "seg": segs, "zs": zss, "bsp": bsps, "pos_vs_last_zs": pos}

def invalidation_for(bsp, day_zss, low_by_date=None):
    """给最新买卖点写失效价位(脚本给数值, LLM 只引用)"""
    t = bsp["type"]
    if not day_zss:
        return None
    z = day_zss[-1]
    if "3a" in t or "3b" in t:
        return {"rule": "跌回中枢上沿(ZG)之下则三买失效", "px": z["zg"]}
    if "1" in t and bsp["bs"] == "B":
        px = (low_by_date or {}).get(bsp["d"])
        return {"rule": "跌破一买当日K线低点则背驰段延伸,候选失效",
                "px": round(px, 3) if px is not None else None}
    if "2" in t and bsp["bs"] == "B":
        return {"rule": "跌破前低(dd)则二买失效", "px": z["dd"]}
    return None

def run(symbol, rows, tail_days=2):
    global _ROWS
    _ROWS = rows
    import DataAPI  # 动态注册内存源
    mod = sys.modules.setdefault("DataAPI.MEM_API", type(sys)("DataAPI.MEM_API"))
    mod.CMemDay = CMemDay
    setattr(DataAPI, "MEM_API", mod)

    config = CChanConfig(dict(CHAN_CONFIG))
    chan = CChan(code=symbol, begin_time=None, end_time=None,
                 data_src="custom:MEM_API.CMemDay",
                 lv_list=[KL_TYPE.K_WEEK, KL_TYPE.K_DAY],
                 config=config, autype=AUTYPE.NONE)  # 复权在数据侧(v_daily_qfq)完成

    day = chan[KL_TYPE.K_DAY]
    week = chan[KL_TYPE.K_WEEK]
    closes = [r["close"] for r in rows]
    last_close = closes[-1]
    last_date = rows[-1]["date"]

    day_x = extract_level(day, last_close)
    week_x = extract_level(week, last_close, tail_bi=6, tail_seg=3, tail_zs=2, tail_bsp=4)

    # 最近 tail_days 根K内的新鲜买卖点 = 选股信号
    recent_dates = {r["date"] for r in rows[-tail_days:]}
    fresh = [b for b in day_x["bsp"] if b["d"] in recent_dates]
    # 周-日粗糙区间套: 周线最近bsp的笔时间窗内是否有日线bsp
    confluence = []
    for wb in week_x["bsp"][-2:]:
        for db in day_x["bsp"]:
            if abs((datetime.fromisoformat(db["d"]) - datetime.fromisoformat(wb["d"])).days) <= 40 \
                    and wb["bs"] == db["bs"]:
                confluence.append({"week": wb, "day": db})
                break

    mas = {f"ma{n}": _ma(closes, n) for n in (5, 10, 20, 60)}
    ma_state = None
    if mas["ma20"] and mas["ma60"]:
        spread = abs(mas["ma5"] - mas["ma20"]) / last_close if mas["ma5"] else None
        ma_state = {
            "long": bool(mas["ma5"] and mas["ma5"] > mas["ma20"] > mas["ma60"]),
            "entangled": bool(spread is not None and spread < 0.02),  # 均线缠绕近似(11-14课"吻")
        }

    invalidations = [
        {"bsp": b, "invalidation": invalidation_for(
            b, day_x["zs"], {r["date"]: r["low"] for r in rows[-10:]})} for b in fresh
    ]
    verdict = make_verdict(day_x, fresh, last_close, invalidations)
    summary = make_summary(symbol, last_date, last_close, day_x, week_x, fresh,
                           confluence, mas, ma_state)
    summary["verdict"] = verdict_sentence(verdict)

    out = {
        "contract": CONTRACT,
        "meta": {
            "symbol": symbol, "asof": last_date, "bars_day": len(rows),
            "engine": ENGINE_TAG, "config_hash": CONFIG_HASH,
            "adjust": "input_side(qfq expected)", "stance": "structure_proxy",
        },
        "day": day_x,
        "week": week_x,
        "ma": {"values": mas, "state": ma_state},
        "signals": {
            "fresh_bsp": fresh,
            "week_day_confluence": confluence,
            "actionable_date": "次一交易日(信号基于已收盘K线, 防前视)",
        },
        "verdict": verdict,
        "invalidations": invalidations,
        "summary": summary,
        "caveats": [
            "日-周两级近似缠论(structure_proxy): 无分钟K, 无次级别确认, 日线笔为最小结构单元",
            "最新笔/买卖点 sure=false 属'当前帧'语义, 次日新K可能使其消失或位移",
            "背驰=MACD peak 法 rate<0.9, 是24课'辅助判断'的量化近似, 非原文力度定义",
            "本输出仅结构事实, 不构成任何操作指令",
        ],
    }
    return out

_POS_TXT = {"above_zs": "中枢上方", "in_zs": "中枢区间内", "below_zs": "中枢下方"}
_DIR_TXT = {"UP": "向上", "DOWN": "向下"}

def make_verdict(day_x, fresh, last_close, invalidations):
    """四态操作判定(确定性规则, 缠论买卖点即操作点): 买入候选/持有/卖出减仓/等待观察
    持仓者与空仓者分别给答案; 每个判定带止损或触发条件。脚本算判定, LLM 只转述。"""
    zs = day_x["zs"][-1] if day_x["zs"] else None
    bi_dir = day_x["bi"][-1]["dir"] if day_x["bi"] else None
    pos = day_x["pos_vs_last_zs"]
    buys = [b for b in fresh if b["bs"] == "B"]
    sells = [b for b in fresh if b["bs"] == "S"]
    stop = None
    for iv in invalidations:
        if iv.get("invalidation") and iv["invalidation"].get("px") is not None:
            stop = iv["invalidation"]["px"]
            break

    if sells:
        t = ",".join(b["type"] for b in sells)
        return {"action": "卖出/减仓",
                "for_holder": f"出现{t}类卖点, 按缠论规则应减仓或离场",
                "for_watcher": "不介入",
                "stop_px": None,
                "watch": [f"若后续放量收复并站稳中枢上沿 {zs['zg'] if zs else '前高'} 之上, 重新评估"]}
    if buys:
        t = ",".join(b["type"] for b in buys)
        sure = all(b["sure"] for b in buys)
        return {"action": "买入候选",
                "for_holder": "已持有则继续持有, 止损上移至失效价位",
                "for_watcher": f"出现{t}类买点{'(已确认)' if sure else '(未确认, 次日可能消失)'}, "
                               f"可考虑介入, 严格以失效价位为止损",
                "stop_px": stop,
                "watch": ["次日大幅低开(超过3%)则放弃本信号",
                          f"跌破失效价位 {stop if stop is not None else '(见invalidations)'} 即认错离场"]}
    if pos == "above_zs" and zs:
        if bi_dir == "UP":
            return {"action": "持有",
                    "for_holder": f"结构健康(中枢上方且笔向上), 持有, 止损设中枢上沿 {zs['zg']}",
                    "for_watcher": "此位置追高无新买点依据, 等回踩中枢上沿企稳(类三买)再考虑",
                    "stop_px": zs["zg"],
                    "watch": [f"回落跌破 {zs['zg']} 则离场(回中枢=三买逻辑失效)"]}
        return {"action": "持有(警惕)",
                "for_holder": f"中枢上方但最近一笔向下, 持有但收紧止损至 {zs['zg']}",
                "for_watcher": "等待方向明确",
                "stop_px": zs["zg"],
                "watch": [f"收盘跌破 {zs['zg']} 转卖出", "缩量企稳后重新走强则解除警惕"]}
    if pos == "in_zs" and zs:
        return {"action": "等待观察",
                "for_holder": f"中枢内震荡, 持有观察, 底线是中枢下沿 {zs['zd']}",
                "for_watcher": "中枢内不动手, 等方向选择",
                "stop_px": zs["zd"],
                "watch": [f"放量站上中枢上沿 {zs['zg']} 转看多(三买候选)",
                          f"收盘跌破中枢下沿 {zs['zd']} 转看空, 持仓离场"]}
    # below_zs 或无中枢
    if bi_dir == "DOWN":
        return {"action": "等待观察(弱势)",
                "for_holder": "弱势结构, 反弹到中枢下沿附近减仓" if zs else "弱势结构, 反弹减仓",
                "for_watcher": "空仓等待, 不接下落中的刀",
                "stop_px": None,
                "watch": ["等底分型出现且下跌出现背驰(一买候选)再评估",
                          (f"收复中枢下沿 {zs['zd']} 之上才算转强" if zs else "站上前中枢区间才算转强")]}
    return {"action": "等待观察(反抽)",
            "for_holder": f"下跌后的反抽, 能否收复 {zs['zd'] if zs else '前低区间'} 是关键, 反抽无力则减仓",
            "for_watcher": "反抽不追, 等站稳或回落出背驰再说",
            "stop_px": None,
            "watch": [(f"放量收复 {zs['zd']} 并站稳看反转" if zs else "放量收复前中枢看反转"),
                      "反抽缩量衰竭则顺势回避"]}

def verdict_sentence(v):
    parts = [f"操作判定: {v['action']}"]
    parts.append(f"持仓者: {v['for_holder']}")
    parts.append(f"空仓者: {v['for_watcher']}")
    if v.get("stop_px") is not None:
        parts.append(f"关键价位: {v['stop_px']}")
    if v.get("watch"):
        parts.append("观察条件: " + "; ".join(v["watch"]))
    return "。".join(parts) + "。"

def make_summary(symbol, last_date, last_close, day_x, week_x, fresh, confluence, mas, ma_state):
    """确定性拼装成品结论句 — 弱模型可整句照抄, 保底平均水平输出"""
    s = {}
    # 日线一句话
    parts = []
    if day_x["bi"]:
        b = day_x["bi"][-1]
        parts.append(f"最近一笔{_DIR_TXT.get(b['dir'], b['dir'])}"
                     f"({b['b']}起, {'已确认' if b['sure'] else '未确认·当前帧'})")
    if day_x["zs"]:
        z = day_x["zs"][-1]
        parts.append(f"现价{last_close}位于最近中枢[{z['zd']}, {z['zg']}]的"
                     f"{_POS_TXT.get(day_x['pos_vs_last_zs'], '未知位置')}")
    if day_x["bsp"]:
        p = day_x["bsp"][-1]
        parts.append(f"最近{'买' if p['bs'] == 'B' else '卖'}点为{p['d']}的{p['type']}类"
                     f"({'已确认' if p['sure'] else '未确认'})")
    s["day"] = f"{symbol} 日线({last_date}): " + ("; ".join(parts) if parts else "结构要素不足")
    # 周线一句话
    wp = []
    if week_x["seg"]:
        g = week_x["seg"][-1]
        wp.append(f"当前线段{_DIR_TXT.get(g['dir'], g['dir'])}")
    if week_x["zs"]:
        z = week_x["zs"][-1]
        wp.append(f"周线中枢[{z['zd']}, {z['zg']}]")
    if week_x["bi"]:
        b = week_x["bi"][-1]
        wp.append(f"最近周线笔{_DIR_TXT.get(b['dir'], b['dir'])}")
    s["week"] = "周线: " + ("; ".join(wp) if wp else "结构要素不足(历史太短)")
    # 信号一句话
    if fresh:
        kinds = ", ".join(f"{b['d']}出现{b['type']}类{'买' if b['bs'] == 'B' else '卖'}点"
                          f"({'已确认' if b['sure'] else '未确认·次日可能消失'})" for b in fresh)
        s["signal"] = f"新鲜信号: {kinds}。属候选而非确认, 失效价位见 invalidations。"
    else:
        s["signal"] = "最近交易日无新鲜买卖点。"
    if confluence:
        s["signal"] += f" 周-日同向共振{len(confluence)}处(粗糙区间套)。"
    # 均线一句话
    if ma_state:
        m = []
        m.append("均线多头排列(5>20>60)" if ma_state["long"] else "均线非多头排列")
        if ma_state["entangled"]:
            m.append("5-20缠绕(乖离<2%, 变盘观察)")
        s["ma"] = "; ".join(m)
    return s

def load_csv(path):
    import csv as _csv
    rows = []
    with open(path, encoding="utf-8") as f:
        rd = _csv.DictReader(f)
        for r in rd:
            rows.append({"date": r["date"][:10], "open": float(r["open"]), "high": float(r["high"]),
                         "low": float(r["low"]), "close": float(r["close"]),
                         "volume": float(r.get("volume") or 0) or None,
                         "amount": float(r.get("amount") or 0) or None})
    return rows

def load_duckdb(db, symbol, start=None):
    import duckdb
    con = duckdb.connect(db, read_only=True)
    q = "SELECT date, open, high, low, close, volume, turnover FROM v_daily_qfq WHERE thscode = ?"
    if start:
        q += " AND date >= ?"
    q += " ORDER BY date"
    args = [symbol] + ([start] if start else [])
    rows = [{"date": str(r[0])[:10], "open": float(r[1]), "high": float(r[2]), "low": float(r[3]),
             "close": float(r[4]), "volume": float(r[5] or 0) or None, "amount": float(r[6] or 0) or None}
            for r in con.execute(q, args).fetchall()]
    con.close()
    return rows

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--symbol", required=True)
    ap.add_argument("--csv")
    ap.add_argument("--duckdb")
    ap.add_argument("--stdin-json", action="store_true")
    ap.add_argument("--start")
    ap.add_argument("--tail-days", type=int, default=2)
    ap.add_argument("--out", help="把JSON写到文件(缺省打到stdout)")
    a = ap.parse_args()
    if a.csv:
        rows = load_csv(a.csv)
    elif a.duckdb:
        rows = load_duckdb(a.duckdb, a.symbol, a.start)
    elif a.stdin_json:
        rows = json.load(sys.stdin)
    else:
        ap.error("需要 --csv / --duckdb / --stdin-json 之一")
    if len(rows) < 120:
        print(json.dumps({"error": f"K线不足120根({len(rows)}), 结构不可靠, 拒绝计算"}, ensure_ascii=False))
        sys.exit(1)
    result = json.dumps(run(a.symbol, rows, a.tail_days), ensure_ascii=False)
    if a.out:
        open(a.out, "w", encoding="utf-8").write(result)
        print(json.dumps({"written": a.out}, ensure_ascii=False))
    else:
        print(result)

if __name__ == "__main__":
    main()
```

## File: scripts/data_stock_names.csv
size: 125069
sha: ae1d674d315484f7c0c0974569a1111b6fe8b872
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/scripts/data_stock_names.csv

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/scripts/data_stock_names.csv

## File: scripts/get_data.py
size: 10898
sha: a5661f4039a4ec485f950a10fc42e2808b4cb29f
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/scripts/get_data.py

```text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
get_data.py — 取日K数据, 输出 CSV (date,open,high,low,close,volume,amount 前复权)
数据源两档:
  akshare  免费, 不需要任何账号和 key (默认, 装完技能即可用; pip install akshare)
  hithink  同花顺官方 Financial-API, 更快更稳 (需环境变量 HITHINK_FINANCE_API_KEY,
           申请方法见 references/getting-started.md: 用同花顺账号登录 fuyao.aicubes.cn/admin)
用法:
  python get_data.py --symbol 600519 [--years 3] [--out moutai.csv] [--source auto|akshare|hithink]
  --source auto(默认): 有 key 用 hithink, 没 key 用 akshare
代码格式随意: 600519 / 600519.SH / sh600519 都认(自动归一)。
"""
import argparse
import csv
import datetime
import json
import os
import re
import sys
import time
import urllib.parse
import urllib.request

if hasattr(sys.stdout, "reconfigure"):
    sys.stdout.reconfigure(encoding="utf-8")

def _load_key():
    k = os.environ.get("HITHINK_FINANCE_API_KEY")
    if k:
        return k
    base = os.environ.get("APPDATA") or os.path.expanduser("~/.config")
    p = os.path.join(base, "hithink-finance", "credentials.env")
    if os.path.exists(p):
        for line in open(p, encoding="utf-8"):
            if line.startswith("HITHINK_FINANCE_API_KEY_DPAPI="):
                return _dpapi_unprotect(line.split("=", 1)[1].strip())
            if line.startswith("HITHINK_FINANCE_API_KEY="):
                return line.split("=", 1)[1].strip()
    return None

def _dpapi_unprotect(b64):
    import base64
    import ctypes
    import ctypes.wintypes as wt

    class BLOB(ctypes.Structure):
        _fields_ = [("cbData", wt.DWORD), ("pbData", ctypes.POINTER(ctypes.c_char))]

    raw = base64.b64decode(b64)
    buf = ctypes.create_string_buffer(raw, len(raw))
    bin_ = BLOB(len(raw), ctypes.cast(buf, ctypes.POINTER(ctypes.c_char)))
    bout = BLOB()
    if not ctypes.windll.crypt32.CryptUnprotectData(
            ctypes.byref(bin_), None, None, None, None, 0, ctypes.byref(bout)):
        return None
    try:
        return ctypes.string_at(bout.pbData, bout.cbData).decode()
    finally:
        ctypes.windll.kernel32.LocalFree(bout.pbData)

KEY = _load_key()

def norm_code(s):
    """600519 / 600519.SH / sh600519 → (六位码, 带后缀码)"""
    s = s.strip().upper().replace("SH", "").replace("SZ", "").replace("BJ", "")
    digits = re.sub(r"\D", "", s)
    if len(digits) != 6:
        raise SystemExit(json.dumps({"error": f"无法识别股票代码: {s}, 请给6位数字代码"}, ensure_ascii=False))
    if digits.startswith(("60", "68")):
        suffix = "SH"
    elif digits.startswith(("00", "30")):
        suffix = "SZ"
    else:
        suffix = "BJ"
    return digits, f"{digits}.{suffix}"

def resolve_name(query):
    """股票名 → (六位码, 带后缀码, 权威名称)。
    解析顺序: ①打包名录(零网络,首选) ②同花顺搜索(有key,兜新股) ③akshare名录。
    蠢模型保底: 名称→代码这步必须由脚本确定性完成, 严禁模型凭记忆猜代码。"""
    table = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data_stock_names.csv")
    if os.path.exists(table):
        exact, part = [], []
        with open(table, encoding="utf-8") as f:
            next(f)
            for line in f:
                code_full, name = line.strip().split(",", 1)
                if name == query:
                    exact.append((code_full, name))
                elif query in name:
                    part.append((code_full, name))
        pick = exact or part
        if len(pick) == 1:
            full, name = pick[0]
            return full.split(".")[0], full, name
        if len(pick) > 1:
            raise SystemExit(json.dumps({"error": f"「{query}」匹配到多只股票, 请让用户确认要哪只",
                "candidates": [f"{c} {n}" for c, n in pick[:5]]}, ensure_ascii=False))
        # 名录没有(可能是新股) → 继续走在线解析
    if KEY:
        q = urllib.parse.urlencode({"q": query})
        req = urllib.request.Request(f"https://fuyao.aicubes.cn/api/meta/tickers/search?{q}",
                                     headers={"X-api-key": KEY})
        try:
            b = json.loads(urllib.request.urlopen(req, timeout=20).read())
            items = (b.get("data") or {}).get("item") or []
            exact = [i for i in items if i.get("name") == query]
            pick = (exact or items)
            if len(pick) > 1 and not exact:
                raise SystemExit(json.dumps({"error": f"「{query}」匹配到多只股票, 请让用户确认",
                    "candidates": [f"{i.get('thscode')} {i.get('name')}" for i in pick[:5]]}, ensure_ascii=False))
            if pick:
                full = pick[0]["thscode"]
                return full.split(".")[0], full, pick[0].get("name", query)
        except SystemExit:
            raise
        except Exception:
            pass  # 搜索失败退回akshare名录
    import akshare as ak
    df = ak.stock_info_a_code_name()
    exact = df[df["name"] == query]
    if exact.empty:
        part = df[df["name"].str.contains(query, na=False)]
        if part.empty:
            raise SystemExit(json.dumps({"error": f"找不到股票「{query}」, 请确认名称或直接给6位代码"},
                                        ensure_ascii=False))
        if len(part) > 1:
            raise SystemExit(json.dumps({"error": f"「{query}」匹配到多只股票, 请让用户确认",
                "candidates": [f"{r['code']} {r['name']}" for _, r in part.head(5).iterrows()]},
                ensure_ascii=False))
        exact = part
    code6 = str(exact.iloc[0]["code"]).zfill(6)
    _, full = norm_code(code6)
    return code6, full, str(exact.iloc[0]["name"])

def fetch_akshare(code6, years):
    """免费源, 双通道: 东财(主) → 新浪(备)。东财对部分网络环境(尤其海外IP)会断连。"""
    import akshare as ak
    start_d = datetime.date.today() - datetime.timedelta(days=int(years * 365))
    last_err = None
    for attempt in range(2):                      # 东财两次
        try:
            df = ak.stock_zh_a_hist(symbol=code6, period="daily",
                                    start_date=start_d.strftime("%Y%m%d"),
                                    end_date=datetime.date.today().strftime("%Y%m%d"),
                                    adjust="qfq")
            if df is not None and not df.empty:
                return [{"date": str(r["日期"])[:10], "open": float(r["开盘"]),
                         "high": float(r["最高"]), "low": float(r["最低"]),
                         "close": float(r["收盘"]), "volume": float(r["成交量"]),
                         "amount": float(r["成交额"])} for _, r in df.iterrows()]
        except Exception as e:
            last_err = e
            time.sleep(2)
    try:                                          # 新浪备用
        prefix = "sh" if code6.startswith(("60", "68")) else ("sz" if code6.startswith(("00", "30")) else "bj")
        df = ak.stock_zh_a_daily(symbol=f"{prefix}{code6}", adjust="qfq",
                                 start_date=start_d.strftime("%Y%m%d"),
                                 end_date=datetime.date.today().strftime("%Y%m%d"))
        if df is not None and not df.empty:
            rows = []
            for _, r in df.iterrows():
                rows.append({"date": str(r["date"])[:10], "open": float(r["open"]),
                             "high": float(r["high"]), "low": float(r["low"]),
                             "close": float(r["close"]), "volume": float(r["volume"]),
                             "amount": float(r["amount"]) if "amount" in df.columns else None})
            return rows
    except Exception as e:
        last_err = e
    raise SystemExit(json.dumps({
        "error": f"免费数据源都连不上({type(last_err).__name__}), 常见于网络环境限制",
        "hint": "稍后重试; 或申请同花顺key走官方源(见references/getting-started.md); 有代理时关掉代理再试"},
        ensure_ascii=False))

def fetch_hithink(code_full, years):
    end = int(time.time() * 1000)
    start = end - 86400_000 * int(years * 365)
    q = urllib.parse.urlencode({"thscode": code_full, "interval": "1d",
                                "adjust": "forward", "start": start, "end": end})
    req = urllib.request.Request(
        f"https://fuyao.aicubes.cn/api/a-share/prices/historical?{q}",
        headers={"X-api-key": KEY})
    b = json.loads(urllib.request.urlopen(req, timeout=60).read())
    if b.get("code") != 0:
        raise SystemExit(json.dumps({"error": f"同花顺接口返回 code={b.get('code')} {b.get('message')}",
                                     "hint": "key 无效或过期时, 重新去 fuyao.aicubes.cn/admin 签发"},
                                    ensure_ascii=False))
    rows = []
    for it in b["data"]["item"]:
        d = datetime.datetime.fromtimestamp(it["date_ms"] / 1000).strftime("%Y-%m-%d")
        rows.append({"date": d, "open": it["open_price"], "high": it["high_price"],
                     "low": it["low_price"], "close": it["close_price"],
                     "volume": it["volume"], "amount": it["turnover"]})
    return rows

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--symbol", required=True)
    ap.add_argument("--years", type=float, default=3)
    ap.add_argument("--out", help="输出CSV路径, 缺省打到stdout")
    ap.add_argument("--source", choices=["auto", "akshare", "hithink"], default="auto")
    a = ap.parse_args()
    if re.search(r"[^0-9A-Za-z.\s]", a.symbol):        # 含中文等 → 名称解析
        code6, code_full, name = resolve_name(a.symbol.strip())
    else:
        code6, code_full = norm_code(a.symbol)
        name = None

    src = a.source
    if src == "auto":
        src = "hithink" if KEY else "akshare"
    if src == "hithink" and not KEY:
        raise SystemExit(json.dumps({"error": "缺 HITHINK_FINANCE_API_KEY",
                                     "hint": "申请方法见 references/getting-started.md, 或改用 --source akshare"},
                                    ensure_ascii=False))
    rows = fetch_hithink(code_full, a.years) if src == "hithink" else fetch_akshare(code6, a.years)

    f = open(a.out, "w", newline="", encoding="utf-8") if a.out else sys.stdout
    w = csv.writer(f)
    w.writerow(["date", "open", "high", "low", "close", "volume", "amount"])
    for r in rows:
        w.writerow([r["date"], r["open"], r["high"], r["low"], r["close"], r["volume"], r["amount"]])
    if a.out:
        f.close()
        print(json.dumps({"written": a.out, "bars": len(rows), "source": src,
                          "symbol": code_full, "name": name}, ensure_ascii=False))

if __name__ == "__main__":
    main()
```

## File: scripts/make_testdata.py
size: 891
sha: 45931a1b310ccdc8de2f1b743088751cf849ed13
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/scripts/make_testdata.py

```text
#!/usr/bin/env python3
"""生成合成日K testdata.csv (600根, 趋势+回调+噪声, 可形成完整缠论结构) — 无真实数据时自测用"""
import math, random, datetime, sys
random.seed(42)
rows = ["date,open,high,low,close,volume"]
price, d, n = 10.0, datetime.date(2024, 1, 2), 0
while n < 600:
    if d.weekday() < 5:
        drift = 0.004 * math.sin(n / 40.0) + (0.002 if (n // 120) % 2 == 0 else -0.0015)
        ret = drift + random.gauss(0, 0.018)
        o = price; c = max(0.5, price * (1 + ret))
        h = max(o, c) * (1 + abs(random.gauss(0, 0.006)))
        l = min(o, c) * (1 - abs(random.gauss(0, 0.006)))
        rows.append(f"{d.isoformat()},{o:.2f},{h:.2f},{l:.2f},{c:.2f},{random.randint(100000,900000)}")
        price = c; n += 1
    d += datetime.timedelta(days=1)
open("testdata.csv", "w").write("\n".join(rows))
print(f"testdata.csv written ({n} bars)")
```

## File: scripts/scan_market.py
size: 5175
sha: da3bccc71e517aaf0998efab2f3b1081c0265d6d
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/scripts/scan_market.py

```text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
scan_market.py — L0-L1 全市场缠论结构扫描 (选股漏斗前两层, 纯代码层)
L0: marketdb v_daily_qfq 全A, 剔ST(名称含ST)/上市不足min-bars/近端停牌
L1: 每股 chan_engine.run() 全量计算, 收集"最近 tail-days 根K内出现买卖点"的候选
输出: scan_YYYYMMDD.json {meta, candidates:[{symbol,name,fresh_bsp,pos,ma,invalidations,week_confluence}], stats}
用法:
  python scan_market.py --duckdb data/market.duckdb [--workers 4] [--limit 0] [--out dir]
说明: 结构扫描不做情绪预筛(22ms/股便宜到不需要省), 情绪/资金标签在 L2(fupan_fetch 数据)交叉时再加。
"""
import argparse
import json
import os
import sys
import time
from concurrent.futures import ProcessPoolExecutor
from datetime import date

if hasattr(sys.stdout, "reconfigure"):
    sys.stdout.reconfigure(encoding="utf-8")

_HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, _HERE)

def list_universe(db, min_bars):
    import duckdb
    con = duckdb.connect(db, read_only=True)
    rows = con.execute("""
        SELECT k.thscode, COALESCE(s.name,''), COUNT(*) AS n, MAX(k.date) AS last_d
        FROM v_daily_qfq k LEFT JOIN v_symbol s ON s.thscode = k.thscode
        GROUP BY 1, 2
    """).fetchall()
    latest = max(r[3] for r in rows) if rows else None
    uni = []
    for code, name, n, last_d in rows:
        if n < min_bars:
            continue                       # 上市太短
        if "ST" in (name or "").upper():
            continue                       # 剔ST
        if last_d != latest:
            continue                       # 近端无K=停牌/退市
        uni.append((code, name))
    con.close()
    return uni, str(latest)[:10] if latest else None

def _scan_one(args):
    code, name, db, start, tail_days = args
    try:
        from chan_engine import load_duckdb, run
        rows = load_duckdb(db, code, start)
        if len(rows) < 120:
            return None
        out = run(code, rows, tail_days)
        fresh = out["signals"]["fresh_bsp"]
        if not fresh:
            return None
        return {
            "symbol": code, "name": name, "asof": out["meta"]["asof"],
            "fresh_bsp": fresh,
            "pos_vs_last_zs": out["day"]["pos_vs_last_zs"],
            "last_zs": out["day"]["zs"][-1] if out["day"]["zs"] else None,
            "ma_state": out["ma"]["state"],
            "week_confluence": bool(out["signals"]["week_day_confluence"]),
            "invalidations": out["invalidations"],
        }
    except Exception as e:  # 单股失败不拖垮全扫
        return {"symbol": code, "error": str(e)[:200]}

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--duckdb", required=True)
    ap.add_argument("--workers", type=int, default=max(1, (os.cpu_count() or 4) - 2))
    ap.add_argument("--min-bars", type=int, default=120)
    ap.add_argument("--start", default=None, help="加速: 只取该日期后的K, 默认全部(建议3年)")
    ap.add_argument("--tail-days", type=int, default=2)
    ap.add_argument("--limit", type=int, default=0, help="调试: 只扫前N只")
    ap.add_argument("--out", default=".")
    a = ap.parse_args()

    t0 = time.time()
    uni, asof = list_universe(a.duckdb, a.min_bars)
    if a.limit:
        uni = uni[: a.limit]
    tasks = [(c, n, a.duckdb, a.start, a.tail_days) for c, n in uni]

    results, errors = [], []
    if a.workers <= 1:
        it = map(_scan_one, tasks)
    else:
        ex = ProcessPoolExecutor(max_workers=a.workers)
        it = ex.map(_scan_one, tasks, chunksize=64)
    for r in it:
        if r is None:
            continue
        (errors if "error" in r else results).append(r)

    # 排序: 周日共振 > 买点类型(1>2>3) > 有失效价位的
    def rank(c):
        types = "".join(b["type"] for b in c["fresh_bsp"])
        t_rank = 0 if "1" in types else (1 if "2" in types else 2)
        return (not c["week_confluence"], t_rank)
    results.sort(key=rank)

    out = {
        "meta": {"asof": asof, "universe": len(uni), "scanned": len(tasks),
                 "elapsed_s": round(time.time() - t0, 1), "engine": "chan_engine/chanlun_structure_v1",
                 "note": "候选=最近tail_days根K出现bsp, 全部是'当前帧'候选非确认信号"},
        "candidates": results,
        "stats": {
            "n_candidates": len(results),
            "n_errors": len(errors),
            "by_type": _count_types(results),
        },
        "errors": errors[:20],
    }
    tag = (asof or str(date.today())).replace("-", "")
    path = os.path.join(a.out, f"scan_{tag}.json")
    with open(path, "w", encoding="utf-8") as f:
        json.dump(out, f, ensure_ascii=False)
    print(json.dumps({"written": path, **out["meta"], **out["stats"]}, ensure_ascii=False))

def _count_types(results):
    cnt = {}
    for c in results:
        for b in c["fresh_bsp"]:
            for t in b["type"].split(","):
                key = ("buy_" if b["bs"] == "B" else "sell_") + t.strip()
                cnt[key] = cnt.get(key, 0) + 1
    return cnt

if __name__ == "__main__":
    main()
```

## File: scripts/setup_env.py
size: 5265
sha: 95590a60f254821f231c0d1995566a26b5a73805
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/scripts/setup_env.py

```text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
setup_env.py — 环境自检与分层安装 (给 AI 助手替用户跑的, 报错文案写给普通人看)
分层:
  核心层   零第三方依赖: 缠论计算引擎已打包在本技能内, 有 Python 3.11+ 就能跑 (CSV 输入)
  推荐层   --recommended: 装 akshare (免费行情, 不需要任何账号, 装完即可分析任意A股)
  完整层   --full: 再装 duckdb (同花顺全市场本地库, 全市场扫描用)
用法:
  python setup_env.py              # 只自检, 报告缺什么
  python setup_env.py --recommended
  python setup_env.py --full
  python setup_env.py --set-key    # 本地录入同花顺数据钥匙(输入不回显, 不经过AI对话)
pip 自动走清华镜像, 国内外网络都能装。
"""
import importlib.util
import os
import json
import subprocess
import sys

if hasattr(sys.stdout, "reconfigure"):
    sys.stdout.reconfigure(encoding="utf-8")

MIRROR = ["-i", "https://pypi.tuna.tsinghua.edu.cn/simple"]

def has(mod):
    return importlib.util.find_spec(mod) is not None

def pip_install(*pkgs):
    cmd = [sys.executable, "-m", "pip", "install", "-q", *pkgs, *MIRROR]
    r = subprocess.run(cmd, capture_output=True, text=True)
    if r.returncode != 0:
        # 镜像失败退回官方源再试一次
        r = subprocess.run([sys.executable, "-m", "pip", "install", "-q", *pkgs],
                           capture_output=True, text=True)
    return r.returncode == 0, (r.stderr or "")[-300:]

def cred_path():
    base = os.environ.get("APPDATA") or os.path.expanduser("~/.config")
    return os.path.join(base, "hithink-finance", "credentials.env")

def _dpapi_protect(data):
    """Windows 用户级 DPAPI 加密(仅本机本用户可解), 纯 ctypes 零依赖"""
    import base64
    import ctypes
    import ctypes.wintypes as wt

    class BLOB(ctypes.Structure):
        _fields_ = [("cbData", wt.DWORD), ("pbData", ctypes.POINTER(ctypes.c_char))]

    buf = ctypes.create_string_buffer(data, len(data))
    bin_ = BLOB(len(data), ctypes.cast(buf, ctypes.POINTER(ctypes.c_char)))
    bout = BLOB()
    if not ctypes.windll.crypt32.CryptProtectData(
            ctypes.byref(bin_), None, None, None, None, 0, ctypes.byref(bout)):
        raise OSError("DPAPI 加密失败")
    try:
        return base64.b64encode(ctypes.string_at(bout.pbData, bout.cbData)).decode()
    finally:
        ctypes.windll.kernel32.LocalFree(bout.pbData)

def set_key():
    """钥匙只在本地终端录入并落本地文件, 绝不经过AI对话记录"""
    if sys.stdin.isatty():
        import getpass
        key = getpass.getpass("粘贴你的同花顺数据钥匙(以 sk-fuyao- 开头, 输入不显示), 回车确认: ").strip()
    else:
        key = sys.stdin.readline().strip()
    if not key.startswith("sk-"):
        print(json.dumps({"error": "格式不像有效钥匙(应以 sk- 开头), 未保存"}, ensure_ascii=False))
        sys.exit(1)
    p = cred_path()
    os.makedirs(os.path.dirname(p), exist_ok=True)
    if os.name == "nt":
        line = "HITHINK_FINANCE_API_KEY_DPAPI=" + _dpapi_protect(key.encode()) + "\n"
        how = "DPAPI 加密(仅本机本用户可解)"
    else:
        line = "HITHINK_FINANCE_API_KEY=" + key + "\n"
        how = "文件权限600"
    with open(p, "w", encoding="utf-8") as f:
        f.write(line)
    if os.name != "nt":
        os.chmod(p, 0o600)
    print(json.dumps({"saved": p, "protection": how,
                      "message": "钥匙已存本机, 之后取数自动使用官方源"}, ensure_ascii=False))

def main():
    if "--set-key" in sys.argv:
        set_key()
        return
    report = {"python": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"}

    if sys.version_info < (3, 11):
        report["status"] = "python_too_old"
        report["message"] = ("本机 Python 版本是 " + report["python"] +
                             "，缠论引擎需要 3.11 或更新。对你的 AI 助手说：帮我安装 Python 3.11，它会带你装好。")
        print(json.dumps(report, ensure_ascii=False))
        sys.exit(1)

    report["core"] = "就绪(引擎已随技能打包, 无需安装)"
    report["akshare"] = "已装" if has("akshare") else "未装(免费行情源, 推荐)"
    report["duckdb"] = "已装" if has("duckdb") else "未装(仅全市场扫描需要, 可不装)"

    want = []
    if "--recommended" in sys.argv or "--full" in sys.argv:
        if not has("akshare"):
            want.append("akshare")
    if "--full" in sys.argv and not has("duckdb"):
        want.append("duckdb==1.3.2")

    for pkg in want:
        ok, err = pip_install(pkg)
        key = pkg.split("==")[0]
        report[key] = "安装成功" if ok else f"安装失败: {err}"
        if not ok:
            report["message"] = f"{key} 没装上，把这条结果原样发给你的 AI 助手，它会处理。"

    report.setdefault("status", "ok")
    if report["status"] == "ok" and not want:
        report["message"] = "环境就绪。" + ("" if has("akshare") else
                            "想直接分析A股行情, 跑: python setup_env.py --recommended")
    print(json.dumps(report, ensure_ascii=False))

if __name__ == "__main__":
    main()
```

## File: scripts/visualize.py
size: 4776
sha: f9393d7f0a15f2a449f2a600e1b5f98f57db1804
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/scripts/visualize.py

```text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
visualize.py — 把缠论结构画在K线上 (自包含HTML/SVG, 零依赖, 供人工核对与展示)
用法: python visualize.py --symbol 600519.SH --csv k.csv [--out chart.html] [--bars 250]
画: 蜡烛图 + 笔(折线) + 中枢(矩形带ZG/ZD) + 买卖点(标记) + 标题带操作判定
"""
import argparse
import html
import json
import os
import sys

if hasattr(sys.stdout, "reconfigure"):
    sys.stdout.reconfigure(encoding="utf-8")
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from chan_engine import load_csv, run  # noqa: E402

W, H, PAD_T, PAD_B, PAD_L, PAD_R = 1180, 560, 56, 28, 10, 64

def build_svg(symbol, rows, out):
    n = len(rows)
    x_of = {r["date"]: PAD_L + (W - PAD_L - PAD_R) * (i + 0.5) / n for i, r in enumerate(rows)}
    lo = min(r["low"] for r in rows)
    hi = max(r["high"] for r in rows)
    span = (hi - lo) or 1

    def y_of(p):
        return PAD_T + (H - PAD_T - PAD_B) * (hi - p) / span

    bw = max(1.2, (W - PAD_L - PAD_R) / n * 0.62)
    s = []
    # 中枢矩形(先画在底层)
    for z in out["day"]["zs"]:
        if z["e"] < rows[0]["date"]:
            continue
        x1 = x_of.get(z["b"], PAD_L)
        x2 = x_of.get(z["e"], W - PAD_R)
        y1, y2 = y_of(z["zg"]), y_of(z["zd"])
        dash = "" if z["sure"] else ' stroke-dasharray="5 4"'
        s.append(f'<rect x="{x1:.1f}" y="{y1:.1f}" width="{x2-x1:.1f}" height="{y2-y1:.1f}" '
                 f'fill="#1e3a8a12" stroke="#1e3a8a" stroke-width="1.2"{dash}/>')
        s.append(f'<text x="{x2+4:.1f}" y="{y1+4:.1f}" font-size="10" fill="#1e3a8a">ZG {z["zg"]}</text>')
        s.append(f'<text x="{x2+4:.1f}" y="{y2+4:.1f}" font-size="10" fill="#1e3a8a">ZD {z["zd"]}</text>')
    # 蜡烛
    for r in rows:
        x = x_of[r["date"]]
        up = r["close"] >= r["open"]
        c = "#c0392b" if up else "#16794c"          # A股红涨绿跌
        s.append(f'<line x1="{x:.1f}" y1="{y_of(r["high"]):.1f}" x2="{x:.1f}" '
                 f'y2="{y_of(r["low"]):.1f}" stroke="{c}" stroke-width="1"/>')
        yo, yc = y_of(r["open"]), y_of(r["close"])
        y1, hgt = min(yo, yc), max(abs(yc - yo), 0.8)
        fill = c if not up else "#fff"
        s.append(f'<rect x="{x-bw/2:.1f}" y="{y1:.1f}" width="{bw:.1f}" height="{hgt:.1f}" '
                 f'fill="{fill}" stroke="{c}" stroke-width="1"/>')
    # 笔折线
    pts = []
    for b in out["day"]["bi"]:
        if b["b"] in x_of and not pts:
            pts.append((x_of[b["b"]], y_of(b["bv"])))
        if b["e"] in x_of:
            pts.append((x_of[b["e"]], y_of(b["ev"])))
    if len(pts) > 1:
        d = " ".join(f'{x:.1f},{y:.1f}' for x, y in pts)
        s.append(f'<polyline points="{d}" fill="none" stroke="#0b0f1a" stroke-width="2" opacity=".85"/>')
    # 买卖点标记
    for p in out["day"]["bsp"]:
        if p["d"] not in x_of:
            continue
        x, y = x_of[p["d"]], y_of(p["px"])
        buy = p["bs"] == "B"
        col = "#c0392b" if buy else "#16794c"
        dy = 16 if buy else -10
        s.append(f'<circle cx="{x:.1f}" cy="{y:.1f}" r="3.5" fill="{col}"/>')
        s.append(f'<text x="{x:.1f}" y="{y+dy:.1f}" font-size="11" font-weight="700" '
                 f'text-anchor="middle" fill="{col}">{"B" if buy else "S"}{p["type"]}'
                 f'{"" if p["sure"] else "?"}</text>')
    verdict = html.escape(out["verdict"]["action"])
    title = (f'{html.escape(symbol)} · 缠论结构 · {out["meta"]["asof"]} · 判定: {verdict}'
             f'（虚线中枢/带?买卖点=未确认）')
    return (f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {W} {H}" '
            f'style="max-width:100%;background:#fafbfc">'
            f'<text x="{PAD_L}" y="24" font-size="15" font-weight="700" fill="#0b0f1a">{title}</text>'
            + "".join(s) + "</svg>")

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--symbol", required=True)
    ap.add_argument("--csv", required=True)
    ap.add_argument("--out")
    ap.add_argument("--bars", type=int, default=250)
    a = ap.parse_args()
    rows_all = load_csv(a.csv)
    out = run(a.symbol, rows_all)
    rows = rows_all[-a.bars:]
    svg = build_svg(a.symbol, rows, out)
    page = (f'<!doctype html><meta charset="utf-8"><title>{html.escape(a.symbol)} 缠论结构</title>'
            f'<body style="margin:16px;font-family:sans-serif">{svg}'
            f'<p style="font-size:13px;color:#626b7d;max-width:1100px">{html.escape(out["summary"]["verdict"])}</p></body>')
    path = a.out or f'chan_{a.symbol.replace(".", "_")}.html'
    open(path, "w", encoding="utf-8").write(page)
    print(json.dumps({"written": path, "bars": len(rows)}, ensure_ascii=False))

if __name__ == "__main__":
    main()
```

## File: references/chanlun-core.md
size: 5072
sha: 5825ab2c4f7b140ab2067af67ed0fc6db2250791
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/references/chanlun-core.md

```text
# 缠论理论核心 · 完备性16项清单（全部锚定原文课号）

> 原文语料：缠中说禅《教你炒股票》108课（2006-06-07 第1课 → 2008-08-29 第108课）。
> 最全 Markdown 版本：[stockServ/chzhshch-108-plus](https://github.com/stockServ/chzhshch-108-plus)
> ，唯一把**课后回复**（缠论补丁的主要载体）整理进 md 的仓库，含疑似缠师回复标注。
> 全博文档案（1135篇含解盘）：[chzhshch.blog](https://chzhshch.blog/)（/stocks/001~108）。
> 缠师李彪 2008-10-31 去世，理论动力学部分未写完（第104课"几何结构与能量动力结构1"无后续），任何实现声称100%还原都不可信，本技能明示为近似（structure_proxy）。

## 16项清单（引擎覆盖标注）

| # | 概念 | 定义要点 | 出处课号 | 本引擎 |
|---|------|---------|---------|--------|
| 1 | K线包含处理 | 相邻互含合并：向上取高高/低高，向下反之；分型判断前必做 | 62、65 | ✅ |
| 2 | 分型 | 顶分型=处理后第二根高点低点均为三根最高；强弱与心理 | 62、79、81、82 | ✅ |
| 3 | 笔 | 老笔：顶底分型不共用K且之间≥1根独立K（62/65/77课）；**新笔**：放宽为"不共用K+顶最高K与底最低K之间不计包含≥3根K"，出自缠师本人2007-09-18《忽闻台风可休市》博文正文，不在108课内 | 62、65、77、台风帖 | ✅ 老笔(bi_strict) |
| 4 | 线段 | ≥3笔且前3笔重叠；特征序列分型；第一种破坏(无缺口)/第二种破坏(有缺口须反向确认)。**社区最大分歧点**：严格特征序列派/1+1终结派/线段破坏派 | 65、67、71、78 | ✅ 特征序列(seg_algo=chan) |
| 5 | 中枢 | 某级别走势中被≥3个连续次级别走势重叠的部分；延伸(≤9段)/扩展/扩张/新生 | 17、20、35 | ✅ 段内中枢(笔段分形派近似) |
| 6 | 走势类型 | 盘整=1中枢；趋势=≥2同向不重叠中枢；分解定理一/二 | 17、35 | ✅ 近似(线段级segseg/segzs) |
| 7 | 级别与递归 | 级别由递归定义产生≠K线周期；原文递归起点是"每笔交易" | 35、77 | ⚠️ 近似：日-周两层 |
| 8 | 同级别分解 | 按同级别买卖点之间的连接操作 | 38、39、40 | ❌ 只做叙述提示 |
| 9 | 背驰 | 趋势背驰(第二中枢后离开段力度弱于进入段)/盘整背驰(a+A+b中b弱于a)；MACD仅"辅助判断" | 15、24、25、27、37、43 | ✅ MACD peak量化近似(声明) |
| 10 | 区间套 | 多级别逐级收缩精确定位背驰点 | 27、29、61 | ⚠️ 周-日两层粗糙版+声明 |
| 11 | 三类买卖点 | 1买=趋势背驰转折点(17)；2买=1买后首次次级别回调低点(53)；3买=次级别离开中枢后回抽不回(20)；完备性(21)；2/3重合与小转大时2买最佳(53) | 17、20、21、53 | ✅ 6类(1,1p,2,2s,3a,3b) |
| 12 | 小转大 | 背驰级别小于当下走势级别→小背驰引发大转折 | 43、44 | ❌ 叙述提示 |
| 13 | 走势必完美 | 任何级别走势类型终要走完自己的结构 | 17、102 | ✅ 引擎隐含 |
| 14 | 中阴阶段 | 一类买卖点后级别归属未明的阶段；结束时间辅助判断 | 89、90 | ❌ 叙述提示(不确定性申明的理论依据) |
| 15 | 当下判断与操作 | 反对预测崇拜(5/32/68)；资金管理(31)；持股持币(45)；利润率最大操作(49)；每日走势分类(46,复盘直接可用)；机械化操作(105) | 5、31、32、45、46、49、68、105 | 解读层 |
| 16 | 均线系统 | 缠绕与"吻"(飞吻/唇吻/湿吻,11-14)；均线面积力度(15)；中小资金高效买卖法(16)；轮动强弱指标(106) | 11-16、106 | ✅ 部分(ma状态)，日K-only下唯一可完整落地的原文体系 |

## 开源实现的通病（选型时的坑）

1. **线段三派分裂**：chan.py 提供三种算法可选（chan/1+1/break，后两种已弃用）；czsc 1.0 核心干脆不做线段（作者立场：以笔为a0，"5分钟笔等价1分钟线段"）
2. **中枢递归妥协**：原文中枢由"次级别走势类型"重叠构成（35课递归定义），几乎所有实现用笔/段直接替代（笔段分形派），本引擎同此，已声明
3. **背驰被量化取代力度原义**：原文背驰=力度比较无量化定义，MACD 仅辅助（24课标题自明）；实现普遍把 MACD 面积/峰值当定义本身
4. **区间套几乎无人真做**：需多级别联立递归到分钟级
5. **数据源决定上限**：递归起点从某K线周期起步已是妥协；日K-only 场景只能做日-周-月粗糙三层

## 为什么"心算缠论"被禁止（证据）

- 两套确定性脚本引擎（自写v5t vs chan.py）同数据对拍：笔对齐率 0.87-1.0，**中枢对齐率仅 0.0-0.42**，买卖点数量差数倍
- 社区 8 个缠论 Agent skill 中 6 个认真实现（含 czsc 作者本人的官方 skill）全部走"脚本算结构"路线；唯一纯 LLM 裸算的实现自曝"背驰判断取决于你选哪个高点，这是判断问题"
- 结构对口径极敏感 → LLM 心算=第三套随温度漂移、不可复现的口径
```

## File: references/engine-notes.md
size: 3441
sha: a971ae8974fb17d097581403a52ba2eca4aec6e3
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/references/engine-notes.md

````text
# 引擎口径与配置说明（chan.py 内核）

## 选型定案（2026-08-24 调研，四维横评）

| 引擎 | 理论覆盖(16项) | 集成 | 判决 |
|---|---|---|---|
| **chan.py (Vespa314)** | ≈11/16：笔/线段(特征序列)/中枢/6类买卖点/12种背驰算法/多级别联立 | MIT、纯Python≥3.11、核心零第三方依赖、单股1500根22ms | ✅ 主引擎，vendor 钉 commit `429d6ed` |
| czsc 1.0.x | ≈5/16：分型/笔/笔中枢+信号函数，**无线段对象**(作者立场) | pip即装但核心在Rust二进制不可读 | 备选/对拍用，不进主流水线 |
| chanlun-pro | 全但核心 cl.py 需付费授权文件 | GitHub 的 Apache-2.0 名不副实 | ❌ 排除 |
| 自写 | 对拍成本极高(中枢对齐率实证0.0-0.42) | — | ❌ 排除 |

chan.py 注意：README 按作者2.2万行私有完整版写的，开源版约5300行，**以 quick_guide.md 为准**；
上游 2026-06-25 后静默，vendor+钉commit，遇 bug 自行 patch（MIT 允许）。

## 配置陷阱（README 默认值不可信，已在 chan_engine.py 全部显式钉死）

| 参数 | README说 | 代码实际 | 本引擎钉死值 |
|---|---|---|---|
| `divergence_rate` | 0.9 | **inf = 根本不判背驰** | 0.9 |
| `gap_as_kl` | True | False | False |
| `max_bs2_rate` | — | 0.9999 | 0.618 |
| `min_zs_cnt` | — | — | 1 |
| `macd_algo` | — | peak | peak（24课"辅助判断"本义） |

配置指纹：输出 JSON 的 `meta.config_hash` 是配置的 md5 前8位，对拍/回归时先核对它。

## chanlun_structure_v1 字段明细

```
meta:    symbol / asof / bars_day / engine(chan.py@commit) / config_hash / stance=structure_proxy
day,week:
  bi[]:  i(序号) dir(UP/DOWN) sure b/e(起止日) bv/ev(起止价)
  seg[]: i dir sure b/e zs_n(段内中枢数)
  zs[]:  b/e sure zg/zd(中枢上下沿) gg/dd(峰值) bi_n
  bsp[]: d(日期) bs(B/S) type(1,1p,2,2s,3a,3b可组合) px sure
  pos_vs_last_zs: above_zs / in_zs / below_zs
ma:      values(ma5/10/20/60) state{long:多头排列, entangled:缠绕(5-20乖离<2%, 11-14课"吻"近似)}
signals: fresh_bsp(最近tail_days根K的bsp=选股信号) / week_day_confluence(周日同向bsp时间窗≤40天)
         / actionable_date(防前视声明)
invalidations[]: 每个fresh_bsp的失效规则+价位数值（3买→跌回ZG失效；1买→跌破当日低点；2买→跌破dd）
caveats: 口径声明四条（报告必须保留要点）
```

## 数据要求

- 前复权日K（复权在数据侧完成，引擎 autype=NONE 不再复权）；除权除息后历史结构会整体漂移，复盘对比要意识到
- ≥120 根拒绝计算（结构不可靠）；建议 ≥500 根（2年）
- 周K由日K按 ISO 周合成（引擎内部完成，无需另备周K）

## 性能基准（实测）

单股 600 根日K 双级别全量 ≈10ms；1500 根 22ms；全市场 5000 股单进程 ≈2 分钟，
`scan_market.py --workers N` 可并行。扫描哲学：**结构扫描便宜到不需要预筛**，全市场直接扫。

## 贡献指南（欢迎 PR 的方向）

- 新笔(台风帖口径)支持：`bi_algo` 配置暴露与对拍报告
- 线段口径对拍：chan vs 1+1 vs break 三算法在真实A股数据上的差异统计
- 中枢延伸/扩展(20课)的显式标注
- czsc 对拍脚本（validation/：理论不变量破坏=硬错误；数量差异=口径差异不算bug）
- 均线系统完整版：面积力度(15课)、三类吻(11-14课)的显式检测
````

## File: references/getting-started.md
size: 2656
sha: d76ca6ba5731a56774dd238689566dd4123bb2bb
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/references/getting-started.md

````text
# 新手三步上手指南

不需要懂编程，不需要知道"API"是什么。整个准备工作就是：用同花顺账号登录一个网页，复制一串字符。

## 第一步：拿数据钥匙（免费，大约 2 分钟）

分析股票需要行情数据，数据来自同花顺官方，用一把"钥匙"来取。申请方法：

1. 打开网页 [fuyao.aicubes.cn/admin](https://fuyao.aicubes.cn/admin)
2. 用你的**同花顺账号**登录（就是你手机上看行情用的那个同花顺 App 的账号；没有的话下载同花顺 App 注册一个）
3. 登录后点「签发 / 创建 API Key」
4. 复制出现的那串以 `sk-fuyao-` 开头的字符。这就是你的数据钥匙，只显示一次，先存在备忘录里，不要发给别人

三个常见疑问：

- **收费吗？** 目前免费。
- **安全吗？** 这把钥匙只能读取行情数据（K线、涨跌停这些公开信息），碰不到你的股票账户，更碰不到钱。不想用了随时回那个网页作废它。
- **和我的炒股账户有关系吗？** 没有任何关系，它不知道你持仓什么，也下不了单。

## 第二步：把钥匙交给 AI 存好

最省事的方式：**直接把钥匙发给你的 AI 助手**，说一句"帮我存好这个数据钥匙"。它会立即把钥匙加密存进你本机（Windows 用系统级加密，只有你这台电脑的你能解开），存好后你可以删掉聊天里那条消息；不放心随时回申请网页作废重签一把。

介意钥匙出现在聊天记录里的话，也可以自己在终端录入（输入过程不显示任何字符）：

```
python scripts/setup_env.py --set-key
```

两种方式效果相同，之后取数自动走官方源。

## 第三步：开始分析

对 AI 说：

> 帮我用缠论分析贵州茅台

你会得到一份包含四样东西的分析：

1. **操作判定**：现在是买入候选、持有、卖出减仓，还是等待观察
2. **持仓者和空仓者分开的建议**：手里有票和没票的人，动作不一样
3. **关键价位**：止损或失效价位，到了这个价就是判断错了，认错离场
4. **观察条件**：如果是"等待"，明确告诉你等什么信号、看什么价位

换任何股票名字或代码都可以。想扫全市场找最近出现买点的股票，对 AI 说"帮我扫描全市场的缠论买点"（这个功能耗时约 2 分钟，建议在配置好数据库的电脑或服务器上跑）。

## 遇到问题

把报错原样发给你的 AI 助手，它会按本技能的说明排查。装不上、跑不通的问题多数出在 Python 版本（需要 3.11 以上），让 AI 带你装就行。
````

## File: .github/make_skillhub_zip.py
size: 2012
sha: 5e1b91525941dadf5072b4e068ecdebec3f74f75
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/.github/make_skillhub_zip.py

```text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""打腾讯 SkillHub 专用包: git archive 当前 HEAD → LICENSE 改 .txt(平台拒绝无扩展名文件) → 版号命名 zip
用法: python .github/make_skillhub_zip.py   (在仓库根目录跑, 输出到 ~/Downloads)
"""
import os
import re
import shutil
import subprocess
import sys
import tempfile
import zipfile

if hasattr(sys.stdout, "reconfigure"):
    sys.stdout.reconfigure(encoding="utf-8")

repo = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
ver = re.search(r'^version: "([^"]+)"', open(os.path.join(repo, "SKILL.md"), encoding="utf-8").read(),
                re.M).group(1)
out = os.path.join(os.path.expanduser("~"), "Downloads", f"chanlun-engine-skill-v{ver}-skillhub.zip")

with tempfile.TemporaryDirectory() as td:
    tar = os.path.join(td, "a.tar")
    subprocess.run(["git", "-C", repo, "archive", "-o", tar, "HEAD",
                    ":(exclude).github", ":(exclude).gitignore"], check=True)
    src = os.path.join(td, "x")
    os.makedirs(src)
    subprocess.run(["tar", "-xf", tar, "-C", src], check=True)
    for p in (os.path.join(src, "LICENSE"), os.path.join(src, "engine", "chanpy", "LICENSE")):
        if os.path.exists(p):
            shutil.move(p, p + ".txt")
    npath = os.path.join(src, "engine", "chanpy", "NOTICE.md")
    if os.path.exists(npath):
        n = open(npath, encoding="utf-8").read().replace("LICENSE 原文见本目录", "LICENSE.txt 原文见本目录")
        open(npath, "w", encoding="utf-8").write(n)
    zf = zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED)
    for root, _, files in os.walk(src):
        for f in files:
            p = os.path.join(root, f)
            zf.write(p, os.path.relpath(p, src))
    zf.close()

names = zipfile.ZipFile(out).namelist()
noext = [x for x in names if "." not in x.split("/")[-1]]
assert "SKILL.md" in names and not noext, f"打包校验失败: noext={noext}"
print(f"OK {out} ({len(names)} files, {os.path.getsize(out)//1024} KB, v{ver})")
```

## File: .github/workflows/clawhub-publish.yml
size: 1616
sha: f9bb071c3e67e7065396f755f22266ccbce8a3cd
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/.github/workflows/clawhub-publish.yml

```text
name: Publish to ClawHub

on:
  workflow_dispatch: {}
  push:
    branches: [main]
    paths:
      - 'SKILL.md'
      - 'scripts/**'
      - 'references/**'
      - 'engine/**'
      - 'AGENTS.md'
      - 'README.md'

permissions:
  contents: write

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
          node-version: '24'

      - name: Install ClawHub CLI
        run: npm install -g clawhub@latest

      - name: Login to ClawHub
        run: clawhub login --token "${{ secrets.CLAWHUB_TOKEN }}"

      - name: Publish skill
        run: |
          VERSION=$(grep '^version:' SKILL.md | head -1 | awk '{print $2}' | tr -d '"' | tr -d "'")
          if [ -z "$VERSION" ]; then
            echo ">>> No version in SKILL.md frontmatter, abort"; exit 1
          fi
          clawhub publish . \
            --slug chanlun-engine-skill \
            --name chanlun-engine-skill \
            --version "$VERSION" \
            --changelog "Auto-published from GitHub commit ${{ github.sha }}"
          echo "VERSION=$VERSION" >> "$GITHUB_ENV"

      - name: GitHub Release (同版本, 已存在则跳过)
        env:
          GH_TOKEN: ${{ github.token }}
        run: |
          if gh release view "v$VERSION" --repo "${{ github.repository }}" >/dev/null 2>&1; then
            echo ">>> release v$VERSION 已存在, 跳过"
          else
            gh release create "v$VERSION" \
              --repo "${{ github.repository }}" \
              --title "v$VERSION" \
              --generate-notes
          fi
```

## File: .gitignore
size: 61
sha: b73896170ef3be2c1c404879c2da8b1b75f8bec6
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/.gitignore

```text
vendor/
data/
*.duckdb
__pycache__/
scan_*.json
testdata.csv
```

## File: AGENTS.md
size: 980
sha: 0b8685be82df23c8d350aec7f54e6690c7373270
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/AGENTS.md

````text
# chanlun-engine-skill

本仓库是一个 Agent Skill：用确定性脚本计算 A 股缠论结构（分型/笔/线段/中枢/买卖点/背驰），
输出四态操作判定（买入候选/持有/卖出减仓/等待观察）与失效价位。

**规则入口：读 [SKILL.md](SKILL.md) 并严格遵守其中的硬性禁令与新手引导流程。**
核心纪律：脚本算一切结构与判定，你只解读转述；禁止自己看K线心算缠论。

常用命令（在仓库根目录）：

```bash
python scripts/setup_env.py --recommended        # 环境自检+装免费行情源
python scripts/get_data.py --symbol 600519 --out k.csv   # 取日K(自动选数据源)
python scripts/chan_engine.py --symbol 600519.SH --csv k.csv   # 结构+判定 JSON
```

Codex 用户安装为技能：把本仓库放入 `.agents/skills/chanlun-engine-skill/`（项目级）
或 `~/.agents/skills/chanlun-engine-skill/`（用户级），或用 `$skill-installer install <本仓库URL>`。
````

## File: engine/chanpy/__init__.py
size: 0
sha: e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/__init__.py

```text

```

## File: engine/chanpy/Bi/Bi.py
size: 10760
sha: a3e7b60e6ac405562447fd8325522b95fadcc658
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Bi/Bi.py

```text
from typing import List, Optional

from Common.cache import make_cache
from Common.CEnum import BI_DIR, BI_TYPE, DATA_FIELD, FX_TYPE, MACD_ALGO
from Common.ChanException import CChanException, ErrCode
from KLine.KLine import CKLine
from KLine.KLine_Unit import CKLine_Unit

class CBi:
    def __init__(self, begin_klc: CKLine, end_klc: CKLine, idx: int, is_sure: bool):
        # self.__begin_klc = begin_klc
        # self.__end_klc = end_klc
        self.__dir = None
        self.__idx = idx
        self.__type = BI_TYPE.STRICT

        self.set(begin_klc, end_klc)

        self.__is_sure = is_sure
        self.__used_to_be_sure = is_sure
        self.__sure_end: List[CKLine] = []

        self.__seg_idx: Optional[int] = None

        from Seg.Seg import CSeg
        self.parent_seg: Optional[CSeg[CBi]] = None  # 在哪个线段里面

        from BuySellPoint.BS_Point import CBS_Point
        self.bsp: Optional[CBS_Point] = None  # 尾部是不是买卖点

        self.next: Optional[CBi] = None
        self.pre: Optional[CBi] = None

    def clean_cache(self):
        self._memoize_cache = {}

    @property
    def begin_klc(self): return self.__begin_klc

    @property
    def end_klc(self): return self.__end_klc

    @property
    def dir(self): return self.__dir

    @property
    def idx(self): return self.__idx

    @property
    def type(self): return self.__type

    @property
    def is_sure(self): return self.__is_sure

    @property
    def used_to_be_sure(self): return self.__used_to_be_sure

    @property
    def is_used_to_be_sure(self): return self.is_sure or self.used_to_be_sure

    @property
    def sure_end(self): return self.__sure_end

    @property
    def klc_lst(self):
        klc = self.begin_klc
        while True:
            yield klc
            klc = klc.next
            if not klc or klc.idx > self.end_klc.idx:
                break

    @property
    def klc_lst_re(self):
        klc = self.end_klc
        while True:
            yield klc
            klc = klc.pre
            if not klc or klc.idx < self.begin_klc.idx:
                break

    @property
    def seg_idx(self): return self.__seg_idx

    def set_seg_idx(self, idx):
        self.__seg_idx = idx

    def __str__(self):
        return f"{self.dir}|{self.begin_klc} ~ {self.end_klc}"

    def check(self):
        try:
            if self.is_down():
                assert self.begin_klc.high > self.end_klc.low
            else:
                assert self.begin_klc.low < self.end_klc.high
        except Exception as e:
            raise CChanException(f"{self.idx}:{self.begin_klc[0].time}~{self.end_klc[-1].time}笔的方向和收尾位置不一致!", ErrCode.BI_ERR) from e

    def set(self, begin_klc: CKLine, end_klc: CKLine):
        self.__begin_klc: CKLine = begin_klc
        self.__end_klc: CKLine = end_klc
        if begin_klc.fx == FX_TYPE.BOTTOM:
            self.__dir = BI_DIR.UP
        elif begin_klc.fx == FX_TYPE.TOP:
            self.__dir = BI_DIR.DOWN
        else:
            raise CChanException("ERROR DIRECTION when creating bi", ErrCode.BI_ERR)
        self.check()
        self.clean_cache()

    @make_cache
    def get_begin_val(self):
        return self.begin_klc.low if self.is_up() else self.begin_klc.high

    @make_cache
    def get_end_val(self):
        return self.end_klc.high if self.is_up() else self.end_klc.low

    @make_cache
    def get_begin_klu(self) -> CKLine_Unit:
        if self.is_up():
            return self.begin_klc.get_peak_klu(is_high=False)
        else:
            return self.begin_klc.get_peak_klu(is_high=True)

    @make_cache
    def get_end_klu(self) -> CKLine_Unit:
        if self.is_up():
            return self.end_klc.get_peak_klu(is_high=True)
        else:
            return self.end_klc.get_peak_klu(is_high=False)

    @make_cache
    def amp(self):
        return abs(self.get_end_val() - self.get_begin_val())

    @make_cache
    def get_klu_cnt(self):
        return self.get_end_klu().idx - self.get_begin_klu().idx + 1

    @make_cache
    def get_klc_cnt(self):
        assert self.end_klc.idx == self.get_end_klu().klc.idx
        assert self.begin_klc.idx == self.get_begin_klu().klc.idx
        return self.end_klc.idx - self.begin_klc.idx + 1

    @make_cache
    def _high(self):
        return self.end_klc.high if self.is_up() else self.begin_klc.high

    @make_cache
    def _low(self):
        return self.begin_klc.low if self.is_up() else self.end_klc.low

    @make_cache
    def _mid(self):
        return (self._high() + self._low()) / 2  # 笔的中位价

    @make_cache
    def is_down(self):
        return self.dir == BI_DIR.DOWN

    @make_cache
    def is_up(self):
        return self.dir == BI_DIR.UP

    def update_virtual_end(self, new_klc: CKLine):
        self.append_sure_end(self.end_klc)
        self.update_new_end(new_klc)
        self.__used_to_be_sure = self.__is_sure
        self.__is_sure = False

    def restore_from_virtual_end(self, sure_end: CKLine):
        self.__is_sure = True
        self.__used_to_be_sure = True
        self.update_new_end(new_klc=sure_end)
        self.__sure_end = []

    def append_sure_end(self, klc: CKLine):
        self.__sure_end.append(klc)

    def update_new_end(self, new_klc: CKLine):
        self.__end_klc = new_klc
        self.check()
        self.clean_cache()

    def cal_macd_metric(self, macd_algo, is_reverse):
        if macd_algo == MACD_ALGO.AREA:
            return self.Cal_MACD_half(is_reverse)
        elif macd_algo == MACD_ALGO.PEAK:
            return self.Cal_MACD_peak()
        elif macd_algo == MACD_ALGO.FULL_AREA:
            return self.Cal_MACD_area()
        elif macd_algo == MACD_ALGO.DIFF:
            return self.Cal_MACD_diff()
        elif macd_algo == MACD_ALGO.SLOPE:
            return self.Cal_MACD_slope()
        elif macd_algo == MACD_ALGO.AMP:
            return self.Cal_MACD_amp()
        elif macd_algo == MACD_ALGO.AMOUNT:
            return self.Cal_MACD_trade_metric(DATA_FIELD.FIELD_TURNOVER, cal_avg=False)
        elif macd_algo == MACD_ALGO.VOLUMN:
            return self.Cal_MACD_trade_metric(DATA_FIELD.FIELD_VOLUME, cal_avg=False)
        elif macd_algo == MACD_ALGO.VOLUMN_AVG:
            return self.Cal_MACD_trade_metric(DATA_FIELD.FIELD_VOLUME, cal_avg=True)
        elif macd_algo == MACD_ALGO.AMOUNT_AVG:
            return self.Cal_MACD_trade_metric(DATA_FIELD.FIELD_TURNOVER, cal_avg=True)
        elif macd_algo == MACD_ALGO.TURNRATE_AVG:
            return self.Cal_MACD_trade_metric(DATA_FIELD.FIELD_TURNRATE, cal_avg=True)
        elif macd_algo == MACD_ALGO.RSI:
            return self.Cal_Rsi()
        else:
            raise CChanException(f"unsupport macd_algo={macd_algo}, should be one of area/full_area/peak/diff/slope/amp", ErrCode.PARA_ERROR)

    @make_cache
    def Cal_Rsi(self):
        rsi_lst: List[float] = []
        for klc in self.klc_lst:
            rsi_lst.extend(klu.rsi for klu in klc.lst)
        return 10000.0/(min(rsi_lst)+1e-7) if self.is_down() else max(rsi_lst)

    @make_cache
    def Cal_MACD_area(self):
        _s = 1e-7
        begin_klu = self.get_begin_klu()
        end_klu = self.get_end_klu()
        for klc in self.klc_lst:
            for klu in klc.lst:
                if klu.idx < begin_klu.idx or klu.idx > end_klu.idx:
                    continue
                if (self.is_down() and klu.macd.macd < 0) or (self.is_up() and klu.macd.macd > 0):
                    _s += abs(klu.macd.macd)
        return _s

    @make_cache
    def Cal_MACD_peak(self):
        peak = 1e-7
        for klc in self.klc_lst:
            for klu in klc.lst:
                if abs(klu.macd.macd) > peak:
                    if self.is_down() and klu.macd.macd < 0:
                        peak = abs(klu.macd.macd)
                    elif self.is_up() and klu.macd.macd > 0:
                        peak = abs(klu.macd.macd)
        return peak

    def Cal_MACD_half(self, is_reverse):
        if is_reverse:
            return self.Cal_MACD_half_reverse()
        else:
            return self.Cal_MACD_half_obverse()

    @make_cache
    def Cal_MACD_half_obverse(self):
        _s = 1e-7
        begin_klu = self.get_begin_klu()
        peak_macd = begin_klu.macd.macd
        for klc in self.klc_lst:
            for klu in klc.lst:
                if klu.idx < begin_klu.idx:
                    continue
                if klu.macd.macd*peak_macd > 0:
                    _s += abs(klu.macd.macd)
                else:
                    break
            else:  # 没有被break，继续找写一个KLC
                continue
            break
        return _s

    @make_cache
    def Cal_MACD_half_reverse(self):
        _s = 1e-7
        begin_klu = self.get_end_klu()
        peak_macd = begin_klu.macd.macd
        for klc in self.klc_lst_re:
            for klu in klc[::-1]:
                if klu.idx > begin_klu.idx:
                    continue
                if klu.macd.macd*peak_macd > 0:
                    _s += abs(klu.macd.macd)
                else:
                    break
            else:  # 没有被break，继续找写一个KLC
                continue
            break
        return _s

    @make_cache
    def Cal_MACD_diff(self):
        """
        macd红绿柱最大值最小值之差
        """
        _max, _min = float("-inf"), float("inf")
        for klc in self.klc_lst:
            for klu in klc.lst:
                macd = klu.macd.macd
                if macd > _max:
                    _max = macd
                if macd < _min:
                    _min = macd
        return _max-_min

    @make_cache
    def Cal_MACD_slope(self):
        begin_klu = self.get_begin_klu()
        end_klu = self.get_end_klu()
        if self.is_up():
            return (end_klu.high - begin_klu.low)/end_klu.high/(end_klu.idx - begin_klu.idx + 1)
        else:
            return (begin_klu.high - end_klu.low)/begin_klu.high/(end_klu.idx - begin_klu.idx + 1)

    @make_cache
    def Cal_MACD_amp(self):
        begin_klu = self.get_begin_klu()
        end_klu = self.get_end_klu()
        if self.is_down():
            return (begin_klu.high-end_klu.low)/begin_klu.high
        else:
            return (end_klu.high-begin_klu.low)/begin_klu.low

    def Cal_MACD_trade_metric(self, metric: str, cal_avg=False) -> float:
        _s = 0
        for klc in self.klc_lst:
            for klu in klc.lst:
                metric_res = klu.trade_info.metric[metric]
                if metric_res is None:
                    return 0.0
                _s += metric_res
        return _s / self.get_klu_cnt() if cal_avg else _s

    # def set_klc_lst(self, lst):
    #     self.__klc_lst = lst
```

## File: engine/chanpy/Bi/BiConfig.py
size: 982
sha: cbc99c46ef2bdb5ab225641b2fdc78e4393820da
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Bi/BiConfig.py

```text
from Common.CEnum import FX_CHECK_METHOD
from Common.ChanException import CChanException, ErrCode

class CBiConfig:
    def __init__(
        self,
        bi_algo="normal",
        is_strict=True,
        bi_fx_check="half",
        gap_as_kl=True,
        bi_end_is_peak=True,
        bi_allow_sub_peak=True,
    ):
        self.bi_algo = bi_algo
        self.is_strict = is_strict
        if bi_fx_check == "strict":
            self.bi_fx_check = FX_CHECK_METHOD.STRICT
        elif bi_fx_check == "loss":
            self.bi_fx_check = FX_CHECK_METHOD.LOSS
        elif bi_fx_check == "half":
            self.bi_fx_check = FX_CHECK_METHOD.HALF
        elif bi_fx_check == 'totally':
            self.bi_fx_check = FX_CHECK_METHOD.TOTALLY
        else:
            raise CChanException(f"unknown bi_fx_check={bi_fx_check}", ErrCode.PARA_ERROR)

        self.gap_as_kl = gap_as_kl
        self.bi_end_is_peak = bi_end_is_peak
        self.bi_allow_sub_peak = bi_allow_sub_peak
```

## File: engine/chanpy/Bi/BiList.py
size: 9051
sha: 008fdf12ba3731987bfc3bf18451b0aa9d2fc80a
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Bi/BiList.py

```text
from typing import List, Optional, Union, overload

from Common.CEnum import FX_TYPE, KLINE_DIR
from KLine.KLine import CKLine

from .Bi import CBi
from .BiConfig import CBiConfig

class CBiList:
    def __init__(self, bi_conf=CBiConfig()):
        self.bi_list: List[CBi] = []
        self.last_end = None  # 最后一笔的尾部
        self.config = bi_conf

        self.free_klc_lst = []  # 仅仅用作第一笔未画出来之前的缓存，为了获得更精准的结果而已，不加这块逻辑其实对后续计算没太大影响

    def __str__(self):
        return "\n".join([str(bi) for bi in self.bi_list])

    def __iter__(self):
        yield from self.bi_list

    @overload
    def __getitem__(self, index: int) -> CBi: ...

    @overload
    def __getitem__(self, index: slice) -> List[CBi]: ...

    def __getitem__(self, index: Union[slice, int]) -> Union[List[CBi], CBi]:
        return self.bi_list[index]

    def __len__(self):
        return len(self.bi_list)

    def try_create_first_bi(self, klc: CKLine) -> bool:
        for exist_free_klc in self.free_klc_lst:
            if exist_free_klc.fx == klc.fx:
                continue
            if self.can_make_bi(klc, exist_free_klc):
                self.add_new_bi(exist_free_klc, klc)
                self.last_end = klc
                return True
        self.free_klc_lst.append(klc)
        self.last_end = klc
        return False

    def update_bi(self, klc: CKLine, last_klc: CKLine, cal_virtual: bool) -> bool:
        # klc: 倒数第二根klc
        # last_klc: 倒数第1根klc
        flag1 = self.update_bi_sure(klc)
        if cal_virtual:
            flag2 = self.try_add_virtual_bi(last_klc)
            return flag1 or flag2
        else:
            return flag1

    def can_update_peak(self, klc: CKLine):
        if self.config.bi_allow_sub_peak or len(self.bi_list) < 2:
            return False
        if self.bi_list[-1].is_down() and klc.high < self.bi_list[-1].get_begin_val():
            return False
        if self.bi_list[-1].is_up() and klc.low > self.bi_list[-1].get_begin_val():
            return False
        if not end_is_peak(self.bi_list[-2].begin_klc, klc):
            return False
        if self[-1].is_down() and self[-1].get_end_val() < self[-2].get_begin_val():
            return False
        if self[-1].is_up() and self[-1].get_end_val() > self[-2].get_begin_val():
            return False
        return True

    def update_peak(self, klc: CKLine, for_virtual=False):
        if not self.can_update_peak(klc):
            return False
        _tmp_last_bi = self.bi_list[-1]
        self.bi_list.pop()
        if not self.try_update_end(klc, for_virtual=for_virtual):
            self.bi_list.append(_tmp_last_bi)
            return False
        else:
            if for_virtual:
                self.bi_list[-1].append_sure_end(_tmp_last_bi.end_klc)
            return True

    def update_bi_sure(self, klc: CKLine) -> bool:
        # klc: 倒数第二根klc
        _tmp_end = self.get_last_klu_of_last_bi()
        self.delete_virtual_bi()
        # 返回值：是否出现新笔
        if klc.fx == FX_TYPE.UNKNOWN:
            return _tmp_end != self.get_last_klu_of_last_bi()  # 虚笔是否有变
        if self.last_end is None or len(self.bi_list) == 0:
            return self.try_create_first_bi(klc)
        if klc.fx == self.last_end.fx:
            return self.try_update_end(klc)
        elif self.can_make_bi(klc, self.last_end):
            self.add_new_bi(self.last_end, klc)
            self.last_end = klc
            return True
        elif self.update_peak(klc):
            return True
        return _tmp_end != self.get_last_klu_of_last_bi()

    def delete_virtual_bi(self):
        if len(self) > 0 and not self.bi_list[-1].is_sure:
            sure_end_list = [klc for klc in self.bi_list[-1].sure_end]
            if len(sure_end_list):
                self.bi_list[-1].restore_from_virtual_end(sure_end_list[0])
                self.last_end = self[-1].end_klc
                for sure_end in sure_end_list[1:]:
                    self.add_new_bi(self.last_end, sure_end, is_sure=True)
                    self.last_end = self[-1].end_klc
            else:
                del self.bi_list[-1]
        self.last_end = self[-1].end_klc if len(self) > 0 else None
        if len(self) > 0:
            self[-1].next = None

    def try_add_virtual_bi(self, klc: CKLine, need_del_end=False):
        if need_del_end:
            self.delete_virtual_bi()
        if len(self) == 0:
            return False
        if klc.idx == self[-1].end_klc.idx:
            return False
        if (self[-1].is_up() and klc.high >= self[-1].end_klc.high) or (self[-1].is_down() and klc.low <= self[-1].end_klc.low):
            # 更新最后一笔
            self.bi_list[-1].update_virtual_end(klc)
            return True
        _tmp_klc = klc
        while _tmp_klc and _tmp_klc.idx > self[-1].end_klc.idx:
            assert _tmp_klc is not None
            if self.can_make_bi(_tmp_klc, self[-1].end_klc, for_virtual=True):
                # 新增一笔
                self.add_new_bi(self.last_end, _tmp_klc, is_sure=False)
                return True
            elif self.update_peak(_tmp_klc, for_virtual=True):
                return True
            _tmp_klc = _tmp_klc.pre
        return False

    def add_new_bi(self, pre_klc, cur_klc, is_sure=True):
        self.bi_list.append(CBi(pre_klc, cur_klc, idx=len(self.bi_list), is_sure=is_sure))
        if len(self.bi_list) >= 2:
            self.bi_list[-2].next = self.bi_list[-1]
            self.bi_list[-1].pre = self.bi_list[-2]

    def satisfy_bi_span(self, klc: CKLine, last_end: CKLine):
        bi_span = self.get_klc_span(klc, last_end)
        if self.config.is_strict:
            return bi_span >= 4
        uint_kl_cnt = 0
        tmp_klc = last_end.next
        while tmp_klc:
            uint_kl_cnt += len(tmp_klc.lst)
            if not tmp_klc.next:  # 最后尾部虚笔的时候，可能klc.idx == last_end.idx+1
                return False
            if tmp_klc.next.idx < klc.idx:
                tmp_klc = tmp_klc.next
            else:
                break
        return bi_span >= 3 and uint_kl_cnt >= 3

    def get_klc_span(self, klc: CKLine, last_end: CKLine) -> int:
        span = klc.idx - last_end.idx
        if not self.config.gap_as_kl:
            return span
        if span >= 4:  # 加速运算，如果span需要真正精确的值，需要去掉这一行
            return span
        tmp_klc = last_end
        while tmp_klc and tmp_klc.idx < klc.idx:
            if tmp_klc.has_gap_with_next():
                span += 1
            tmp_klc = tmp_klc.next
        return span

    def can_make_bi(self, klc: CKLine, last_end: CKLine, for_virtual: bool = False):
        satisify_span = True if self.config.bi_algo == 'fx' else self.satisfy_bi_span(klc, last_end)
        if not satisify_span:
            return False
        if not last_end.check_fx_valid(klc, self.config.bi_fx_check, for_virtual):
            return False
        if self.config.bi_end_is_peak and not end_is_peak(last_end, klc):
            return False
        return True

    def try_update_end(self, klc: CKLine, for_virtual=False) -> bool:
        def check_top(klc: CKLine, for_virtual):
            if for_virtual:
                return klc.dir == KLINE_DIR.UP
            else:
                return klc.fx == FX_TYPE.TOP

        def check_bottom(klc: CKLine, for_virtual):
            if for_virtual:
                return klc.dir == KLINE_DIR.DOWN
            else:
                return klc.fx == FX_TYPE.BOTTOM

        if len(self.bi_list) == 0:
            return False
        last_bi = self.bi_list[-1]
        if (last_bi.is_up() and check_top(klc, for_virtual) and klc.high >= last_bi.get_end_val()) or \
           (last_bi.is_down() and check_bottom(klc, for_virtual) and klc.low <= last_bi.get_end_val()):
            last_bi.update_virtual_end(klc) if for_virtual else last_bi.update_new_end(klc)
            self.last_end = klc
            return True
        else:
            return False

    def get_last_klu_of_last_bi(self) -> Optional[int]:
        return self.bi_list[-1].get_end_klu().idx if len(self) > 0 else None

def end_is_peak(last_end: CKLine, cur_end: CKLine) -> bool:
    if last_end.fx == FX_TYPE.BOTTOM:
        cmp_thred = cur_end.high  # 或者严格点选择get_klu_max_high()
        klc = last_end.get_next()
        while True:
            if klc.idx >= cur_end.idx:
                return True
            if klc.high > cmp_thred:
                return False
            klc = klc.get_next()
    elif last_end.fx == FX_TYPE.TOP:
        cmp_thred = cur_end.low  # 或者严格点选择get_klu_min_low()
        klc = last_end.get_next()
        while True:
            if klc.idx >= cur_end.idx:
                return True
            if klc.low < cmp_thred:
                return False
            klc = klc.get_next()
    return True
```

## File: engine/chanpy/BuySellPoint/__init__.py
size: 0
sha: e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/BuySellPoint/__init__.py

```text

```

## File: engine/chanpy/BuySellPoint/BS_Point.py
size: 1517
sha: 71fdd728475bb809fc7502c054cd2dd5704107dc
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/BuySellPoint/BS_Point.py

```text
from typing import Dict, Generic, List, Optional, TypeVar, Union

from Bi.Bi import CBi
from ChanModel.Features import CFeatures
from Common.CEnum import BSP_TYPE
from Seg.Seg import CSeg

LINE_TYPE = TypeVar('LINE_TYPE', CBi, CSeg)

class CBS_Point(Generic[LINE_TYPE]):
    def __init__(self, bi: LINE_TYPE, is_buy, bs_type: BSP_TYPE, relate_bsp1: Optional['CBS_Point'], feature_dict=None):
        self.bi: LINE_TYPE = bi
        self.klu = bi.get_end_klu()
        self.is_buy = is_buy
        self.type: List[BSP_TYPE] = [bs_type]
        self.relate_bsp1 = relate_bsp1

        self.bi.bsp = self  # type: ignore
        self.features = CFeatures(feature_dict)

        self.is_segbsp = False

        self.init_common_feature()

    def add_type(self, bs_type: BSP_TYPE):
        self.type.append(bs_type)

    def type2str(self):
        return ",".join([x.value for x in self.type])

    def add_another_bsp_prop(self, bs_type: BSP_TYPE, relate_bsp1):
        self.add_type(bs_type)
        if self.relate_bsp1 is None:
            self.relate_bsp1 = relate_bsp1
        elif relate_bsp1 is not None:
            assert self.relate_bsp1.klu.idx == relate_bsp1.klu.idx

    def add_feat(self, inp1: Union[str, Dict[str, float], Dict[str, Optional[float]], 'CFeatures'], inp2: Optional[float] = None):
        self.features.add_feat(inp1, inp2)

    def init_common_feature(self):
        # 用于配置适用所有买卖点的特征
        self.add_feat({
            'bsp_bi_amp': self.bi.amp(),
        })
```

## File: engine/chanpy/BuySellPoint/BSPointConfig.py
size: 3020
sha: 17a48f5425dd66ccfd5b9b8a6afcf4ed1be1d240
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/BuySellPoint/BSPointConfig.py

```text
from typing import Dict, List, Optional

from Common.CEnum import BSP_TYPE, MACD_ALGO
from Common.func_util import _parse_inf

class CBSPointConfig:
    def __init__(self, **args):
        self.b_conf = CPointConfig(**args)
        self.s_conf = CPointConfig(**args)

    def GetBSConfig(self, is_buy):
        return self.b_conf if is_buy else self.s_conf

class CPointConfig:
    def __init__(self,
                 divergence_rate,
                 min_zs_cnt,
                 bsp1_only_multibi_zs,
                 max_bs2_rate,
                 macd_algo,
                 bs1_peak,
                 bs_type,
                 bsp2_follow_1,
                 bsp3_follow_1,
                 bsp3_peak,
                 bsp2s_follow_2,
                 max_bsp2s_lv,
                 strict_bsp3,
                 bsp3a_max_zs_cnt,
                 ):
        self.divergence_rate = divergence_rate
        self.min_zs_cnt = min_zs_cnt
        self.bsp1_only_multibi_zs = bsp1_only_multibi_zs
        self.max_bs2_rate = max_bs2_rate
        assert self.max_bs2_rate <= 1
        self.SetMacdAlgo(macd_algo)
        self.bs1_peak = bs1_peak
        self.tmp_target_types = bs_type
        self.target_types: List[BSP_TYPE] = []
        self.bsp2_follow_1 = bsp2_follow_1
        self.bsp3_follow_1 = bsp3_follow_1
        self.bsp3_peak = bsp3_peak
        self.bsp2s_follow_2 = bsp2s_follow_2
        self.max_bsp2s_lv: Optional[int] = max_bsp2s_lv
        self.strict_bsp3 = strict_bsp3
        self.bsp3a_max_zs_cnt = bsp3a_max_zs_cnt
        assert self.bsp3a_max_zs_cnt >= 1

    def parse_target_type(self):
        _d: Dict[str, BSP_TYPE] = {x.value: x for x in BSP_TYPE}
        if isinstance(self.tmp_target_types, str):
            self.tmp_target_types = [t.strip() for t in self.tmp_target_types.split(",")]
        for target_t in self.tmp_target_types:
            assert target_t in ['1', '2', '3a', '2s', '1p', '3b']
        self.target_types = [_d[_type] for _type in self.tmp_target_types]

    def SetMacdAlgo(self, macd_algo):
        _d = {
            "area": MACD_ALGO.AREA,
            "peak": MACD_ALGO.PEAK,
            "full_area": MACD_ALGO.FULL_AREA,
            "diff": MACD_ALGO.DIFF,
            "slope": MACD_ALGO.SLOPE,
            "amp": MACD_ALGO.AMP,
            "amount": MACD_ALGO.AMOUNT,
            "volumn": MACD_ALGO.VOLUMN,
            "amount_avg": MACD_ALGO.AMOUNT_AVG,
            "volumn_avg": MACD_ALGO.VOLUMN_AVG,
            "turnrate_avg": MACD_ALGO.TURNRATE_AVG,
            "rsi": MACD_ALGO.RSI,
        }
        self.macd_algo = _d[macd_algo]

    def set(self, k, v):
        # 安全化: 原实现为 exec(f"self.{k} = {v}"), 已改为直接赋值(vendor patch, 行为等价)
        if v == 'float("inf")' or v == "float('inf')":
            v = float("inf")
        elif v == 'float("-inf")' or v == "float('-inf')":
            v = float("-inf")
        if k == "macd_algo":
            self.SetMacdAlgo(v)
        else:
            setattr(self, k, v)
```

## File: engine/chanpy/BuySellPoint/BSPointList.py
size: 18307
sha: c5da98ac75665d55b0fcf89cb8355c5be49b6804
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/BuySellPoint/BSPointList.py

```text
from typing import Dict, Generic, Iterable, List, Optional, Tuple, TypeVar

from Bi.Bi import CBi
from Bi.BiList import CBiList
from Common.CEnum import BSP_TYPE
from Common.func_util import has_overlap
from Seg.Seg import CSeg
from Seg.SegListComm import CSegListComm
from ZS.ZS import CZS

from .BS_Point import CBS_Point
from .BSPointConfig import CBSPointConfig, CPointConfig

LINE_TYPE = TypeVar('LINE_TYPE', CBi, CSeg[CBi])
LINE_LIST_TYPE = TypeVar('LINE_LIST_TYPE', CBiList, CSegListComm[CBi])

class CBSPointList(Generic[LINE_TYPE, LINE_LIST_TYPE]):
    def __init__(self, bs_point_config: CBSPointConfig):
        self.bsp_store_dict: Dict[BSP_TYPE, Tuple[List[CBS_Point[LINE_TYPE]], List[CBS_Point[LINE_TYPE]]]] = {}
        self.bsp_store_flat_dict: Dict[int, CBS_Point[LINE_TYPE]] = {}

        self.bsp1_list: List[CBS_Point[LINE_TYPE]] = []
        self.bsp1_dict: Dict[int, CBS_Point[LINE_TYPE]] = {}

        self.config = bs_point_config
        self.last_sure_pos = -1
        self.last_sure_seg_idx = 0

    def store_add_bsp(self, bsp_type: BSP_TYPE, bsp: CBS_Point[LINE_TYPE]):
        if bsp_type not in self.bsp_store_dict:
            self.bsp_store_dict[bsp_type] = ([], [])
        if len(self.bsp_store_dict[bsp_type][bsp.is_buy]) > 0:
            assert self.bsp_store_dict[bsp_type][bsp.is_buy][-1].bi.idx < bsp.bi.idx, f"{bsp_type}, {bsp.is_buy} {self.bsp_store_dict[bsp_type][bsp.is_buy][-1].bi.idx} {bsp.bi.idx}"
        self.bsp_store_dict[bsp_type][bsp.is_buy].append(bsp)
        self.bsp_store_flat_dict[bsp.bi.idx] = bsp

    def add_bsp1(self, bsp: CBS_Point[LINE_TYPE]):
        if len(self.bsp1_list) > 0:
            assert self.bsp1_list[-1].bi.idx < bsp.bi.idx
        self.bsp1_list.append(bsp)
        self.bsp1_dict[bsp.bi.idx] = bsp

    def clear_store_end(self):
        for bsp_list in self.bsp_store_dict.values():
            for is_buy in [True, False]:
                while len(bsp_list[is_buy]) > 0:
                    if bsp_list[is_buy][-1].bi.get_end_klu().idx <= self.last_sure_pos:
                        break
                    del self.bsp_store_flat_dict[bsp_list[is_buy][-1].bi.idx]
                    # 同时把失效买卖点从Bi删除
                    bsp_list[is_buy][-1].bi.bsp = None
                    bsp_list[is_buy].pop()

    def clear_bsp1_end(self):
        while len(self.bsp1_list) > 0:
            if self.bsp1_list[-1].bi.get_end_klu().idx <= self.last_sure_pos:
                break
            del self.bsp1_dict[self.bsp1_list[-1].bi.idx]
            self.bsp1_list.pop()

    def bsp_iter(self) -> Iterable[CBS_Point[LINE_TYPE]]:
        for bsp_list in self.bsp_store_dict.values():
            yield from bsp_list[True]
            yield from bsp_list[False]

    def bsp_iter_v2(self) -> Iterable[CBS_Point[LINE_TYPE]]:
        list_indices = []
        for bsp_type, bsp_list in self.bsp_store_dict.items():
            if bsp_list[True]:
                list_indices.append([bsp_type, True, len(bsp_list[True]) - 1])
            if bsp_list[False]:
                list_indices.append([bsp_type, False, len(bsp_list[False]) - 1])

        while list_indices:
            max_idx = -1
            max_bi_idx = -1
            max_bsp = None

            for i, (bsp_type, is_buy, idx) in enumerate(list_indices):
                if idx >= 0:
                    bsp = self.bsp_store_dict[bsp_type][is_buy][idx]
                    if bsp.bi.idx > max_bi_idx:
                        max_bi_idx = bsp.bi.idx
                        max_idx = i
                        max_bsp = bsp

            if max_bsp is None:
                break

            yield max_bsp

            list_indices[max_idx][2] -= 1
            if list_indices[max_idx][2] < 0:
                list_indices.pop(max_idx)

    def __len__(self):
        return len(self.bsp_store_flat_dict)

    def cal(self, bi_list: LINE_LIST_TYPE, seg_list: CSegListComm[LINE_TYPE]):
        self.clear_store_end()
        self.clear_bsp1_end()
        self.cal_seg_bs1point(seg_list, bi_list)
        self.cal_seg_bs2point(seg_list, bi_list)
        self.cal_seg_bs3point(seg_list, bi_list)

        self.update_last_pos(seg_list)

    def update_last_pos(self, seg_list: CSegListComm):
        self.last_sure_pos = -1
        self.last_sure_seg_idx = 0
        seg_idx = len(seg_list)-1
        while seg_idx >= 0:
            seg = seg_list[seg_idx]
            if seg.is_sure:
                self.last_sure_pos = seg.end_bi.get_begin_klu().idx
                self.last_sure_seg_idx = seg.idx
                return
            seg_idx -= 1

    def seg_need_cal(self, seg: CSeg):
        return seg.end_bi.get_end_klu().idx > self.last_sure_pos

    def add_bs(
        self,
        bs_type: BSP_TYPE,
        bi: LINE_TYPE,
        relate_bsp1: Optional[CBS_Point],
        is_target_bsp: bool = True,
        feature_dict=None,
    ):
        is_buy = bi.is_down()
        if exist_bsp := self.bsp_store_flat_dict.get(bi.idx):
            assert exist_bsp.is_buy == is_buy
            exist_bsp.add_another_bsp_prop(bs_type, relate_bsp1)
            if feature_dict is not None:
                exist_bsp.add_feat(feature_dict)
            return
        if bs_type not in self.config.GetBSConfig(is_buy).target_types:
            is_target_bsp = False

        if is_target_bsp or bs_type in [BSP_TYPE.T1, BSP_TYPE.T1P]:
            bsp = CBS_Point[LINE_TYPE](
                bi=bi,
                is_buy=is_buy,
                bs_type=bs_type,
                relate_bsp1=relate_bsp1,
                feature_dict=feature_dict,
            )
        else:
            return
        if is_target_bsp:
            self.store_add_bsp(bs_type, bsp)
        else:
            bsp.bi.bsp = None
        if bs_type in [BSP_TYPE.T1, BSP_TYPE.T1P]:
            self.add_bsp1(bsp)

    def cal_seg_bs1point(self, seg_list: CSegListComm[LINE_TYPE], bi_list: LINE_LIST_TYPE):
        for seg in seg_list[self.last_sure_seg_idx:]:
            if not self.seg_need_cal(seg):
                continue
            self.cal_single_bs1point(seg, bi_list)

    def cal_single_bs1point(self, seg: CSeg[LINE_TYPE], bi_list: LINE_LIST_TYPE):
        BSP_CONF = self.config.GetBSConfig(seg.is_down())
        zs_cnt = seg.get_multi_bi_zs_cnt() if BSP_CONF.bsp1_only_multibi_zs else len(seg.zs_lst)
        is_target_bsp = (BSP_CONF.min_zs_cnt <= 0 or zs_cnt >= BSP_CONF.min_zs_cnt)
        if len(seg.zs_lst) > 0 and \
           not seg.zs_lst[-1].is_one_bi_zs() and \
           ((seg.zs_lst[-1].bi_out and seg.zs_lst[-1].bi_out.idx >= seg.end_bi.idx) or seg.zs_lst[-1].bi_lst[-1].idx >= seg.end_bi.idx) \
           and seg.end_bi.idx - seg.zs_lst[-1].get_bi_in().idx > 2:
            self.treat_bsp1(seg, BSP_CONF, is_target_bsp)
        else:
            self.treat_pz_bsp1(seg, BSP_CONF, bi_list, is_target_bsp)

    def treat_bsp1(self, seg: CSeg[LINE_TYPE], BSP_CONF: CPointConfig, is_target_bsp: bool):
        last_zs = seg.zs_lst[-1]
        break_peak, _ = last_zs.out_bi_is_peak(seg.end_bi.idx)
        if BSP_CONF.bs1_peak and not break_peak:
            is_target_bsp = False
        is_diver, divergence_rate = last_zs.is_divergence(BSP_CONF, out_bi=seg.end_bi)
        if not is_diver:
            is_target_bsp = False
        feature_dict = {
            'divergence_rate': divergence_rate,
            'zs_cnt': len(seg.zs_lst),
        }
        self.add_bs(bs_type=BSP_TYPE.T1, bi=seg.end_bi, relate_bsp1=None, is_target_bsp=is_target_bsp, feature_dict=feature_dict)

    def treat_pz_bsp1(self, seg: CSeg[LINE_TYPE], BSP_CONF: CPointConfig, bi_list: LINE_LIST_TYPE, is_target_bsp):
        last_bi = seg.end_bi
        pre_bi = bi_list[last_bi.idx-2]
        if last_bi.seg_idx != pre_bi.seg_idx:
            return
        if last_bi.dir != seg.dir:
            return
        if last_bi.is_down() and last_bi._low() > pre_bi._low():  # 创新低
            return
        if last_bi.is_up() and last_bi._high() < pre_bi._high():  # 创新高
            return
        in_metric = pre_bi.cal_macd_metric(BSP_CONF.macd_algo, is_reverse=False)
        out_metric = last_bi.cal_macd_metric(BSP_CONF.macd_algo, is_reverse=True)
        is_diver, divergence_rate = out_metric <= BSP_CONF.divergence_rate*in_metric, out_metric/(in_metric+1e-7)
        if not is_diver:
            is_target_bsp = False
        if isinstance(bi_list, CBiList):
            assert isinstance(last_bi, CBi) and isinstance(pre_bi, CBi)
        feature_dict = {
            'divergence_rate': divergence_rate,
            'bsp1_bi_amp': last_bi.amp(),
        }
        self.add_bs(bs_type=BSP_TYPE.T1P, bi=last_bi, relate_bsp1=None, is_target_bsp=is_target_bsp, feature_dict=feature_dict)

    def cal_seg_bs2point(self, seg_list: CSegListComm[LINE_TYPE], bi_list: LINE_LIST_TYPE):
        for seg in seg_list[self.last_sure_seg_idx:]:
            config = self.config.GetBSConfig(seg.is_down())
            if BSP_TYPE.T2 not in config.target_types and BSP_TYPE.T2S not in config.target_types:
                continue
            if not self.seg_need_cal(seg):
                continue
            self.treat_bsp2(seg, seg_list, bi_list)

    def treat_bsp2(self, seg: CSeg, seg_list: CSegListComm[LINE_TYPE], bi_list: LINE_LIST_TYPE):
        if len(seg_list) > 1:
            BSP_CONF = self.config.GetBSConfig(seg.is_down())
            bsp1_bi = seg.end_bi
            real_bsp1 = self.bsp1_dict.get(bsp1_bi.idx)
            if bsp1_bi.idx + 2 >= len(bi_list):
                return
            break_bi = bi_list[bsp1_bi.idx + 1]
            bsp2_bi = bi_list[bsp1_bi.idx + 2]
        else:
            BSP_CONF = self.config.GetBSConfig(seg.is_up())
            bsp1_bi, real_bsp1 = None, None
            if len(bi_list) == 1:
                return
            bsp2_bi = bi_list[1]
            break_bi = bi_list[0]
        if BSP_CONF.bsp2_follow_1 and (not bsp1_bi or bsp1_bi.idx not in self.bsp_store_flat_dict):
            return
        retrace_rate = bsp2_bi.amp()/break_bi.amp()
        bsp2_flag = retrace_rate <= BSP_CONF.max_bs2_rate
        if bsp2_flag:
            feature_dict = {
                'bsp2_retrace_rate': retrace_rate,
                'bsp2_break_bi_amp': break_bi.amp(),
                'bsp2_bi_amp': bsp2_bi.amp(),
            }
            self.add_bs(bs_type=BSP_TYPE.T2, bi=bsp2_bi, relate_bsp1=real_bsp1, feature_dict=feature_dict)  # type: ignore
        elif BSP_CONF.bsp2s_follow_2:
            return
        if BSP_TYPE.T2S not in self.config.GetBSConfig(seg.is_down()).target_types:
            return
        self.treat_bsp2s(seg_list, bi_list, bsp2_bi, break_bi, real_bsp1, BSP_CONF)  # type: ignore

    def treat_bsp2s(
        self,
        seg_list: CSegListComm,
        bi_list: LINE_LIST_TYPE,
        bsp2_bi: LINE_TYPE,
        break_bi: LINE_TYPE,
        real_bsp1: Optional[CBS_Point],
        BSP_CONF: CPointConfig,
    ):
        bias = 2
        _low, _high = None, None
        while bsp2_bi.idx + bias < len(bi_list):  # 计算类二
            bsp2s_bi = bi_list[bsp2_bi.idx + bias]
            assert bsp2s_bi.seg_idx is not None and bsp2_bi.seg_idx is not None
            if BSP_CONF.max_bsp2s_lv is not None and bias/2 > BSP_CONF.max_bsp2s_lv:
                break
            if bsp2s_bi.seg_idx != bsp2_bi.seg_idx and (bsp2s_bi.seg_idx < len(seg_list)-1 or bsp2s_bi.seg_idx - bsp2_bi.seg_idx >= 2 or seg_list[bsp2_bi.seg_idx].is_sure):
                break
            if bias == 2:
                if not has_overlap(bsp2_bi._low(), bsp2_bi._high(), bsp2s_bi._low(), bsp2s_bi._high()):
                    break
                _low = max([bsp2_bi._low(), bsp2s_bi._low()])
                _high = min([bsp2_bi._high(), bsp2s_bi._high()])
            elif not has_overlap(_low, _high, bsp2s_bi._low(), bsp2s_bi._high()):
                break

            if bsp2s_break_bsp1(bsp2s_bi, break_bi):
                break
            retrace_rate = abs(bsp2s_bi.get_end_val()-break_bi.get_end_val())/break_bi.amp()
            if retrace_rate > BSP_CONF.max_bs2_rate:
                break
            feature_dict = {
                'bsp2s_retrace_rate': retrace_rate,
                'bsp2s_break_bi_amp': break_bi.amp(),
                'bsp2s_bi_amp': bsp2s_bi.amp(),
                'bsp2s_lv': bias/2,
            }
            self.add_bs(bs_type=BSP_TYPE.T2S, bi=bsp2s_bi, relate_bsp1=real_bsp1, feature_dict=feature_dict)  # type: ignore
            bias += 2

    def cal_seg_bs3point(self, seg_list: CSegListComm[LINE_TYPE], bi_list: LINE_LIST_TYPE):
        for seg in seg_list[self.last_sure_seg_idx:]:
            if not self.seg_need_cal(seg):
                continue
            config = self.config.GetBSConfig(seg.is_down())
            if BSP_TYPE.T3A not in config.target_types and BSP_TYPE.T3B not in config.target_types:
                continue
            if len(seg_list) > 1:
                bsp1_bi = seg.end_bi
                bsp1_bi_idx = bsp1_bi.idx
                BSP_CONF = self.config.GetBSConfig(seg.is_down())
                real_bsp1 = self.bsp1_dict.get(bsp1_bi.idx)
                next_seg_idx = seg.idx+1
                next_seg = seg.next  # 可能为None, 所以并不一定可以保证next_seg_idx == next_seg.idx
            else:
                next_seg = seg
                next_seg_idx = seg.idx
                bsp1_bi, real_bsp1 = None, None
                bsp1_bi_idx = -1
                BSP_CONF = self.config.GetBSConfig(seg.is_up())
            if BSP_CONF.bsp3_follow_1 and (not bsp1_bi or bsp1_bi.idx not in self.bsp_store_flat_dict):
                continue
            if next_seg:
                self.treat_bsp3_after(seg_list, next_seg, BSP_CONF, bi_list, real_bsp1, bsp1_bi_idx, next_seg_idx)
            self.treat_bsp3_before(seg_list, seg, next_seg, bsp1_bi, BSP_CONF, bi_list, real_bsp1, next_seg_idx)

    def treat_bsp3_after(
        self,
        seg_list: CSegListComm[LINE_TYPE],
        next_seg: CSeg[LINE_TYPE],
        BSP_CONF: CPointConfig,
        bi_list: LINE_LIST_TYPE,
        real_bsp1,
        bsp1_bi_idx,
        next_seg_idx
    ):
        first_zs = next_seg.get_first_multi_bi_zs()
        if first_zs is None:
            return
        if BSP_CONF.strict_bsp3 and first_zs.get_bi_in().idx != bsp1_bi_idx+1:
            return

        config = self.config.GetBSConfig(next_seg.is_down())
        bsp3a_max_zs_cnt = config.bsp3a_max_zs_cnt
        for zs_idx, zs in enumerate(next_seg.get_multi_bi_zs_lst()):
            if zs_idx >= bsp3a_max_zs_cnt:
                break
            if zs.bi_out is None or zs.bi_out.idx+1 >= len(bi_list):
                break
            bsp3_bi = bi_list[zs.bi_out.idx+1]
            if bsp3_bi.parent_seg is None:
                if next_seg.idx != len(seg_list)-1:
                    break
            elif bsp3_bi.parent_seg.idx != next_seg.idx:
                if len(bsp3_bi.parent_seg.bi_list) >= 3:
                    break
            if bsp3_bi.dir == next_seg.dir:
                break
            if bsp3_bi.seg_idx != next_seg_idx and next_seg_idx < len(seg_list)-2:
                break
            if bsp3_back2zs(bsp3_bi, zs):
                continue
            bsp3_peak_zs = bsp3_break_zspeak(bsp3_bi, zs)
            if BSP_CONF.bsp3_peak and not bsp3_peak_zs:
                continue
            feature_dict = {
                'bsp3_zs_height': (zs.high - zs.low)/zs.low,
                'bsp3_bi_amp': bsp3_bi.amp(),
            }
            self.add_bs(bs_type=BSP_TYPE.T3A, bi=bsp3_bi, relate_bsp1=real_bsp1, feature_dict=feature_dict)  # type: ignore

    def treat_bsp3_before(
        self,
        seg_list: CSegListComm[LINE_TYPE],
        seg: CSeg[LINE_TYPE],
        next_seg: Optional[CSeg[LINE_TYPE]],
        bsp1_bi: Optional[LINE_TYPE],
        BSP_CONF: CPointConfig,
        bi_list: LINE_LIST_TYPE,
        real_bsp1,
        next_seg_idx
    ):
        cmp_zs = seg.get_final_multi_bi_zs()
        if cmp_zs is None:
            return
        if not bsp1_bi:
            return
        if BSP_CONF.strict_bsp3 and (cmp_zs.bi_out is None or cmp_zs.bi_out.idx != bsp1_bi.idx):
            return
        end_bi_idx = cal_bsp3_bi_end_idx(next_seg)
        for bsp3_bi in bi_list[bsp1_bi.idx+2::2]:
            if bsp3_bi.idx > end_bi_idx:
                break
            assert bsp3_bi.seg_idx is not None
            if bsp3_bi.seg_idx != next_seg_idx and bsp3_bi.seg_idx < len(seg_list)-1:
                break
            if bsp3_back2zs(bsp3_bi, cmp_zs):  # type: ignore
                continue
            feature_dict = {
                'bsp3_zs_height': (cmp_zs.high - cmp_zs.low)/cmp_zs.low,
                'bsp3_bi_amp': bsp3_bi.amp(),
            }
            self.add_bs(bs_type=BSP_TYPE.T3B, bi=bsp3_bi, relate_bsp1=real_bsp1, feature_dict=feature_dict)  # type: ignore
            break

    def getSortedBspList(self) -> List[CBS_Point[LINE_TYPE]]:
        return sorted(self.bsp_iter(), key=lambda bsp: bsp.bi.idx)

    def get_latest_bsp(self, number: int) -> List[CBS_Point[LINE_TYPE]]:
        res = []
        for bsp in self.bsp_iter_v2():
            res.append(bsp)
            if number != 0 and len(res) >= number:
                break
        return res

def bsp2s_break_bsp1(bsp2s_bi: LINE_TYPE, bsp2_break_bi: LINE_TYPE) -> bool:
    return (bsp2s_bi.is_down() and bsp2s_bi._low() < bsp2_break_bi._low()) or \
           (bsp2s_bi.is_up() and bsp2s_bi._high() > bsp2_break_bi._high())

def bsp3_back2zs(bsp3_bi: LINE_TYPE, zs: CZS) -> bool:
    return (bsp3_bi.is_down() and bsp3_bi._low() < zs.high) or (bsp3_bi.is_up() and bsp3_bi._high() > zs.low)

def bsp3_break_zspeak(bsp3_bi: LINE_TYPE, zs: CZS) -> bool:
    return (bsp3_bi.is_down() and bsp3_bi._high() >= zs.peak_high) or (bsp3_bi.is_up() and bsp3_bi._low() <= zs.peak_low)

def cal_bsp3_bi_end_idx(seg: Optional[CSeg[LINE_TYPE]]):
    if not seg:
        return float("inf")
    if seg.get_multi_bi_zs_cnt() == 0 and seg.next is None:
        return float("inf")
    end_bi_idx = seg.end_bi.idx-1
    for zs in seg.zs_lst:
        if zs.is_one_bi_zs():
            continue
        if zs.bi_out is not None:
            end_bi_idx = zs.bi_out.idx
            break
    return end_bi_idx
```

## File: engine/chanpy/Chan.py
size: 13907
sha: 7202ab2ca310d03872868076033c2b4f9ecaee78
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Chan.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Chan.py

## File: engine/chanpy/ChanConfig.py
size: 7150
sha: b367f8cc7b97f1e960e6ca945b084a7f772fbbee
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/ChanConfig.py

```text
from typing import List

from Bi.BiConfig import CBiConfig
from BuySellPoint.BSPointConfig import CBSPointConfig
from Common.CEnum import TREND_TYPE
from Common.ChanException import CChanException, ErrCode
from Common.func_util import _parse_inf
from Math.BOLL import BollModel
from Math.Demark import CDemarkEngine
from Math.KDJ import KDJ
from Math.MACD import CMACD
from Math.RSI import RSI
from Math.TrendModel import CTrendModel
from Seg.SegConfig import CSegConfig
from ZS.ZSConfig import CZSConfig

class CChanConfig:
    def __init__(self, conf=None):
        if conf is None:
            conf = {}
        conf = ConfigWithCheck(conf)
        self.bi_conf = CBiConfig(
            bi_algo=conf.get("bi_algo", "normal"),
            is_strict=conf.get("bi_strict", True),
            bi_fx_check=conf.get("bi_fx_check", "strict"),
            gap_as_kl=conf.get("gap_as_kl", False),
            bi_end_is_peak=conf.get('bi_end_is_peak', True),
            bi_allow_sub_peak=conf.get("bi_allow_sub_peak", True),
        )
        self.seg_conf = CSegConfig(
            seg_algo=conf.get("seg_algo", "chan"),
            left_method=conf.get("left_seg_method", "peak"),
        )
        self.zs_conf = CZSConfig(
            need_combine=conf.get("zs_combine", True),
            zs_combine_mode=conf.get("zs_combine_mode", "zs"),
            one_bi_zs=conf.get("one_bi_zs", False),
            zs_algo=conf.get("zs_algo", "normal"),
        )

        self.trigger_step = conf.get("trigger_step", False)
        self.skip_step = conf.get("skip_step", 0)

        self.kl_data_check = conf.get("kl_data_check", True)
        self.max_kl_misalgin_cnt = conf.get("max_kl_misalgin_cnt", 2)
        self.max_kl_inconsistent_cnt = conf.get("max_kl_inconsistent_cnt", 5)
        self.auto_skip_illegal_sub_lv = conf.get("auto_skip_illegal_sub_lv", False)
        self.print_warning = conf.get("print_warning", True)
        self.print_err_time = conf.get("print_err_time", True)

        self.mean_metrics: List[int] = conf.get("mean_metrics", [])
        self.trend_metrics: List[int] = conf.get("trend_metrics", [])
        self.macd_config = conf.get("macd", {"fast": 12, "slow": 26, "signal": 9})
        self.cal_demark = conf.get("cal_demark", False)
        self.cal_rsi = conf.get("cal_rsi", False)
        self.cal_kdj = conf.get("cal_kdj", False)
        self.rsi_cycle = conf.get("rsi_cycle", 14)
        self.kdj_cycle = conf.get("kdj_cycle", 9)
        self.demark_config = conf.get("demark", {
            'demark_len': 9,
            'setup_bias': 4,
            'countdown_bias': 2,
            'max_countdown': 13,
            'tiaokong_st': True,
            'setup_cmp2close': True,
            'countdown_cmp2close': True,
        })
        self.boll_n = conf.get("boll_n", 20)

        self.set_bsp_config(conf)

        conf.check()

    def GetMetricModel(self):
        res: List[CMACD | CTrendModel | BollModel | CDemarkEngine | RSI | KDJ] = [
            CMACD(
                fastperiod=self.macd_config['fast'],
                slowperiod=self.macd_config['slow'],
                signalperiod=self.macd_config['signal'],
            )
        ]
        res.extend(CTrendModel(TREND_TYPE.MEAN, mean_T) for mean_T in self.mean_metrics)

        for trend_T in self.trend_metrics:
            res.append(CTrendModel(TREND_TYPE.MAX, trend_T))
            res.append(CTrendModel(TREND_TYPE.MIN, trend_T))
        res.append(BollModel(self.boll_n))
        if self.cal_demark:
            res.append(CDemarkEngine(
                demark_len=self.demark_config['demark_len'],
                setup_bias=self.demark_config['setup_bias'],
                countdown_bias=self.demark_config['countdown_bias'],
                max_countdown=self.demark_config['max_countdown'],
                tiaokong_st=self.demark_config['tiaokong_st'],
                setup_cmp2close=self.demark_config['setup_cmp2close'],
                countdown_cmp2close=self.demark_config['countdown_cmp2close'],
            ))
        if self.cal_rsi:
            res.append(RSI(self.rsi_cycle))
        if self.cal_kdj:
            res.append(KDJ(self.kdj_cycle))
        return res

    def set_bsp_config(self, conf):
        para_dict = {
            "divergence_rate": float("inf"),
            "min_zs_cnt": 1,
            "bsp1_only_multibi_zs": True,
            "max_bs2_rate": 0.9999,
            "macd_algo": "peak",
            "bs1_peak": True,
            "bs_type": "1,1p,2,2s,3a,3b",
            "bsp2_follow_1": True,
            "bsp3_follow_1": True,
            "bsp3_peak": False,
            "bsp2s_follow_2": False,
            "max_bsp2s_lv": None,
            "strict_bsp3": False,
            "bsp3a_max_zs_cnt": 1,
        }
        args = {para: conf.get(para, default_value) for para, default_value in para_dict.items()}
        self.bs_point_conf = CBSPointConfig(**args)

        self.seg_bs_point_conf = CBSPointConfig(**args)
        self.seg_bs_point_conf.b_conf.set("macd_algo", "slope")
        self.seg_bs_point_conf.s_conf.set("macd_algo", "slope")
        self.seg_bs_point_conf.b_conf.set("bsp1_only_multibi_zs", False)
        self.seg_bs_point_conf.s_conf.set("bsp1_only_multibi_zs", False)

        # 安全化: 原实现用 exec 拼接字符串装载配置, 已改为直接方法调用(vendor patch, 行为等价)
        for k, v in conf.items():
            if k.endswith("-buy"):
                self.bs_point_conf.b_conf.set(k.replace("-buy", ""), v)
            elif k.endswith("-sell"):
                self.bs_point_conf.s_conf.set(k.replace("-sell", ""), v)
            elif k.endswith("-segbuy"):
                self.seg_bs_point_conf.b_conf.set(k.replace("-segbuy", ""), v)
            elif k.endswith("-segsell"):
                self.seg_bs_point_conf.s_conf.set(k.replace("-segsell", ""), v)
            elif k.endswith("-seg"):
                self.seg_bs_point_conf.b_conf.set(k.replace("-seg", ""), v)
                self.seg_bs_point_conf.s_conf.set(k.replace("-seg", ""), v)
            elif k in args:
                self.bs_point_conf.b_conf.set(k, v)
                self.bs_point_conf.s_conf.set(k, v)
            else:
                raise CChanException(f"unknown para = {k}", ErrCode.PARA_ERROR)
        self.bs_point_conf.b_conf.parse_target_type()
        self.bs_point_conf.s_conf.parse_target_type()
        self.seg_bs_point_conf.b_conf.parse_target_type()
        self.seg_bs_point_conf.s_conf.parse_target_type()

class ConfigWithCheck:
    def __init__(self, conf):
        self.conf = conf

    def get(self, k, default_value=None):
        res = self.conf.get(k, default_value)
        if k in self.conf:
            del self.conf[k]
        return res

    def items(self):
        visit_keys = set()
        for k, v in self.conf.items():
            yield k, v
            visit_keys.add(k)
        for k in visit_keys:
            del self.conf[k]

    def check(self):
        if len(self.conf) > 0:
            invalid_key_lst = ",".join(list(self.conf.keys()))
            raise CChanException(f"invalid CChanConfig: {invalid_key_lst}", ErrCode.PARA_ERROR)
```

## File: engine/chanpy/ChanModel/Features.py
size: 475
sha: da7091b3cc3e3e6e06cb1bd1c45bdb370c2cbcc6
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/ChanModel/Features.py

```text
from typing import Optional

class CFeatures:
    def __init__(self, initFeat=None):
        self.__features = {} if initFeat is None else dict(initFeat)

    def items(self):
        yield from self.__features.items()

    def __getitem__(self, k):
        return self.__features[k]

    def add_feat(self, inp1, inp2: Optional[float] = None):
        if inp2 is None:
            self.__features.update(inp1)
        else:
            self.__features.update({inp1: inp2})
```

## File: engine/chanpy/Combiner/__init__.py
size: 0
sha: e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Combiner/__init__.py

```text

```

## File: engine/chanpy/Combiner/Combine_Item.py
size: 955
sha: 977608b4674ecb8343d58f111d0c7e3649da8b87
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Combiner/Combine_Item.py

```text
from Common.ChanException import CChanException, ErrCode

class CCombine_Item:
    def __init__(self, item):
        from Bi.Bi import CBi
        from KLine.KLine_Unit import CKLine_Unit
        from Seg.Seg import CSeg
        if isinstance(item, CBi):
            self.time_begin = item.begin_klc.idx
            self.time_end = item.end_klc.idx
            self.high = item._high()
            self.low = item._low()
        elif isinstance(item, CKLine_Unit):
            self.time_begin = item.time
            self.time_end = item.time
            self.high = item.high
            self.low = item.low
        elif isinstance(item, CSeg):
            self.time_begin = item.start_bi.begin_klc.idx
            self.time_end = item.end_bi.end_klc.idx
            self.high = item._high()
            self.low = item._low()
        else:
            raise CChanException(f"{type(item)} is unsupport sub class of CCombine_Item", ErrCode.COMMON_ERROR)
```

## File: engine/chanpy/Combiner/KLine_Combiner.py
size: 6396
sha: 41aee703c1e4c3b69e0555910650d9b9bc090ff0
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Combiner/KLine_Combiner.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Combiner/KLine_Combiner.py

## File: engine/chanpy/Common/__init__.py
size: 0
sha: e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Common/__init__.py

```text

```

## File: engine/chanpy/Common/cache.py
size: 914
sha: f1f0a7b1daa37f7a92a8456aeb7cc5b600c3e0f5
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Common/cache.py

```text
import inspect
import types

class make_cache:
    def __init__(self, func):
        self.func = func

        fargspec = inspect.getfullargspec(func)
        if len(fargspec.args) != 1 or fargspec.args[0] != "self":
            raise Exception("@memoize must be `(self)`")

        # set key for this function
        self.func_key = str(func)

    def __get__(self, instance, cls):
        if instance is None:
            raise Exception("@memoize's must be bound")

        if not hasattr(instance, "_memoize_cache"):
            setattr(instance, "_memoize_cache", {})

        return types.MethodType(self, instance)

    def __call__(self, *args, **kwargs):
        instance = args[0]
        cache = instance._memoize_cache

        if self.func_key in cache:
            return cache[self.func_key]

        result = self.func(*args, **kwargs)
        cache[self.func_key] = result
        return result
```

## File: engine/chanpy/Common/CEnum.py
size: 2308
sha: 98c18418780c4c4803790127ca29b48929b4f53b
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Common/CEnum.py

```text
from enum import Enum, auto
from typing import Literal

class DATA_SRC(Enum):
    BAO_STOCK = auto()
    CCXT = auto()
    CSV = auto()
    AKSHARE = auto()

class KL_TYPE(Enum):
    K_1S = 1
    K_3S = 2
    K_5S = 3
    K_10S = 4
    K_15S = 5
    K_20S = 6
    K_30S = 7
    K_1M = 8
    K_3M = 9
    K_5M = 10
    K_10M = 11
    K_15M = 12
    K_30M = 13
    K_60M = 14
    K_DAY = 15
    K_WEEK = 16
    K_MON = 17
    K_QUARTER = 18
    K_YEAR = 19

class KLINE_DIR(Enum):
    UP = auto()
    DOWN = auto()
    COMBINE = auto()
    INCLUDED = auto()

class FX_TYPE(Enum):
    BOTTOM = auto()
    TOP = auto()
    UNKNOWN = auto()

class BI_DIR(Enum):
    UP = auto()
    DOWN = auto()

class BI_TYPE(Enum):
    UNKNOWN = auto()
    STRICT = auto()
    SUB_VALUE = auto()  # 次高低点成笔
    TIAOKONG_THRED = auto()
    DAHENG = auto()
    TUIBI = auto()
    UNSTRICT = auto()
    TIAOKONG_VALUE = auto()

BSP_MAIN_TYPE = Literal['1', '2', '3']

class BSP_TYPE(Enum):
    T1 = '1'
    T1P = '1p'
    T2 = '2'
    T2S = '2s'
    T3A = '3a'  # 中枢在1类后面
    T3B = '3b'  # 中枢在1类前面

    def main_type(self) -> BSP_MAIN_TYPE:
        return self.value[0]  # type: ignore

class AUTYPE(Enum):
    QFQ = auto()
    HFQ = auto()
    NONE = auto()

class TREND_TYPE(Enum):
    MEAN = "mean"
    MAX = "max"
    MIN = "min"

class TREND_LINE_SIDE(Enum):
    INSIDE = auto()
    OUTSIDE = auto()

class LEFT_SEG_METHOD(Enum):
    ALL = auto()
    PEAK = auto()

class FX_CHECK_METHOD(Enum):
    STRICT = auto()
    LOSS = auto()
    HALF = auto()
    TOTALLY = auto()

class SEG_TYPE(Enum):
    BI = auto()
    SEG = auto()

class MACD_ALGO(Enum):
    AREA = auto()
    PEAK = auto()
    FULL_AREA = auto()
    DIFF = auto()
    SLOPE = auto()
    AMP = auto()
    VOLUMN = auto()
    AMOUNT = auto()
    VOLUMN_AVG = auto()
    AMOUNT_AVG = auto()
    TURNRATE_AVG = auto()
    RSI = auto()

class DATA_FIELD:
    FIELD_TIME = "time_key"
    FIELD_OPEN = "open"
    FIELD_HIGH = "high"
    FIELD_LOW = "low"
    FIELD_CLOSE = "close"
    FIELD_VOLUME = "volume"  # 成交量
    FIELD_TURNOVER = "turnover"  # 成交额
    FIELD_TURNRATE = "turnover_rate"  # 换手率

TRADE_INFO_LST = [DATA_FIELD.FIELD_VOLUME, DATA_FIELD.FIELD_TURNOVER, DATA_FIELD.FIELD_TURNRATE]
```

## File: engine/chanpy/Common/ChanException.py
size: 2205
sha: a4036d0a76c8615e5c920c2cae305699222ca3c8
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Common/ChanException.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Common/ChanException.py

## File: engine/chanpy/Common/CTime.py
size: 1521
sha: 47f40763eab1da1aa19a55ae7d924a8e34a11c5c
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Common/CTime.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Common/CTime.py

## File: engine/chanpy/Common/func_util.py
size: 907
sha: 7b45251147c09497a75aee62bc9a30be41c4cdbc
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Common/func_util.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Common/func_util.py

## File: engine/chanpy/DataAPI/__init__.py
size: 0
sha: e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/DataAPI/__init__.py

```text

```

## File: engine/chanpy/DataAPI/CommonStockAPI.py
size: 720
sha: 5ec130b07157e2e0d3553de8160c4f9e46a803ef
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/DataAPI/CommonStockAPI.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/DataAPI/CommonStockAPI.py

## File: engine/chanpy/DataAPI/csvAPI.py
size: 3035
sha: 401b9c746cf2b64c8b8f84634a5d1c12d91c7f37
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/DataAPI/csvAPI.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/DataAPI/csvAPI.py

## File: engine/chanpy/KLine/__init__.py
size: 0
sha: e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/KLine/__init__.py

```text

```

## File: engine/chanpy/KLine/KLine.py
size: 4439
sha: 885a78fec7d9e4a8b203dc9dc018fcab7a96ec9b
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/KLine/KLine.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/KLine/KLine.py

## File: engine/chanpy/KLine/KLine_List.py
size: 8111
sha: f62b125397ab49e18eb7585981aa23a41702c7f1
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/KLine/KLine_List.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/KLine/KLine_List.py

## File: engine/chanpy/KLine/KLine_Unit.py
size: 5728
sha: ac5389cddc9a2ff431a021d409e59d0c8f05392e
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/KLine/KLine_Unit.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/KLine/KLine_Unit.py

## File: engine/chanpy/KLine/TradeInfo.py
size: 422
sha: 47c86f145475c7a1209464c6a87bd6b4bcc49a2e
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/KLine/TradeInfo.py

```text
from typing import Dict, Optional

from Common.CEnum import TRADE_INFO_LST

class CTradeInfo:
    def __init__(self, info: Dict[str, float]):
        self.metric: Dict[str, Optional[float]] = {}
        for metric_name in TRADE_INFO_LST:
            self.metric[metric_name] = info.get(metric_name)

    def __str__(self):
        return " ".join([f"{metric_name}:{value}" for metric_name, value in self.metric.items()])
```

## File: engine/chanpy/LICENSE
size: 1061
sha: 325b9224b5a8b6b91e4f059120d006476c1f834d
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/LICENSE

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/LICENSE

## File: engine/chanpy/Math/__init__.py
size: 0
sha: e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Math/__init__.py

```text

```

## File: engine/chanpy/Math/BOLL.py
size: 672
sha: 26322681d3ef64da3a497f284373110b44be3743
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Math/BOLL.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Math/BOLL.py

## File: engine/chanpy/Math/Demark.py
size: 8239
sha: 82d9b05b854540e086908224604d9b2b143d9177
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Math/Demark.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Math/Demark.py

## File: engine/chanpy/Math/KDJ.py
size: 924
sha: 0fad01aedba95a99ec0aefb90f59647febd4e99f
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Math/KDJ.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Math/KDJ.py

## File: engine/chanpy/Math/MACD.py
size: 1186
sha: 15b6fd625c6adf7de784a36c62f959bbe78d5747
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Math/MACD.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Math/MACD.py

## File: engine/chanpy/Math/RSI.py
size: 1235
sha: b00211c680d0491154acbf15c7b93b597fbe8498
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Math/RSI.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Math/RSI.py

## File: engine/chanpy/Math/TrendLine.py
size: 2157
sha: 60ec487efcd3e842e773405ac04fd0e79b314329
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Math/TrendLine.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Math/TrendLine.py

## File: engine/chanpy/Math/TrendModel.py
size: 733
sha: ee63a10a06db0952e253116f45893d71c9fe366c
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Math/TrendModel.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Math/TrendModel.py

## File: engine/chanpy/NOTICE.md
size: 705
sha: bcd52ca960915eef54110702d877912faa5fa49a
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/NOTICE.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/NOTICE.md

## File: engine/chanpy/Seg/__init__.py
size: 0
sha: e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/__init__.py

```text

```

## File: engine/chanpy/Seg/Eigen.py
size: 1014
sha: af38a5e34528dc272e83ca2195a12354bc19f1fb
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/Eigen.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/Eigen.py

## File: engine/chanpy/Seg/EigenFX.py
size: 8063
sha: 6fb30e5ac5fa9c005e13031948c8fdfa15c826c2
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/EigenFX.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/EigenFX.py

## File: engine/chanpy/Seg/Seg.py
size: 5966
sha: 4ddae92eb8fcac21054b4e9e606790a9850aec4a
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/Seg.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/Seg.py

## File: engine/chanpy/Seg/SegConfig.py
size: 493
sha: 0ee3f55a58afb93f988cb6569b35655ad665fc22
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/SegConfig.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/SegConfig.py

## File: engine/chanpy/Seg/SegListChan.py
size: 3430
sha: 622043c6b08ed1c5ff4b81fd00fca296cc3f4144
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/SegListChan.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/SegListChan.py

## File: engine/chanpy/Seg/SegListComm.py
size: 8493
sha: 29a3a18683d4fe34f765749d3c07a7779d08e0b3
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/SegListComm.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/SegListComm.py

## File: engine/chanpy/Seg/SegListDef.py
size: 2298
sha: 944b1292c4c12210d525f814620ac38679cf06e5
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/SegListDef.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/SegListDef.py

## File: engine/chanpy/Seg/SegListDYH.py
size: 3883
sha: 2f18135433c29d5653c48bfe5e4f430abd9cc90a
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/SegListDYH.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/Seg/SegListDYH.py

## File: engine/chanpy/ZS/__init__.py
size: 0
sha: e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/ZS/__init__.py

```text

```

## File: engine/chanpy/ZS/ZS.py
size: 7640
sha: 1e0c982f5ac8c7833e02df529028241eba785b87
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/ZS/ZS.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/ZS/ZS.py

## File: engine/chanpy/ZS/ZSConfig.py
size: 271
sha: f5c1286488dd7f67dabc4b5140b27b7b1fa9a769
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/ZS/ZSConfig.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/ZS/ZSConfig.py

## File: engine/chanpy/ZS/ZSList.py
size: 6381
sha: c0cbef2523935d383186eb4e186b2f0f5f2c8289
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/ZS/ZSList.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/engine/chanpy/ZS/ZSList.py

## File: LICENSE
size: 1090
sha: 39ab0a01eed869cfb64d0d62801a77f305f2db82
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/LICENSE

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/LICENSE

## File: SECURITY.md
size: 1522
sha: 3fe37db44ae9848829fe09924173989a02873232
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/SECURITY.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/SECURITY.md

## File: TROUBLESHOOTING.md
size: 1440
sha: 312eb8fdb79228b8bcf1289c000b371d380a83f9
upstream: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/TROUBLESHOOTING.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/adsorgcn/chanlun-engine-skill/blob/HEAD/TROUBLESHOOTING.md
