量因子该做成开关不是权重；前序因子不该进仓位

把 step49/50 两个分层结论做成仓位因子做组合层面评估，结果与分层表给人的印象
不一致，两个因子的命运相反。

方法上设了三道约束——分层结论转仓位规则最容易在这三处翻车：

  1 阈值取整数（vr60 切 1/2/4）、权重取整数比，一个参数都不搜。观测到的四分位
    边界在不同时段并不一致（样本外 0.63/1.26/2.28/5.34、发现期 0.62/1.48/
    3.11/7.97），用样本分位数等于在同一批数据上既发现又调参
  2 权重归一化到均值 1，各方案投出去的平均资金相同，均R 才可比
  3 判据是四项一起看：均R / R夏普 / 最大回撤 / 峰值加权并发。只看均值必然误判

全样本 3941 笔，假定滑点 5bp/taker 腿：

                     盈亏平衡滑点  R夏普  回撤R  峰值并发  总R/峰值并发
  等权（现状）           16.7bp   0.420  17.3    7.00      371.4
  仅量因子（加权）       18.2bp   0.442  12.7    7.98      367.4
  仅前序因子             17.0bp   0.421  19.2    8.46      312.6
  硬砍高量档（vr60≥4）   18.6bp   0.496  11.2    6.00      389.3
  硬砍 + 前序权重        19.0bp   0.500  11.0    7.19      332.1

① 前序因子不能做仓位。+6bp 余量在 5bp 滑点假设下只值约 0.011R，而这批信号
按定义 100% 发生在别的币已有仓位时——加权就是在敞口最集中的时刻加杠杆。
盈亏平衡只买到 +0.3bp，峰值并发 7.00→8.46、回撤 17.3→19.2，按峰值保证金归一
后是净负的（371→313）。§3.31 里「可用于加仓位权重」那句作废。出路可能是改用
放宽 ATR 门控兑现（多做几笔而非每笔做大），未测。

② 量因子「不做」优于「少做」。硬砍付笔数 −22%、总R −10%，换回撤 −35% 和峰值
并发 7→6。并发这一项单独就值：§3.31 已把峰值敞口列为扩币的前置约束。

③ 优势的形态是削尾不是抬均值。均R 差在各滑点档几乎恒定（0.085→0.082），但
基数在塌，所以相对优势随成本上升放大：15bp 处总R/回撤 2.57→11.86，靠的是回撤
从 150.5 掉到 60.3。这两个因子买的是尾部风险，不是收益。

可操作口径要用发现期：盈亏平衡滑点样本外 18.2bp、发现期只有 13.5bp（硬砍后
15.6bp），差距就是 2026 的 ATR 压缩。13.5 与 shadow_budget 的 15.19bp 同量级，
互为印证。影子测量要对标 13.5 / 15.6，不是 18.6。

开关先不上：只是 live 信号路径加一行，随时能加。等实测滑点出来再定——远低于
13.5bp 则等权就够，贴着 13.5bp 则这 2.1bp 就是生死线。

Co-authored-by: Cursor <cursoragent@cursor.com>

.gitignore

@@ -1,39 +1,48 @@
 # MacOS
 .DS_Store
 
-# Python编译文件和缓存
+# Python
 __pycache__/
 *.py[cod]
 *$py.class
 *.pyc
 *.pyo
+.pytest_cache/
 
-# 策略文件的缓存
-strategies/__pycache__/
-
-# Machine Learning / AI model files
-*_model*_xgb_model.json
-*modelchan*.json
-*.libsvm
-feature_meta
-*_model_feature_data.csv
-*.pem
-
-# Log files
+# Logs & databases
 *.log
-
-# Database files
 *.sqlite
 *.sqlite-shm
 *.sqlite-wal
-.DS_Store
-交易记录/~$交易规则.docx
-/datasvc/data
-.DS_Store
-.DS_Store
-/data_provider/data
-.DS_Store
-.DS_Store
-.DS_Store
-.DS_Store
-.DS_Store
+
+# Office documents kept alongside the repo but not part of it.
+# "~$" files are Excel's lock files, recreated every time a workbook is opened.
+*.xlsx
+*.xls
+~$*
+
+# Local data
+data/
+
+# Exchange history fetched by research/live/*.py. 40MB and re-fetchable from
+# the venue, so it stays local; the small result CSVs it feeds are committed.
+research/live/cache/
+
+# Scratch outputs from short shakedown runs, superseded by the real collection.
+research/out/archive/
+
+# Per-trade simulation dumps from research/step*.py. 70MB+ and regenerable by
+# rerunning the step; the summaries they feed live in HANDOFF.md.
+research/out/*.feather
+
+# Virtualenvs. venv writes its own .gitignore since 3.11, but only for the
+# directory it creates — declare it here so other layouts are covered too.
+.venv/
+venv/
+
+# Local tooling
+.gstack/
+research/out/*.jsonl.gz
+research/out/penetration.csv
+research/out/shadow_*.csv
+research/out/run_meta_*.json

K线动能理论.txt

@@ -1,236 +0,0 @@
-均线
-5m, 15m, 30m, 1h, 2h, 4h, 8h, 12h, 16h, 1d, 2d, 3d, 1w, 2w, 1M
-
-参考时间周期
-大周期：1h
-小周期：15m
-
-价格在1h周期ema156之上为大周期上涨，反之为大周期下跌
-在1h大周期上涨时，小周期15m，下跌触碰到
-
-顺大逆小
-大周期看多，小周期跌完做多，跌完：顶分型和EMA52归零轴反弹
-大周期看空，小周期涨完做空，涨完：顶分型和EMA52归零轴反抽
-
-中枢分类
-常规中枢
-上升中枢
-收敛中枢
-扩散中枢
-下行中枢
-止损放到顶底分型的高低点
-1. 从大周期开始找到价格接近ema52，MACD也接近零轴的周期，需要看这个周期的长级别是否高位空，大趋势方向
-2. 然后去小于这个时间周期的周期找买卖点，小级趋势方向和大趋势相反并且开始反向，小级别需要检查MACD是否归零轴反转，同时价格是否接近EMA52
-
-
-EMA52线的反弹比零轴的反弹弱
-EMA52线和MACD白线同时归零轴同时满足的话是完美形态，最佳买卖点
-
-跟随策略，先调整小级别，然后依次往大级别调整，直到整个周期结束
-大级别MACD在零轴之上为多头趋势，回调踩EMA52做多，直到跳空背离，隐形，更大级别EMA52顶部归零轴平仓
-大级别MACD在零轴之下为空头趋势，上涨踩EMA52做空，直到跳空背离，隐形，更大级别EMA52底部归零轴平仓
-盘整趋势在零轴上下移动，价格在大级别EMA52之间移动，根据连续跳空背离，隐形，归零轴EMA52线开仓和平仓
-
-
-
-MACD归零轴的两种情况，两者是或的关系，满足任意一种都是归零轴，归零轴的四种走势：
-1. K线下跌或者上涨后触碰当前时间级别的EMA52附近
-2. MACD的白线快线无限接近零轴，
-3. MACD归零轴时，如果此时k线始终保持在EMA24附近，如果一直是EMA24之上之后出现反弹行情就会很大（最强反弹）这种反弹是2个时间级别同时归零轴形成的反弹，容易创新高新低，一般出现在强势行情。
-4. K线先触碰EMA52，而MACD黄白线都未归零轴
-
-高位空
-当MACD的黄白线远离零轴运行时，与零轴有一定的距离，形成了零轴的高危形态。随着K线出现缓慢上涨或者下跌，或者盘整，MACD的能量柱出现衰减，同时能量柱与MACD黄白线形成空间夹角，随着能量柱越来越小，夹角越来越大形成高位空。这种容易形成回调下跌，特别是导致次一级的MACD穿越零轴
-
-穿越零轴的定义，需要同时满足以下条件
-1. 在某个时间级别，k线的价格或者指数有效击穿当前时间级别的EMA52
-2. MACD黄线慢线有效击穿零轴
-
-MACD黄白线和零轴的几种形态：
-离开零轴
-当MACD黄白线穿过零轴那么进入第一阶段离开零轴，此时能量柱变化越来越大，不断增长，k线加速上涨
-高位
-当MACD黄白线离开零轴，到一高点时，能量柱此时处于最大，开始减弱时MACD处于高位，高位时MACD黄白线和能量柱是同向的，高位过后是高位空
-高位空
-当MACD黄白线处于高位，随着K线出现缓慢上涨或者横盘整理，MACD黄白线保持高位出现平滑横盘走势，此时，MACD的能量柱出现衰减变化，同时能量柱和黄白线之间形成一定的空间夹脚，随着能量柱的不断衰减就导致黄白线和能量柱之间的空间夹脚越来越大，因此就形成高位空
-归零轴
-当MACD黄白线在高位，驱动K线上涨的能量所产生的加速度小于或者等于零，K线减速上涨或者下跌，能量变化越来越小，能量柱呈现出一根比一根短的排列方式
-穿零轴
-同时满足以下两个条件
-1. 在某个时间级别，K线的价格或者指数有效击穿当前时间级别的EMA52
-2. 当前时间级别MACD的黄线慢线有效击穿零轴
-有效的定义是：当前K线正好击穿EMA52的支撑位后，如果当前这个K线收盘后的第二根K线任然保持在EMA52之下才算有效击穿，如果只是上下影线击穿，后期K线任然运行在EMA52之上不算有效击穿，MACD同理
-零轴缠绕/纠缠
-具体是指MACD跟零轴无限接近或者缠绕的状态，或者是已经完成第一次归零轴调整之后，在等待大级别调整的时候。
-分为无限接近和上下缠绕状态。代表本级别已经调整完毕，即不产生反弹支撑，也不形成阻力压力，不考虑次级别的技术形态，通过更大的时间级别或者其他时间级别进行分析
-
-隐形形态
-当MACD的黄白线发生交叉时，必有相应的能量柱释放出来。金叉，则会释放零轴之上的能量柱，反之死叉，则会释放出零轴之下的能量柱。如果黄白线无交叉，而k线出现上涨或者下跌，则代表能量柱的隐形状态，代表K线的运行无能量配合，那么这种上涨或者下跌就变成无效的结果。无能量配合的上涨必下跌，无能量配合的下跌必反弹
-1. 远离零轴的高位隐形形态
-某个时间级别的MACD黄白线处在远离零轴的高位，且K线继续拉升上涨或者下跌，但是并没有释放出相对应方向的能量柱，此后，K线将出现归零轴的走势下跌或者上涨。此形态是高位隐形形态+高位空的形态，则当前级别的MACD在后续走势中必将出现会拉零轴甚至穿零轴的走势。因此，远离零轴的高位隐形形态解决的是当前时间级别归零轴的需求。
-2. 归零轴的隐形形态
-归零轴后反弹出现的隐形形态，我们称之为归零轴的隐形形态。这种形态必然会导致当前级别的MACD黄白线出现穿零轴的走势。MACD在归零轴的情况下，零轴所提供的反弹或者支撑能量是最大的，而如果零轴所能提供的最大能量都产生不了相应的能量柱，这种支撑就变成了无效的支撑，MACD的黄白线就只能击穿零轴渠道零轴的反方向。
-如何确认隐形形态的顶部
-1. 通过顶底分型来确认
-2. 通过次级别的背离确认隐形高位
-3. 通过单位调整周期之内的时间级别嵌套逻辑确认隐形的高位
-顶底分型在K线动能理论的应用
-1. 分型对应的MACD处在高位空的形态
-2. 分型所对应的MACD出现隐形形态
-
-零轴之上高位隐形 + K线顶分型 = 下跌归零轴
-零轴之上归零轴隐形 + K线顶分型 = 下跌穿零轴
-
-零轴之下高位隐形 + K线底分型 = 上涨归零轴
-零轴之下归零轴隐形 + K线底分型 = 上涨穿零轴
-
-K线的3种盘整结构，上涨和下跌均适用，下面是上涨结构的分析，下跌反之
-1. K线强势的走势结构
-一般应用是在单边上涨行情中，某个时间级别的K线经过一轮拉升之后，进入调整的阶段，此时K线如果在高位一直处于横盘震荡走势，而MACD的黄白线却趋于归零轴运行，则当黄白线归零轴之后，出现有效反弹行情。
-2. K线超强势结构
-超强势结构往往容易发生破前高的走势。在某个时间级别，当K线经过一轮强势拉升上涨后，变为倾斜向上缓慢上行，K线一直处于这个时间级别的EMA24之上或者附近，经过一段时间的运行，导致当前级别的MACD黄白线无限归零轴的形态，此时，K线往往容易出现速度快，力度强且破前高的走势。对于超强势调整结构，最重要的是次级别不破零轴，并保持在当前级别的EMA24之上或者附近，而当前级别的黄白线运动一段时间后无限趋于零轴。一般来说，超强势调整结构容易出现在某个大的时间级别处于单边行情中。
-3. 弱势调整结构
-在弱势调整结构中，K线是通过下跌的方式快速地将当前级别的MACD的黄白线拉回零轴，同时，K线的价格也会快速下跌到本级别EMA52附近位置。在弱势调整结构中，MACD归零轴后所形成的支撑反弹往往不会破前高，而是走出能量不足的走势形态。在此结构中，只有MACD的黄白线出现死叉后才会继续下跌，并且只有在弱势调整结构中，死叉下跌才有效。
-
-
-单位调整周期
-指K线在某个时间级别，MACD的黄白线由零轴出发到远离零轴再到回到零轴的区间段称为这个时间级别的调整周期。可以分为零轴同方向和穿零轴出发两种。一个单位调整周期的起点往往是买点，同时终点也是另一个周期的买点。单位周期的判断依据是黄白线归零轴不是量能柱的多少。
-注意：如果单位调整周期的起始和终止都直接穿零轴的，代表这个时间级别在运行的过程中，是无效的时间级别，也就是这个时间级别在我们的分析的过程中要跳过的。
-隐形单位调整周期
-MACD黄白线归零轴后，由于零轴的支撑或者压力而发生的反弹或者反抽，没有释放出相应的能量柱而形成的周期，为隐形单位调整周期。隐形单位调整周期会引起黄白线反向穿零轴的走势。
-
-零轴粘合
-MACD黄白线在刚穿零轴的时候会出现：黄白线离零轴的距离比较近，黄白线沿着能量柱运行，黄白线在运行的过程中没有释放出反向能量柱。零轴粘合属性是：强支撑，弱反弹。这种形态我们更强调支撑能量，弱化反弹属性。零轴粘合几乎是贴近零轴运行，因此其反弹的动能就是为无效。斜率小，黄白线喝能量柱之间基本没有空隙。能量柱可以略微减弱但是不能释放下跌方向的能量柱。由此可见黄线没有跟白线有交叉，黄线对白线有支撑作用。如果当前时间级别内部逻辑关系走完，这个时间级别则被视为无效时间级别。
-
-零轴倒挂
-MACD黄白线在穿零轴的时候与零轴的距离比较近，同时黄白线沿着能量柱运行，在运行的过程中，能量柱衰减导致它跟黄白线之间形成夹角空位，同时黄白线产生交叉并释放反向能量柱。
-1. 黄白线穿零轴后未远离零轴形成一定高度，而是靠近零轴运行
-2. 能量柱的衰减导致其与黄白线之间形成了一定的夹角空位
-3. 黄白线在运行的过程中发生了交叉而放出反向能量柱
-弱支撑，弱反弹。如果当前时间级别内部逻辑关系走完，这个时间级别则被视为无效时间级别。如果某个时间级别的盘口形态是零轴倒挂，那么这个时间级别很容易直接击穿零轴，而无法形成有效的反弹和反抽行情。
-
-零轴粘合和倒挂的有效性
-在上涨行情中，当K线处在零轴粘合或者零轴倒挂的形态时，如果K线的价格处在当前级别的EMA52之上或者处在多级别EMA均线交汇处之上和附近时，此时由于K线受到EMA均线的支撑，零轴粘合或者零轴倒挂反而容易形成强支撑的特点。此时需要结合MACD的形态和K线均线支撑综合分析盘面。
-
-线段
-上涨线段是指MACD的黄白线第一次上穿零轴到下一次下穿零轴中间的运行区域，以黄线穿零轴为准。在这个线段找到阶段性的卖点，阶段性高点。
-下跌线段是指MACD的黄白线第一次下穿零轴到下一次上穿零轴中间的运行区域，以黄线穿零轴为准。在这个线段找到阶段性的买点，阶段性低点。
-1. 同一条线段是比较背离的区域，背离的比较不可再跨线段的区域进行
-2. 线段可以将不同时间级别的K线化繁为简，一个时间级别的形态只需要确定盘面所处的线段即可
-
-背离
-在K线分析中，背离是指价格跟能量之间的相悖性，当价格创出阶段性新高点，而推动价格上涨的能量出现衰减，这种情况就是背离，也就是说价格和能量之间产生了不匹配关系。
-
-顶背离 - 确认卖点
-在某个时间级别，MACD运行在零轴上方，当K线的价格走势一峰比一峰高，价格一直处在上涨趋势中时，MACD的黄白线或者能量柱的高度却一波比一波低，即当价格的高点比前一次价格的高点高，而MACD指标的高点比前一次高点低，这种形态称为顶背离形态。需要注意的是，这两次高点在运行的过程中，MACD的黄白线始终处在同一条上涨线段周期中，不能跨线段比较。
-顶背离包括黄白线背离和柱背离两种情况，也可能出现多次背离的情况。线背离以白线的最高点作为参考点，K线上影线最高点作为K线的参考点，能量堆的最高点可能和K线的最高点不是一一对应，但是不影响判断，可以使用能量堆的面积进行计算。
-
-底背离 - 确认买点
-在某个时间级别，MACD运行在零轴下方，一般出现价格的低位区。当K线的价格走势持续下跌，而MACD的黄白线或者能量柱却持续靠近零轴，即当前价格的低点比前一次低点好要低，而MACD指标的低点却比前一次低点高，但是下跌能量却在衰减的现象，于是价格跌无可跌，是短期买入信号
-底背离包括黄白线背离和柱背离两种情况，也可能出现多次背离的情况。线背离以白线的最低点作为参考点，K线上影线最低点作为K线的参考点，能量堆的最低点可能和K线的最低点不是一一对应，但是不影响判断，可以使用能量堆的面积进行计算。
-
-顶底背离高低点有效性的方法
-1. 通过顶底分型确认顶底背离的高低点
-2. 通过次级别的背离确认当前级别的背离高点，这里的次级别不是单指一级次级别，可以是多级的
-
-单位调整周期内的连续跳空背离
-K线经过一波上涨或者下跌后，MACD的黄白线由高位回零轴且未归到零轴，能量柱在连续的衰减调整过程中，反而逐渐由衰减转为增长，于是就出现了跳空走势，这种走势称为MACD的连续跳空形态。
-1. 连续跳空发生在单位调整周期内，线跟柱在零轴同方向
-2. MACD的能量柱需包含在黄白线之内
-3. 能量柱在衰减的过程中未放出反向能量柱，而是由衰减转为增长
-单位调整周期之内的背离是价格跟能量柱之间的关系，同时单位调整周期之内的背离，解决的是归零轴的需求
-连续跳空的应用和意义
-单位调整周期之内，能量堆连接在一起的时候，出现的价格跟能量柱之间的关系即为连续跳空，而连续跳空的意义
-1. 连续跳空背离解决归零轴的需求，主要是小级别的走势，比如5分钟的连续跳空背离则为归零轴走势，因为5分钟级别只包含一个3分钟级别，是5分钟内的小级别，因此，5分钟级别如果出现连续跳空背离，会导致5分钟级别MACD黄白线归零轴走势
-2. 连续跳空更大的作用是确认穿零轴之后的第一个背离参考点，当MACD黄白线穿零轴的时候，最重要的是确认当前线段的1号参考点，有了1号参考点，后续行情才有参考的对象。连续跳空往往发生在MACD黄白线刚刚穿零轴的位置，一般由零轴粘合的形态演化而成连续跳空，这是因为零轴粘合具有强支撑的特点，容易形成跳空走势。
-
-穿零轴时的参考点确认方法
-1. 如果MACD黄白线穿零轴之后出现连续跳空，则以连续跳空的高点作为1号参考点，此时连续跳空形态代表新的单位周期调整周期的开始。当黄白线穿零轴后，黄线之后的第一个能量堆没有更高的能量柱，而是到了第一个跳空高低点出现第一个高低点。穿零轴产生的能量柱左侧黄白线处在下跌线段，右侧处在上涨线段。因此穿零轴的能量柱被切成两半，左侧在下跌线段，所以不能以黄线击穿零轴的左侧作为上涨线段的1号参考点。背离一定要在同一线段中进行比较，而不能跨线段找背离。那么穿零轴之后跳空产生的高低点才能作为1号参考点。后续的背离要以这个参考点进行比较。
-2. 如果MACD黄白线穿零轴后无连续跳空，没有更高的能量柱出现则不能确定1号参考点，如果穿零轴后没有找到更高低的能量柱，那么这个线段的第一个单位调整周期是无效周期。
-3. 如果黄线穿零轴之后有更高低的能量柱，则以更高的能量柱作为1号参考点，此参考点可以是穿零轴时的能量柱高点确定。
-
-单位调整周期之内的分立跳空背离
-在某个时间级别，当一个单位调整周期之内包含两个或者两个以上的能量堆，能量堆之间被反向能量堆分隔开，同时MACD黄白线一直处于远离零轴的高位，未归零轴，且一直保持原有的趋势运行，被分割的能量堆与黄白线都处在零轴的同方向，能量堆包含在黄白线之内，就形成分离跳空形态。
-分立跳空背离
-如果在某个时间级别的单位调整周期内，黄白线未归零轴，K线在经过一段时间的调整并放出反向能量柱之后，继续沿着原有方向运行，导致再一次出现的能量堆，同时黄白线再一次远离零轴，能量堆和能量堆之间形成背离关系，这种就是分离跳空背离。分立跳空背离解决的是归零轴的需求
-
-分立跳空背离 + 黄白线高位 = 归零轴
-
-分立跳空不背离 = 单边上涨或者下跌行情
-
-最佳买卖点
-单位周期之内 + 隐形 + 分立跳空 + 背离 + 黄白线高位空
-
-跳空产生的原理：跳空的产生是当前级别之下的小级别归零轴反弹或反抽导致的，比如1小时时间级别的单位调整周期跳空，是因为1小时时间级别之内包含3分钟，5分钟，15分钟，30分钟这些下级别。1小时级别的MACD归零轴的途中，必然导致其内部的小级别先于本级别归零轴。因此，当这些小级别归零轴后，如果产生反弹反抽的走势，则会导致当前1小时级别的MACD黄白线再一次被拉高，此时便产生了跳空的走势。
-时间级别在高位中归零轴的顺序是：由小级别到大级别依此归零轴。当K线经过一轮拉升下跌后，当前级别的MACD黄白线处在高位，此时如果K线进入调整状态，则这个时间级别所包含的小级别由小到大依次归零轴，直至本级别归零轴为止，如此才完成了次级别的单位调整周期的调整。
-
-单位周期之内的分立跳空顶背离
-MACD黄白线在零轴之上第一个单位调整周期 + 分立跳空背离（一次或多次） + 黄白线处在零轴的高位空 + 分立跳空隐形状态
-单位周期之内的分立跳空底背离
-MACD黄白线在零轴之下第一个单位调整周期 + 分立跳空背离（一次或多次） + 黄白线处在零轴的高位空 + 分立跳空隐形形态
-
-单位调整周期之内的跳空非背离
-如果在单位调整周期内发生了跳空的形态，当跳空能量堆的高度高于前一个能量堆的高度，此时的跳空则为非背离跳空。非背离跳空可以理解为单位周期的单边行情，前一个能量堆失效，以新的最高的能量堆作为后续行情的1号参考点。不管是连续跳空还是分立跳空都遵守这个法则。
-
-单位调整周期之间的背离
-单位调整周期之间的背离，是指两个或者两个以上的单位调整周期相比较而建立的关系，相比较的周期必须在同一个线段周期内，不可跨线段比较。当K线在某个时间级别的线段中，MACD经过了一个单位调整周期的运行，黄白线在此回零轴后，由于零轴的支撑反弹或压力反抽的作用，因此出现第二个单位调整周期，当第二个单位调整周期的黄白线这里特指白线离开零轴的距离小于第一个单位调整周期黄白线离开零轴的距离时，单位调整周期之间就产生了相悖的关系，即价格穿新高或新低，而白线能量区出现了减弱或增强，这种背离称为单位调整周期之间的背离，单位调整周期之间的背离也叫区间背离。
-
-上涨线段单位调整周期之间的顶背离为卖点（前提：长级别MACD在高位）
-下跌线段单位调整周期之间的底背离为买点（前提：长级别MACD在高位）
-
-单位调整周期之间的背离，其核心的本质是描述某个时间级别在线段中的运行逻辑，即为线段完成调整的重要依据。
-单位调整周期之间的背离是为了满足线段调整的需求
-
-判断某个时间级别线段结束趋势的依据为：在某个时间级别的线段中，第二个单位调整周期与第一个单位调整周期之间产生背离关系，即为此线段终结的依据，而后出现的单位调整周期无论归零轴多少次，从能量产生的逻辑上都是依次减弱直至趋于零。
-
-单位调整周期之间的背离而穿零轴变盘的依据是：当某个级别在线段中出现周期之间的背离形态，同时完成了线段的调整，但是其长级别MACD的黄白线处在高位空的形态时，当前级别的背离会导致穿零轴走势。
-
-在K线的时间逻辑中，判断一个时间级别完成自己的当值任务的标准是：本级别在当前的线段中产生了周期间的背离关系，并趋向于零轴的调整。本级别是否穿零轴并非由本级别背离的属性决定，而是由长级别决定。因此，当本级别完成线段调整之后，就要看长级别处在什么形态之下，长级别的形态属性决定了后续的行情走势。
-
-时间级别升级：是指当本级别在其线段中产生了背离关系而趋向于零轴，达到了平衡状态且保持在零轴之上（代表完成了其线段的调整任务），其长级别同时也处在归零轴的形态，此时当前级别即要发生时间级别升级。时间级别升级之后，本级别将会产生新的线段，之后本级别的线段关系则升级为线段与线段之间的关系。
-
-确定时间级别升级的条件
-1. 当前级别多次归零轴背离而完成了线段的调整，之后新的单位调整周期MACD的白线DIF比前一个单位调整周期的白线DIF高
-2. 当前级别完成线段调整，长级别MACD的黄白线无限接近零轴
-
-线段背离
-当某个时间级别升级之后，便产生了一条新的线段，如果线段和线段之间构成相悖关系时，我们称为线段背离，而线段背离则必然导致当前时间级别穿零轴。线段背离比较的是两个线段中最高或最低的白线DIF。
-
-动能不足
-如果K线走势中不破前高点上涨动能衰减，或者不破前低点，下跌动能也衰减，这种形态称为动能不足，本质上和背离是一样的，都是能量衰减的一种变现，背离所具有的属性和原理适用于动能不足。
-单位调整周期内，之间，线段之内，线段之间的隐形背离或隐形动能不足
-
-主级别归零轴启动反弹的内部过程：
-1. 第一过程，主级别所包含的小级别在零轴之下首先完成超跌反弹的过程
-2. 第二过程，小级别完成底部调整后，才正式启动主级别归零轴反弹
-
-底部形态变盘的四个阶段
-确认底部区域需要四个条件
-1. 确认引起下跌行情中的主要时间级别
-当K线出现下跌行情时，一定是某个时间级别在零轴之上进行的归零轴调整而引起的，受到零轴的引力作用，这个级别的MACD黄白线会被拉回零轴。这个时间级别是：上穿零轴后第一次开始归零轴的时间级别。
-2. 确认主级别归零轴后的形态属性
-K线价格要触碰到EMA52均线的位置附近，同时MACD的黄白线无限接近零轴。也就是说，K线的价格一旦触碰到EMA52的位置附近，因为这个位置能否形成支撑反弹，主要是看归零轴的这两个条件能否一直保持，并开始归零轴反弹的第一个过程，即主级别所包含的小级别在零轴之下的超跌反弹。
-3. 在归零轴的形态满足条件的情况下，确认子级别是否有高位空的形态
-当主级别第一次触碰到当前级别EMA52均线的位置附近时，我们要看包含在主级别之下的小级别在零轴的下方是否产生了高位空的形态。只有当这些小级别出现高位空的形态时，才能出现有效的归零轴的超跌反弹，而超跌反弹的变向则为主级别归零轴后出现的止跌反弹的走势。
-4. 确认零轴之下的最大子级别运行底部变盘的四个阶段
-当主级别进入底部区域后，小级别的超跌反弹将逐级别开始，而时间级别的运行逻辑则是从小级别依次运行。因此，当主级别包含的小级别零轴之下的最后一个子级别完成调整后，主级别的归零轴反弹才正式开启。这些零轴之下的子级别的运行逻辑即为主级别底部变盘的四个阶段。
-第一阶段：零轴之下的子级别的单边下跌
-第二阶段：零轴之下的子级别的超跌反弹
-第三阶段：零轴之下的子级别的归零轴反抽之后产生背离/动能不足
-第四阶段：零轴之下的子级别跟零轴形成粘合或者零轴纠缠
-
-底部形态V字反转的条件
-当主级别归零轴后，由于小级别的超跌反弹和反抽容易在行情的底部走出横盘震荡的走势，当某个时间级别的超跌反弹导致K线突破这个横盘区间时，我们便把这种走势称为V字反转的走势
-V字反转走势发生的条件
-1. 主级别保持归零轴形态且MACD出现收敛的状态
-2. 零轴之下大多数小级别已经完成线段调整，并形成了底部的横盘结构，剩下未调整的级别没有明显的高位空
-3. 下一个长级别的超跌反弹归零轴所触碰到EMA52均线的位置需要有效突破底部横盘震荡的区间
-MACD收敛
-K线在下跌行情中进入底部区域，当MACD的黄白线由倾斜向下趋于零轴的方向转为拐头形态，同时下跌能量柱由逐渐增长转为衰减时，我们把这种形态称为MACD收敛形态
-抢底原理
-当行情运行到当前级别底部调整的第三阶段时，即背离/下跌动能不足时，即为我们最佳买入机会。因为一旦启动了V字反转的走势，K线的价格将不容易再出现大的回调机会，而V字反转的行情极容易导致剩下的海味调整的其他小级别直接击穿零轴，或者出现以横代跌的走势而不在出现明显的反抽下跌。这就是V字反转结构形成的条件下的抢底原理。
-
-第一代时间级别当值的有效性满足两个条件
-1. 第一代时间级别不能击穿零轴，如果击穿零轴，则本级别当值作用失效
-2. 每个当值的第一代时间级别的反弹行情必须推动其长级别在上涨线段中的第一个单位调整周期处于高位的形态
-

README.md

@@ -0,0 +1,130 @@
+# Chan — 缠论分析引擎
+
+把 OHLCV K 线拆成缠论结构（K 线单元 → 合并 K 线 → 分型 → 笔 → 线段 → 中枢 → 买卖点），
+配一个 TradingView Charting Library 的 Web 界面，外加一套验证信号有效性的回测脚本。
+
+标的不限：加密永续（ccxt）与 A 股（akshare）都走同一条分析链路。
+
+```
+chanlun/      缠论引擎，纯 pandas/numpy，无外部指标库依赖
+web/          Flask API + 图表界面
+research/     信号有效性验证脚本（step1 ~ step30）
+data/         本地 K 线（freqtrade 的 feather 格式）
+```
+
+## 安装
+
+需要 Python ≥ 3.11（pandas 3.x / numpy 2.x 的要求，不是本项目代码的限制）。
+
+```bash
+python -m venv .venv
+.venv/bin/pip install -r requirements.txt          # 核心运行时，8 个包
+.venv/bin/pip install -r requirements-dev.txt      # 另加测试与 research/ 所需
+```
+
+## 跑 Web
+
+```bash
+cd web
+../.venv/bin/python app.py        # 默认 http://0.0.0.0:8128
+```
+
+从仓库根跑 `.venv/bin/python web/app.py` 也可以——Python 会把脚本所在目录放进 `sys.path`。
+但**不能用 `python -m web.app`**，也不能 `import web.app`：`web/` 内部是无前缀导入
+（`import config`、`from api.analyze import bp`），`-m` 方式下 `sys.path` 里是仓库根而不是
+`web/`，会 `ModuleNotFoundError: No module named 'config'`。
+
+配置全部走环境变量，见 `web/config.py`：
+
+| 变量 | 默认值 | 用途 |
+|------|--------|------|
+| `FLASK_HOST` / `FLASK_PORT` | `0.0.0.0` / `8128` | 监听地址 |
+| `DATA_SERVICE_URL` | `https://provider.jackyu66.com` | 行情 REST 源 |
+| `DATA_SERVICE_WS_URL` | `wss://jackyu66.com/ws` | 行情 WebSocket 源 |
+| `ASHARE_DP_URL` | `http://103.179.242.166:8000` | A 股数据源 |
+| `CHAN_HTTP_PROXY` | 未设置则不走代理 | ccxt / HTTP 代理 |
+| `MACD_FACTOR` / `MACD_SMOOTH` | `1` / `1` | MACD 周期倍数，默认 12/26/9 |
+
+主要接口：`GET /api/analyze` 返回某标的某周期的完整缠论结构，`/api/klines/recent`
+取最新 K 线，`/api/trend_filter` 与 `/api/trend_detail` 做多周期趋势筛选，
+`/api/symbols`、`/api/search_stock`、`/api/sectors` 等负责标的检索。页面在 `/` 与 `/chan_tv`。
+
+## 作为库使用
+
+```python
+import pandas as pd
+from chanlun import TF_DF
+
+# 需要 date/open/high/low/close/volume 六列，date 为 datetime
+df = pd.read_feather("data/binance/futures/BTC_USDT_USDT-1h-futures.feather")
+
+tf = TF_DF(df, interval=1, timeframe="1h")
+
+len(tf.klu_list)    # K 线单元
+len(tf.klc_list)    # 合并 K 线（处理包含关系后）
+len(tf.bi_list)     # 笔
+len(tf.seg_list)    # 线段
+len(tf.zs_list)     # 中枢
+tf.bi_list[-1].dir  # Chan_BI_DIR.DOWN
+tf.chanmacd         # MACD 结构分析（背驰判定用）
+```
+
+**`interval` 的单位是分钟**，对传入的 df 做重采样；`interval=1` 是特例，表示原样使用、
+不重采样。所以拿 1h 的 feather 要传 `interval=1`，拿 1m 数据想看 1h 才传 `interval=60`：
+
+```python
+df1m = pd.read_feather("data/binance/futures/BTC_USDT_USDT-1m-futures.feather")
+TF_DF(df1m, interval=5,  timeframe="5m")
+TF_DF(df1m, interval=60, timeframe="1h")
+```
+
+传错不会报错，只会静默给出错误周期的结构——1h 数据配 `interval=4` 相当于按 4 分钟
+重采样，结果与 `interval=1` 完全相同。
+
+## 分析流程
+
+`TF_DF.init_TF_DF()` 按顺序做这几步，每步的实现在 `chanlun/pipeline/builders/` 下同名文件：
+
+1. `resample_to_interval` — 重采样（`interval != 1` 时）
+2. `add_indicators` — 追加 33 列指标（MACD / BBANDS / EMA / RSI / ATR 等）
+3. `cal_kl_data` → `klu_list` — K 线单元
+4. `get_klc_list` → `klc_list` — 按包含关系合并 K 线，并标记分型
+5. `cal_bi_list` → `bi_list` — 笔
+6. `cal_bi_zs_list_pure` → `bi_zs_list` — 笔中枢
+7. `get_seg_list` → `seg_list` — 线段
+8. `get_zs_list` / `get_big_zs_list` — 中枢与大级别中枢
+9. `ChanMACD(klu_list)` — MACD 段 / 柱堆结构，供背驰判定
+
+## 数据
+
+`data/<交易所>/futures/<SYMBOL>-<周期>-futures.feather`，即 freqtrade 的下载格式，
+如 `data/binance/futures/BTC_USDT_USDT-1h-futures.feather`。
+`research/lib/data.py` 负责定位：`BTC/USDT:USDT` + `1h` 会解析到上面这个路径，
+找不到本地文件则回落到远端拉取。
+
+## 测试
+
+```bash
+.venv/bin/python -m pytest chanlun/tests web/tests -q
+```
+
+`chanlun/tests/test_ta_compat.py` 有个**需要注意的陷阱**：它把 `chanlun/indicators/ta.py`
+的输出逐 bar 钉在 TA-Lib 上，但 **TA-Lib 不存在时会静默跳过**。也就是说改了 `ta.py`
+之后在没装 TA-Lib 的环境里跑，测试会显示通过，其实一项都没验证。改动那个文件时请先装：
+
+```bash
+sudo apt-get install -y libta-lib0 ta-lib-dev
+.venv/bin/pip install TA-Lib technical
+```
+
+## 已知问题
+
+- **`web/DEPLOY_GUIDE.md` 已失效**：它引用的 `deploy_venv.sh`、`stop_venv.sh`、
+  `status_venv.sh` 等 6 个脚本都在 `7f393b9` 精简提交里删掉了，目前没有部署脚本。
+  两个 systemd unit 文件（`web/chanlun-web*.service`）仍可参考，但它们用 gunicorn
+  且写死端口 8123，与 `config.py` 默认的 8128 不一致，gunicorn 也不在依赖清单里。
+- **`web/README.txt` 已过时**：它说的 `web/requirements.txt` 不存在，依赖清单在仓库根目录。
+- **四个零引用的死文件**：`chanlun/analysis/` 下的 `ChanPY.py`、`ChanLun_Classifier.py`、
+  `Find_Trend.py`、`ChanHeng.py` 全项目无人引用。`ChanPY.py` 依赖未安装的外部 chan.py 库，
+  另外三个需要 matplotlib / mplfinance / xgboost / scikit-learn——这些都**不在**依赖清单里，
+  是有意为之。要用得自行安装。

chanlun.txt

@@ -1,13 +0,0 @@
-1. **第一类买卖点**：
-   - 定义：趋势反转的起始点，即在下跌趋势结束时形成的买点（第一类买点），或在上涨趋势结束时形成的卖点（第一类卖点）。这是市场多空力量发生根本性转变的位置。
-   - 与MACD背驰的关系：Macd背驰是指出中枢后形成的Macd的红绿柱面积比进入中枢时的面积绝对值小，背驰比较的黄白线和柱子面积都在0轴的一个方向上。第一类买点都是在0轴之下背驰形成的,第一类卖点都是在0轴之上的背驰形成的。
-
-2. **第二类买卖点**：
-   - 定义：趋势确认后的回调点。在第一类买卖点之后，价格会回调或反弹，形成第二类买点（回调不破前低）或第二类卖点（反弹不破前高），是对第一类买卖点的确认。第二类买点都是第一次上0轴后回抽确认形成的。第二类卖点都是第一次0轴之下上涨确认形成的。第二类买卖点只会在趋势确认后，第一类买卖点出现之后出现一次，不会重复出现，除非趋势反转之后。
-
-3. **第三类买卖点**：
-   - 定义：趋势延续的确认点。价格突破回调或反弹的中枢区间后，回踩不破关键位置（如中枢上沿或下沿），形成第三类买点（上升趋势延续）或第三类卖点（下降趋势延续）。第三类买卖点只会在中枢确认之后出现。
-
-
-
-我们交易的是币安的比特币合约, 数据格式是json, 数据包括现有的持仓, 仓位历史, 账户余额, 你用缠论分析之后, 给出以下分析, 最近的一个中枢在哪里，现在的趋势是什么，现在是否是买卖点，如果是，是那一类买卖点，应该进行何种操作。

chanlun/__init__.py

@@ -0,0 +1,11 @@
+"""缠论引擎正式包。
+
+推荐::
+    from chanlun import ChanLun, TF_DF
+    from chanlun.core.ChanEnum import Chan_BI_DIR
+"""
+
+from chanlun.pipeline.orchestrator import ChanLun
+from chanlun.pipeline.timeframe import TF_DF
+
+__all__ = ["ChanLun", "TF_DF"]

chanlun/analysis/ChanLun_Classifier.py

@@ -6,22 +6,20 @@ sys.path.append(os.path.abspath("/Users/jack/Project/freqtrade/user_data/Chan"))
 import numpy as np
 from datetime import timedelta
 from pandas import DataFrame
-from ChanEnum import Chan_FX_TYPE, Chan_KLINE_DIR, Chan_BI_DIR, Chan_SEG_DIR, Chan_ZS_DIR, Chan_BSP_DIR, Chan_BSP_TYPE, Chan_KLC_FX
-from ChanKLU import ChanKLU
-from ChanKLC import ChanKLC
-from ChanBI import ChanBI
-from ChanSBI import ChanSBI
-from ChanSEG import ChanSEG
-from ChanZS import ChanZS
-from ChanBSP import ChanBSP
-import talib.abstract as ta
+from chanlun.core.ChanEnum import Chan_FX_TYPE, Chan_KLINE_DIR, Chan_BI_DIR, Chan_SEG_DIR, Chan_ZS_DIR, Chan_BSP_DIR, Chan_BSP_TYPE, Chan_KLC_FX
+from chanlun.core.ChanKLU import ChanKLU
+from chanlun.core.ChanKLC import ChanKLC
+from chanlun.core.ChanBI import ChanBI
+from chanlun.core.ChanSBI import ChanSBI
+from chanlun.core.ChanSEG import ChanSEG
+from chanlun.core.ChanZS import ChanZS
+from chanlun.core.ChanBSP import ChanBSP
 import pandas as pd
 import matplotlib.pyplot as plt
 from matplotlib.dates import DateFormatter, date2num
 import matplotlib.patches as patches
-from technical.util import resample_to_interval
 from decimal import Decimal
-from ChanLun import ChanLun
+from chanlun.pipeline.orchestrator import ChanLun
 import xgboost as xgb
 from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report
 

chanlun/analysis/ChanPivotClassifier.py

@@ -0,0 +1,292 @@
+"""
+中枢结构特征提取 + 标签化
+Market Structure Dataset Builder — Phase 1
+
+定位: 训练数据集构建工具，不是交易信号生成器。
+Feature 描述中枢内部结构，Label 记录中枢后实际演化。
+"""
+
+import math
+import json
+from typing import Optional
+from chanlun.core.ChanEnum import Chan_BI_DIR
+
+
+class ChanPivotClassifier:
+    """
+    中枢结构特征提取 + 标签化
+    输入: bi_zs_list (list[ChanBIZS])
+    输出: 结构化数据集 (list[dict])
+    """
+
+    DATASET_VERSION = "pivot_v1"
+    FEATURE_SCHEMA = ["duration_norm", "contraction", "shift_norm"]
+    LABEL_SCHEMA = {"name": "break_direction", "values": ["up", "down", "none"]}
+
+    def __init__(self, bi_zs_list: list, symbol: str = "", timeframe: str = ""):
+        self.bi_zs_list = bi_zs_list
+        self.symbol = symbol
+        self.timeframe = timeframe
+
+    # ------------------------------------------------------------------
+    # Feature extraction
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def calc_duration(zs) -> int:
+        """持续时间: 第一笔首K → 最后一笔末K 的 index 差"""
+        bi_list = zs.bi_list
+        start_idx = bi_list[0].start_klc.index
+        end_idx = bi_list[-1].end_klc.index
+        return end_idx - start_idx
+
+    @staticmethod
+    def calc_contraction(zs) -> float:
+        """收敛率: 后窗口振幅均值 / 前窗口振幅均值"""
+        bi_list = zs.bi_list
+        if len(bi_list) < 4:
+            return 1.0
+
+        n = min(3, len(bi_list) // 2)
+        first_ranges = [bi.high - bi.low for bi in bi_list[:n]]
+        last_ranges = [bi.high - bi.low for bi in bi_list[-n:]]
+
+        first_mean = sum(first_ranges) / len(first_ranges)
+        last_mean = sum(last_ranges) / len(last_ranges)
+
+        if first_mean == 0:
+            return 1.0
+        return last_mean / first_mean
+
+    @staticmethod
+    def calc_shift(zs) -> tuple[float, float]:
+        """重心漂移: 前后半段重心均值差 (原始值, 归一化值)"""
+        bi_list = zs.bi_list
+        mid = len(bi_list) // 2
+
+        first_centers = [(bi.high + bi.low) / 2 for bi in bi_list[:mid]]
+        last_centers = [(bi.high + bi.low) / 2 for bi in bi_list[mid:]]
+
+        shift_raw = (
+            sum(last_centers) / len(last_centers)
+            - sum(first_centers) / len(first_centers)
+        )
+
+        zs_height = zs.zg - zs.zd
+        if zs_height == 0:
+            shift_norm = 0.0
+        else:
+            shift_norm = shift_raw / zs_height
+
+        return shift_raw, shift_norm
+
+    @staticmethod
+    def compute_duration_norm(duration_raw: int, historical_durations: list) -> float:
+        """用历史窗口均值归一化 duration"""
+        if not historical_durations:
+            return 1.0
+        avg = sum(historical_durations) / len(historical_durations)
+        if avg == 0:
+            return 1.0
+        return duration_raw / avg
+
+    @staticmethod
+    def compute_features(zs, historical_durations: Optional[list] = None):
+        """计算单个中枢的全部结构特征（实时友好）"""
+        duration_raw = ChanPivotClassifier.calc_duration(zs)
+        contraction = ChanPivotClassifier.calc_contraction(zs)
+        shift_raw, shift_norm = ChanPivotClassifier.calc_shift(zs)
+
+        if historical_durations is not None and len(historical_durations) > 0:
+            duration_norm = ChanPivotClassifier.compute_duration_norm(
+                duration_raw, historical_durations
+            )
+        else:
+            duration_norm = 1.0
+
+        return {
+            "duration_raw": duration_raw,
+            "duration_norm": round(duration_norm, 4),
+            "contraction": round(contraction, 4),
+            "shift_raw": round(shift_raw, 6),
+            "shift_norm": round(shift_norm, 4),
+            "zs_height": round(zs.zg - zs.zd, 6),
+        }
+
+    # ------------------------------------------------------------------
+    # Label computation
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _clamp(x: float, lo: float = 0.0, hi: float = 1.0) -> float:
+        return max(lo, min(hi, x))
+
+    def _compute_label(self, zs, contraction: float, shift_norm: float) -> dict:
+        """计算标签: up / down / none + 连续置信度"""
+        bi_out = zs.bi_out
+
+        if bi_out is None:
+            return {
+                "label": "none",
+                "label_confidence": 0.0,
+                "label_detail": {
+                    "bi_out_dir": "none",
+                    "score_breakout": 0.0,
+                    "score_shift": 0.0,
+                    "score_contraction": 0.0,
+                },
+            }
+
+        zs_height = zs.zg - zs.zd
+        if zs_height == 0:
+            zs_height = 1e-8
+
+        # ---- 向上突破分数 ----
+        if bi_out.dir == Chan_BI_DIR.UP:
+            raw_breakout = (bi_out.high - zs.gg) / zs_height
+            score_breakout_up = self._clamp(raw_breakout)
+            score_shift_up = math.tanh(self._clamp(shift_norm, -3.0, 3.0))
+            score_contraction_up = max(0.0, 1.0 - contraction)
+        else:
+            score_breakout_up = 0.0
+            score_shift_up = 0.0
+            score_contraction_up = 0.0
+
+        up_score = (
+            score_breakout_up * 0.5
+            + score_shift_up * 0.3
+            + score_contraction_up * 0.2
+        )
+
+        # ---- 向下突破分数 ----
+        if bi_out.dir == Chan_BI_DIR.DOWN:
+            raw_breakout = (zs.dd - bi_out.low) / zs_height
+            score_breakout_down = self._clamp(raw_breakout)
+            score_shift_down = math.tanh(self._clamp(-shift_norm, -3.0, 3.0))
+            score_contraction_down = max(0.0, 1.0 - contraction)
+        else:
+            score_breakout_down = 0.0
+            score_shift_down = 0.0
+            score_contraction_down = 0.0
+
+        down_score = (
+            score_breakout_down * 0.5
+            + score_shift_down * 0.3
+            + score_contraction_down * 0.2
+        )
+
+        # ---- 判定 ----
+        threshold = 0.15
+
+        if up_score > down_score and up_score > threshold:
+            label = "up"
+            confidence = up_score
+            detail = {
+                "bi_out_dir": "up",
+                "score_breakout": round(score_breakout_up, 4),
+                "score_shift": round(score_shift_up, 4),
+                "score_contraction": round(score_contraction_up, 4),
+            }
+        elif down_score > up_score and down_score > threshold:
+            label = "down"
+            confidence = down_score
+            detail = {
+                "bi_out_dir": "down",
+                "score_breakout": round(score_breakout_down, 4),
+                "score_shift": round(score_shift_down, 4),
+                "score_contraction": round(score_contraction_down, 4),
+            }
+        else:
+            label = "none"
+            confidence = max(up_score, down_score)
+            bi_dir = "up" if bi_out.dir == Chan_BI_DIR.UP else "down"
+            detail = {
+                "bi_out_dir": bi_dir,
+                "score_breakout": round(max(score_breakout_up, score_breakout_down), 4),
+                "score_shift": round(max(score_shift_up, score_shift_down), 4),
+                "score_contraction": round(max(score_contraction_up, score_contraction_down), 4),
+            }
+
+        return {
+            "label": label,
+            "label_confidence": round(confidence, 4),
+            "label_detail": detail,
+        }
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def extract(self) -> list[dict]:
+        """主入口：对每个中枢提取 3 特征 + 1 标签"""
+
+        # 第一遍：计算原始值
+        raw = []
+        for i, zs in enumerate(self.bi_zs_list):
+            if not zs.is_sure or len(zs.bi_list) < 3:
+                continue
+
+            duration_raw = ChanPivotClassifier.calc_duration(zs)
+            contraction = ChanPivotClassifier.calc_contraction(zs)
+            shift_raw, shift_norm = ChanPivotClassifier.calc_shift(zs)
+
+            raw.append({
+                "zs": zs,
+                "zs_index": i,
+                "duration_raw": duration_raw,
+                "contraction": contraction,
+                "shift_raw": shift_raw,
+                "shift_norm": shift_norm,
+                "zs_height": zs.zg - zs.zd,
+            })
+
+        # 第二遍：组装输出 + 计算 label
+        result = []
+        for r in raw:
+            zs = r["zs"]
+            historical = [x["duration_raw"] for x in raw]
+            duration_norm = ChanPivotClassifier.compute_duration_norm(
+                r["duration_raw"], historical
+            )
+            label_info = self._compute_label(zs, r["contraction"], r["shift_norm"])
+
+            # 时间处理
+            start_time = None
+            end_time = None
+            if hasattr(zs, "start_time") and zs.start_time is not None:
+                start_time = str(zs.start_time)
+            if hasattr(zs, "end_time") and zs.end_time is not None:
+                end_time = str(zs.end_time)
+
+            result.append({
+                "dataset_version": self.DATASET_VERSION,
+                "feature_schema": self.FEATURE_SCHEMA,
+                "label_schema": self.LABEL_SCHEMA,
+
+                "symbol": self.symbol,
+                "timeframe": self.timeframe,
+                "zs_index": r["zs_index"],
+                "zs_start_time": start_time,
+                "zs_end_time": end_time,
+
+                "duration_norm": round(duration_norm, 4),
+                "contraction": round(r["contraction"], 4),
+                "shift_norm": round(r["shift_norm"], 4),
+
+                "label": label_info["label"],
+                "label_confidence": label_info["label_confidence"],
+                "label_detail": label_info["label_detail"],
+
+                "duration_raw": r["duration_raw"],
+                "shift_raw": round(r["shift_raw"], 6),
+                "zs_height": round(r["zs_height"], 6),
+            })
+
+        return result
+
+    def export_json(self, path: str):
+        """导出为 JSON 文件"""
+        data = self.extract()
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False, default=str)
+        return len(data)

chanlun/analysis/ChanPivotMonitor.py

@@ -0,0 +1,145 @@
+"""
+实时中枢特征跟踪器
+Real-time Pivot Feature Tracker
+
+定位: 观察者 — 不修改管线，只观察 bi_zs_list 中当前中枢的特征变化。
+每次管线重算后调用 update()，检测 bi_count 是否增长，若增长则重新计算
+shift / contraction / duration。
+"""
+
+from collections import deque
+from typing import Optional
+from chanlun.analysis.ChanPivotClassifier import ChanPivotClassifier
+
+
+class ChanPivotMonitor:
+    """
+    实时追踪当前中枢的结构特征。
+
+    update() 每次管线重算后调用，对比 bi_count 判断是否有新笔加入中枢。
+    若 bi_count 增长则重新计算 3 个结构特征并返回最新值。
+    """
+
+    def __init__(self, window_size: int = 10):
+        self._window_size = window_size
+        self._duration_history: deque[int] = deque(maxlen=window_size)
+        self._current_zs_id: Optional[tuple] = None
+        self._current_bi_count: int = 0
+        self._current_is_sure: bool = False
+        self._current_state: Optional[dict] = None
+        self._duration_added_for_zs: set = set()  # 已加入窗口的中枢 ID（上限 200）
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def update(self, bi_zs_list: list) -> Optional[dict]:
+        """
+        主入口：检测当前中枢特征变化。
+
+        参数:
+            bi_zs_list: 当前管线产出的笔中枢列表
+
+        返回:
+            特征 dict（有变化时），无变化返回 None
+        """
+        if not bi_zs_list:
+            self._current_zs_id = None
+            self._current_bi_count = 0
+            self._current_is_sure = False
+            self._current_state = None
+            return None
+
+        zs = self._find_current_zs(bi_zs_list)
+        if zs is None:
+            return None
+
+        zs_id = self._make_zs_id(zs)
+        bi_count = len(zs.bi_list)
+        is_sure = zs.is_sure
+
+        # 无变化 → 跳过
+        if (zs_id == self._current_zs_id
+                and bi_count == self._current_bi_count
+                and is_sure == self._current_is_sure):
+            return None
+
+        # 中枢切换 → 将旧中枢 duration 加入窗口
+        if zs_id != self._current_zs_id:
+            self._maybe_add_to_history()
+
+        self._current_zs_id = zs_id
+        self._current_bi_count = bi_count
+        self._current_is_sure = is_sure
+
+        features = ChanPivotClassifier.compute_features(
+            zs, list(self._duration_history)
+        )
+
+        self._current_state = {
+            "zs_id": zs_id,
+            "zs_index": zs.index,
+            "zs_dir": str(zs.dir),
+            "bi_count": bi_count,
+            "is_sure": zs.is_sure,
+            "zg": round(zs.zg, 6),
+            "zd": round(zs.zd, 6),
+            "gg": round(zs.gg, 6),
+            "dd": round(zs.dd, 6),
+            **features,
+            "start_time": str(t) if (t := getattr(zs, "start_time", None)) else None,
+        }
+
+        # 中枢刚变为已确认时，将其 duration 加入滚动窗口
+        if is_sure and zs_id not in self._duration_added_for_zs:
+            self._add_duration(features["duration_raw"])
+            self._duration_added_for_zs.add(zs_id)
+
+        return self._current_state
+
+    def get_current(self) -> Optional[dict]:
+        """返回当前中枢的最新特征"""
+        return self._current_state
+
+    def get_duration_history(self) -> list[int]:
+        """返回用于归一化的 duration 滚动窗口"""
+        return list(self._duration_history)
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _make_zs_id(zs) -> tuple:
+        """生成中枢的稳定标识（基于首笔首K线时间戳，不随 DataFrame 窗口偏移而变化）"""
+        bi0 = zs.bi_list[0]
+        return (bi0.start_klc.start_time,)
+
+    @staticmethod
+    def _find_current_zs(bi_zs_list: list):
+        """
+        找到当前活跃中枢：
+        优先取最后一个 is_sure=False（形成中）的中枢，
+        没有则取最后一个 is_sure=True 的中枢。
+        """
+        forming = None
+        last_sure = None
+        for zs in bi_zs_list:
+            if len(zs.bi_list) < 3:
+                continue
+            if not zs.is_sure:
+                forming = zs
+            else:
+                last_sure = zs
+        return forming if forming is not None else last_sure
+
+    def _add_duration(self, duration_raw: int):
+        """将已确认中枢的 duration 加入滚动窗口"""
+        self._duration_history.append(duration_raw)
+
+    def _maybe_add_to_history(self):
+        """旧中枢切换前，若已确认且未记录过，则将其 duration 加入窗口"""
+        if (self._current_state and self._current_state["is_sure"]
+                and self._current_zs_id not in self._duration_added_for_zs):
+            self._add_duration(self._current_state["duration_raw"])
+            self._duration_added_for_zs.add(self._current_zs_id)

chanlun/analysis/ChanZone.py

@@ -0,0 +1,566 @@
+"""
+结构价值区 (Structure Zone) 系统
+
+将多时间周期的 Chan 中枢边界 (ZD/ZG/GG/DD) 和 EMA52 统一表示为带强度评分的价值区对象。
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Any
+from datetime import datetime
+
+
+# ============================================================
+# Dataclasses
+# ============================================================
+
+@dataclass
+class RawZonePoint:
+    """内部中间结构：从 Chan 中枢提取的单个价格点"""
+    price: float
+    timeframe: str            # '5m', '1h', '4h' 等
+    structure_type: str       # 'bi_zhongshu' | 'xd_zhongshu' | 'ema52'
+    boundary_type: str        # 'ZD' | 'ZG' | 'GG' | 'DD' | 'EMA52'
+    source_zs_id: int         # 来源 ZS 在列表中的 index（调试用）
+    is_sure: bool             # 来源 ZS 是否已完成
+    candle_time: Optional[str] = None  # 来源 ZS 的 end_time（用于 recency 计算）
+
+
+@dataclass
+class StructureZone:
+    """统一的价值区对象"""
+    id: int
+    lower: float
+    upper: float
+    center: float                        # (lower + upper) / 2
+    width_pct: float                     # (upper - lower) / center * 100
+    zone_type: str                       # 'support' | 'resistance' | 'neutral'
+    timeframes: List[str]                # 参与形成此区间的时间周期
+    structure_types: List[str]           # 参与形成的结构类型
+    boundary_types: List[str]            # 参与形成的边界类型
+    overlap_count: int                   # 聚类中的原始点数
+    touch_count: int                     # MVP: 等于 overlap_count
+    recency_score: float                 # 0.0 - 1.0, 1.0 = 最近
+    ema52_distance_pct: float            # 到最近 EMA52 的距离百分比
+    ema52_aligned: bool                  # 是否有 EMA52 落在区间内
+    strength_score: float                # 0-100 综合评分
+    confidence: float                    # 0.0 - 1.0
+    first_seen: Optional[str]            # 最早的 candle_time
+    last_seen: Optional[str]             # 最晚的 candle_time
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class StructureZoneConfig:
+    """StructureZone 提取与评分配置"""
+    cluster_radius_pct: float = 0.5         # 价格聚类半径（百分比）
+    min_overlap_for_zone: int = 2           # 最少重叠点数才能形成区间
+    max_zones: int = 20                     # 返回的最大区间数
+    recency_halflife_bars: int = 50         # recency 衰减半衰期（K线数）
+    zone_timeframes: List[str] = field(default_factory=lambda: ['4h', '1h', '30m', '15m', '5m'])
+    kl_lines_per_tf: int = 500              # 每个时间周期使用最近多少根K线
+    structure_weights: Dict[str, float] = field(default_factory=lambda: {
+        'bi_zhongshu':   1.0,   # 笔中枢 — 最直接的价格行为
+        'xd_zhongshu':   0.8,   # 线段中枢 — 较高级别但粒度较粗
+        'ema52':         0.4,   # EMA — 趋势参考，弱于结构
+    })
+
+
+# ============================================================
+# Extraction
+# ============================================================
+
+def extract_raw_points_from_tf_df(
+    tf_df_dict: Dict[str, Any],
+    ema_symbols: List[str],
+    config: StructureZoneConfig,
+) -> List[RawZonePoint]:
+    """
+    从 ChanLun.tf_df_dict 中提取所有原始价格点。
+    仅处理 config.zone_timeframes 中存在的时间周期。
+    """
+    points: List[RawZonePoint] = []
+
+    for tf_name in config.zone_timeframes:
+        if tf_name not in tf_df_dict:
+            continue
+
+        tf_df = tf_df_dict[tf_name]
+
+        # 1. 笔中枢 (ChanBIZS)
+        try:
+            if hasattr(tf_df, 'seg_list') and tf_df.seg_list:
+                bi_zs_result = tf_df.cal_bi_zs(tf_df.seg_list)
+                if bi_zs_result:
+                    _extract_from_zs_objects(
+                        points, tf_name, 'bi_zhongshu', bi_zs_result, config.kl_lines_per_tf
+                    )
+        except Exception:
+            pass
+
+        # 2. 线段中枢 (ChanZS)
+        try:
+            zs_list = getattr(tf_df, 'zs_list', None)
+            if zs_list:
+                _extract_from_zs_objects(
+                    points, tf_name, 'xd_zhongshu', zs_list, config.kl_lines_per_tf
+                )
+        except Exception:
+            pass
+
+    # 3. EMA52 值
+    for tf_name in config.zone_timeframes:
+        if tf_name in tf_df_dict:
+            try:
+                ema_val = tf_df_dict[tf_name].get_ema52()
+                if ema_val is not None and ema_val > 0:
+                    points.append(RawZonePoint(
+                        price=float(ema_val),
+                        timeframe=tf_name,
+                        structure_type='ema52',
+                        boundary_type='EMA52',
+                        source_zs_id=-1,
+                        is_sure=True,
+                        candle_time=None,
+                    ))
+            except Exception:
+                pass
+
+    return points
+
+
+def _extract_from_zs_objects(
+    points: List[RawZonePoint],
+    tf_name: str,
+    structure_type: str,
+    zs_list,
+    kl_limit: int,
+):
+    """从 ZS 链表中提取 ZD/ZG/GG/DD 点"""
+    count = 0
+    node = zs_list
+    while hasattr(node, 'next'):
+        node = node.next
+    # 从链表头开始遍历
+    head = zs_list
+    # 收集所有节点
+    all_nodes = []
+    cur = head
+    while cur is not None and hasattr(cur, 'next'):
+        all_nodes.append(cur)
+        cur = cur.next
+    # 只取最近 kl_limit 根K线内的 ZS
+    all_nodes = all_nodes[-kl_limit:] if len(all_nodes) > kl_limit else all_nodes
+
+    for idx, zs in enumerate(all_nodes):
+        if not getattr(zs, 'is_sure', False):
+            continue
+        try:
+            zg = float(zs.zg)
+            zd = float(zs.zd)
+            gg = float(zs.gg) if getattr(zs, 'gg', 0) else zg
+            dd = float(zs.dd) if getattr(zs, 'dd', 0) else zd
+            end_time = str(zs.end_time) if hasattr(zs, 'end_time') and zs.end_time else None
+        except (ValueError, TypeError, AttributeError):
+            continue
+
+        if zg <= 0 or zd <= 0:
+            continue
+
+        zs_id = getattr(zs, 'index', idx)
+        points.append(RawZonePoint(price=zg, timeframe=tf_name, structure_type=structure_type,
+                                   boundary_type='ZG', source_zs_id=zs_id, is_sure=True,
+                                   candle_time=end_time))
+        points.append(RawZonePoint(price=zd, timeframe=tf_name, structure_type=structure_type,
+                                   boundary_type='ZD', source_zs_id=zs_id, is_sure=True,
+                                   candle_time=end_time))
+        points.append(RawZonePoint(price=gg, timeframe=tf_name, structure_type=structure_type,
+                                   boundary_type='GG', source_zs_id=zs_id, is_sure=True,
+                                   candle_time=end_time))
+        points.append(RawZonePoint(price=dd, timeframe=tf_name, structure_type=structure_type,
+                                   boundary_type='DD', source_zs_id=zs_id, is_sure=True,
+                                   candle_time=end_time))
+
+
+def extract_raw_points_from_serialized(
+    analyses: Dict[str, Dict],
+    ema52_dict: Dict[str, Optional[float]],
+    config: StructureZoneConfig,
+) -> List[RawZonePoint]:
+    """
+    从已序列化的分析结果中提取价格点（用于 web API，避免重复计算）。
+    analyses: {'5m': {'zs_list': [...], 'bi_zs_list': [...]}, '15m': {...}, ...}
+    ema52_dict: {'5m': 123.45, '15m': None, ...}
+    """
+    points: List[RawZonePoint] = []
+
+    for tf_name in config.zone_timeframes:
+        if tf_name not in analyses:
+            continue
+
+        analysis = analyses[tf_name]
+
+        # 笔中枢
+        bi_zs_items = analysis.get('bi_zs_list', [])
+        for idx, zs in enumerate(bi_zs_items):
+            if not zs.get('is_sure', False):
+                continue
+            try:
+                zg = float(zs['zg']); zd = float(zs['zd'])
+                gg = float(zs.get('gg', zg)); dd = float(zs.get('dd', zd))
+                end_time = zs.get('end_time')
+            except (ValueError, KeyError):
+                continue
+            if zg <= 0 or zd <= 0:
+                continue
+            points.append(RawZonePoint(price=zg, timeframe=tf_name, structure_type='bi_zhongshu',
+                                       boundary_type='ZG', source_zs_id=idx, is_sure=True,
+                                       candle_time=str(end_time) if end_time else None))
+            points.append(RawZonePoint(price=zd, timeframe=tf_name, structure_type='bi_zhongshu',
+                                       boundary_type='ZD', source_zs_id=idx, is_sure=True,
+                                       candle_time=str(end_time) if end_time else None))
+            points.append(RawZonePoint(price=gg, timeframe=tf_name, structure_type='bi_zhongshu',
+                                       boundary_type='GG', source_zs_id=idx, is_sure=True,
+                                       candle_time=str(end_time) if end_time else None))
+            points.append(RawZonePoint(price=dd, timeframe=tf_name, structure_type='bi_zhongshu',
+                                       boundary_type='DD', source_zs_id=idx, is_sure=True,
+                                       candle_time=str(end_time) if end_time else None))
+
+        # 线段中枢
+        zs_items = analysis.get('zs_list', [])
+        for idx, zs in enumerate(zs_items):
+            if not zs.get('is_sure', False):
+                continue
+            try:
+                zg = float(zs['zg']); zd = float(zs['zd'])
+                gg = float(zs.get('gg', zg)); dd = float(zs.get('dd', zd))
+                end_time = zs.get('end_time')
+            except (ValueError, KeyError):
+                continue
+            if zg <= 0 or zd <= 0:
+                continue
+            points.append(RawZonePoint(price=zg, timeframe=tf_name, structure_type='xd_zhongshu',
+                                       boundary_type='ZG', source_zs_id=idx, is_sure=True,
+                                       candle_time=str(end_time) if end_time else None))
+            points.append(RawZonePoint(price=zd, timeframe=tf_name, structure_type='xd_zhongshu',
+                                       boundary_type='ZD', source_zs_id=idx, is_sure=True,
+                                       candle_time=str(end_time) if end_time else None))
+            points.append(RawZonePoint(price=gg, timeframe=tf_name, structure_type='xd_zhongshu',
+                                       boundary_type='GG', source_zs_id=idx, is_sure=True,
+                                       candle_time=str(end_time) if end_time else None))
+            points.append(RawZonePoint(price=dd, timeframe=tf_name, structure_type='xd_zhongshu',
+                                       boundary_type='DD', source_zs_id=idx, is_sure=True,
+                                       candle_time=str(end_time) if end_time else None))
+
+    # EMA52
+    for tf_name in config.zone_timeframes:
+        ema_val = ema52_dict.get(tf_name)
+        if ema_val is not None and ema_val > 0:
+            points.append(RawZonePoint(
+                price=float(ema_val),
+                timeframe=tf_name,
+                structure_type='ema52',
+                boundary_type='EMA52',
+                source_zs_id=-1,
+                is_sure=True,
+                candle_time=None,
+            ))
+
+    return points
+
+
+# ============================================================
+# Clustering
+# ============================================================
+
+def cluster_raw_points(
+    points: List[RawZonePoint],
+    config: StructureZoneConfig,
+) -> List[List[RawZonePoint]]:
+    """
+    贪心单通聚类：将价格相近的 RawZonePoint 归为一组。
+    仅在 1D 价格轴上操作，O(n log n)。
+    """
+    if not points:
+        return []
+
+    sorted_points = sorted(points, key=lambda p: p.price)
+    clusters: List[List[RawZonePoint]] = []
+
+    for p in sorted_points:
+        placed = False
+        for cluster in reversed(clusters):
+            # 检查是否可以放入当前聚类（与聚类均价比较）
+            avg_price = sum(pt.price for pt in cluster) / len(cluster)
+            if abs(p.price - avg_price) / avg_price * 100 <= config.cluster_radius_pct:
+                cluster.append(p)
+                placed = True
+                break
+        if not placed:
+            clusters.append([p])
+
+    # 过滤点数不足的聚类
+    return [c for c in clusters if len(c) >= config.min_overlap_for_zone]
+
+
+# ============================================================
+# Scoring & Building
+# ============================================================
+
+def build_structure_zones(
+    clusters: List[List[RawZonePoint]],
+    current_price: float,
+    ema52_values: Dict[str, Optional[float]],
+    latest_candle_time: Optional[str],
+    config: StructureZoneConfig,
+) -> List[StructureZone]:
+    """
+    从聚类构建 StructureZone 列表，计算所有字段和评分。
+    """
+    zones: List[StructureZone] = []
+
+    # 收集所有 EMA52 值
+    ema_prices = [v for v in ema52_values.values() if v is not None and v > 0]
+
+    for zone_id, cluster in enumerate(clusters):
+        prices = [p.price for p in cluster]
+        lower = min(prices)
+        upper = max(prices)
+        center = (lower + upper) / 2
+        width_pct = (upper - lower) / center * 100 if center > 0 else 0.0
+
+        # 区间类型
+        if upper < current_price:
+            zone_type = 'support'      # 区间在当前价格下方 → 支撑
+        elif lower > current_price:
+            zone_type = 'resistance'   # 区间在当前价格上方 → 阻力
+        else:
+            zone_type = 'neutral'      # 区间跨越当前价格
+
+        timeframes = sorted(set(p.timeframe for p in cluster))
+        structure_types = sorted(set(p.structure_type for p in cluster))
+        boundary_types = sorted(set(p.boundary_type for p in cluster))
+        overlap_count = len(cluster)
+
+        # Recency
+        times = [p.candle_time for p in cluster if p.candle_time]
+        first_seen = min(times) if times else None
+        last_seen = max(times) if times else None
+        recency_score = _calc_recency(last_seen, latest_candle_time, config.recency_halflife_bars)
+
+        # EMA52 alignment
+        ema52_distance_pct = 999.0
+        ema52_aligned = False
+        if ema_prices:
+            distances = [abs(center - ep) / ep * 100 for ep in ema_prices]
+            ema52_distance_pct = round(min(distances), 2)
+        ema52_aligned = any(lower <= ep <= upper for ep in ema_prices)
+
+        # Strength score
+        strength_score = _calc_strength(cluster, config, recency_score, ema52_aligned, ema52_distance_pct, width_pct)
+
+        # Confidence
+        confidence = _calc_confidence(overlap_count, len(timeframes), cluster)
+
+        zones.append(StructureZone(
+            id=zone_id + 1,
+            lower=round(lower, 2),
+            upper=round(upper, 2),
+            center=round(center, 2),
+            width_pct=round(width_pct, 2),
+            zone_type=zone_type,
+            timeframes=timeframes,
+            structure_types=structure_types,
+            boundary_types=boundary_types,
+            overlap_count=overlap_count,
+            touch_count=overlap_count,  # MVP: 等于 overlap_count
+            recency_score=round(recency_score, 3),
+            ema52_distance_pct=ema52_distance_pct,
+            ema52_aligned=ema52_aligned,
+            strength_score=round(strength_score, 1),
+            confidence=round(confidence, 2),
+            first_seen=first_seen,
+            last_seen=last_seen,
+        ))
+
+    # 按强度降序排列
+    zones.sort(key=lambda z: z.strength_score, reverse=True)
+
+    # 截断
+    if config.max_zones > 0 and len(zones) > config.max_zones:
+        zones = zones[:config.max_zones]
+
+    return zones
+
+
+def _calc_recency(
+    last_seen: Optional[str],
+    latest_time: Optional[str],
+    halflife_bars: int,
+) -> float:
+    """计算 recency 分数：越近越高"""
+    if not last_seen or not latest_time:
+        return 0.5
+
+    try:
+        # 尝试解析 ISO 格式时间
+        from dateutil import parser
+        t_last = parser.parse(last_seen)
+        t_latest = parser.parse(latest_time)
+        offset_seconds = (t_latest - t_last).total_seconds()
+        if offset_seconds < 0:
+            return 1.0
+        # 假设每根K线平均 5 分钟
+        bar_seconds = 300
+        offset_bars = offset_seconds / bar_seconds
+        # 指数衰减: 2 ^ (-offset / halflife)
+        score = 2.0 ** (-offset_bars / halflife_bars)
+        return float(score)
+    except Exception:
+        return 0.5
+
+
+def _calc_strength(
+    cluster: List[RawZonePoint],
+    config: StructureZoneConfig,
+    recency_score: float,
+    ema52_aligned: bool,
+    ema52_distance_pct: float,
+    width_pct: float,
+) -> float:
+    """计算综合强度评分 (0-100)"""
+
+    # 组件 1: 结构类型多样性 (0-40)
+    structure_type_counts: Dict[str, int] = {}
+    for p in cluster:
+        structure_type_counts[p.structure_type] = structure_type_counts.get(p.structure_type, 0) + 1
+    total = sum(structure_type_counts.values())
+    structure_score = 0.0
+    for st, count in structure_type_counts.items():
+        weight = config.structure_weights.get(st, 0.5)
+        structure_score += weight * count
+    structure_score = min(structure_score / max(1, total), 1.0)
+    c1 = structure_score * 40
+
+    # 组件 2: 多周期确认 (0-25)
+    tf_set = set(p.timeframe for p in cluster)
+    tf_diversity = len(tf_set)
+    c2 = min(tf_diversity / 5, 1.0) * 25
+
+    # 组件 3: 区间紧密度 (0-15) — 越窄越强
+    tightness = max(0.0, 1.0 - (width_pct / 3.0))
+    c3 = tightness * 15
+
+    # 组件 4: Recency (0-10)
+    c4 = recency_score * 10
+
+    # 组件 5: EMA52 共振 (0-10)
+    if ema52_aligned:
+        ema_proximity = max(0.0, 1.0 - (ema52_distance_pct / 2.0))
+        c5 = ema_proximity * 10
+    else:
+        c5 = 0.0
+
+    return c1 + c2 + c3 + c4 + c5
+
+
+def _calc_confidence(
+    overlap_count: int,
+    tf_count: int,
+    cluster: List[RawZonePoint],
+) -> float:
+    """计算置信度 (0-1)"""
+    base = min(overlap_count / 6.0, 0.85)
+    # 多周期加分
+    tf_bonus = min(tf_count / 5.0, 0.1)
+    # 是否所有点都来自 sure 的 ZS
+    all_sure = all(p.is_sure for p in cluster)
+    sure_bonus = 0.05 if all_sure else 0.0
+    return min(base + tf_bonus + sure_bonus, 1.0)
+
+
+# ============================================================
+# Top-level pipeline
+# ============================================================
+
+def analyze_structure_zones(
+    tf_df_dict: Dict[str, Any],
+    ema_symbols: List[str],
+    current_price: Optional[float] = None,
+    config: Optional[StructureZoneConfig] = None,
+) -> List[StructureZone]:
+    """
+    一站式分析：提取 → 聚类 → 评分 → 返回排序后的 StructureZone 列表。
+    """
+    if config is None:
+        config = StructureZoneConfig()
+
+    # 提取
+    raw_points = extract_raw_points_from_tf_df(tf_df_dict, ema_symbols, config)
+
+    if not raw_points:
+        return []
+
+    # 获取当前价格
+    if current_price is None:
+        for tf_name in config.zone_timeframes:
+            if tf_name in tf_df_dict:
+                try:
+                    ema_val = tf_df_dict[tf_name].get_ema52()
+                    if ema_val and ema_val > 0:
+                        current_price = float(ema_val)
+                        break
+                except Exception:
+                    pass
+        if current_price is None:
+            current_price = 0.0
+
+    # EMA52 值
+    ema52_values = {}
+    for tf_name in config.zone_timeframes:
+        if tf_name in tf_df_dict:
+            try:
+                ema52_values[tf_name] = tf_df_dict[tf_name].get_ema52()
+            except Exception:
+                ema52_values[tf_name] = None
+
+    # 最晚时间
+    latest_time = None
+    times = [p.candle_time for p in raw_points if p.candle_time]
+    if times:
+        latest_time = max(times)
+
+    # 聚类
+    clusters = cluster_raw_points(raw_points, config)
+
+    # 构建 & 评分
+    return build_structure_zones(clusters, current_price, ema52_values, latest_time, config)
+
+
+def analyze_structure_zones_from_serialized(
+    analyses: Dict[str, Dict],
+    ema52_dict: Dict[str, Optional[float]],
+    current_price: float,
+    config: Optional[StructureZoneConfig] = None,
+) -> List[StructureZone]:
+    """
+    从已序列化的分析结果构建 StructureZone（用于 web API）。
+    """
+    if config is None:
+        config = StructureZoneConfig()
+
+    raw_points = extract_raw_points_from_serialized(analyses, ema52_dict, config)
+
+    if not raw_points:
+        return []
+
+    # 最晚时间
+    latest_time = None
+    times = [p.candle_time for p in raw_points if p.candle_time]
+    if times:
+        latest_time = max(times)
+
+    # EMA52 值（用于 alignment 检测）
+    ema_values = {tf: v for tf, v in ema52_dict.items() if v is not None and v > 0}
+
+    clusters = cluster_raw_points(raw_points, config)
+    return build_structure_zones(clusters, current_price, ema_values, latest_time, config)

chanlun/analysis/Find_Trend.py

@@ -2,7 +2,7 @@ import ccxt
 import pandas as pd
 import numpy as np
 import mplfinance as mpf
-from talib import MACD, SMA
+from chanlun.indicators import ta
 from datetime import datetime, timedelta
 import logging
 import datetime as dt
@@ -249,8 +249,9 @@ def analyze_higher_timeframe(df_30m):
 # 8. Back-divergence detection (enhanced)
 def detect_back_divergence(df, strokes, higher_trend):
     try:
-        macd, signal, hist = MACD(df['Close'], fastperiod=12, slowperiod=26, signalperiod=9)
-        sma20 = SMA(df['Close'], timeperiod=20)
+        macd_df = ta.MACD(df['Close'], fastperiod=12, slowperiod=26, signalperiod=9)
+        macd, hist = macd_df['macd'], macd_df['macdhist']
+        sma20 = ta.SMA(df['Close'], timeperiod=20)
         df['macd'] = macd
         df['hist'] = hist
         df['sma20'] = sma20

chanlun/analysis/fast_bsp.py

@@ -0,0 +1,384 @@
+"""快速三类买卖点（引擎内称第四类，B4/S4）。
+
+原本长在 `research/lib/fast_bsp3.py`，现移入引擎作为唯一实现，研究脚本改为转发导入，
+这样回测口径与 web 图表永远一致。
+
+命名说明：缠论原文里没有「第四类买卖点」，但 B4/S4 也不只是「B3/S3 提前几根」——
+两者的选样口径不同，统计性质符号相反，故单独立类。形态条件是实时可判的：
+
+    中枢已成 -> 收盘突破 zg -> 收盘未跌回中枢 -> 重新上行
+
+最后一步发生的当根就能下单，滞后约 2 根，而引擎 B3/S3 要等 pullback_bi.sure_time，
+滞后 9~10 根。但差别不止滞后：
+
+  判据   引擎用笔端点事后判（回拉笔低点 >= zg），本函数用收盘价实时判
+  方向   引擎由离开笔方向决定，本函数由收盘从哪一侧突破决定
+  口径   627 个中枢里引擎发 625 个信号（几乎不筛），本函数只认 212 个（34%）；
+         被拒的多数是「中枢确认时价格早已离开、此后再没回来」的历史区间
+
+step30 同条件对拍（同一套 pure 笔中枢、同一组过滤器、同样的 1.5/3.0/48 出场）：
+
+                 原始 PF   +大级别同向   +同向+阶梯   胜率    t值
+    引擎 B3/S3     0.66      0.66         0.71      27.4%  -18.76
+    本函数 B4/S4   1.59      1.85         2.26      47.1%  +10.09
+
+同一组过滤器对 B4 有效、对 B3 无效，滞后差解释不了这一点（入场后移 1~4 根只是
+PF 3.18->2.53 的平滑衰减）。且 SL1.5/TP3.0 下随机入场胜率约 33%，引擎那 27.4%
+低于随机——它选中的是一批系统性反向的样本，不是「晚了所以差」。
+
+require_touch 控制是否强求回抽碰到中枢边界。step32/33 的实测表明强求反而更差：
+这等于排除掉「突破后一去不回头」的强势段，而那正是缠论里最强的趋势形态。
+故默认 False（笔数 +21%、滞后 -1 根、PF 2.26→2.37）。
+
+判据本身（收盘越过前一根极值）没有独立预测力：裸用 15 万笔样本 PF 0.95，
+把中枢换成「近20根高点」这类伪阻力位后 PF 0.90。alpha 全部来自中枢结构，
+判据只负责在这个已知价位上确认动能恢复。它也不能用于识别笔端点——
+入场前的回抽极值命中笔端点±2根的比例 19.3%，低于随机基准 22%。
+
+全部判定只使用当根及之前的数据，无未来函数。
+"""
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+from chanlun.core.ChanEnum import Chan_FX_TYPE
+
+# 中枢的「可用时刻」取第几笔的确认时间。
+#   -1  = 最后一笔（历史默认）。中枢每吸收一根K线，最后一笔就可能后移，
+#         于是 available_ts 跟着漂——这是右边缘重画的根因（见 HANDOFF §5.41）。
+#    2  = 第三笔。三笔重叠即中枢成立，此后不再变，理论上更早也更稳。
+# ⛔ step47 已判定 bis[2] 作废（毛 R 0.933 → −0.000，见 HANDOFF §5.42）。
+# 开关保留只为可复现那次 A/B，**不要改默认值**。
+import os as _os
+
+AVAIL_BI_INDEX = -1
+
+
+def _resolve_avail_bi(avail_bi: int | None) -> int:
+    """优先级：显式入参 > 环境变量 CHAN_AVAIL_BI > 模块默认。
+
+    环境变量在调用时读取而非 import 时——ProcessPoolExecutor 在 fork 启动方式下
+    子进程会继承已 import 的模块，import 时读就固化成父进程的值了。
+    """
+    if avail_bi is not None:
+        return avail_bi
+    return int(_os.environ.get("CHAN_AVAIL_BI", AVAIL_BI_INDEX))
+
+
+def timestamps_ms(src: pd.DataFrame) -> np.ndarray:
+    """取毫秒时间戳。研究侧的 df 自带 timestamp，web 侧的不一定，故按 date 回退。
+
+    回退写法不能用 `date.astype("int64") // 10**6`：该值单位取决于列精度，
+    对毫秒精度的列会把时间戳砸平。
+    """
+    if "timestamp" in src.columns:
+        return src["timestamp"].to_numpy()
+    d = pd.to_datetime(src["date"])
+    if getattr(d.dt, "tz", None) is None:
+        d = d.dt.tz_localize("UTC")
+    return (d.dt.tz_convert("UTC").dt.tz_localize(None)
+             .astype("datetime64[ms]").astype("int64").to_numpy())
+
+
+def ensure_timestamp(df: pd.DataFrame) -> pd.DataFrame:
+    """保证 df 带 timestamp 列，缺失时补一份副本，不改动调用方的对象。"""
+    if "timestamp" in df.columns:
+        return df
+    out = df.copy()
+    out["timestamp"] = timestamps_ms(out)
+    return out
+
+
+def build_htf_zones(df_htf: pd.DataFrame, tf: str, chan=None, avail_bi: int | None = None) -> pd.DataFrame:
+    """算 pure 笔中枢，返回带生效时间的区间表。
+
+    available_ts —— 该中枢最早可被使用的时间戳（其确认时刻）。
+    传入已构建好的 chan 可避免重复跑一遍 pipeline（大数据集上省一半时间）。
+    """
+    if chan is None:
+        from chanlun import TF_DF
+
+        chan = TF_DF(df_htf, 1, tf)
+    zs_list = chan.cal_bi_zs_list_pure(chan.bi_list)
+    # 用引擎自己的 dataframe 对齐，避免调用方传入的 df 与引擎内部行数不一致
+    src = chan.dataframe if getattr(chan, "dataframe", None) is not None else df_htf
+    return zones_from_zs_list(zs_list, src, avail_bi=avail_bi)
+
+
+def zones_from_zs_list(zs_list, src: pd.DataFrame, avail_bi: int | None = None) -> pd.DataFrame:
+    """把已算好的 pure 笔中枢转成区间表。
+
+    调用方手工跑过 cal_bi_zs_list_pure 时走这里，免得再算一遍（web 的 analyze_chan
+    就是这种用法）。
+    """
+    ts_of = dict(zip(src["date"].dt.strftime("%Y-%m-%d %H:%M:%S"), timestamps_ms(src)))
+    # 中枢可用时刻取第几笔。在循环外解析一次，别让每个中枢都去读一遍环境变量。
+    i = _resolve_avail_bi(avail_bi)
+
+    rows = []
+    for zs in zs_list:
+        bis = getattr(zs, "bi_list", [])
+        if not bis:
+            continue
+        # 笔数不够时退回最后一笔（i=2 需要至少 3 笔才成立）
+        key_bi = bis[i] if (i == -1 or len(bis) > i) else bis[-1]
+        sure_key = str(getattr(key_bi, "sure_time", "") or "")
+        end_key = str(getattr(key_bi, "end_time", "") or "")
+        avail = ts_of.get(sure_key) or ts_of.get(end_key)
+        if avail is None:
+            continue
+        start_key = str(bis[0].start_time)
+        rows.append({
+            "zg": float(zs.zg), "zd": float(zs.zd),
+            "gg": float(getattr(zs, "gg", zs.zg)), "dd": float(getattr(zs, "dd", zs.zd)),
+            "start_ts": ts_of.get(start_key, avail),
+            "available_ts": int(avail),
+        })
+    out = pd.DataFrame(rows)
+    return out.sort_values("available_ts").reset_index(drop=True) if not out.empty else out
+
+
+def add_zone_ladder(zones: pd.DataFrame) -> pd.DataFrame:
+    """标注每个中枢相对前一个中枢是否同向推进（缠论「趋势 vs 盘整」）。
+
+    z_above / z_below 分别对应向上、向下推进。买信号要求 z_above、卖信号要求 z_below
+    时，30m/2h 的 PF 从 2.72 升到 3.41。
+    """
+    out = zones.copy()
+    if out.empty:
+        out["z_above"], out["z_below"] = pd.Series(dtype=bool), pd.Series(dtype=bool)
+        return out
+    pg, pdn = out["zg"].shift(), out["zd"].shift()
+    out["z_above"] = (out["zd"] > pg).fillna(False)
+    out["z_below"] = (out["zg"] < pdn).fillna(False)
+    return out
+
+
+def htf_fx_timeline(chan_htf, df_htf: pd.DataFrame | None = None) -> pd.DataFrame:
+    """把大级别分型压成一条按确认时间排序的时间线。
+
+    confirm_ts 是该分型最早可被使用的时刻。timestamp 是K线开盘时刻，而分型要等这根K线
+    收盘才算数，所以整体后移一个大级别周期；否则小级别会提前一整根大级别K线拿到信号。
+
+    只取方向与确认时刻——同向过滤用不到背驰强度，省掉 MACD 面积计算。
+    """
+    src = chan_htf.dataframe if getattr(chan_htf, "dataframe", None) is not None else df_htf
+    if src is None or len(src) == 0:
+        return pd.DataFrame(columns=["confirm_ts", "fx_ts", "direction", "price"])
+    ts = timestamps_ms(src)
+    idx_of = {t: i for i, t in enumerate(src["date"].dt.strftime("%Y-%m-%d %H:%M:%S"))}
+    period = int(np.median(np.diff(ts))) if len(ts) > 1 else 0
+
+    rows = []
+    for klc in getattr(chan_htf, "klc_list", []):
+        if klc.fx not in (Chan_FX_TYPE.TOP, Chan_FX_TYPE.BOTTOM):
+            continue
+        if klc.next is None or klc.next.end_klu is None:
+            continue
+        e_key, c_key = str(klc.end_time), str(klc.next.end_klu.time)
+        if e_key not in idx_of or c_key not in idx_of:
+            continue
+        fx_idx, confirm_idx = idx_of[e_key], idx_of[c_key]
+        if confirm_idx <= fx_idx:
+            continue
+        d = 1 if klc.fx == Chan_FX_TYPE.BOTTOM else -1
+        rows.append({
+            "confirm_ts": int(ts[confirm_idx]) + period,
+            "fx_ts": int(ts[fx_idx]),
+            "direction": d,
+            "price": float(klc.low if d == 1 else klc.high),
+        })
+    out = pd.DataFrame(rows)
+    if out.empty:
+        return pd.DataFrame(columns=["confirm_ts", "fx_ts", "direction", "price"])
+    return out.sort_values("confirm_ts").reset_index(drop=True)
+
+
+def attach_htf_agree(sig: pd.DataFrame, df_ltf: pd.DataFrame, tl: pd.DataFrame) -> pd.DataFrame:
+    """给每个小级别信号挂上「入场时刻之前最近的大级别分型」是否同向。
+
+    产出 htf_dir（+1 底 / -1 顶）与 htf_agree（1 同向 / 0 反向 / NaN 无可用分型）。
+    """
+    out = sig.copy()
+    if sig.empty or tl.empty:
+        out["htf_dir"] = np.nan
+        out["htf_agree"] = np.nan
+        return out
+
+    ts_ltf = timestamps_ms(df_ltf)
+    entry_ts = ts_ltf[out["entry_idx"].to_numpy().astype(int)]
+    k = np.searchsorted(tl["confirm_ts"].to_numpy(), entry_ts, side="right") - 1
+    valid = k >= 0
+    k_safe = np.clip(k, 0, len(tl) - 1)
+
+    fx_dir = tl["direction"].to_numpy()[k_safe].astype(float)
+    out["htf_dir"] = np.where(valid, fx_dir, np.nan)
+    out["htf_agree"] = np.where(
+        valid, (fx_dir == out["direction"].to_numpy()).astype(float), np.nan
+    )
+    return out
+
+
+def attach_zone_ladder(sig: pd.DataFrame, zones: pd.DataFrame) -> pd.DataFrame:
+    """按信号方向取该中枢的阶梯标记：买看 z_above、卖看 z_below。
+
+    zone_i 是 find_fast_bsp3 内 enumerate 出的位置序号，故用 iloc 定位。
+    """
+    out = sig.copy()
+    if sig.empty:
+        out["ladder_ok"] = pd.Series(dtype=bool)
+        return out
+    z = zones if "z_above" in zones.columns else add_zone_ladder(zones)
+    above = z["z_above"].to_numpy()
+    below = z["z_below"].to_numpy()
+    zi = out["zone_i"].to_numpy().astype(int)
+    ok = np.where(out["direction"].to_numpy() == 1, above[zi], below[zi])
+    out["ladder_ok"] = ok.astype(bool)
+    return out
+
+
+def find_fast_bsp3(
+    df: pd.DataFrame,
+    zones: pd.DataFrame,
+    scan: int = 200,
+    pullback_win: int = 30,
+    tol: float = -1.0,
+    max_per_zone: int = 1,
+    diag: dict | None = None,
+    require_touch: bool = False,
+) -> pd.DataFrame:
+    """扫描每个中枢，找突破后回抽不回中枢的入场点。
+
+    zones 需含 zg / zd / available_ts，且 available_ts 已是可用时刻。
+    max_per_zone > 1 时，同一中枢在首次入场后继续往后找二次、三次突破回抽，
+    用来检验「趋势里同一中枢反复给机会」是否值得做。
+
+    tol 是「算作回抽中」的边界容差。require_touch=False 时它不再是入场门槛，
+    仅决定哪些K线被视为回抽中而跳过转强判定，故 tol 越大入场越晚。
+    默认负值 = 完全禁用该跳过，突破后每根都检查转强，滞后压到 2.2 根。
+    step34 实测滞后与收益严格单调：9.9根 PF1.88 / 5.8根 2.37 / 2.2根 2.86。
+
+    返回列：
+      entry_idx   实时可下单的K线
+      direction   +1 三买 / -1 三卖
+      bo_idx      突破根
+      pb_idx      回抽极值根
+      lag         entry_idx - bo_idx
+      depth       回抽深度（相对中枢边界，负值表示曾插入中枢）
+      occ         这是该中枢的第几次入场
+    """
+    if zones.empty:
+        return pd.DataFrame()
+
+    ts = df["timestamp"].to_numpy()
+    close = df["close"].to_numpy(dtype=float)
+    high = df["high"].to_numpy(dtype=float)
+    low = df["low"].to_numpy(dtype=float)
+    n = len(df)
+    rows = []
+
+    def note(key: str) -> None:
+        if diag is not None:
+            diag[key] = diag.get(key, 0) + 1
+
+    for zone_i, (_, z) in enumerate(zones.iterrows()):
+        note("中枢总数")
+        zg, zd = float(z["zg"]), float(z["zd"])
+        if zg <= zd:
+            note("×无效中枢")
+            continue
+        start = int(np.searchsorted(ts, z["available_ts"], side="left"))
+        if start >= n - 2:
+            note("×中枢太靠后")
+            continue
+        # 允许多次入场时按比例放宽扫描窗口，否则后几次机会会被窗口截断
+        scan_end = min(start + scan * max_per_zone, n)
+        cursor = start
+
+        for occ in range(1, max_per_zone + 1):
+            if cursor >= n - 2:
+                break
+            # 第一步：找突破。要求突破前确实待在中枢内，避免把远处的价格当突破。
+            was_inside = False
+            bo_idx, d = None, 0
+            for j in range(cursor, scan_end):
+                c = close[j]
+                if zd <= c <= zg:
+                    was_inside = True
+                    continue
+                if not was_inside:
+                    continue
+                bo_idx, d = j, (1 if c > zg else -1)
+                break
+            if bo_idx is None:
+                if occ == 1:
+                    note("×窗口内未突破")
+                break
+
+            edge = zg if d == 1 else zd
+            # 第二步：突破后监控回抽，回抽不跌回中枢且重新顺势 -> 入场
+            touched = False
+            pb_idx = None
+            pb_ext = None
+            entry_idx = None
+            fell_back = False
+            for j in range(bo_idx + 1, min(bo_idx + pullback_win + 1, n)):
+                # 收盘跌回中枢 -> 突破失效
+                if zd <= close[j] <= zg:
+                    fell_back = True
+                    break
+                # 回抽触及边界附近（允许 tol 的毛刺）
+                near = (low[j] <= edge * (1 + tol)) if d == 1 else (high[j] >= edge * (1 - tol))
+                if near:
+                    touched = True
+                    ext = low[j] if d == 1 else high[j]
+                    if pb_ext is None or ((ext < pb_ext) if d == 1 else (ext > pb_ext)):
+                        pb_ext, pb_idx = ext, j
+                    continue
+                # 回抽后重新顺势：收盘创出前一根之上（三买）/ 之下（三卖）
+                # require_touch=False 时不强求回抽碰到中枢边界，
+                # 这样「突破后一去不回头」的强势段也能收进来。
+                if (touched and pb_idx is not None) or not require_touch:
+                    go = close[j] > high[j - 1] if d == 1 else close[j] < low[j - 1]
+                    if go:
+                        entry_idx = j
+                        break
+            if entry_idx is None:
+                if occ == 1:
+                    note("×突破后跌回中枢" if fell_back
+                         else "×回抽未触及边界" if not touched
+                         else "×触及边界但未转强")
+                # 这次突破没走成，从突破点之后继续找下一次
+                cursor = bo_idx + 1
+                continue
+            if pb_ext is None:
+                # 未触及边界就转强（require_touch=False）：取突破至入场间的实际极值
+                seg = slice(bo_idx + 1, entry_idx + 1)
+                pb_ext = float(low[seg].min() if d == 1 else high[seg].max())
+                pb_idx = int((low[seg].argmin() if d == 1 else high[seg].argmax())
+                             + bo_idx + 1)
+            if occ == 1:
+                note("√成交")
+
+            # 回抽深度：>0 表示未插入中枢，越大表示回抽越浅
+            depth = (pb_ext - zg) / zg if d == 1 else (zd - pb_ext) / zd
+            rows.append({
+                "entry_idx": entry_idx, "direction": d,
+                "bo_idx": bo_idx, "pb_idx": pb_idx,
+                "lag": entry_idx - bo_idx,
+                "depth": depth,
+                "zg": zg, "zd": zd,
+                "width_pct": (zg - zd) / close[bo_idx],
+                "occ": occ,
+                "zone_i": zone_i,
+            })
+            cursor = entry_idx + 1
+
+    out = pd.DataFrame(rows)
+    if out.empty:
+        return out
+    # 相邻中枢可能突破到同一根K线，同一时刻只能有一个仓位，保留最早成型的那个
+    return (out.sort_values(["entry_idx", "occ", "zone_i"])
+               .drop_duplicates("entry_idx", keep="first")
+               .reset_index(drop=True))

chanlun/core/ChanBI.py

@@ -1,6 +1,6 @@
 from decimal import Decimal
-import ChanKLC
-from ChanEnum import Chan_BI_DIR
+import chanlun.core.ChanKLC as ChanKLC
+from chanlun.core.ChanEnum import Chan_BI_DIR
 class ChanBI():
 	def __init__(self, klc: ChanKLC, index, ddir=Chan_BI_DIR.UP):
 		self.start_klc = klc

chanlun/core/ChanBIZS.py

@@ -1,5 +1,5 @@
-from ChanEnum import Chan_ZS_DIR, Chan_ZS_TYPE, Chan_BI_DIR
-import ChanBI
+from chanlun.core.ChanEnum import Chan_ZS_DIR, Chan_ZS_TYPE, Chan_BI_DIR
+import chanlun.core.ChanBI as ChanBI
 # 中枢
 class ChanBIZS():
     def __init__(self, start_bi: ChanBI, index, ddir: Chan_ZS_DIR):

chanlun/core/ChanBSP.py

@@ -1,5 +1,5 @@
-import ChanBI
-from ChanEnum import Chan_BSP_TYPE, Chan_BSP_DIR
+import chanlun.core.ChanBI as ChanBI
+from chanlun.core.ChanEnum import Chan_BSP_TYPE, Chan_BSP_DIR
 
 class ChanBSP():
     def __init__(self, bi: ChanBI, index, type: Chan_BSP_TYPE, ddir: Chan_BSP_DIR, sure_time, zs_count, zs, seg):

chanlun/core/ChanEnum.py

@@ -281,6 +281,10 @@ class Chan_BSP_TYPE(Enum):
     S1 = auto()
     S2 = auto()
     S3 = auto()
+    # 第四类：三类买卖点的低滞后变体，几何位置同 B3/S3，但不等笔确认。
+    # 见 chanlun/analysis/fast_bsp.py
+    B4 = auto()
+    S4 = auto()
     NONE = auto()
 """
 class Chan_BSP_TYPE(Enum):

chanlun/core/ChanFastBSP.py

@@ -0,0 +1,40 @@
+from chanlun.core.ChanEnum import Chan_BSP_DIR, Chan_BSP_TYPE
+
+
+class ChanFastBSP():
+	"""第四类买卖点（B4/S4）。
+
+	与 ChanBSP 的区别在于它不挂在笔上：fast_bsp 刻意不等笔确认，入场点是一根具体的
+	K线而非一笔的端点，所以时间与价格直接取自 K 线，没有 bi / klc 可依附。
+
+	htf_agree 与 ladder_ok 是两个独立的过滤标志，不在这里合成——上层（图表或策略）
+	自己决定要不要用、怎么组合。
+	"""
+
+	def __init__(self, time, price, ddir, entry_idx, bo_time=None, pb_time=None,
+	             lag=0, depth=0.0, zg=None, zd=None, occ=1,
+	             htf_dir=None, htf_agree=None, ladder_ok=None):
+		self.time = time
+		self.price = float(price)
+		self.dir = ddir
+		self.type = Chan_BSP_TYPE.B4 if ddir == Chan_BSP_DIR.BUY else Chan_BSP_TYPE.S4
+		self.entry_idx = int(entry_idx)
+		self.bo_time = bo_time
+		self.pb_time = pb_time
+		self.lag = int(lag)
+		self.depth = float(depth)
+		self.zg = float(zg) if zg is not None else None
+		self.zd = float(zd) if zd is not None else None
+		self.occ = int(occ)
+		self.htf_dir = htf_dir
+		self.htf_agree = htf_agree
+		self.ladder_ok = ladder_ok
+		# 入场即成立，没有「等待确认」这个状态；留此字段是为了与 ChanBSP 的序列化对齐
+		self.is_sure = True
+		self.start_time = time
+		self.end_time = time
+		self.sure_time = time
+
+	def __repr__(self):
+		name = str(self.type).replace('Chan_BSP_TYPE.', '')
+		return f"<ChanFastBSP {name} {self.time} {self.price} lag={self.lag}>"

chanlun/core/ChanKLC.py

@@ -1,12 +1,12 @@
 import copy
 from typing import Dict, Optional
 
-from ChanEnum import Chan_FX_TYPE, Chan_KLINE_DIR, Chan_BI_DIR, Chan_KLC_FX
-from ChanEnum import Chan_K_DIR, Chan_MACD_STATE, Chan_PRICE_TREND, Chan_EMA_POS
-from ChanEnum import Chan_EMA_SEMANTIC, Chan_BSP_TYPE, Chan_KLC_STATE, Chan_FX
-import ChanKLU
-import ChanCTime
-import Chan_FX_Box
+from chanlun.core.ChanEnum import Chan_FX_TYPE, Chan_KLINE_DIR, Chan_BI_DIR, Chan_KLC_FX
+from chanlun.core.ChanEnum import Chan_K_DIR, Chan_MACD_STATE, Chan_PRICE_TREND, Chan_EMA_POS
+from chanlun.core.ChanEnum import Chan_EMA_SEMANTIC, Chan_BSP_TYPE, Chan_KLC_STATE, Chan_FX
+import chanlun.core.ChanKLU as ChanKLU
+import chanlun.core.ChanCTime as ChanCTime
+import chanlun.core.Chan_FX_Box as Chan_FX_Box
 # 根据结合律合并K线后的K线
 class ChanKLC():
 	def __init__(self, klu: ChanKLU, index, ddir=Chan_KLINE_DIR.UP):
@@ -63,10 +63,11 @@ class ChanKLC():
 		self.bsp = False
 		self.bsp_type = Chan_BSP_TYPE.NONE
 		# EMA状态字典：key为EMA名称，value为 {'pos': Chan_EMA_POS, 'semantic': Chan_EMA_SEMANTIC}
-		self.ema_status = {}
+		self._ema_status = {}
+		self._ema_status_dirty = False
 		# 向后兼容：保留 ema52_status 和 ema52_pos
-		self.ema52_status = 0
-		self.ema52_pos = Chan_EMA_POS.UNKNOWN
+		self._ema52_status = 0
+		self._ema52_pos = Chan_EMA_POS.UNKNOWN
 		self.bb2633upper = klu.bb2633upper
 		self.bb2633lower = klu.bb2633lower
 		self.bb2633middle = klu.bb2633middle
@@ -283,21 +284,44 @@ class ChanKLC():
 			'ema156': self.ema156,
 			'ema208': self.ema208,
 		}
-		self.ema_status = {}
+		self._ema_status_dirty = False
+		self._ema_status = {}
 		for name, value in ema_configs.items():
 			# 按 EMA 值的百分比自动计算阈值
 			threshold = abs(value) * self.threshold_pct if value and self.threshold_pct > 0 else 0
 			pos = ChanKLC.cal_ema_pos(self.high, self.low, self.close, value, threshold)
 			semantic = ChanKLC.cal_ema_semantic(pos, self.dir, self.ema_dir)
-			self.ema_status[name] = {
+			self._ema_status[name] = {
 				'pos': pos,
 				'semantic': semantic,
 				'value': value,
 				'threshold': threshold,
 			}
 		# 向后兼容
-		self.ema52_pos = self.ema_status['ema52']['pos']
-		self.ema52_status = ChanKLC.semantic_to_int(self.ema_status['ema52']['semantic'])
+		self._ema52_pos = self._ema_status['ema52']['pos']
+		self._ema52_status = ChanKLC.semantic_to_int(self._ema_status['ema52']['semantic'])
+
+	# 以下三个改成惰性求值。原来 set_end_klu 每次合并 KLU 都会立刻重算一遍，
+	# 实测占 TF_DF 构建的约 25%，而全仓（含前端）没有任何地方读取它的产出。
+	# 保留属性形式是为了任何外部读取仍拿到正确值，只是推迟到真被读时才算。
+	@property
+	def ema_status(self):
+		if self._ema_status_dirty:
+			self.cal_all_ema_status()
+		return self._ema_status
+
+	@property
+	def ema52_pos(self):
+		if self._ema_status_dirty:
+			self.cal_all_ema_status()
+		return self._ema52_pos
+
+	@property
+	def ema52_status(self):
+		if self._ema_status_dirty:
+			self.cal_all_ema_status()
+		return self._ema52_status
+
 	def get_ema_pos(self, ema_name):
 		"""获取指定EMA的客观位置，如 klc.get_ema_pos('ema24')"""
 		if ema_name in self.ema_status:
@@ -372,14 +396,14 @@ class ChanKLC():
 				end_time = self.next.end_time
 				high = self.high
 				low = self.pre.low if self.pre.low < self.next.low else self.next.low
-				if self.next.close < self.pre.low:
+				if self.next.close < self.pre.low or True:
 					display = True
 			elif self.fx == Chan_FX_TYPE.BOTTOM:
 				start_time = self.pre.end_time
 				end_time = self.next.end_time
 				high = self.pre.high if self.pre.high > self.next.high else self.next.high
 				low = self.low
-				if self.next.close > self.pre.high:
+				if self.next.close > self.pre.high or True:
 					display = True
 		if high > 0 and self.next.end_time and display:
 			#print(start_time, end_time, high, low)
@@ -448,7 +472,7 @@ class ChanKLC():
 			klu.set_klc(self)
 		self.klc_dir = Chan_KLINE_DIR.UP if self.close > self.open else Chan_KLINE_DIR.DOWN
 		self.cal_indicators()
-		self.cal_all_ema_status()
+		self._ema_status_dirty = True
 		if self.open > self.high:
 			self.open = self.high
 		if self.close > self.high:

chanlun/core/ChanKLU.py

@@ -1,4 +1,4 @@
-from ChanEnum import Chan_FX_TYPE, Chan_KLU_TYPE, Chan_K_DIR, Chan_MACD_STATE, Chan_MACDHIST_STATE, Chan_PRICE_TREND, Chan_KLU_PATTERN, Chan_KLC_FX
+from chanlun.core.ChanEnum import Chan_FX_TYPE, Chan_KLU_TYPE, Chan_K_DIR, Chan_MACD_STATE, Chan_MACDHIST_STATE, Chan_PRICE_TREND, Chan_KLU_PATTERN, Chan_KLC_FX
 class ChanKLU:
 	def __init__(self, time, open, high, low, close, volume):
 		# _time, _close, _open, _high, _low, _extra_info={}
@@ -96,7 +96,6 @@ class ChanKLU:
 		self.trend = trend
 	def set_separate_div(self, separate_div):
 		self.separate_div = separate_div
-		bb2633_status = self.check_bb2633()
 		if self.klc and self.klc.pre and self.klc.next:
 			fx = self.check_fx_dir(self.klc.pre, self.klc.next)
 			if fx == Chan_FX_TYPE.TOP:
@@ -109,17 +108,6 @@ class ChanKLU:
 					self.separate_div = separate_div
 				else:
 					self.separate_div = 0
-		if bb2633_status == 0:
-			self.separate_div = 0
-	def check_bb2633(self, threadhold=300):
-		#print(self.time, self.high, self.bb2633upper, self.low, self.bb2633lower)
-		if abs(self.high - self.bb2633upper) < threadhold:
-			#print(self.time, self.high, self.bb2633upper)
-			return 1
-		if abs(self.low - self.bb2633lower) < threadhold:
-			#print(self.time, self.low, self.bb2633lower)
-			return -1
-		return 0
 	def check_fx_dir(self, pre, next):
 		fx = Chan_FX_TYPE.UNKNOWN
 		if pre.klc_fx_type == Chan_KLC_FX.TOP1 or pre.klc_fx_type == Chan_KLC_FX.TOP2 or next.klc_fx_type == Chan_KLC_FX.TOP1 or next.klc_fx_type == Chan_KLC_FX.TOP2 or self.klc.klc_fx_type == Chan_KLC_FX.TOP1 or self.klc.klc_fx_type == Chan_KLC_FX.TOP2:
@@ -172,27 +160,40 @@ class ChanKLU:
 			return False
 		else:
 			return True
+	# 属性名 ← dataframe 列名。两条赋值路径（逐行 Series / 预取 ndarray）共用这张表，
+	# 免得将来加指标时只改一处、另一处静默漏掉。
+	INDICATOR_FIELDS = (
+		('macd', 'macd'), ('signal', 'macdsignal'), ('macdhist', 'macdhist'),
+		('ema26', 'ema26'), ('ema52', 'ema52'), ('ema24', 'ema24'),
+		('ema104', 'ema104'), ('ema156', 'ema156'), ('ema208', 'ema208'),
+		('ema13', 'ema13'), ('ema7', 'ema7'), ('ema5', 'ema5'),
+		('rsi', 'rsi'), ('volume_ratio', 'volume_ratio'),
+		('bb52upper', 'bb52upper'), ('bb52lower', 'bb52lower'),
+		('bb2633upper', 'bb2633upper'), ('bb2633lower', 'bb2633lower'),
+		('bb2633middle', 'bb2633middle'), ('ma5', 'ma5'),
+	)
+
 	def set_indicators(self, item):
-		self.macd = float(item['macd']) if 'macd' in item and item['macd'] else 0
-		self.signal = float(item['macdsignal']) if 'macdsignal' in item and item['macdsignal'] else 0
-		self.macdhist = float(item['macdhist']) if 'macdhist' in item and item['macdhist'] else 0
-		self.ema26 = float(item['ema26']) if 'ema26' in item and item['ema26'] else 0
-		self.ema52 = float(item['ema52']) if 'ema52' in item and item['ema52'] else 0
-		self.ema24 = float(item['ema24']) if 'ema24' in item and item['ema24'] else 0
-		self.ema104 = float(item['ema104']) if 'ema104' in item and item['ema104'] else 0
-		self.ema156 = float(item['ema156']) if 'ema156' in item and item['ema156'] else 0
-		self.ema208 = float(item['ema208']) if 'ema208' in item and item['ema208'] else 0
-		self.ema13 = float(item['ema13']) if 'ema13' in item and item['ema13'] else 0
-		self.ema7 = float(item['ema7']) if 'ema7' in item and item['ema7'] else 0
-		self.rsi = float(item['rsi']) if 'rsi' in item and item['rsi'] else 0
-		self.volume_ratio = float(item['volume_ratio']) if 'volume_ratio' in item and item['volume_ratio'] else 0
-		self.bb52upper = float(item['bb52upper']) if 'bb52upper' in item and item['bb52upper'] else 0
-		self.bb52lower = float(item['bb52lower']) if 'bb52lower' in item and item['bb52lower'] else 0
-		self.bb2633upper = float(item['bb2633upper']) if 'bb2633upper' in item and item['bb2633upper'] else 0
-		self.bb2633lower = float(item['bb2633lower']) if 'bb2633lower' in item and item['bb2633lower'] else 0
-		self.bb2633middle = float(item['bb2633middle']) if 'bb2633middle' in item and item['bb2633middle'] else 0
-		self.ma5 = float(item['ma5']) if 'ma5' in item and item['ma5'] else 0
-		self.ema5 = float(item['ema5']) if 'ema5' in item and item['ema5'] else 0
+		"""单根赋值。增量追加时每次只有一根，走这条即可。
+
+		原写法是 `float(item[c]) if c in item and item[c] else 0`。其中的真值判断
+		是空转：值为 0.0 时 float(0.0) 仍是 0，值为 NaN 时 NaN 为真值、照样透传。
+		唯一起作用的是「列不存在则填 0」，所以这里只保留那一层。
+		"""
+		for attr, col in self.INDICATOR_FIELDS:
+			v = item[col] if col in item else 0
+			setattr(self, attr, float(v) if v else 0)
+
+	def set_indicators_from(self, cols, i):
+		"""从预取的 {列名: ndarray} 按下标赋值，语义与 set_indicators 相同。
+
+		全量构建时用这条：避免每根 `df.iloc[i]` 构造一个 Series，再在其上做
+		几十次逐键查找——那是 TF_DF 构建 96% 的耗时所在。
+		"""
+		for attr, col in self.INDICATOR_FIELDS:
+			arr = cols.get(col)
+			v = arr[i] if arr is not None else 0
+			setattr(self, attr, float(v) if v else 0)
 	def cal_macd_state(self):
 		# 按定义精简实现：优先级 CROSS0 > 位置(HIGH/HE/RETURN_ZERO) > NEAR0 > UNKNOWN
 		# 首条或缺前一根

chanlun/core/ChanSBI.py

@@ -1,9 +1,9 @@
 import copy
 from typing import Dict, Optional
 
-from ChanEnum import Chan_FX_TYPE, Chan_KLINE_DIR, Chan_BI_DIR
-import ChanKLU
-from ChanBI import ChanBI
+from chanlun.core.ChanEnum import Chan_FX_TYPE, Chan_KLINE_DIR, Chan_BI_DIR
+import chanlun.core.ChanKLU as ChanKLU
+from chanlun.core.ChanBI import ChanBI
 
 class ChanSBI():
     def __init__(self, start_bi: ChanBI, index, dir=Chan_BI_DIR.UP):

chanlun/core/ChanSEG.py

@@ -1,10 +1,10 @@
 import copy
 from typing import Dict, Optional
 
-from ChanEnum import Chan_FX_TYPE, Chan_KLINE_DIR, Chan_SEG_DIR, Chan_BI_DIR, Chan_ZS_DIR
-import ChanCTime
-from ChanBI import ChanBI
-from ChanBIZS import ChanBIZS
+from chanlun.core.ChanEnum import Chan_FX_TYPE, Chan_KLINE_DIR, Chan_SEG_DIR, Chan_BI_DIR, Chan_ZS_DIR
+import chanlun.core.ChanCTime as ChanCTime
+from chanlun.core.ChanBI import ChanBI
+from chanlun.core.ChanBIZS import ChanBIZS
 class ChanSEG():
     def __init__(self, start_bi: ChanBI, index, ddir=Chan_SEG_DIR.UP, pre_end_bi: ChanBI = None):
         self.start_bi = start_bi
@@ -96,7 +96,10 @@ class ChanSEG():
             if self.dir == Chan_SEG_DIR.UP:
                 for index in range(1, len(self.bi_list)):
                     bi = self.bi_list[index]
+                    #print(bi.end_time, bi.next,"UP SEG BI ZS Index")
                     if bi.next == None or bi.next.next == None:
+                        if last_zs and (bi.low > last_zs.zg or bi.high < last_zs.zd):
+                                last_zs.set_end_bi(last_zs.bi_list[-1], last_zs.bi_list[-1].sure_time)
                         continue
                     bi2 = bi.next
                     bi3 = bi.next.next
@@ -118,6 +121,7 @@ class ChanSEG():
                     else:
                         if bi.index > last_zs.bi_list[-1].index and bi.dir == Chan_BI_DIR.DOWN and bi.is_sure:
                             if bi.low > last_zs.zg or bi.high < last_zs.zd:
+                                #print(bi.end_time, "UP SEG BI ZS End")
                                 last_zs.set_end_bi(last_zs.bi_list[-1], last_zs.bi_list[-1].sure_time)
                                 if bi3.is_sure and bi3.index <= self.bi_list[-1].index and bi.check_bi_zs_overlap() and bi.dir == Chan_BI_DIR.DOWN:
                                     zg = min(bi.high, bi2.high, bi3.high)
@@ -143,6 +147,8 @@ class ChanSEG():
                 for index in range(1, len(self.bi_list)):
                     bi = self.bi_list[index]
                     if bi.next == None or bi.next.next == None:
+                        if last_zs and (bi.low > last_zs.zg or bi.high < last_zs.zd):
+                                last_zs.set_end_bi(last_zs.bi_list[-1], last_zs.bi_list[-1].sure_time)
                         continue
                     bi2 = bi.next
                     bi3 = bi.next.next

chanlun/core/ChanZS.py

@@ -1,8 +1,9 @@
 from typing import Dict, Optional
 
-import ChanKLC, ChanSEG
-import ChanCTime
-from ChanEnum import Chan_ZS_DIR
+import chanlun.core.ChanKLC as ChanKLC
+import chanlun.core.ChanSEG as ChanSEG
+import chanlun.core.ChanCTime as ChanCTime
+from chanlun.core.ChanEnum import Chan_ZS_DIR
 # 中枢
 class ChanZS():
     def __init__(self, start_seg: ChanSEG, index, ddir: Chan_ZS_DIR):

chanlun/indicators/ChanMACD.py

@@ -1,8 +1,8 @@
-from ChanKLU import ChanKLU
-from ChanEnum import Chan_MACD_STATE, Chan_MACDSEG_DIR, Chan_MACDHISTSET_DIR, Chan_MACDUNITTF_DIR, Chan_MACDUNITTF_TYPE
-from ChanMACDSeg import ChanMACDSeg
-from ChanMACDUnitTF import ChanMACDUnitTF
-from ChanMACDHistSet import ChanMACDHistSet
+from chanlun.core.ChanKLU import ChanKLU
+from chanlun.core.ChanEnum import Chan_MACD_STATE, Chan_MACDSEG_DIR, Chan_MACDHISTSET_DIR, Chan_MACDUNITTF_DIR, Chan_MACDUNITTF_TYPE
+from chanlun.indicators.ChanMACDSeg import ChanMACDSeg
+from chanlun.indicators.ChanMACDUnitTF import ChanMACDUnitTF
+from chanlun.indicators.ChanMACDHistSet import ChanMACDHistSet
 
 class ChanMACD():
 	def __init__(self, klu_list: list[ChanKLU]):
@@ -31,7 +31,7 @@ class ChanMACD():
 		if self.klu_list:
 			for klu in self.klu_list:
 				hist = klu.macdhist
-				singal = False
+				signal = False
 				if klu.pre and klu.next:
 					if klu.signal > 0:
 						signal = klu.pre.signal > klu.signal and klu.next.signal < klu.signal

chanlun/indicators/ChanMACDHistSet.py

@@ -1,4 +1,4 @@
-from ChanEnum import Chan_MACDHISTSET_DIR, Chan_MACDUNITTF_DIV, Chan_MACD_STATE
+from chanlun.core.ChanEnum import Chan_MACDHISTSET_DIR, Chan_MACDUNITTF_DIV, Chan_MACD_STATE
 
 class ChanMACDHistSet():
     def __init__(self, index, start_time, start_klu, pre_histset, dir):

chanlun/indicators/ChanMACDSeg.py

@@ -1,4 +1,4 @@
-from ChanEnum import Chan_MACDSEG_DIR
+from chanlun.core.ChanEnum import Chan_MACDSEG_DIR
 
 
 class ChanMACDSeg():

chanlun/indicators/ChanMACDUnitTF.py

@@ -1,4 +1,4 @@
-from ChanEnum import Chan_MACD_STATE, Chan_MACDUNITTF_DIR, Chan_MACDHISTSET_DIR, Chan_MACDUNITTF_DIV, Chan_MACDUNITTF_TYPE
+from chanlun.core.ChanEnum import Chan_MACD_STATE, Chan_MACDUNITTF_DIR, Chan_MACDHISTSET_DIR, Chan_MACDUNITTF_DIV, Chan_MACDUNITTF_TYPE
 
 
 class ChanMACDUnitTF():

chanlun/indicators/ta.py

@@ -0,0 +1,196 @@
+"""Drop-in replacement for the `talib.abstract` calls this project makes.
+
+Same call signatures, same column names, same NaN warm-up lengths, so call
+sites only change their import line.
+
+Only what the codebase actually uses is implemented: SMA, MA, EMA, RSI, ATR,
+MACD, BBANDS. Numerical agreement with TA-Lib is enforced by
+`chanlun/tests/test_ta_compat.py`, which skips when talib is absent.
+
+The warm-up conventions below are TA-Lib's, not the textbook ones, and they
+differ between functions — getting them wrong shifts every downstream Chan
+structure by a bar:
+
+  SMA/BBANDS  first value at index period-1
+  EMA         seeded with the SMA of the first `period` values, at index period-1
+  RSI/ATR     Wilder smoothing (alpha = 1/period), first value at index period
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+__all__ = ["SMA", "MA", "EMA", "RSI", "ATR", "MACD", "BBANDS"]
+
+
+def _series(data, price: str = "close") -> pd.Series:
+    """Accept the abstract-API shapes: DataFrame, Series, or ndarray."""
+    if isinstance(data, pd.DataFrame):
+        return data[price].astype(float)
+    if isinstance(data, pd.Series):
+        return data.astype(float)
+    return pd.Series(np.asarray(data, dtype=float))
+
+
+def _recursive(values: np.ndarray, seed: float, start: int, alpha: float, n: int) -> np.ndarray:
+    """out[start] = seed; out[i] = alpha*values[i] + (1-alpha)*out[i-1].
+
+    Delegates the recursion to pandas' C implementation rather than a Python
+    loop — `research/` runs this over long histories.
+    """
+    out = np.full(n, np.nan)
+    if start >= n:
+        return out
+    tail = values[start:].astype(float).copy()
+    tail[0] = seed
+    out[start:] = pd.Series(tail).ewm(alpha=alpha, adjust=False).mean().to_numpy()
+    return out
+
+
+def SMA(data, timeperiod: int = 30, price: str = "close") -> pd.Series:
+    s = _series(data, price)
+    return s.rolling(window=timeperiod, min_periods=timeperiod).mean()
+
+
+def MA(data, timeperiod: int = 30, matype: int = 0, price: str = "close") -> pd.Series:
+    if matype != 0:
+        raise NotImplementedError(f"MA matype={matype} is not used by this codebase")
+    return SMA(data, timeperiod, price=price)
+
+
+def _ema(x: np.ndarray, period: int, start: int) -> np.ndarray:
+    """EMA whose first output lands on `start`, seeded by the SMA of the
+    `period` values ending there.
+
+    `start` is a parameter because MACD needs the fast EMA to begin later than
+    it naturally would; see the note in MACD().
+    """
+    n = x.size
+    if n <= start or start < period - 1:
+        return np.full(n, np.nan)
+    seed = x[start - period + 1: start + 1].mean()
+    return _recursive(x, seed, start, 2.0 / (period + 1.0), n)
+
+
+def EMA(data, timeperiod: int = 30, price: str = "close") -> pd.Series:
+    s = _series(data, price)
+    x = s.to_numpy(dtype=float)
+    return pd.Series(_ema(x, timeperiod, timeperiod - 1), index=s.index)
+
+
+def RSI(data, timeperiod: int = 14, price: str = "close") -> pd.Series:
+    s = _series(data, price)
+    x = s.to_numpy(dtype=float)
+    n = x.size
+    out = np.full(n, np.nan)
+    if n <= timeperiod:
+        return pd.Series(out, index=s.index)
+
+    delta = np.diff(x)
+    gain = np.where(delta > 0.0, delta, 0.0)
+    loss = np.where(delta < 0.0, -delta, 0.0)
+
+    # delta[k] corresponds to bar k+1, so the first `timeperiod` deltas seed bar `timeperiod`.
+    alpha = 1.0 / timeperiod
+    avg_gain = _recursive(gain, gain[:timeperiod].mean(), timeperiod - 1, alpha, n - 1)
+    avg_loss = _recursive(loss, loss[:timeperiod].mean(), timeperiod - 1, alpha, n - 1)
+
+    ag = avg_gain[timeperiod - 1:]
+    al = avg_loss[timeperiod - 1:]
+    with np.errstate(divide="ignore", invalid="ignore"):
+        rsi = np.where(al == 0.0, 100.0, 100.0 - 100.0 / (1.0 + ag / al))
+    out[timeperiod:] = rsi
+    return pd.Series(out, index=s.index)
+
+
+def ATR(data, timeperiod: int = 14) -> pd.Series:
+    if not isinstance(data, pd.DataFrame):
+        raise TypeError("ATR needs a DataFrame with high/low/close")
+    high = data["high"].to_numpy(dtype=float)
+    low = data["low"].to_numpy(dtype=float)
+    close = data["close"].to_numpy(dtype=float)
+    n = high.size
+    out = np.full(n, np.nan)
+    if n <= timeperiod:
+        return pd.Series(out, index=data.index)
+
+    prev_close = close[:-1]
+    tr = np.maximum.reduce([
+        high[1:] - low[1:],
+        np.abs(high[1:] - prev_close),
+        np.abs(low[1:] - prev_close),
+    ])
+
+    # tr[k] is bar k+1; the first `timeperiod` true ranges seed bar `timeperiod`.
+    smoothed = _recursive(tr, tr[:timeperiod].mean(), timeperiod - 1, 1.0 / timeperiod, n - 1)
+    out[timeperiod:] = smoothed[timeperiod - 1:]
+    return pd.Series(out, index=data.index)
+
+
+def MACD(
+    data,
+    fastperiod: int = 12,
+    slowperiod: int = 26,
+    signalperiod: int = 9,
+    price: str = "close",
+) -> pd.DataFrame:
+    if slowperiod < fastperiod:
+        fastperiod, slowperiod = slowperiod, fastperiod
+
+    s = _series(data, price)
+    x = s.to_numpy(dtype=float)
+    n = x.size
+
+    macd = np.full(n, np.nan)
+    signal = np.full(n, np.nan)
+    hist = np.full(n, np.nan)
+    empty = pd.DataFrame({"macd": macd, "macdsignal": signal, "macdhist": hist}, index=s.index)
+
+    # Both EMAs emit their first value on the same bar. That makes the slow one
+    # ordinary, but re-seeds the fast one from the SMA of the `fastperiod`
+    # values ending there instead of carrying the recursion forward from bar
+    # fastperiod-1 — the two disagree by ~0.2 on a 100-priced series.
+    macd_start = slowperiod - 1
+    if n <= macd_start:
+        return empty
+    line = _ema(x, fastperiod, macd_start) - _ema(x, slowperiod, macd_start)
+
+    # The signal EMA runs over the MACD line, so everything shifts by another
+    # signalperiod-1 bars, and TA-Lib trims the MACD line to match.
+    valid = line[macd_start:]
+    if valid.size < signalperiod:
+        return empty
+    sig = _recursive(
+        valid, valid[:signalperiod].mean(), signalperiod - 1, 2.0 / (signalperiod + 1.0), valid.size
+    )
+    start = macd_start + signalperiod - 1
+    macd[start:] = line[start:]
+    signal[macd_start:] = sig
+    hist = macd - signal
+
+    return pd.DataFrame({"macd": macd, "macdsignal": signal, "macdhist": hist}, index=s.index)
+
+
+def BBANDS(
+    data,
+    timeperiod: int = 5,
+    nbdevup: float = 2.0,
+    nbdevdn: float = 2.0,
+    matype: int = 0,
+    price: str = "close",
+) -> pd.DataFrame:
+    if matype != 0:
+        raise NotImplementedError(f"BBANDS matype={matype} is not used by this codebase")
+    s = _series(data, price)
+    middle = s.rolling(window=timeperiod, min_periods=timeperiod).mean()
+    # TA-Lib uses the population standard deviation.
+    std = s.rolling(window=timeperiod, min_periods=timeperiod).std(ddof=0)
+    return pd.DataFrame(
+        {
+            "upperband": middle + nbdevup * std,
+            "middleband": middle,
+            "lowerband": middle - nbdevdn * std,
+        },
+        index=s.index,
+    )

chanlun/pipeline/builders/bi.py

@@ -0,0 +1,680 @@
+"""TF_DF builder mixin — 由 split_tfdf_builders 自动生成，逻辑与原 TF_DF 一致。"""
+from __future__ import annotations
+
+from datetime import timedelta
+from decimal import Decimal
+
+import numpy as np
+import pandas as pd
+from pandas import DataFrame
+
+from chanlun.core.ChanBI import ChanBI
+from chanlun.core.ChanBIZS import ChanBIZS
+from chanlun.core.ChanBSP import ChanBSP
+from chanlun.core.ChanEnum import (
+    Chan_BI_DIR,
+    Chan_BSP_DIR,
+    Chan_BSP_TYPE,
+    Chan_FX_TYPE,
+    Chan_K_DIR,
+    Chan_KLC_FX,
+    Chan_KLC_STATE,
+    Chan_KLINE_DIR,
+    Chan_KLU_PATTERN,
+    Chan_PRICE_TREND,
+    Chan_SEG_DIR,
+    Chan_ZS_DIR,
+)
+from chanlun.core.ChanKLC import ChanKLC
+from chanlun.core.ChanKLU import ChanKLU
+from chanlun.core.ChanSBI import ChanSBI
+from chanlun.core.ChanSEG import ChanSEG
+from chanlun.core.ChanZS import ChanZS, ChanZS_Big
+from chanlun.indicators.ChanMACD import ChanMACD
+
+
+class BiBuilderMixin:
+	def cal_trend(self, klc_list):
+		"""
+		基于价格与EMA24/EMA52的位置关系、以及MACD/Signal/Hist的方向，
+		为每个KLC打上趋势标签：'UP' / 'DOWN' / 'FLAT'。
+		仅设置 klc.trend，不影响其它字段。
+		"""
+		if not klc_list:
+			return klc_list
+		last_trend = Chan_PRICE_TREND.UNKNOWN
+		# 趋势延续性：参考近 N 根已完成的KLC
+		lookback_n = 5
+		prev_klcs = []
+		for klc in klc_list:
+			price = getattr(klc, 'close', None)
+			ema24 = getattr(klc, 'ema24', None)
+			ema52 = getattr(klc, 'ema52', None)
+			macd_raw = getattr(klc, 'macd', None)
+			signal_raw = getattr(klc, 'signal', None)
+			hist_raw = getattr(klc, 'macdhist', None)
+			macd = macd_raw if macd_raw is not None else 0
+			signal = signal_raw if signal_raw is not None else 0
+			hist = hist_raw if hist_raw is not None else 0
+			rsi = getattr(klc, 'rsi', None)
+			macd_ready = macd_raw is not None and signal_raw is not None
+			hist_ready = hist_raw is not None
+			trend = Chan_PRICE_TREND.UNKNOWN
+			score = 0
+			try:
+				# 有效性
+				price_valid = price is not None and price != 0
+				ema24_valid = ema24 is not None and ema24 != 0
+				ema52_valid = ema52 is not None and ema52 != 0
+				# 多因子投票
+				
+				# 1) 均线结构 + 价位
+				if ema24_valid or ema52_valid:
+					ma_votes = 0
+					if ema24_valid and ema52_valid:
+						ma_votes += 1 if ema24 > ema52 else -1
+					if price_valid and ema24_valid:
+						ma_votes += 1 if price > ema24 else 0
+					if price_valid and ema52_valid:
+						ma_votes += 1 if price > ema52 else -1
+					# 限幅，避免相关因子重复计分
+					score += max(-2, min(2, ma_votes))
+				# 2) MACD结构
+				if macd_ready:
+					score += 1 if macd >= signal else -1
+					if hist_ready and hist != 0:
+						score += 1 if hist > 0 else -1
+				# 3) 动量与均线差分斜率
+				pre = getattr(klc, 'pre', None)
+				pre_hist = getattr(pre, 'macdhist', None) if pre else None
+				if pre:
+					pre_close = getattr(pre, 'close', None)
+					if price_valid and pre_close is not None:
+						score += 1 if price >= pre_close else -1
+					pre_ema24 = getattr(pre, 'ema24', None)
+					pre_ema52 = getattr(pre, 'ema52', None)
+					if ema24_valid and ema52_valid and pre_ema24 not in (None, 0) and pre_ema52 not in (None, 0):
+						spread_now = ema24 - ema52
+						spread_pre = pre_ema24 - pre_ema52
+						score += 1 if spread_now >= spread_pre else -1
+					# 3.1) MACD柱体动量趋势：考虑 macdhist 的斜率与过零
+					if hist_ready and pre_hist is not None:
+						# 柱体斜率：上升加分，下降减分
+						if hist > pre_hist:
+							score += 1
+						elif hist < pre_hist:
+							score -= 1
+						# 过零加权：负转正更偏多，正转负更偏空
+						if pre_hist < 0 and hist > 0:
+							score += 1
+						elif pre_hist > 0 and hist < 0:
+							score -= 1
+					# 3.2) EMA52 突破/跌破加权
+					if ema52_valid and price_valid and pre_close is not None and pre_ema52 not in (None, 0):
+						# 看多突破：从均线下方上破且动量配合
+						if pre_close <= pre_ema52 and price > ema52 and (hist is None or pre_hist is None or hist >= pre_hist):
+							score += 1
+						# 看空跌破：从均线上方下破且动量配合
+						if pre_close >= pre_ema52 and price < ema52 and (hist is None or pre_hist is None or hist <= pre_hist):
+							score -= 1
+				# 3.3) EMA52 支撑/阻力触碰（非强穿越）
+				if ema52_valid and price_valid:
+					low_v = getattr(klc, 'low', None)
+					high_v = getattr(klc, 'high', None)
+					if low_v is not None and high_v is not None and ema52 not in (None, 0):
+						# 触碰容差（相对EMA52的0.15%）
+						touch_tol = 0.0015
+						# 作为支撑：收盘在上，最低靠近EMA52
+						near_support_touch = (price > ema52) and (abs(low_v - ema52) / abs(ema52) <= touch_tol)
+						# 作为阻力：收盘在下，最高靠近EMA52
+						near_resistance_touch = (price < ema52) and (abs(high_v - ema52) / abs(ema52) <= touch_tol)
+						if near_support_touch:
+							# 若动量不弱，则更偏多
+							score += 1 if (hist is None or pre_hist is None or hist >= pre_hist) else 0
+						if near_resistance_touch:
+							# 若动量不强，则更偏空
+							score -= 1 if (hist is None or pre_hist is None or hist <= pre_hist) else 0
+				# 3.4) 多次对 EMA52 的"拒绝"配合 MACD 逆向：易形成压/支并反向
+				# 统计近窗口内的上/下拒绝次数：
+				# - 上拒绝：价格位于 EMA52 下方，最高触及/越过 EMA52 但收盘仍在下方
+				# - 下拒绝：价格位于 EMA52 上方，最低触及/跌破 EMA52 但收盘仍在上方
+				recent_up_rejects = 0
+				recent_down_rejects = 0
+				if ema52_valid:
+					window_rej = prev_klcs[-lookback_n:] if len(prev_klcs) > 0 else []
+					rej_tol = 0.0015
+					for wk in window_rej:
+						wk_close = getattr(wk, 'close', None)
+						wk_ema52 = getattr(wk, 'ema52', None)
+						wk_high = getattr(wk, 'high', None)
+						wk_low = getattr(wk, 'low', None)
+						if wk_close is None or wk_ema52 in (None, 0):
+							continue
+						# 上拒绝（阻力）：下方多次试图上破但未站上
+						if wk_close < wk_ema52 and wk_high is not None:
+							if wk_high >= wk_ema52 or abs(wk_high - wk_ema52) / abs(wk_ema52) <= rej_tol:
+								recent_up_rejects += 1
+						# 下拒绝（支撑）：上方多次试图下破但未跌破
+						if wk_close > wk_ema52 and wk_low is not None:
+							if wk_low <= wk_ema52 or abs(wk_low - wk_ema52) / abs(wk_ema52) <= rej_tol:
+								recent_down_rejects += 1
+				# 定义 MACD 的方向偏好
+				macd_bias_up = macd_ready and (macd >= signal) and (not hist_ready or pre_hist is None or hist >= pre_hist)
+				macd_bias_down = macd_ready and (macd <= signal) and (not hist_ready or pre_hist is None or hist <= pre_hist)
+				# 若多次上拒绝且 MACD 偏空，则更偏向下行；若多次下拒绝且 MACD 偏多，则更偏向上行
+				if recent_up_rejects >= 2 and macd_bias_down:
+					score -= 2
+				if recent_down_rejects >= 2 and macd_bias_up:
+					score += 2
+				# 4) RSI 辅助
+				if rsi is not None:
+					if rsi >= 55:
+						score += 1
+					elif rsi <= 45:
+						score -= 1
+				# 5) 指标未就绪回退（EMA/MACD缺失时，用动量与RSI辅助，延续趋势）
+				has_full_ind = ema24_valid and ema52_valid and not (macd == 0 and signal == 0 and hist == 0)
+				if not has_full_ind:
+					# 仅根据价动量/RSI做轻量判断，默认延续 last_trend，除非出现强反向
+					strong_up = False
+					strong_down = False
+					pre = getattr(klc, 'pre', None)
+					if pre:
+						pre_close = getattr(pre, 'close', None)
+						if price_valid and pre_close is not None:
+							strong_up = (price >= pre_close)
+							strong_down = (price < pre_close)
+					if rsi is not None:
+						if rsi >= 60:
+							strong_up = True
+						elif rsi <= 40:
+							strong_down = True
+					if last_trend == Chan_PRICE_TREND.UP and not strong_down:
+						trend = Chan_PRICE_TREND.UP
+					elif last_trend == Chan_PRICE_TREND.DOWN and not strong_up:
+						trend = Chan_PRICE_TREND.DOWN
+					else:
+						trend = Chan_PRICE_TREND.UP if strong_up and not strong_down else (Chan_PRICE_TREND.DOWN if strong_down and not strong_up else Chan_PRICE_TREND.FLAT)
+				else:
+					# 6) 震荡过滤（仅当极近EMA52且MACD贴合时判作震荡）
+					near_flat = False
+					if price_valid and ema52_valid:
+						near_ema52 = abs(price - ema52) / abs(ema52) <= 0.0005  # 0.05%
+						if macd_ready:
+							macd_scale = max(abs(macd), abs(signal), 1e-6)
+							near_macd = abs(macd - signal) / macd_scale <= 0.05
+						else:
+							near_macd = False
+						near_flat = near_ema52 and near_macd
+					# 7) 动态阈值 + 趋势记忆（更强粘滞：趋势中容忍小幅反分）
+					# 引入过去 N 根KLC 的趋势延续性来动态调整翻转阈值，并结合 EMA52 支撑/阻力触碰强化门槛
+					force_flip_down = False
+					force_flip_up = False
+					if near_flat:
+						trend = Chan_PRICE_TREND.FLAT
+					else:
+						# 计算过去窗口的趋势一致性
+						window = prev_klcs[-lookback_n:] if len(prev_klcs) > 0 else []
+						persist_up = 0
+						persist_down = 0
+						for wk in window:
+							if getattr(wk, 'trend', None) == Chan_PRICE_TREND.UP:
+								persist_up += 1
+							elif getattr(wk, 'trend', None) == Chan_PRICE_TREND.DOWN:
+								persist_down += 1
+						persist_ratio_up = (persist_up / len(window)) if len(window) > 0 else 0
+						persist_ratio_down = (persist_down / len(window)) if len(window) > 0 else 0
+						# 基准阈值
+						down_flip_threshold = -2
+						up_flip_threshold = 2
+						# 若最近多为UP，则从UP翻转需更强反向信号；同理对DOWN
+						if last_trend == Chan_PRICE_TREND.UP and persist_ratio_up >= 0.6:
+							down_flip_threshold = -3
+						elif last_trend == Chan_PRICE_TREND.DOWN and persist_ratio_down >= 0.6:
+							up_flip_threshold = 3
+						# EMA52 触碰强化门槛：UP时若出现支撑触碰，下翻更难；DOWN时若出现阻力触碰，上翻更难
+						if ema52_valid and price_valid:
+							low_v = getattr(klc, 'low', None)
+							high_v = getattr(klc, 'high', None)
+							if low_v is not None and high_v is not None and ema52 not in (None, 0):
+								touch_tol = 0.0015
+								near_support_touch = (price > ema52) and (abs(low_v - ema52) / abs(ema52) <= touch_tol)
+								near_resistance_touch = (price < ema52) and (abs(high_v - ema52) / abs(ema52) <= touch_tol)
+								if last_trend == Chan_PRICE_TREND.UP and near_support_touch:
+									# 强化维持UP：进一步降低向下翻转阈值
+									down_flip_threshold = min(down_flip_threshold - 1, -3)
+								if last_trend == Chan_PRICE_TREND.DOWN and near_resistance_touch:
+									# 强化维持DOWN：进一步提高向上翻转阈值
+									up_flip_threshold = max(up_flip_threshold + 1, 3)
+						# 7.1) 复合拐头信号：MACD/Signal 同向拐头 + hist 连续减弱 + 多次未能越过 EMA52
+						pre_macd = getattr(pre, 'macd', None) if pre else None
+						pre_signal = getattr(pre, 'signal', None) if pre else None
+						macd_slope = (macd - pre_macd) if (macd_ready and pre_macd is not None) else 0
+						signal_slope = (signal - pre_signal) if (macd_ready and pre_signal is not None) else 0
+						# hist 连续减弱（绝对值缩小）
+						hist_seq = []
+						for wk in prev_klcs[-2:]:
+							val = getattr(wk, 'macdhist', None)
+							if val is not None:
+								hist_seq.append(val)
+						if hist is not None:
+							hist_seq.append(hist)
+						weaken_steps = 0
+						for i in range(1, len(hist_seq)):
+							if abs(hist_seq[i]) < abs(hist_seq[i-1]):
+								weaken_steps += 1
+						# 近窗口对 EMA52 的"未能站上/跌破"统计（放宽窗口与条件）
+						window_ema = prev_klcs[-4:] if len(prev_klcs) > 0 else []
+						no_up_break = False
+						no_down_break = False
+						if ema52_valid:
+							# 未能有效上破：最近若干根收盘大多数不在 EMA52 上方，且高点多次触及/接近
+							cnt_touch_up = 0
+							cnt_close_above = 0
+							for wk in window_ema:
+								wk_close = getattr(wk, 'close', None)
+								wk_high = getattr(wk, 'high', None)
+								wk_ema = getattr(wk, 'ema52', None)
+								if wk_close is not None and wk_ema not in (None, 0):
+									if wk_close > wk_ema:
+										cnt_close_above += 1
+									if wk_high is not None and (wk_high >= wk_ema or abs(wk_high - wk_ema) / abs(wk_ema) <= 0.0015):
+										cnt_touch_up += 1
+							no_up_break = (cnt_close_above <= 1 and cnt_touch_up >= 1 and price <= ema52)
+							# 未能有效下破：最近若干根收盘大多数不在 EMA52 下方，且低点多次触及/接近
+							cnt_touch_down = 0
+							cnt_close_below = 0
+							for wk in window_ema:
+								wk_close = getattr(wk, 'close', None)
+								wk_low = getattr(wk, 'low', None)
+								wk_ema = getattr(wk, 'ema52', None)
+								if wk_close is not None and wk_ema not in (None, 0):
+									if wk_close < wk_ema:
+										cnt_close_below += 1
+									if wk_low is not None and (wk_low <= wk_ema or abs(wk_low - wk_ema) / abs(wk_ema) <= 0.0015):
+										cnt_touch_down += 1
+							no_down_break = (cnt_close_below <= 1 and cnt_touch_down >= 1 and price >= ema52)
+						# 若当前为UP趋势，出现明显拐头+hist减弱+未能上破EMA52，则加速看空
+						if last_trend == Chan_PRICE_TREND.UP and macd_slope < 0 and signal_slope < 0 and weaken_steps >= 1 and no_up_break and macd_bias_down:
+							score -= 3
+							down_flip_threshold = max(down_flip_threshold, 0)
+							force_flip_down = True
+						# 若当前为DOWN趋势，出现明显拐头+hist减弱+未能下破EMA52，则加速看多
+						if last_trend == Chan_PRICE_TREND.DOWN and macd_slope > 0 and signal_slope > 0 and weaken_steps >= 1 and no_down_break and macd_bias_up:
+							score += 3
+							up_flip_threshold = min(up_flip_threshold, 0)
+							force_flip_up = True
+						# 多次对 EMA52 的拒绝配合 MACD 逆向：加速反向翻转（降低相反方向阈值）
+						if recent_up_rejects >= 2 and macd_bias_down:
+							# 从 UP 向 DOWN 的翻转更容易
+							down_flip_threshold = max(down_flip_threshold, -1)
+						if recent_down_rejects >= 2 and macd_bias_up:
+							# 从 DOWN 向 UP 的翻转更容易
+							up_flip_threshold = min(up_flip_threshold, 1)
+						if force_flip_down:
+							trend = Chan_PRICE_TREND.DOWN
+						elif force_flip_up:
+							trend = Chan_PRICE_TREND.UP
+						elif last_trend == Chan_PRICE_TREND.UP:
+							if score <= down_flip_threshold:
+								trend = Chan_PRICE_TREND.DOWN
+							else:
+								trend = Chan_PRICE_TREND.UP
+						elif last_trend == Chan_PRICE_TREND.DOWN:
+							if score >= up_flip_threshold:
+								trend = Chan_PRICE_TREND.UP
+							else:
+								trend = Chan_PRICE_TREND.DOWN
+						else:
+							# 初始无记忆时，降低进入门槛
+							if score >= 1:
+								trend = Chan_PRICE_TREND.UP
+							elif score <= -1:
+								trend = Chan_PRICE_TREND.DOWN
+							else:
+								trend = Chan_PRICE_TREND.FLAT
+			except Exception:
+				trend = Chan_PRICE_TREND.UNKNOWN
+			# 写回趋势
+			if klc.end_time is None:
+				trend = Chan_PRICE_TREND.FLAT
+			if hasattr(klc, 'set_trend'):
+				klc.set_trend(trend)
+			else:
+				setattr(klc, 'trend', trend)
+			last_trend = trend
+			# 更新滑窗：仅向后看
+			prev_klcs.append(klc)
+			price_diff = klc.close - klc.pre.close if klc.pre else 0
+			#if klc.index > len(klc_list) - 10:
+				#print(klc.start_time, klc.end_time, klc.close, klc.ema24, klc.ema52, klc.macd, klc.signal, klc.macdhist, klc.trend, price_diff, score)
+				#print(klc.start_time, klc.end_time, klc.trend, price_diff, score)
+		return klc_list
+
+	def get_bi_list(self, dataframe):
+		bi_list = self.cal_bi_list(self.get_klc_list(dataframe))
+		#bi_list = self.cal_bi_list_chanlun(self.get_klc_list(dataframe))
+		return bi_list
+
+	def cal_bi_list(self, klc_list):
+		bi_list = []
+		last_top = None
+		last_bottom = None
+		bi_klc_min = 4
+		last_fx_klc = None
+		for klc in klc_list:
+			if last_fx_klc:
+				klc.check_klc_state(last_fx_klc)
+			klc.check_fx_confirmed(last_top, last_bottom)
+			fx = self.check_fx(klc)
+			if fx == Chan_FX_TYPE.TOP:
+				if last_bottom:
+					if self.check_top_fx(last_bottom, klc) == False:
+						fx = Chan_FX_TYPE.UNKNOWN
+			if fx == Chan_FX_TYPE.BOTTOM:
+				if last_top:
+					if self.check_bottom_fx(last_top, klc) == False:
+						#print(klc.end_time, last_top.end_time, "---")
+						fx = Chan_FX_TYPE.UNKNOWN
+			# Do nothing
+			if fx == Chan_FX_TYPE.UNKNOWN:
+				if len(bi_list) > 0:
+					bi_list[-1].add_klc(klc)
+					klc.set_bi(bi_list[-1])
+				#continue
+				if len(bi_list) > 0 and klc.end_klu:
+					last_bi = bi_list[-1]
+					#print(klc.start_time, last_bi.start_time, last_bi.end_time, last_bi.dir, last_bi.high, last_bi.low, last_bottom.end_time,  "last bi")
+					if last_top and last_bi.dir == Chan_BI_DIR.DOWN:
+						if last_bottom and klc.high > last_bi.high:
+							#print(klc.end_time, "Top 7, 1", last_bi.start_time, klc.high, last_bi.high)
+							#klc.klc_fx_type = Chan_KLC_FX.TOP7
+							#klc.fx = Chan_FX_TYPE.TOP
+							"""
+							last_bi.set_end_klc(last_bottom, klc)
+							bi = ChanBI(last_bottom, len(bi_list), Chan_BI_DIR.UP)
+							#klc.set_klc_fx_type(Chan_KLC_FX.BOTTOM7)
+							#klc.bb_out = True
+							last_bi.set_next(bi)
+							bi.set_pre(last_bi)
+							for klc_index in range(last_bi.end_klc.index, len(klc_list)):
+								bi.add_klc(klc_list[klc_index])
+							bi_list.append(bi)
+							last_top = klc
+							klc.set_bi(bi)
+							#print(klc.start_time, bi.start_time, bi.end_time, bi.dir, bi.high, bi.low, bi.is_sure)
+							"""
+					else:
+						if last_bottom and last_bi.dir == Chan_BI_DIR.UP:
+							if last_top and klc.low < last_bi.low:
+								#print(klc.end_time, "Bottom 8, 2", last_bi.start_time)
+								#klc.klc_fx_type = Chan_KLC_FX.BOTTOM8
+								#klc.fx = Chan_FX_TYPE.BOTTOM
+								"""
+								last_bi.set_end_klc(last_top, klc)
+								bi = ChanBI(last_top, len(bi_list), Chan_BI_DIR.DOWN)
+								#klc.set_klc_fx_type(Chan_KLC_FX.TOP6)
+								#klc.bb_out = True
+								last_bi.set_next(bi)
+								bi.set_pre(last_bi)
+								for klc_index in range(last_bi.end_klc.index, len(klc_list)):
+									bi.add_klc(klc_list[klc_index])
+								bi_list.append(bi)
+								last_bottom = klc
+								klc.set_bi(bi)
+								#print(klc.start_time, bi.start_time, bi.end_time, bi.dir, bi.high, bi.low, bi.is_sure)
+								"""
+			else:
+				last_fx_klc = klc
+				if fx == Chan_FX_TYPE.TOP:
+					#print(klc.end_time, fx, klc.pre.high, klc.high, klc.pre.start_time, klc.pre.end_time)
+					if last_top:
+						if last_bottom:
+							#print(klc.start_time, last_bottom.start_time, last_top.start_time)
+							if last_bottom.index < last_top.index:
+								# Second top lower to be second sell point
+								if last_top.high > klc.high:
+									bi_list[-1].add_klc(klc)
+									klc.set_bi(bi_list[-1])
+									#klc.set_klc_fx_type(Chan_KLC_FX.TOP3)
+									#print(klc.end_time, klc.fx, "二类卖点Sell 1")
+								else:
+									# A new top found
+									#last_top.set_fx(Chan_FX_TYPE.UNKNOWN)
+									last_top = klc
+									#print(klc.start_time, klc.fx, bi_list[-1].dir, "Last Top Change 1")
+									klc.set_klc_fx_type(Chan_KLC_FX.TOP1)
+									self.check_fx_pattern(klc)
+									#print(klc.end_time, klc.fx, "一类卖点Sell 1")
+									bi_list[-1].add_klc(klc)
+									klc.set_bi(bi_list[-1])
+							# 不满足结合律的分型
+							else:
+								#klc.set_klc_fx_type(Chan_KLC_FX.TOP0)
+								#print(klc.end_time, klc.klc_fx_type)
+								if last_bottom.index + bi_klc_min > klc.index:
+									if last_top.high > klc.high:
+										#print(klc.start_time, klc.fx, "二类卖点Sell 1")
+										#klc.set_klc_fx_type(Chan_KLC_FX.TOP8)
+										bi_list[-1].add_klc(klc)
+										klc.set_bi(bi_list[-1])
+									# New TOP Found前面的UKNOWN可能出现TOP7，但是这里的也可能出现TOP8分型
+									else:
+										# 顶分型在出现2之前超过前一个笔的顶 TOP8
+										if last_top.index + bi_klc_min < klc.index and len(bi_list) > 1:
+											pre_last_bi = bi_list[-2]
+											last_bi = bi_list[-1]
+											if pre_last_bi.is_sure and not last_bi.is_sure and pre_last_bi.dir == Chan_BI_DIR.UP and False:
+												#pre_last_bi.update_bi(klc)
+												bi_list.remove(last_bi)
+												pre_last_bi.set_next(None)
+												#last_top.set_fx(Chan_FX_TYPE.PTOP)
+												last_top = klc
+												last_bottom = pre_last_bi.start_klc
+												#print(klc.start_time, klc.fx, bi_list[-1].dir, "Last Top Bottom Change 1")
+												klc.set_klc_fx_type(Chan_KLC_FX.TOP2)
+												#print(klc.start_time, last_bi.start_klc.start_time, "New TOP Found reset last bi")
+												#klc.set_state("10")
+												#print(klc.start_time, klc.fx, "笔卖点Sell 1")
+											###klc.set_klc_fx_type(Chan_KLC_FX.TOP2) # when bi is down but the fx is top
+											bi_list[-1].add_klc(klc)
+											klc.set_bi(bi_list[-1])
+											#klc.set_klc_fx_type(Chan_KLC_FX.TOP8)
+											#print(klc.start_time, last_bi.start_klc.start_time, "New TOP Found reset last bi")
+										else:
+											#klc.set_fx(Chan_FX_TYPE.PTOP)
+											bi_list[-1].add_klc(klc)
+											klc.set_bi(bi_list[-1])
+											#print(klc.end_time, klc.fx, "无效顶分型")
+								# 满足结合律
+								else:
+									# New Temp TOP and last bottom confirmed ***** confirm last down bi(last bottom and last top)
+									last_bi = bi_list[-1]
+									if not last_bi.is_sure:
+										last_bi.set_end_klc(last_bottom, klc)
+									bi = ChanBI(last_bottom, len(bi_list), Chan_BI_DIR.UP)
+									last_bi.set_next(bi)
+									bi.set_pre(last_bi)
+									bi.add_klc(klc)
+									bi_list.append(bi)
+									last_top = klc
+									#print(klc.end_time, klc.fx, bi_list[-1].dir, "Last Top Change 2")
+									klc.set_klc_fx_type(Chan_KLC_FX.TOP2)
+									self.check_fx_pattern(klc)
+									#bi_list[-1].add_klc(klc)
+									klc.set_bi(bi_list[-1])
+									#print(klc.start_time, last_bottom.start_time, "Normal TOP Found, Confirm down bi 4")
+						# last bottom = None 初始化的时候用，其他时间不用
+						else:
+							# 初始化的时候用，其他时间不用
+							if last_top.high < klc.high:
+								last_bi = bi_list[-1]
+								last_bi.set_start_klc(klc, Chan_BI_DIR.DOWN)
+								last_top = klc
+								#print(klc.start_time, klc.fx, bi_list[-1].dir, "Last Top Change 3")
+								bi_list[-1].add_klc(klc)
+								klc.set_bi(bi_list[-1])
+							# 初始化的时候用，其他时间不用
+							else:
+								#klc.set_fx(Chan_FX_TYPE.TT)
+								#print(klc.start_time, klc.fx, "二类卖点Sell 2")
+								bi_list[-1].add_klc(klc)
+								klc.set_bi(bi_list[-1])
+					# last_top == None 初始化的时候用，其他时间不用
+					else:
+						if last_bottom:
+							# 不满足结合律的分型
+							if last_bottom.index + bi_klc_min > klc.index:
+								#klc.set_fx(Chan_FX_TYPE.PTOP)
+								bi_list[-1].add_klc(klc)
+								klc.set_bi(bi_list[-1])
+								#print(klc.start_time, klc.fx, "中枢卖点Sell 1")
+							else:
+								# First temp top and last bottom confirmed
+								last_top = klc
+								#print(klc.start_time, klc.fx, bi_list[-1].dir,  "Last Top Change 4")
+								bi_list[-1].add_klc(klc)
+								klc.set_bi(bi_list[-1])
+						# Last top = None, last bottom = None, create first down bi 初始化的时候用，其他时间不用
+						else:
+							# First temp top
+							last_top = klc
+							bi = ChanBI(klc, len(bi_list), Chan_BI_DIR.DOWN)
+							bi_list.append(bi)
+							bi.add_klc(klc)
+							klc.set_bi(bi_list[-1])
+							#print(klc.start_time, klc.fx, bi_list[-1].dir, "Last Top Change 5")
+				#klc.fx = Bottom ========================
+				else:
+					if last_bottom:
+						if last_top:
+							# Bottom after top and find a new bottom
+							if last_top.index < last_bottom.index:
+								# Second bottom uppper to be second buy point and confirm last bi
+								if last_bottom.low < klc.low:
+									bi_list[-1].add_klc(klc)
+									klc.set_bi(bi_list[-1])
+									#klc.set_klc_fx_type(Chan_KLC_FX.BOTTOM3)
+									#print(last_bottom.start_time, last_bottom.end_time, "--------------------------------1")
+									#print(klc.end_time, klc.fx, "二类买点Buy 1")
+								else:
+									# A new bottom found
+									last_bottom = klc
+									#print(klc.end_time, klc.fx, bi_list[-1].dir, "Last Bottom Change 1")
+									klc.set_klc_fx_type(Chan_KLC_FX.BOTTOM1)
+									self.check_fx_pattern(klc)
+									#print(klc.end_time, klc.fx, "一类买点Buy 1")
+									bi_list[-1].add_klc(klc)
+									klc.set_bi(bi_list[-1])
+							# 不满足结合律的分型
+							else:
+								#klc.set_klc_fx_type(Chan_KLC_FX.BOTTOM0)
+								#print(klc.end_time, klc.klc_fx_type)
+								if last_top.index + bi_klc_min > klc.index:
+									if last_bottom.low < klc.low:
+										#print(klc.end_time, klc.fx, "中枢买点Buy 1")
+										bi_list[-1].add_klc(klc)
+										klc.set_bi(bi_list[-1])
+										#klc.set_klc_fx_type(Chan_KLC_FX.BOTTOM8)
+									# Found new bottom没有意义，上面UNKNOWN的时候已经是笔破坏了
+									else:
+										#print(klc.end_time, last_bottom.end_time, "Found a new bottom")
+										if last_bottom.index + bi_klc_min < klc.index and len(bi_list) > 1:
+											pre_last_bi = bi_list[-2]
+											last_bi = bi_list[-1]
+											if pre_last_bi.is_sure and not last_bi.is_sure and pre_last_bi.dir == Chan_BI_DIR.DOWN and False: 
+												#pre_last_bi.update_bi(klc)
+												bi_list.remove(last_bi)
+												pre_last_bi.set_next(None)
+												last_bottom = klc
+												last_top = pre_last_bi.start_klc
+												#print(klc.start_time, klc.fx, bi_list[-1].dir, "Last Top Bottom Change 2")
+												klc.set_klc_fx_type(Chan_KLC_FX.BOTTOM2)
+												#print(klc.start_time, last_bi.start_klc.start_time, "New BOTTOM Found reset last bi")
+												#print(klc.start_time, klc.fx, "笔买点Buy 1")
+											###klc.set_klc_fx_type(Chan_KLC_FX.BOTTOM2) # when bi is up but the fx is bottom
+											bi_list[-1].add_klc(klc)
+											klc.set_bi(bi_list[-1])
+											#klc.set_klc_fx_type(Chan_KLC_FX.BOTTOM8)
+										else:
+											#klc.set_fx(Chan_FX_TYPE.UNKNOWN)
+											bi_list[-1].add_klc(klc)
+											klc.set_bi(bi_list[-1])
+											print(klc.end_time, klc.fx, "无效底分型")
+								# 满足结合律的分型
+								else:
+									# New Temp Bottom and last top confirmed ***** confirm last up bi(last bottom and last top)
+									last_bi = bi_list[-1]
+									if not last_bi.is_sure:
+										last_bi.set_end_klc(last_top, klc)
+									bi = ChanBI(last_top, len(bi_list), Chan_BI_DIR.DOWN)
+									last_bi.set_next(bi)
+									bi.set_pre(last_bi)
+									bi.add_klc(klc)
+									bi_list.append(bi)
+									last_bottom = klc
+									#print(klc.start_time, klc.fx, bi_list[-1].dir, "Last Bottom Change 2")
+									klc.set_klc_fx_type(Chan_KLC_FX.BOTTOM2)
+									self.check_fx_pattern(klc)
+									#bi_list[-1].add_klc(klc)
+									klc.set_bi(bi_list[-1])
+									#print(klc.start_time, last_top.start_time, "Normal Bottom Found, Confirm up bi 6")
+						# last_top = None 初始化的时候用，其他时间不用
+						else:
+							if last_bottom.low > klc.low:
+								last_bi = bi_list[-1]
+								last_bi.set_start_klc(klc, Chan_BI_DIR.UP)
+								#last_bottom.set_fx(Chan_FX_TYPE.UNKNOWN)
+								last_bottom = klc
+								#print(klc.start_time, klc.fx, bi_list[-1].dir, "Last Bottom Change 3")
+								bi_list[-1].add_klc(klc)
+								klc.set_bi(bi_list[-1])
+								#print(klc.start_time, klc.fx, "笔买点Buy 3")
+							else:
+								#klc.set_fx(Chan_FX_TYPE.BB)
+								#klc.set_state('-20')
+								#print(klc.start_time, klc.fx, "二类买点Buy 2")
+								bi_list[-1].add_klc(klc)
+								klc.set_bi(bi_list[-1])
+					# last_bottom = None 初始化的时候用，其他时间不用
+					else:
+						if last_top:
+							# 不满足结合律的分型
+							if last_top.index + bi_klc_min > klc.index:
+								#klc.set_fx(Chan_FX_TYPE.PBOTTOM)
+								bi_list[-1].add_klc(klc)
+								klc.set_bi(bi_list[-1])
+								#print(klc.start_time, klc.fx, "中枢买点Buy 1")
+							else:
+								# First temp bottom and last top confirmed
+								last_bottom = klc
+								#print(klc.start_time, klc.fx, bi_list[-1].dir, "Last Bottom Change 4")
+								bi_list[-1].add_klc(klc)
+								klc.set_bi(bi_list[-1])
+								#print(klc.start_time, klc.fx, "一类买点Buy 1")
+						# Last top = None, last bottom = None, create first up bi
+						else:
+							# First temp bottom and no top yet
+							last_bottom = klc
+							bi = ChanBI(klc, len(bi_list), Chan_BI_DIR.UP)
+							#klc.set_klc_fx_type(Chan_KLC_FX.BOTTOM7)
+							bi_list.append(bi)
+							bi_list[-1].add_klc(klc)
+							klc.set_bi(bi_list[-1])
+							#print(klc.start_time, klc.fx, bi_list[-1].dir, "Last Bottom Change 5")
+							#print(klc.start_time, klc.fx, "笔买点Buy 4")
+		self.get_above_zero_bsp(klc_list)
+		#print(bi_list[-1].start_time, bi_list[-1].end_time, len(bi_list[-1].klc_list))
+		return bi_list
+
+	def check_top_fx(self, last_bottom, klc):
+		if (last_bottom.high > klc.pre.low or last_bottom.high > klc.next.low) and (klc.index - last_bottom.index < 100):
+			return False
+		return True
+	
+
+	def check_bottom_fx(self, last_top, klc):
+		if (last_top.low < klc.pre.high or last_top.low < klc.next.high) and (klc.index - last_top.index < 100):
+			return False
+		return True
+	# 线段内的中枢

chanlun/pipeline/builders/bsp.py

@@ -0,0 +1,410 @@
+"""TF_DF builder mixin — 由 split_tfdf_builders 自动生成，逻辑与原 TF_DF 一致。"""
+from __future__ import annotations
+
+from datetime import timedelta
+from decimal import Decimal
+
+import numpy as np
+import pandas as pd
+from pandas import DataFrame
+
+from chanlun.core.ChanBI import ChanBI
+from chanlun.core.ChanBIZS import ChanBIZS
+from chanlun.core.ChanBSP import ChanBSP
+from chanlun.core.ChanEnum import (
+    Chan_BI_DIR,
+    Chan_BSP_DIR,
+    Chan_BSP_TYPE,
+    Chan_FX_TYPE,
+    Chan_K_DIR,
+    Chan_KLC_FX,
+    Chan_KLC_STATE,
+    Chan_KLINE_DIR,
+    Chan_KLU_PATTERN,
+    Chan_PRICE_TREND,
+    Chan_SEG_DIR,
+    Chan_ZS_DIR,
+)
+from chanlun.core.ChanKLC import ChanKLC
+from chanlun.core.ChanKLU import ChanKLU
+from chanlun.core.ChanSBI import ChanSBI
+from chanlun.core.ChanSEG import ChanSEG
+from chanlun.core.ChanZS import ChanZS, ChanZS_Big
+from chanlun.indicators.ChanMACD import ChanMACD
+
+
+class BspBuilderMixin:
+	def get_bsp_state(self, dataframe):
+		klu_list = self.get_klu_list(dataframe)
+		klc_list = self.get_klc_list(klu_list)
+		bi_list = self.cal_bi_list(klc_list)
+		seg_list = self.get_seg_list(bi_list)
+		bi_zs_list = self.cal_bi_zs(seg_list)
+		bsp_list = self.find_all_bsp(bi_list, bi_zs_list)
+		bsp_state_list = [0] * len(dataframe)
+		klc_index = 0
+		for index in range(0, len(dataframe)):
+			if klc_index == len(klc_list):
+				klc_index = len(klc_list) - 1
+			klc = klc_list[klc_index]
+			if klc.end_klu and klc.end_klu.idx == index:
+				if klc.klc_fx_type == Chan_KLC_FX.TOP2:
+					bi = klc.bi.pre
+					if bi and bi.is_sure and bi.end_klc.bsp_type == Chan_BSP_TYPE.B3:
+						# 第三类买点
+						bsp_state_list[index] = -1
+						#print(klc.end_time, "B3")
+					else:
+						bsp_state_list[index] = 0
+				elif klc.klc_fx_type == Chan_KLC_FX.BOTTOM2:
+					bi = klc.bi.pre
+					if bi and bi.is_sure and bi.end_klc.bsp_type == Chan_BSP_TYPE.S3:
+						# 第三类卖点
+						bsp_state_list[index] = 1
+						#print(klc.end_time, "S3")
+					else:
+						bsp_state_list[index] = 0
+				klc_index += 1
+			else:
+				bsp_state_list[index] = 0
+		return bsp_state_list
+
+	def get_above_zero_bsp(self, klc_list):
+		buy_bsp_list = []
+		sell_bsp_list = []
+		above_zero = False
+		buy_bsp = None
+		sell_bsp = None
+		for klc in klc_list:
+			if klc.pre and klc.pre.signal < 0 and klc.signal > 0:
+				above_zero = True
+			if klc.pre and klc.pre.signal > 0 and klc.signal < 0:
+				above_zero = False
+			if above_zero and klc.klc_fx_type == Chan_KLC_FX.BOTTOM2 and klc.macd > 0:
+				buy_bsp = klc
+				buy_bsp_list.append(klc)
+				#print(klc.end_time, "MACD 0轴上穿，回调笔底分型做多")
+			if buy_bsp and klc.pre and klc.pre.macdhist > 0 and klc.macdhist < 0:
+				sell_bsp = klc
+				sell_bsp_list.append(klc)
+				buy_bsp = None
+				#print(klc.end_time, "Sell BSP Found")
+		return buy_bsp_list
+
+	def find_all_bsp(self, bi_list, bi_zs_list):
+		"""
+		笔中枢的三类买卖点识别
+
+		三类买点：中枢形成后，一笔向上离开中枢（低点 > zg），
+				 随后回拉的一笔低点不跌回中枢（低点 >= zg），确认支撑有效。
+		三类卖点：中枢形成后，一笔向下离开中枢（高点 < zd），
+				 随后反弹的一笔高点不回到中枢（高点 <= zd），确认压力有效。
+
+		参数:
+			bi_list: 笔列表
+			bi_zs_list: 笔中枢列表（二维列表，每个seg内的中枢列表）
+
+		返回:
+			bsp_list: ChanBSP 列表，包含所有识别到的三类买卖点
+		"""
+		bsp_list = []
+		if len(bi_list) < 4 or len(bi_zs_list) == 0:
+			return bsp_list
+
+		for zs in bi_zs_list:
+			if not zs.is_sure or len(zs.bi_list) < 3:
+				continue
+			#print(zs.start_time, zs.end_time, zs.dir, zs.is_sure, len(zs.bi_list))
+			# 中枢结束后的第一笔（离开笔）
+			last_zs_bi = zs.bi_list[-1]
+			if last_zs_bi.dir == Chan_BI_DIR.UP:
+				if last_zs_bi.is_sure and last_zs_bi.end_klc.high <= zs.zg or (last_zs_bi.next and last_zs_bi.next.is_sure and last_zs_bi.next.end_klc.low < zs.zd):
+					leave_bi = last_zs_bi.next
+				else:
+					leave_bi = last_zs_bi
+			else:
+				if last_zs_bi.is_sure and last_zs_bi.end_klc.low >= zs.zd or (last_zs_bi.next and last_zs_bi.next.is_sure and last_zs_bi.next.end_klc.high > zs.zg):
+					leave_bi = last_zs_bi.next
+				else:
+					leave_bi = last_zs_bi
+			#print(zs.zg, zs.zd)
+			if leave_bi is None or not leave_bi.is_sure:
+				continue
+			if (zs.dir == Chan_ZS_DIR.UP and leave_bi.dir == Chan_BI_DIR.UP and leave_bi.end_klc.high < zs.zg and leave_bi.end_klc.high > zs.zd) or (zs.dir == Chan_ZS_DIR.DOWN and leave_bi.dir == Chan_BI_DIR.DOWN and leave_bi.end_klc.low < zs.zg and leave_bi.end_klc.low > zs.zd):
+				#print("--------------------", leave_bi.dir, leave_bi.end_klc.high, leave_bi.end_klc.low, zs.zg, zs.zd)
+				leave_bi = leave_bi.next
+			# 三类买点：向上离开中枢后回拉不破 zg
+			#print("Leave bi:", leave_bi.start_time, leave_bi.end_time, leave_bi.dir, leave_bi.is_sure, leave_bi.low, leave_bi.high)
+			if leave_bi.dir == Chan_BI_DIR.UP:
+				first_bsp_bi_div = self.check_bi_div(zs, leave_bi)
+				# 确认一类卖点：离开断能量小于进入段能量
+				if first_bsp_bi_div:
+					bsp = ChanBSP(
+						leave_bi, len(bsp_list),
+						Chan_BSP_TYPE.S1,
+						Chan_BSP_DIR.SELL,
+						leave_bi.sure_time,
+						zs.index+1, zs, None
+					)
+					leave_bi.end_klc.set_bsp_type(Chan_BSP_TYPE.S1)
+					bsp_list.append(bsp)
+				# 回拉笔
+				pullback_bi = leave_bi.next
+				#print(pullback_bi.start_klc.start_time, pullback_bi.dir, pullback_bi.is_sure, pullback_bi.low, pullback_bi.high)
+				if pullback_bi and pullback_bi.is_sure and pullback_bi.dir == Chan_BI_DIR.DOWN:
+					if pullback_bi.low >= zs.zg:
+						# 确认三类买点：回拉笔的低点不跌回中枢
+						bsp = ChanBSP(
+							pullback_bi, len(bsp_list),
+							Chan_BSP_TYPE.B3,
+							Chan_BSP_DIR.BUY,
+							pullback_bi.sure_time,
+							zs.index+1, zs, None
+						)
+						pullback_bi.end_klc.set_bsp_type(Chan_BSP_TYPE.B3)
+						bsp_list.append(bsp)
+				# 二类卖点
+				if first_bsp_bi_div:
+					second_bsp_bi = pullback_bi.next
+					if second_bsp_bi and second_bsp_bi.is_sure and second_bsp_bi.end_klc.high < leave_bi.end_klc.high:
+						# 确认二类卖点：一类卖点后回拉不超过一类卖点高点
+						bsp = ChanBSP(
+							second_bsp_bi, len(bsp_list),
+							Chan_BSP_TYPE.S2,
+							Chan_BSP_DIR.SELL,
+							second_bsp_bi.sure_time,
+							zs.index+1, zs, None
+						)
+						second_bsp_bi.end_klc.set_bsp_type(Chan_BSP_TYPE.B2)
+						bsp_list.append(bsp)
+			# 三类卖点：向下离开中枢后反弹不破 zd
+			elif leave_bi.dir == Chan_BI_DIR.DOWN:
+				first_bsp_bi_div = self.check_bi_div(zs, leave_bi)
+				# 确认一类买点：离开段能量小于进入段
+				if first_bsp_bi_div:
+					bsp = ChanBSP(
+						leave_bi, len(bsp_list),
+						Chan_BSP_TYPE.B1,
+						Chan_BSP_DIR.BUY,
+						leave_bi.sure_time,
+						zs.index+1, zs, None
+					)
+					leave_bi.end_klc.set_bsp_type(Chan_BSP_TYPE.B1)
+					bsp_list.append(bsp)
+				# 反弹笔
+				bounce_bi = leave_bi.next
+				#print(bounce_bi.start_klc.start_time, bounce_bi.dir, bounce_bi.is_sure, bounce_bi.low, bounce_bi.high)
+				if bounce_bi and bounce_bi.is_sure and bounce_bi.dir == Chan_BI_DIR.UP:
+					if bounce_bi.high <= zs.zd:
+						# 确认三类卖点：反弹笔的高点不回到中枢
+						bsp = ChanBSP(
+							bounce_bi, len(bsp_list),
+							Chan_BSP_TYPE.S3,
+							Chan_BSP_DIR.SELL,
+							bounce_bi.sure_time,
+							zs.index+1, zs, None
+						)
+						bounce_bi.end_klc.set_bsp_type(Chan_BSP_TYPE.S3)
+						bsp_list.append(bsp)
+				# 二类卖点
+				if first_bsp_bi_div:
+					second_bsp_bi = bounce_bi.next
+					if second_bsp_bi and second_bsp_bi.is_sure and second_bsp_bi.end_klc.low > leave_bi.end_klc.low:
+						# 确认二类买点：一类买点后回拉不超过一类卖点高点
+						bsp = ChanBSP(
+							second_bsp_bi, len(bsp_list),
+							Chan_BSP_TYPE.B2,
+							Chan_BSP_DIR.BUY,
+							second_bsp_bi.sure_time,
+							zs.index+1, zs, None
+						)
+						second_bsp_bi.end_klc.set_bsp_type(Chan_BSP_TYPE.B2)
+						bsp_list.append(bsp)
+		return bsp_list
+
+	def check_bi_div(self, zs, leave_bi):
+		enter_bi = zs.bi_list[0].pre
+		macdhist_div = 0
+		if enter_bi and enter_bi.dir == leave_bi.dir:
+			macdhist_div = abs(leave_bi.macd_hist) - abs(enter_bi.macd_hist)
+		#print(enter_bi.end_time, leave_bi.end_time, macdhist_div < 0)
+		return macdhist_div < 0
+
+	def find_first_bsp(self, bi_list, bi_zs_list):
+		"""
+		笔中枢的一类买卖点识别
+
+		一类买点：下跌趋势中，最后一个中枢完成后，向下离开中枢的笔创新低，
+				 但该笔与进入中枢前的最后一笔下跌形成底背驰（力度减弱），
+				 即趋势力竭的转折点。
+		一类卖点：上涨趋势中，最后一个中枢完成后，向上离开中枢的笔创新高，
+				 但该笔与进入中枢前的最后一笔上涨形成顶背驰（力度减弱），
+				 即趋势力竭的转折点。
+
+		简化判断：中枢形成后，离开中枢的笔（突破笔）本身即为一类买卖点的触发笔。
+
+		参数:
+			bi_list: 笔列表
+			bi_zs_list: 笔中枢列表（扁平列表，每个元素是一个中枢对象）
+
+		返回:
+			bsp_list: ChanBSP 列表，包含所有识别到的一类买卖点
+		"""
+		bsp_list = []
+		if len(bi_list) < 4 or len(bi_zs_list) == 0:
+			return bsp_list
+
+		for zs in bi_zs_list:
+			if not zs.is_sure or len(zs.bi_list) < 3:
+				continue
+
+			# 找到中枢的最后一笔
+			last_zs_bi = zs.bi_list[-1]
+
+			# 确定离开笔：中枢最后一笔之后的第一笔
+			if last_zs_bi.dir == Chan_BI_DIR.UP:
+				# 中枢最后一笔向上，如果没有真正离开中枢，取下一笔
+				if last_zs_bi.is_sure and last_zs_bi.end_klc.high <= zs.zg:
+					leave_bi = last_zs_bi.next
+				else:
+					leave_bi = last_zs_bi
+			else:
+				# 中枢最后一笔向下，如果没有真正离开中枢，取下一笔
+				if last_zs_bi.is_sure and last_zs_bi.end_klc.low >= zs.zd:
+					leave_bi = last_zs_bi.next
+				else:
+					leave_bi = last_zs_bi
+
+			if leave_bi is None or not leave_bi.is_sure:
+				continue
+
+			# 一类买点：向下离开中枢（leave_bi向下，低点 < zd），趋势力竭
+			if leave_bi.dir == Chan_BI_DIR.DOWN and leave_bi.low < zs.zd:
+				# 背驰判断：比较离开笔与中枢内最后一笔同向笔的MACD柱状累积面积
+				# 缠论原文：两段同向走势的MACD柱状面积比较，面积缩小即为背驰
+				compare_bi = None
+				for bi in reversed(zs.bi_list):
+					if bi.dir == Chan_BI_DIR.DOWN and bi is not leave_bi:
+						compare_bi = bi
+						break
+
+				is_divergence = False
+				if compare_bi:
+					# 笔的macd_hist是该笔内所有KLU的macdhist累积面积
+					leave_macd_area = abs(leave_bi.macd_hist)
+					compare_macd_area = abs(compare_bi.macd_hist)
+
+					# 价格创新低但MACD面积缩小 = 底背驰
+					if leave_bi.low <= compare_bi.low and leave_macd_area < compare_macd_area:
+						is_divergence = True
+					# 即使没创新低，MACD面积明显缩小也算背驰
+					elif leave_macd_area < compare_macd_area * 0.5:
+						is_divergence = True
+				else:
+					# 没有对比笔时，只要离开中枢就算一类买点
+					is_divergence = True
+
+				if is_divergence:
+					bsp = ChanBSP(
+						leave_bi, len(bsp_list),
+						Chan_BSP_TYPE.T1,
+						Chan_BSP_DIR.BUY,
+						leave_bi.sure_time,
+						1, zs, None
+					)
+					bsp_list.append(bsp)
+
+			# 一类卖点：向上离开中枢（leave_bi向上，高点 > zg），趋势力竭
+			elif leave_bi.dir == Chan_BI_DIR.UP and leave_bi.high > zs.zg:
+				# 背驰判断：比较离开笔与中枢内最后一笔同向笔的MACD柱状累积面积
+				compare_bi = None
+				for bi in reversed(zs.bi_list):
+					if bi.dir == Chan_BI_DIR.UP and bi is not leave_bi:
+						compare_bi = bi
+						break
+
+				is_divergence = False
+				if compare_bi:
+					leave_macd_area = abs(leave_bi.macd_hist)
+					compare_macd_area = abs(compare_bi.macd_hist)
+
+					# 价格创新高但MACD面积缩小 = 顶背驰
+					if leave_bi.high >= compare_bi.high and leave_macd_area < compare_macd_area:
+						is_divergence = True
+					# 即使没创新高，MACD面积明显缩小也算背驰
+					elif leave_macd_area < compare_macd_area * 0.5:
+						is_divergence = True
+				else:
+					is_divergence = True
+
+				if is_divergence:
+					bsp = ChanBSP(
+						leave_bi, len(bsp_list),
+						Chan_BSP_TYPE.T1,
+						Chan_BSP_DIR.SELL,
+						leave_bi.sure_time,
+						1, zs, None
+					)
+					bsp_list.append(bsp)
+
+		return bsp_list
+
+
+	def find_second_bsp(self, bi_list, first_bsp_list):
+		"""
+		笔中枢的二类买卖点识别
+
+		二类买点：一类买点出现后，价格向上反弹一笔，再回落一笔，
+				 回落笔的低点不跌破一类买点的低点，确认底部成立。
+		二类卖点：一类卖点出现后，价格向下回落一笔，再反弹一笔，
+				 反弹笔的高点不超过一类卖点的高点，确认顶部成立。
+
+		参数:
+			bi_list: 笔列表
+			first_bsp_list: 一类买卖点列表（find_first_bsp 的返回值）
+
+		返回:
+			bsp_list: ChanBSP 列表，包含所有识别到的二类买卖点
+		"""
+		bsp_list = []
+		if not first_bsp_list or len(bi_list) < 4:
+			return bsp_list
+
+		for first_bsp in first_bsp_list:
+			trigger_bi = first_bsp.bi  # 一类买卖点的触发笔
+
+			if first_bsp.dir == Chan_BSP_DIR.BUY:
+				# 一买之后：trigger_bi 向下 -> 反弹笔(向上) -> 回落笔(向下)
+				# 回落笔的低点 > trigger_bi 的低点 => 二类买点
+				bounce_bi = trigger_bi.next  # 反弹笔（向上）
+				if bounce_bi and bounce_bi.is_sure and bounce_bi.dir == Chan_BI_DIR.UP:
+					pullback_bi = bounce_bi.next  # 回落笔（向下）
+					if pullback_bi and pullback_bi.is_sure and pullback_bi.dir == Chan_BI_DIR.DOWN:
+						if pullback_bi.low > trigger_bi.low:
+							bsp = ChanBSP(
+								pullback_bi, len(bsp_list),
+								Chan_BSP_TYPE.T2,
+								Chan_BSP_DIR.BUY,
+								pullback_bi.sure_time,
+								1, first_bsp.zs, None
+							)
+							bsp_list.append(bsp)
+
+			elif first_bsp.dir == Chan_BSP_DIR.SELL:
+				# 一卖之后：trigger_bi 向上 -> 回落笔(向下) -> 反弹笔(向上)
+				# 反弹笔的高点 < trigger_bi 的高点 => 二类卖点
+				drop_bi = trigger_bi.next  # 回落笔（向下）
+				if drop_bi and drop_bi.is_sure and drop_bi.dir == Chan_BI_DIR.DOWN:
+					bounce_bi = drop_bi.next  # 反弹笔（向上）
+					if bounce_bi and bounce_bi.is_sure and bounce_bi.dir == Chan_BI_DIR.UP:
+						if bounce_bi.high < trigger_bi.high:
+							bsp = ChanBSP(
+								bounce_bi, len(bsp_list),
+								Chan_BSP_TYPE.T2,
+								Chan_BSP_DIR.SELL,
+								bounce_bi.sure_time,
+								1, first_bsp.zs, None
+							)
+							bsp_list.append(bsp)
+
+		return bsp_list

chanlun/pipeline/builders/fast_bsp.py

@@ -0,0 +1,148 @@
+"""第四类买卖点（B4/S4）接入 TF_DF。
+
+判定逻辑全在 chanlun/analysis/fast_bsp.py，这里只负责把引擎的中枢/K线喂进去，
+再把结果包成 ChanFastBSP。
+
+刻意不在 init_TF_DF 里默认计算：现有构造路径的开销保持不变，由调用方按需触发。
+"""
+from __future__ import annotations
+
+import re
+
+import pandas as pd
+
+from chanlun.analysis.fast_bsp import (
+	add_zone_ladder,
+	attach_htf_agree,
+	attach_zone_ladder,
+	ensure_timestamp,
+	find_fast_bsp3,
+	htf_fx_timeline,
+	zones_from_zs_list,
+)
+from chanlun.core.ChanEnum import Chan_BSP_DIR
+from chanlun.core.ChanFastBSP import ChanFastBSP
+
+# 区间套配对：小级别出中枢与买卖点，大级别只出分型定方向。
+# 取值来自 research/HANDOFF.md §1.5，是回测里实际用过的组合。
+FAST_BSP_HTF_PAIR = {
+	'1m': '5m',
+	'5m': '30m',
+	'15m': '1h',
+	'30m': '2h',
+}
+
+# 未列入配对表的周期回落到这个倍数
+FAST_BSP_HTF_FALLBACK_RATIO = 4
+
+_TF_UNIT_MINUTES = {'m': 1, 'h': 60, 'd': 1440, 'w': 10080}
+
+
+def timeframe_minutes(tf: str) -> int | None:
+	"""'30m' -> 30，'2h' -> 120。无法解析时返回 None。"""
+	if not tf:
+		return None
+	m = re.fullmatch(r'(\d+)\s*([mhdw])', str(tf).strip().lower())
+	if not m:
+		return None
+	return int(m.group(1)) * _TF_UNIT_MINUTES[m.group(2)]
+
+
+def resolve_htf(tf: str) -> tuple[str, int] | None:
+	"""给小级别找配套的大级别，返回 (标签, 分钟数)。"""
+	minutes = timeframe_minutes(tf)
+	if minutes is None:
+		return None
+	paired = FAST_BSP_HTF_PAIR.get(str(tf).strip().lower())
+	if paired:
+		return paired, timeframe_minutes(paired)
+	return f'{minutes * FAST_BSP_HTF_FALLBACK_RATIO}m', minutes * FAST_BSP_HTF_FALLBACK_RATIO
+
+
+class FastBspBuilderMixin:
+	def build_fast_bsp_htf(self, df, timeframe=None):
+		"""对同一份 df 重采样得到大级别，不额外拉数据。
+
+		大级别只用来取分型方向，样本太少就没有过滤意义，故重采样后不足 60 根时放弃。
+		"""
+		tf = timeframe or getattr(self, 'timeframe', None)
+		htf = resolve_htf(tf)
+		ltf_minutes = timeframe_minutes(tf)
+		if htf is None or not ltf_minutes:
+			return None
+		label, minutes = htf
+		if not minutes or len(df) * ltf_minutes < minutes * 60:
+			return None
+		try:
+			from chanlun.pipeline.timeframe import TF_DF
+
+			return TF_DF(df, minutes, label)
+		except Exception:
+			return None
+
+	def cal_fast_bsp(self, df=None, bi_zs_list=None, htf_chan=None, with_htf=True,
+	                 timeframe=None, **kw):
+		"""算第四类买卖点，返回 ChanFastBSP 列表。
+
+		bi_zs_list 传入已算好的 pure 笔中枢可免去重复计算。
+		with_htf=False 时跳过大级别构建，只留 ladder_ok 这一个过滤标志。
+		kw 透传给 find_fast_bsp3（scan / pullback_win / tol / require_touch 等）。
+		"""
+		src = df if df is not None else getattr(self, 'dataframe', None)
+		if src is None or len(src) == 0:
+			self.fast_bsp_list = []
+			return self.fast_bsp_list
+
+		src = ensure_timestamp(src)
+		if bi_zs_list is None:
+			bi_zs_list = getattr(self, 'bi_zs_list', None)
+			if not bi_zs_list:
+				bi_zs_list = self.cal_bi_zs_list_pure(self.cal_bi_list(self.get_klc_list(self.cal_kl_data(src))))
+
+		zones = zones_from_zs_list(bi_zs_list, src)
+		if zones.empty:
+			self.fast_bsp_list = []
+			return self.fast_bsp_list
+
+		zones = add_zone_ladder(zones)
+		sig = find_fast_bsp3(src, zones, **kw)
+		if sig.empty:
+			self.fast_bsp_list = []
+			return self.fast_bsp_list
+
+		sig = attach_zone_ladder(sig, zones)
+
+		if with_htf:
+			if htf_chan is None:
+				htf_chan = self.build_fast_bsp_htf(src, timeframe)
+			sig = attach_htf_agree(sig, src, htf_fx_timeline(htf_chan) if htf_chan is not None else pd.DataFrame())
+		else:
+			sig['htf_dir'] = None
+			sig['htf_agree'] = None
+
+		times = src['date'].dt.strftime('%Y-%m-%d %H:%M:%S').to_numpy()
+		close = src['close'].to_numpy(dtype=float)
+
+		out = []
+		for r in sig.itertuples(index=False):
+			entry_idx = int(r.entry_idx)
+			agree = getattr(r, 'htf_agree', None)
+			htf_dir = getattr(r, 'htf_dir', None)
+			out.append(ChanFastBSP(
+				time=times[entry_idx],
+				price=close[entry_idx],
+				ddir=Chan_BSP_DIR.BUY if r.direction == 1 else Chan_BSP_DIR.SELL,
+				entry_idx=entry_idx,
+				bo_time=times[int(r.bo_idx)],
+				pb_time=times[int(r.pb_idx)] if r.pb_idx == r.pb_idx else None,
+				lag=r.lag,
+				depth=r.depth,
+				zg=r.zg,
+				zd=r.zd,
+				occ=r.occ,
+				htf_dir=None if htf_dir is None or htf_dir != htf_dir else int(htf_dir),
+				htf_agree=None if agree is None or agree != agree else bool(agree),
+				ladder_ok=bool(r.ladder_ok),
+			))
+		self.fast_bsp_list = out
+		return out

chanlun/pipeline/builders/incremental.py

@@ -0,0 +1,171 @@
+"""增量更新：新K只追加 KLU/KLC，笔与笔中枢在当前列表上重算。
+
+不改 init_TF_DF 的整段语义。笔必须整表重扫：最后一笔 is_sure 允许收回
+（OWN_CHAN_ZS_001 上 60 天出现 7 次）。笔中枢用 cal_bi_zs_list_pure。
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+import pandas as pd
+from pandas import DataFrame
+from chanlun.pipeline.resample import resample_to_interval
+
+from chanlun.core.ChanEnum import Chan_FX_TYPE, Chan_KLC_FX, Chan_KLC_STATE
+from chanlun.core.ChanKLU import ChanKLU
+
+
+class IncrementalBuilderMixin:
+	def init_stream(self, df, interval=1, timeframe=None):
+		"""用历史K线初始化流式状态，之后用 append_bar / replace_last_bar。"""
+		if df is None or df.empty:
+			raise ValueError("DataFrame for stream is empty.")
+		if "date" not in df.columns:
+			raise ValueError(f"DataFrame missing 'date' column. Columns: {df.columns.tolist()}")
+		self.timeframe = timeframe
+		self.interval = interval
+		if interval == 1:
+			self.dataframe = df.copy()
+		else:
+			self.dataframe = resample_to_interval(df, interval)
+		self.dataframe = self.add_indicators(self.dataframe)
+		self.klu_list = []
+		self.klc_list = []
+		self.bi_list = []
+		self.bi_zs_list = []
+		self.seg_list = []
+		self.zs_list = []
+		self.bsp_list = []
+		self.klc_fx_list = []
+		self.big_zs_list = []
+		self._klc_feed_last_klu = None
+		for i in range(len(self.dataframe)):
+			self._append_row_at(i, rebuild=False)
+		self.rebuild_bi_zs()
+		return self
+
+	def append_bar(self, row):
+		"""追加一根已收盘K线。同一时间戳则改为替换最后一根。"""
+		self._ensure_stream_state()
+		item = self._normalize_row(row)
+		if self.klu_list and self.klu_list[-1].time == self._row_time_str(item):
+			return self.replace_last_bar(item)
+		self._append_item_to_dataframe(item)
+		self.dataframe = self.add_indicators(self.dataframe)
+		self._append_row_at(len(self.dataframe) - 1, rebuild=True)
+		return self
+
+	def replace_last_bar(self, row):
+		"""更新最后一根K（未完成K线走新OHLC）。包含关系从 KLU 列表重放。"""
+		self._ensure_stream_state()
+		if not self.klu_list:
+			return self.append_bar(row)
+		item = self._normalize_row(row)
+		idx = self.dataframe.index[-1]
+		for key, val in item.items():
+			self.dataframe.at[idx, key] = val
+		self.dataframe = self.add_indicators(self.dataframe)
+		self._apply_item_to_klu(self.klu_list[-1], self.dataframe.iloc[-1])
+		self._rebuild_klc_from_klu()
+		self.rebuild_bi_zs()
+		return self
+
+	def rebuild_bi_zs(self):
+		"""在当前 KLC 上重算笔 + cal_bi_zs_list_pure。会先清分型标记。"""
+		self._reset_klc_bi_marks(self.klc_list)
+		self.bi_list = self.cal_bi_list(self.klc_list) if self.klc_list else []
+		self.bi_zs_list = self.cal_bi_zs_list_pure(self.bi_list) if self.bi_list else []
+		return self.bi_zs_list
+
+	def _ensure_stream_state(self):
+		if not hasattr(self, "klu_list") or self.klu_list is None:
+			self.klu_list = []
+		if not hasattr(self, "klc_list") or self.klc_list is None:
+			self.klc_list = []
+		if not hasattr(self, "dataframe") or self.dataframe is None:
+			self.dataframe = DataFrame(
+				columns=["date", "open", "high", "low", "close", "volume"]
+			)
+		if not hasattr(self, "_klc_feed_last_klu"):
+			self._klc_feed_last_klu = self.klu_list[-1] if self.klu_list else None
+		if not hasattr(self, "bi_zs_list"):
+			self.bi_zs_list = []
+
+	def _rebuild_klc_from_klu(self):
+		self.klc_list = []
+		last_klu = None
+		for klu in self.klu_list:
+			self._push_klu_into_klc_list(self.klc_list, klu, last_klu)
+			last_klu = klu
+		self._klc_feed_last_klu = last_klu
+
+	def _append_row_at(self, idx, rebuild=True):
+		item = self.dataframe.iloc[idx]
+		klu = self._klu_from_item(item, idx)
+		if self.klu_list:
+			self.klu_list[-1].set_next(klu)
+			klu.set_pre(self.klu_list[-1])
+		self._push_klu_into_klc_list(self.klc_list, klu, self._klc_feed_last_klu)
+		self._klc_feed_last_klu = klu
+		self.klu_list.append(klu)
+		if rebuild:
+			self.rebuild_bi_zs()
+
+	def _klu_from_item(self, item, idx):
+		klu = ChanKLU(
+			self._item_time_str(item),
+			item["open"],
+			item["high"],
+			item["low"],
+			item["close"],
+			item["volume"],
+		)
+		klu.set_idx(idx)
+		if not hasattr(klu, "ema13"):
+			klu.ema13 = 0
+		if "macd" in item:
+			klu.set_indicators(item)
+		return klu
+
+	def _apply_item_to_klu(self, klu, item):
+		klu.time = self._item_time_str(item)
+		klu.open = item["open"]
+		klu.high = item["high"]
+		klu.low = item["low"]
+		klu.close = item["close"]
+		klu.volume = item["volume"]
+		klu.range = klu.high - klu.low
+		klu.body = abs(klu.close - klu.open)
+		if "macd" in item:
+			klu.set_indicators(item)
+
+	def _reset_klc_bi_marks(self, klc_list):
+		for klc in klc_list:
+			klc.fx = Chan_FX_TYPE.UNKNOWN
+			klc.klc_fx_type = Chan_KLC_FX.UNKNOWN
+			klc.klc_state = Chan_KLC_STATE.UNKNOWN
+			klc.bi = None
+			klc.fx_confirmed = False
+
+	def _item_time_str(self, item):
+		date = item["date"]
+		if hasattr(date, "to_pydatetime"):
+			date = date.to_pydatetime()
+		if isinstance(date, datetime):
+			return date.strftime("%Y-%m-%d %H:%M:%S")
+		return str(date)
+
+	def _row_time_str(self, item):
+		return self._item_time_str(item)
+
+	def _normalize_row(self, row):
+		if isinstance(row, pd.Series):
+			return row
+		return pd.Series(row)
+
+	def _append_item_to_dataframe(self, item):
+		row_df = DataFrame([item])
+		if self.dataframe is None or self.dataframe.empty:
+			self.dataframe = row_df
+		else:
+			self.dataframe = pd.concat([self.dataframe, row_df], ignore_index=True)

chanlun/pipeline/builders/indicators.py

@@ -0,0 +1,132 @@
+"""TF_DF builder mixin — 由 split_tfdf_builders 自动生成，逻辑与原 TF_DF 一致。"""
+from __future__ import annotations
+
+from datetime import timedelta
+from decimal import Decimal
+
+import numpy as np
+import pandas as pd
+from chanlun.indicators import ta
+from pandas import DataFrame
+
+from chanlun.core.ChanBI import ChanBI
+from chanlun.core.ChanBIZS import ChanBIZS
+from chanlun.core.ChanBSP import ChanBSP
+from chanlun.core.ChanEnum import (
+    Chan_BI_DIR,
+    Chan_BSP_DIR,
+    Chan_BSP_TYPE,
+    Chan_FX_TYPE,
+    Chan_K_DIR,
+    Chan_KLC_FX,
+    Chan_KLC_STATE,
+    Chan_KLINE_DIR,
+    Chan_KLU_PATTERN,
+    Chan_PRICE_TREND,
+    Chan_SEG_DIR,
+    Chan_ZS_DIR,
+)
+from chanlun.core.ChanKLC import ChanKLC
+from chanlun.core.ChanKLU import ChanKLU
+from chanlun.core.ChanSBI import ChanSBI
+from chanlun.core.ChanSEG import ChanSEG
+from chanlun.core.ChanZS import ChanZS, ChanZS_Big
+from chanlun.indicators.ChanMACD import ChanMACD
+
+
+class IndicatorsBuilderMixin:
+	def get_ema52(self, index=-1):
+		if self.klu_list:
+			ema52_value = self.klu_list[index].ema52
+			# 处理NaN值
+			if pd.isna(ema52_value) or ema52_value is None:
+				return None
+			return float(ema52_value)
+		return None
+
+	def get_ema24(self, index=-1):
+		if self.klu_list:
+			ema24_value = self.klu_list[index].ema24
+			# 处理NaN值
+			if pd.isna(ema24_value) or ema24_value is None:
+				return None
+			return float(ema24_value)
+		return None
+
+	def add_indicators(self, df):
+		fast = 26
+		slow = 52
+		period = 9
+		macd = ta.MACD(df, fastperiod=fast, slowperiod=slow, signalperiod=period)
+		bb365 = ta.BBANDS(df, timeperiod=365, nbdevup=3.0, nbdevdn=3.0, matype=0)
+		bb120 = ta.BBANDS(df, timeperiod=120, nbdevup=3.0, nbdevdn=3.0, matype=0)
+		bb30 = ta.BBANDS(df, timeperiod=41, nbdevup=2.3, nbdevdn=2.3, matype=0)
+		bb302 = ta.BBANDS(df, timeperiod=41, nbdevup=2.0, nbdevdn=2.0, matype=0)
+		bb30 = ta.BBANDS(df, timeperiod=20, nbdevup=2.0, nbdevdn=2.0, matype=0)
+		bb302 = ta.BBANDS(df, timeperiod=20, nbdevup=2.0, nbdevdn=2.0, matype=0)
+		bb2633 = ta.BBANDS(df, timeperiod=26, nbdevup=3.0, nbdevdn=3.0, matype=0)
+		# 计算布林带中轨（移动平均线）
+		bb30_middle = ta.SMA(df, timeperiod=90)
+		
+		# 手动计算布林带 %B 指标 (BBP)
+		# %B = (Price - Lower Band) / (Upper Band - Lower Band)
+		bbp365 = (df['close'] - bb365['lowerband']) / (bb365['upperband'] - bb365['lowerband'])
+		bbp120 = (df['close'] - bb120['lowerband']) / (bb120['upperband'] - bb120['lowerband'])
+		bbp30 = (df['close'] - bb30['lowerband']) / (bb30['upperband'] - bb30['lowerband'])
+		bbp302 = (df['close'] - bb302['lowerband']) / (bb302['upperband'] - bb302['lowerband'])
+		bbp2633 = (df['close'] - bb2633['lowerband']) / (bb2633['upperband'] - bb2633['lowerband'])
+		df['bb2633upper'] = bb2633['upperband']
+		df['bb2633lower'] = bb2633['lowerband']
+		df['bbp2633'] = bbp2633
+		df['bb2633middle'] = bb2633['middleband']
+		df['atr'] = ta.ATR(df, timeperiod=14)
+		df['bbup365'] = bb365['upperband']
+		df['bblow365'] = bb365['lowerband']
+		df['bbp365'] = bbp365
+		df['bbup120'] = bb120['upperband']
+		df['bblow120'] = bb120['lowerband']
+		df['bbp120'] = bbp120
+		df['bbup30'] = bb30['upperband']
+		df['bblow30'] = bb30['lowerband']
+		df['bbmiddle30'] = bb30_middle  # 添加bb30中轨
+		df['bbp30'] = bbp30
+		df['bbup302'] = bb302['upperband']
+		df['bblow302'] = bb302['lowerband']
+		df['bbp302'] = bbp302
+		df['macd'] = macd['macd']
+		df['macdsignal'] = macd['macdsignal']
+		df['macdhist'] = macd['macdhist']
+		df['ema5'] = ta.EMA(df, timeperiod=5)
+		df['ema10'] = ta.EMA(df, timeperiod=10)
+		df['ema24'] = ta.EMA(df, timeperiod=24)
+		df['ema52'] = ta.EMA(df, timeperiod=52)
+		df['ema104'] = ta.EMA(df, timeperiod=104)
+		df['ema156'] = ta.EMA(df, timeperiod=156)
+		df['ema208'] = ta.EMA(df, timeperiod=208)
+		df['ema26'] = ta.EMA(df, timeperiod=26)
+		df['ema13'] = ta.EMA(df, timeperiod=13)
+		df['ema7'] = ta.EMA(df, timeperiod=7)
+		df['rsi'] = ta.RSI(df, timeperiod=14)
+		df['volume_ratio'] = self.cal_volume_ratio(df)
+		return df
+
+	def get_ema_state(self, dataframe):
+		klu_list = self.get_klu_list(dataframe)
+		klc_list = self.get_klc_list(klu_list)
+		bi_list = self.cal_bi_list(klc_list)
+		klu_state_list = []
+		for klu in klu_list:
+			if klu.near0_return == 1:
+				klu_state_list.append("1")
+			elif klu.near0_return == 9:
+				klu_state_list.append("-1")
+			elif klu.candle_dir == Chan_K_DIR.BULL:
+				klu_state_list.append("2")
+			elif klu.candle_dir == Chan_K_DIR.BEAR:
+				klu_state_list.append("-2")
+			else:
+				klu_state_list.append("0")
+		return klu_state_list
+
+	def get_decimal(self, value):
+		return Decimal("{:.2f}".format(value))

chanlun/pipeline/builders/kline.py

@@ -0,0 +1,563 @@
+"""TF_DF builder mixin — 由 split_tfdf_builders 自动生成，逻辑与原 TF_DF 一致。"""
+from __future__ import annotations
+
+from datetime import timedelta
+from decimal import Decimal
+
+import numpy as np
+import pandas as pd
+from pandas import DataFrame
+
+from chanlun.core.ChanBI import ChanBI
+from chanlun.core.ChanBIZS import ChanBIZS
+from chanlun.core.ChanBSP import ChanBSP
+from chanlun.core.ChanEnum import (
+    Chan_BI_DIR,
+    Chan_BSP_DIR,
+    Chan_BSP_TYPE,
+    Chan_FX_TYPE,
+    Chan_K_DIR,
+    Chan_KLC_FX,
+    Chan_KLC_STATE,
+    Chan_KLINE_DIR,
+    Chan_KLU_PATTERN,
+    Chan_PRICE_TREND,
+    Chan_SEG_DIR,
+    Chan_ZS_DIR,
+)
+from chanlun.core.ChanKLC import ChanKLC
+from chanlun.core.ChanKLU import ChanKLU
+from chanlun.core.ChanSBI import ChanSBI
+from chanlun.core.ChanSEG import ChanSEG
+from chanlun.core.ChanZS import ChanZS, ChanZS_Big
+from chanlun.indicators.ChanMACD import ChanMACD
+
+
+class KlineBuilderMixin:
+	def get_klu_state(self, dataframe):
+		klc_list = self.get_klc_list(self.get_klu_list(dataframe))
+		bi_list = self.cal_bi_list(klc_list)
+		klu_state_list = []
+		klc_index = 0
+		for index in range(0, len(dataframe)):
+			if klc_index == len(klc_list):
+				klc_index = len(klc_list) - 1
+			klc = klc_list[klc_index]
+			if klc.end_klu and klc.end_klu.idx == index:
+				if klc.klc_state == Chan_KLC_STATE.S10:
+					klu_state_list.append("10")
+					#print(klc.end_time, klc.klc_fx_type)
+				elif klc.klc_state == Chan_KLC_STATE.S_10:
+					klu_state_list.append("-10")
+					#print(klc.end_time, klc.klc_fx_type)
+				elif klc.klc_state == Chan_KLC_STATE.S11:
+					klu_state_list.append("11")
+					#print(klc.end_time, klc.klc_fx_type)
+				elif klc.klc_state == Chan_KLC_STATE.S_11:
+					klu_state_list.append("-11")
+					#print(klc.end_time, klc.klc_fx_type)
+				else:
+					klu_state_list.append("00")
+				klc_index += 1
+			else:
+				klu_state_list.append("00")
+		print(klu_state_list[:20])
+		return klu_state_list
+
+
+	def check_fx1(self, klc):
+		if klc.pre and klc.next:
+			if klc.high > klc.pre.high and klc.high > klc.next.high and klc.low > klc.pre.low and klc.low > klc.next.low:
+				if klc.pre.pre and klc.next.next:
+					if klc.high > klc.pre.pre.high and klc.high > klc.next.next.high:
+						#if (klc.close > klc.ema52 or klc.next.close > klc.next.ema52) and klc.macd > 0:
+						klc.set_fx(Chan_FX_TYPE.TOP)
+						#print(klc.start_time, klc.end_time,klc.next.start_time, klc.next.end_time, klc.macd, klc.state, klc.fx, "TOP")
+						return Chan_FX_TYPE.TOP
+			elif klc.low < klc.pre.low and klc.low < klc.next.low and klc.high < klc.pre.high and klc.high < klc.next.high:
+				#if (klc.close < klc.ema52 or klc.next.close < klc.next.ema52) and klc.macd < 0:
+				if klc.pre.pre and klc.next.next:
+					if klc.low < klc.pre.pre.low and klc.low < klc.next.next.low:
+						klc.set_fx(Chan_FX_TYPE.BOTTOM)
+						#print(klc.start_time, klc.end_time,klc.next.start_time, klc.next.end_time, klc.macd, klc.state, klc.fx, "BOTTOM")
+						return Chan_FX_TYPE.BOTTOM
+		return Chan_FX_TYPE.UNKNOWN
+
+	def check_fx(self, klc):
+		# 右K未完成（仍在包含合并）时不分型：否则确认笔会随 next 扩区间被 check_*_fx 收回
+		if klc.pre and klc.next and klc.next.end_klu is not None:
+			if klc.high > klc.pre.high and klc.high > klc.next.high and klc.low > klc.pre.low and klc.low > klc.next.low:
+				#if (klc.close > klc.ema52 or klc.next.close > klc.next.ema52) and klc.macd > 0:
+				klc.set_fx(Chan_FX_TYPE.TOP)
+				#print(klc.start_time, klc.end_time,klc.next.start_time, klc.next.end_time, klc.macd, klc.state, klc.fx, "TOP")
+				return Chan_FX_TYPE.TOP
+			elif klc.low < klc.pre.low and klc.low < klc.next.low and klc.high < klc.pre.high and klc.high < klc.next.high:
+				#if (klc.close < klc.ema52 or klc.next.close < klc.next.ema52) and klc.macd < 0:
+				klc.set_fx(Chan_FX_TYPE.BOTTOM)
+				#print(klc.start_time, klc.end_time,klc.next.start_time, klc.next.end_time, klc.macd, klc.state, klc.fx, "BOTTOM")
+				return Chan_FX_TYPE.BOTTOM
+		return Chan_FX_TYPE.UNKNOWN
+
+	def check_fx3(self, klc):
+		# 右K未完成（仍在包含合并）时不分型：否则确认笔会随 next 扩区间被 check_*_fx 收回
+		if klc.pre and klc.next and klc.next.end_klu is not None:
+			next_klu = klc.next.end_klu.next
+			if klc.high > klc.pre.high and klc.high > klc.next.high and klc.low > klc.pre.low and klc.low > klc.next.low and klc.high > next_klu.high:
+				#if (klc.close > klc.ema52 or klc.next.close > klc.next.ema52) and klc.macd > 0:
+				klc.set_fx(Chan_FX_TYPE.TOP)
+				#print(klc.start_time, klc.end_time,klc.next.start_time, klc.next.end_time, klc.macd, klc.state, klc.fx, "TOP")
+				return Chan_FX_TYPE.TOP
+			elif klc.low < klc.pre.low and klc.low < klc.next.low and klc.high < klc.pre.high and klc.high < klc.next.high and klc.low < next_klu.low:
+				#if (klc.close < klc.ema52 or klc.next.close < klc.next.ema52) and klc.macd < 0:
+				klc.set_fx(Chan_FX_TYPE.BOTTOM)
+				#print(klc.start_time, klc.end_time,klc.next.start_time, klc.next.end_time, klc.macd, klc.state, klc.fx, "BOTTOM")
+				return Chan_FX_TYPE.BOTTOM
+		return Chan_FX_TYPE.UNKNOWN
+	def check_fx2(self, klc):
+		if klc.pre and klc.next:
+			if klc.high > klc.pre.close and klc.close > klc.next.close and klc.close > klc.pre.close and klc.close > klc.next.close:
+				#if (klc.close > klc.ema52 or klc.next.close > klc.next.ema52) and klc.macd > 0:
+				klc.set_fx(Chan_FX_TYPE.TOP)
+				#print(klc.start_time, klc.end_time,klc.next.start_time, klc.next.end_time, klc.macd, klc.state, klc.fx, "TOP")
+				return Chan_FX_TYPE.TOP
+			elif klc.low < klc.pre.close and klc.close < klc.next.close and klc.close < klc.pre.close and klc.close < klc.next.close:
+				#if (klc.close < klc.ema52 or klc.next.close < klc.next.ema52) and klc.macd < 0:
+				klc.set_fx(Chan_FX_TYPE.BOTTOM)
+				#print(klc.start_time, klc.end_time,klc.next.start_time, klc.next.end_time, klc.macd, klc.state, klc.fx, "BOTTOM")
+				return Chan_FX_TYPE.BOTTOM
+		return Chan_FX_TYPE.UNKNOWN
+
+	def check_fx_pattern(self, klc):
+		klu_list = klc.pre.klu_list + klc.klu_list + klc.next.klu_list
+		
+		self.cal_klu_pattern(klu_list)
+		p = ""
+		for klu in klu_list:
+			p += klu.to_string()
+		#print(p)
+
+	def cal_volume_ratio(self, dataframe, window=10):
+		df = dataframe.copy()
+		# 计算过去N根K线的平均成交量
+		df['avg_volume'] = df['volume'].rolling(window=window).mean()
+		# 计算量比
+		df['volume_ratio'] = df['volume'] / df['avg_volume']
+		# 填充缺失值（前N根K线）
+		df['volume_ratio'] = df['volume_ratio'].fillna(1.0)
+		return df['volume_ratio']
+
+	def cal_kl_data(self, dataframe:DataFrame):
+		"""按行构造 KLU 链。
+
+		这里刻意不用 `dataframe.iloc[i]`：那会为每一根新建一个几十列的 Series，
+		随后 set_indicators 再在其上做几十次逐键查找。实测这两件事合计占 TF_DF
+		构建耗时的 96%。改为先把用到的列取成 ndarray，循环里只做整数下标访问。
+		"""
+		n = len(dataframe)
+		if n == 0:
+			return []
+
+		times = self._format_times(dataframe['date'])
+		o_a = dataframe['open'].to_numpy(dtype=float)
+		h_a = dataframe['high'].to_numpy(dtype=float)
+		l_a = dataframe['low'].to_numpy(dtype=float)
+		c_a = dataframe['close'].to_numpy(dtype=float)
+		v_a = dataframe['volume'].to_numpy(dtype=float)
+
+		has_ind = 'macd' in dataframe.columns
+		ind_cols = {}
+		if has_ind:
+			for _attr, col in ChanKLU.INDICATOR_FIELDS:
+				if col in dataframe.columns:
+					ind_cols[col] = dataframe[col].to_numpy(dtype=float)
+
+		klu_list = []
+		last_klu = None
+		for i in range(n):
+			klu = ChanKLU(times[i], o_a[i], h_a[i], l_a[i], c_a[i], v_a[i])
+			klu.set_idx(i)
+			klu_list.append(klu)
+			if last_klu:
+				last_klu.set_next(klu)
+				klu.set_pre(last_klu)
+			last_klu = klu
+			if has_ind:
+				klu.set_indicators_from(ind_cols, i)
+		return klu_list
+
+	@staticmethod
+	def _format_times(col):
+		"""向量化 strftime。非 datetime 列（少见）退回逐个格式化。"""
+		fmt = '%Y-%m-%d %H:%M:%S'
+		try:
+			return col.dt.strftime(fmt).to_numpy()
+		except AttributeError:
+			return np.array([d.strftime(fmt) for d in col], dtype=object)
+
+	def get_kl_data(self, dataframe:DataFrame):
+		return self.cal_kl_data(dataframe)
+
+	def _push_klu_into_klc_list(self, klc_list, klu, last_klu):
+		"""把一根 KLU 并入包含K线列表。与 get_klc_list 的几何规则相同。"""
+		if len(klc_list) > 0:
+			last_klc = klc_list[-1]
+			if klu.exception:
+				ddir = Chan_KLINE_DIR.DOWN
+				if last_klc.high < klu.high:
+					ddir = Chan_KLINE_DIR.UP
+				klc = ChanKLC(klu, index=len(klc_list), ddir=ddir)
+				klc.high = klu.close if klu.close > klu.open else klu.open
+				klc.low = klu.open if klu.close > klu.open else klu.close
+				klc_list.append(klc)
+				last_klc.set_next(klc)
+				klc.set_pre(last_klc)
+				last_klc.set_end_klu(last_klu)
+				klc.set_pre_fx()
+			else:
+				included = last_klc.check_klu_included(klu)
+				if not included:
+					ddir = Chan_KLINE_DIR.DOWN
+					if last_klc.high < klu.high:
+						ddir = Chan_KLINE_DIR.UP
+					klc = ChanKLC(klu, index=len(klc_list), ddir=ddir)
+					klc_list.append(klc)
+					last_klc.set_next(klc)
+					klc.set_pre(last_klc)
+					last_klc.set_end_klu(last_klu)
+					klc.set_pre_fx()
+				else:
+					last_klc.add_klu(klu)
+		else:
+			ddir = Chan_KLINE_DIR.UP
+			if klu.open > klu.close:
+				ddir = Chan_KLINE_DIR.DOWN
+			klc = ChanKLC(klu, 0, ddir)
+			klc_list.append(klc)
+
+	def get_klc_list(self, klu_list):
+		klc_list = []
+		# ChanMACD.__init__ 已调用 cal_macd_state，切勿再调一次（会重复堆积 seg/unittf）。
+		# lean 模式跳过整套 MACD 状态机：它只服务于 bsp/背驰/web 展示，笔与中枢不依赖它。
+		if getattr(self, 'lean', False):
+			self._last_chan_macd = None
+		else:
+			macd = ChanMACD(klu_list)
+			klu_list = macd.klu_list
+			self._last_chan_macd = macd
+
+		last_klu = None
+		for klu in klu_list:
+			self._push_klu_into_klc_list(klc_list, klu, last_klu)
+			last_klu = klu
+		klc_list = self.cal_trend(klc_list)
+		return klc_list
+
+
+	def get_klu_list(self, dataframe):
+		klu_list = self.get_kl_data(dataframe)
+		#klu_list = self.cal_klu_pattern(klu_list)
+		return klu_list
+
+	def cal_klu_pattern(self, klu_list):
+		"""
+		计算裸K的pattern - 识别反转形态
+		"""
+		if not klu_list or len(klu_list) < 3:
+			return klu_list
+			
+		for i, klu in enumerate(klu_list):
+			# 单根K线反转模式识别
+			self._detect_single_reversal_pattern(klu)
+			
+			# 双根K线形态识别
+			if i >= 1:
+				self._detect_double_pattern(klu_list[i-1], klu)
+			
+			# 三根K线形态识别
+			if i >= 2:
+				self._detect_triple_pattern(klu_list[i-2], klu_list[i-1], klu)
+			
+			#if klu.pattern != Chan_KLU_PATTERN.UNKNOWN:
+				#print(klu.time, klu.pattern, klu.lower_shadow_ratio, klu.upper_shadow_ratio, klu.body_ratio, klu.lower_shadow_ratio/klu.body_ratio, klu.upper_shadow_ratio/klu.body_ratio)
+		return klu_list
+	
+
+	def _detect_single_reversal_pattern(self, klu):
+		"""检测单根K线反转模式"""
+		body = abs(klu.close - klu.open)
+		upper_shadow = klu.high - max(klu.close, klu.open)
+		lower_shadow = min(klu.close, klu.open) - klu.low
+		total_range = klu.high - klu.low
+		
+		# 避免除零
+		if total_range == 0:
+			return
+		
+		body_ratio = body / total_range
+		upper_ratio = upper_shadow / total_range
+		lower_ratio = lower_shadow / total_range
+		#print(klu.time, upper_ratio, lower_ratio, body_ratio, upper_ratio/body_ratio, lower_ratio/body_ratio)
+		# 避免body_ratio为0时的除零错误
+		if body_ratio == 0:
+			return
+		# 锤子线/上吊线 - 反转信号
+		if lower_ratio / body_ratio >= 2:
+			# 锤子线：底部反转，需要前面一段
+			if klu.close > klu.open and klu.pre:
+				klu.set_pattern(Chan_KLU_PATTERN.HAMMER)  # 底部反转
+			# 上吊线：顶部反转，需要前一根是上涨趋势
+			elif klu.close < klu.open and klu.pre:
+				klu.set_pattern(Chan_KLU_PATTERN.HANGING_MAN)  # 顶部反转
+		
+		# 倒锤子线/射击之星 - 反转信号
+		elif upper_ratio / body_ratio >= 2:
+			# 倒锤子线：底部反转，需要前一根是下跌趋势
+			if klu.close > klu.open and klu.pre:
+				klu.set_pattern(Chan_KLU_PATTERN.INVERTED_HAMMER)  # 底部反转
+			# 射击之星：顶部反转，需要前一根是上涨趋势
+			elif klu.close < klu.open and klu.pre:
+				klu.set_pattern(Chan_KLU_PATTERN.SHOOTING_STAR)  # 顶部反转
+		
+		# 十字星 - 反转信号
+		elif body_ratio <= 0.1:
+			if upper_ratio > 0.4 and lower_ratio > 0.4:
+				klu.set_pattern(Chan_KLU_PATTERN.LONG_LEGGED_DOJI)  # 强烈反转信号
+			elif upper_ratio > 0.4 and lower_ratio <= 0.1:
+				# 墓碑十字星：顶部反转，需要前一根是上涨趋势
+				if klu.pre and klu.pre.close > klu.pre.open:
+					klu.set_pattern(Chan_KLU_PATTERN.GRAVESTONE_DOJI)  # 顶部反转
+			elif lower_ratio > 0.4 and upper_ratio <= 0.1:
+				# 蜻蜓十字星：底部反转，需要前一根是下跌趋势
+				if klu.pre and klu.pre.close < klu.pre.open:
+					klu.set_pattern(Chan_KLU_PATTERN.DRAGONFLY_DOJI)  # 底部反转
+			else:
+				klu.set_pattern(Chan_KLU_PATTERN.DOJI)  # 一般反转信号
+	
+
+	def _detect_double_pattern(self, prev_klu, curr_klu):
+		"""检测两根K线形成的形态
+		包括：吞没形态(看涨/看跌)、乌云盖顶、曙光初现
+		"""
+		# 如果前一根K线已经有形态，不再识别双K线形态
+		if prev_klu.pattern != Chan_KLU_PATTERN.UNKNOWN:
+			return
+		
+		# 计算K线实体
+		prev_body = abs(prev_klu.close - prev_klu.open)
+		curr_body = abs(curr_klu.close - curr_klu.open)
+		
+		# 判断K线颜色（阴阳）
+		prev_bullish = prev_klu.close > prev_klu.open
+		curr_bullish = curr_klu.close > curr_klu.open
+		
+		# 检查是否存在长期趋势（至少需要5根K线的趋势）
+		def check_long_trend(klu, bullish_trend=True, min_bars=5):
+			"""检查是否存在长期趋势
+			bullish_trend=True: 检查上涨趋势
+			bullish_trend=False: 检查下跌趋势
+			min_bars: 最少需要多少根K线形成趋势
+			"""
+			if not klu or not klu.pre:
+				return False
+			return True
+				
+			# 使用EMA指标判断长期趋势
+			if klu.ema52 > 0:
+				if bullish_trend and klu.close < klu.ema52:
+					return False
+				if not bullish_trend and klu.close > klu.ema52:
+					return False
+			
+			# 检查连续的K线方向
+			count = 0
+			current = klu.pre
+			
+			while current and count < min_bars:
+				if not current.pre:
+					break
+					
+				if bullish_trend:
+					# 上涨趋势：当前收盘价高于前一根收盘价
+					if current.close <= current.pre.close:
+						break
+				else:
+					# 下跌趋势：当前收盘价低于前一根收盘价
+					if current.close >= current.pre.close:
+						break
+						
+				count += 1
+				current = current.pre
+				
+			return count >= min_bars
+		
+		# 1. 看涨吞没形态：前阴后阳，后者完全吞没前者
+		# 要求前面有明显的下跌趋势
+		if not prev_bullish and curr_bullish and \
+		   abs(curr_klu.open - prev_klu.close) < 10 and \
+		   curr_klu.close > prev_klu.open and \
+		   check_long_trend(prev_klu, bullish_trend=False, min_bars=5):
+			curr_klu.set_pattern(Chan_KLU_PATTERN.BULLISH_ENGULFING)
+			return
+		
+		# 2. 看跌吞没形态：前阳后阴，后者完全吞没前者
+		# 要求前面有明显的上涨趋势
+		if prev_bullish and not curr_bullish and \
+		   abs(curr_klu.open - prev_klu.close) < 10 and \
+		   curr_klu.close < prev_klu.open and \
+		   check_long_trend(prev_klu, bullish_trend=True, min_bars=5):
+			curr_klu.set_pattern(Chan_KLU_PATTERN.BEARISH_ENGULFING)
+			return
+		
+		# 3. 乌云盖顶：前阳后阴，后者开盘价高于前者最高价，收盘价在前者实体中部以下
+		# 要求前面有明显的上涨趋势
+		if prev_bullish and not curr_bullish and \
+		   curr_klu.open > prev_klu.high and \
+		   curr_klu.close < (prev_klu.open + prev_klu.close) / 2 and \
+		   curr_klu.close > prev_klu.open and \
+		   check_long_trend(prev_klu, bullish_trend=True, min_bars=5):
+			curr_klu.set_pattern(Chan_KLU_PATTERN.DARK_CLOUD_COVER)
+			return
+		
+		# 4. 曙光初现：前阴后阳，后者开盘价低于前者最低价，收盘价在前者实体中部以上
+		# 要求前面有明显的下跌趋势
+		if not prev_bullish and curr_bullish and \
+		   curr_klu.open < prev_klu.low and \
+		   curr_klu.close > (prev_klu.open + prev_klu.close) / 2 and \
+		   curr_klu.close < prev_klu.open and \
+		   check_long_trend(prev_klu, bullish_trend=False, min_bars=5):
+			curr_klu.set_pattern(Chan_KLU_PATTERN.PIERCING_LINE)
+			return
+		
+		# 平顶和平底移至三根K线形态中判断
+
+
+	def _detect_triple_pattern(self, first_klu, second_klu, third_klu):
+		"""检测三根K线形成的形态
+		包括：早晨之星、黄昏之星、平顶、平底
+		"""
+		# 如果前两根K线已经有形态，不再识别三K线形态
+		if first_klu.pattern != Chan_KLU_PATTERN.UNKNOWN or \
+		   second_klu.pattern != Chan_KLU_PATTERN.UNKNOWN:
+			return
+		
+		# 判断K线颜色（阴阳）
+		first_bullish = first_klu.close > first_klu.open
+		second_bullish = second_klu.close > second_klu.open
+		third_bullish = third_klu.close > third_klu.open
+		
+		# 计算实体大小
+		first_body = abs(first_klu.close - first_klu.open)
+		second_body = abs(second_klu.close - second_klu.open)
+		third_body = abs(third_klu.close - third_klu.open)
+		
+		# 检查是否存在长期趋势（至少需要5根K线的趋势）
+		def check_long_trend(klu, bullish_trend=True, min_bars=5):
+			"""检查是否存在长期趋势
+			bullish_trend=True: 检查上涨趋势
+			bullish_trend=False: 检查下跌趋势
+			min_bars: 最少需要多少根K线形成趋势
+			"""
+			if not klu or not klu.pre:
+				return False
+				
+			# 使用EMA指标判断长期趋势
+			if klu.ema52 > 0:
+				if bullish_trend and klu.close < klu.ema52:
+					return False
+				if not bullish_trend and klu.close > klu.ema52:
+					return False
+			
+			# 检查连续的K线方向
+			count = 0
+			current = klu.pre
+			
+			while current and count < min_bars:
+				if not current.pre:
+					break
+					
+				if bullish_trend:
+					# 上涨趋势：当前收盘价高于前一根收盘价
+					if current.close <= current.pre.close:
+						break
+				else:
+					# 下跌趋势：当前收盘价低于前一根收盘价
+					if current.close >= current.pre.close:
+						break
+						
+				count += 1
+				current = current.pre
+				
+			return count >= min_bars
+		
+		# 1. 早晨之星：第一根阴线，第二根十字星或小实体，第三根阳线
+		# 要求前面有明显的下跌趋势
+		if not first_bullish and third_bullish and \
+		   second_body < first_body * 0.3 and \
+		   third_body > first_body * 0.5 and \
+		   max(second_klu.open, second_klu.close) < first_klu.close and \
+		   min(second_klu.open, second_klu.close) < third_klu.open and \
+		   third_klu.close > (first_klu.open + first_klu.close) / 2 and \
+		   check_long_trend(first_klu, bullish_trend=False, min_bars=7):
+			third_klu.set_pattern(Chan_KLU_PATTERN.MORNING_STAR)
+			return
+		
+		# 2. 黄昏之星：第一根阳线，第二根十字星或小实体，第三根阴线
+		# 要求前面有明显的上涨趋势
+		if first_bullish and not third_bullish and \
+		   second_body < first_body * 0.3 and \
+		   third_body > first_body * 0.5 and \
+		   min(second_klu.open, second_klu.close) > first_klu.close and \
+		   max(second_klu.open, second_klu.close) > third_klu.open and \
+		   third_klu.close < (first_klu.open + first_klu.close) / 2 and \
+		   check_long_trend(first_klu, bullish_trend=True, min_bars=7):
+			third_klu.set_pattern(Chan_KLU_PATTERN.EVENING_STAR)
+			return
+			
+		# 3. 平顶：三根K线的最高点几乎相同（上升趋势中更有意义）
+		# 要求前面有明显的上涨趋势
+		if (abs(first_klu.high - second_klu.high) / first_klu.high < 0.0002 and 
+			abs(second_klu.high - third_klu.high) / second_klu.high < 0.0002 and
+			check_long_trend(first_klu, bullish_trend=True, min_bars=7)):
+			# 额外确认：价格接近阻力位或关键技术指标
+			is_near_resistance = False
+			
+			# 检查是否接近EMA52阻力位
+			if first_klu.ema52 > 0:
+				resistance_level = first_klu.ema52
+				if abs(first_klu.high - resistance_level) / resistance_level < 0.01:
+					is_near_resistance = True
+			
+			# 检查是否有成交量确认（成交量减少表示上涨动能减弱）
+			volume_confirmation = False
+			if (first_klu.volume > 0 and second_klu.volume > 0 and third_klu.volume > 0 and
+				third_klu.volume < second_klu.volume and second_klu.volume < first_klu.volume):
+				volume_confirmation = True
+				
+			if is_near_resistance or volume_confirmation:
+				third_klu.set_pattern(Chan_KLU_PATTERN.TWEEZER_TOP)
+				return
+		
+		# 4. 平底：三根K线的最低点几乎相同（下降趋势中更有意义）
+		# 要求前面有明显的下跌趋势
+		if (abs(first_klu.low - second_klu.low) / first_klu.low < 0.0002 and 
+			abs(second_klu.low - third_klu.low) / second_klu.low < 0.0002 and
+			check_long_trend(first_klu, bullish_trend=False, min_bars=7)):
+			# 额外确认：价格接近支撑位或关键技术指标
+			is_near_support = False
+			
+			# 检查是否接近EMA52支撑位
+			if first_klu.ema52 > 0:
+				support_level = first_klu.ema52
+				if abs(first_klu.low - support_level) / support_level < 0.01:
+					is_near_support = True
+			
+			# 检查是否有成交量确认（成交量减少表示下跌动能减弱）
+			volume_confirmation = False
+			if (first_klu.volume > 0 and second_klu.volume > 0 and third_klu.volume > 0 and
+				third_klu.volume < second_klu.volume and second_klu.volume < first_klu.volume):
+				volume_confirmation = True
+				
+			if is_near_support or volume_confirmation:
+				third_klu.set_pattern(Chan_KLU_PATTERN.TWEEZER_BOTTOM)
+				return
+	

chanlun/pipeline/builders/seg.py

@@ -0,0 +1,315 @@
+"""TF_DF builder mixin — 由 split_tfdf_builders 自动生成，逻辑与原 TF_DF 一致。"""
+from __future__ import annotations
+
+from datetime import timedelta
+from decimal import Decimal
+
+import numpy as np
+import pandas as pd
+from pandas import DataFrame
+
+from chanlun.core.ChanBI import ChanBI
+from chanlun.core.ChanBIZS import ChanBIZS
+from chanlun.core.ChanBSP import ChanBSP
+from chanlun.core.ChanEnum import (
+    Chan_BI_DIR,
+    Chan_BSP_DIR,
+    Chan_BSP_TYPE,
+    Chan_FX_TYPE,
+    Chan_K_DIR,
+    Chan_KLC_FX,
+    Chan_KLC_STATE,
+    Chan_KLINE_DIR,
+    Chan_KLU_PATTERN,
+    Chan_PRICE_TREND,
+    Chan_SEG_DIR,
+    Chan_ZS_DIR,
+)
+from chanlun.core.ChanKLC import ChanKLC
+from chanlun.core.ChanKLU import ChanKLU
+from chanlun.core.ChanSBI import ChanSBI
+from chanlun.core.ChanSEG import ChanSEG
+from chanlun.core.ChanZS import ChanZS, ChanZS_Big
+from chanlun.indicators.ChanMACD import ChanMACD
+
+
+class SegBuilderMixin:
+	def get_seg_list(self, bi_list):
+		seg_list = []
+		up_bi_list = []
+		down_bi_list = []
+		last_up_bi = None
+		last_down_bi = None
+		last_up_sbi = None
+		last_down_sbi = None
+		last_seg = None
+		up_sbi_list = []
+		down_sbi_list = []
+		look_for_bottom = False
+		look_for_top = False
+		for bi in bi_list:
+			#print(len(up_sbi_list), len(down_sbi_list))
+			if len(seg_list) > 0:
+				# Last seg is up
+				if last_seg.dir == Chan_SEG_DIR.UP:
+					if bi.dir == Chan_BI_DIR.DOWN:
+						if len(down_sbi_list) > 1:
+							# Check down sbi inclusion
+							included = last_down_sbi.check_bi_included(bi)
+							if not included:
+								down_sbi = ChanSBI(bi, len(down_sbi_list), bi.dir)
+								last_down_sbi.set_next(down_sbi)
+								last_down_sbi.set_end_bi(last_down_bi)
+								down_sbi.set_pre(last_down_sbi)
+								down_sbi_list.append(down_sbi)
+								fx = last_down_sbi.check_fx()
+								# Found top
+								if fx == Chan_FX_TYPE.TOP:
+									if look_for_top:
+										seg_list[-2].set_sure(bi)
+										look_for_top = False
+										#print(bi.start_time, look_for_top, "UP 1")
+									# Has gap and search for bottom fx
+									if last_down_sbi.has_fx_gap:
+										look_for_bottom = True
+										last_seg.pre_set_end_bi(bi_list[last_down_sbi.start_bi.index - 1])
+										seg = ChanSEG(last_down_sbi.start_bi, len(seg_list), Chan_SEG_DIR.DOWN, bi)
+										seg_list.append(seg)
+										last_seg.set_next(seg)
+										seg.set_pre(last_seg)
+										last_seg = seg
+										up_sbi_list = []
+										last_up_sbi = ChanSBI(last_up_bi, len(up_sbi_list), last_up_bi.dir)
+										up_sbi_list.append(last_up_sbi)
+										#up_sbi_list.append(last_up_sbi)
+										#print(last_up_bi.start_time, last_up_sbi.start_bi.start_time, "Reset up sbi list 1")
+										#print(bi.start_time, look_for_top, "UP 2")
+									# No gap end SEG
+									else:
+										if look_for_bottom:
+											look_for_bottom = False
+											last_seg.set_start_bi(last_down_sbi.start_bi)
+											seg_list[-2].set_end_bi(bi_list[last_down_sbi.start_bi.index - 1], bi)
+											up_sbi_list = []
+											last_up_sbi = ChanSBI(last_up_bi, len(up_sbi_list), last_up_bi.dir)
+											up_sbi_list.append(last_up_sbi)
+											last_seg.add_bi(bi)
+											#up_sbi_list.append(last_up_sbi)
+											#print(last_up_bi.start_time, last_up_sbi.start_bi.start_time, "Reset up sbi list 2")
+											#print(bi.start_time, look_for_top, "UP 3")
+										else:
+											last_seg.set_end_bi(bi_list[last_down_sbi.start_bi.index - 1], bi)
+											seg = ChanSEG(last_down_sbi.start_bi, len(seg_list), Chan_SEG_DIR.DOWN, bi)
+											seg_list.append(seg)
+											last_seg.set_next(seg)
+											seg.set_pre(last_seg)
+											last_seg = seg
+											#print(last_down_sbi.end_bi.start_time, "Normal UP SEG", last_up_sbi.start_bi.start_time, bi.start_time)
+											#l_up_sbi = up_sbi_list[-1]
+											up_sbi_list = []
+											last_up_sbi = ChanSBI(last_up_bi, len(up_sbi_list), last_up_bi.dir)
+											up_sbi_list.append(last_up_sbi)
+											#up_sbi_list.append(last_up_sbi)
+											#print(last_up_bi.start_time, last_up_sbi.start_bi.start_time, "Reset up sbi list 3")
+								last_down_sbi = down_sbi
+							last_seg.add_bi(bi)
+						else:
+							if len(down_sbi_list) == 1:
+								included = last_down_sbi.check_bi_included(bi)
+								if not included:
+									down_sbi = ChanSBI(bi, len(down_sbi_list), bi.dir)
+									last_down_sbi.set_next(down_sbi)
+									last_down_sbi.set_end_bi(last_down_bi)
+									down_sbi.set_pre(last_down_sbi)
+									down_sbi_list.append(down_sbi)
+									last_down_sbi = down_sbi
+									#print(bi.start_time, look_for_top, "UP 4")
+								last_seg.add_bi(bi)
+									
+							else:
+								last_down_sbi = ChanSBI(bi, len(down_sbi_list), bi.dir)
+								down_sbi_list.append(last_down_sbi)
+								last_seg.add_bi(bi)
+								#print(bi.start_time, look_for_top, "UP 5")
+					else:
+						if last_up_sbi:
+							included = last_up_sbi.check_bi_included(bi)
+							if not included:
+								up_sbi = ChanSBI(bi, len(up_sbi_list), bi.dir)
+								last_up_sbi.set_next(up_sbi)
+								last_up_sbi.set_end_bi(last_up_bi)
+								up_sbi.set_pre(last_up_sbi)
+								up_sbi_list.append(up_sbi)
+								last_up_sbi = up_sbi
+								#print(bi.start_time, look_for_top, "UP 6")
+							last_seg.add_bi(bi)
+								
+				# Last seg is down
+				else:
+					if bi.dir == Chan_BI_DIR.UP:
+						if len(up_sbi_list) > 1:
+							# Check down sbi inclusion
+							included = last_up_sbi.check_bi_included(bi)
+							if not included:
+								up_sbi = ChanSBI(bi, len(up_sbi_list), bi.dir)
+								last_up_sbi.set_next(up_sbi)
+								last_up_sbi.set_end_bi(last_up_bi)
+								up_sbi.set_pre(last_up_sbi)
+								up_sbi_list.append(up_sbi)
+								fx = last_up_sbi.check_fx()
+								# Found bottom
+								if fx == Chan_FX_TYPE.BOTTOM:
+									if look_for_bottom:
+										seg_list[-2].set_sure(bi)
+										look_for_bottom = False
+										#print(bi.start_time, look_for_top, "DOWN 1")
+									# Has gap and search for bottom fx
+									if last_up_sbi.has_fx_gap:
+										look_for_top = True
+										last_seg.pre_set_end_bi(bi_list[last_up_sbi.start_bi.index - 1])
+										seg = ChanSEG(last_up_sbi.start_bi, len(seg_list), Chan_SEG_DIR.UP, bi)
+										seg_list.append(seg)
+										last_seg.set_next(seg)
+										seg.set_pre(last_seg)
+										last_seg = seg
+										down_sbi_list = []
+										last_down_sbi = ChanSBI(last_down_bi, len(down_sbi_list), last_down_bi.dir)
+										down_sbi_list.append(last_down_sbi)
+										#down_sbi_list.append(last_down_sbi)
+										#print(last_down_bi.start_time, last_down_sbi.start_bi.start_time, "Reset down sbi list 1")
+										#print(bi.start_time, look_for_top, "DOWN 2")
+									# No gap end SEG
+									else:
+										if look_for_top:
+											look_for_top = False
+											last_seg.set_start_bi(last_up_sbi.start_bi)
+											seg_list[-2].set_end_bi(bi_list[last_up_sbi.start_bi.index - 1], bi)
+											down_sbi_list = []
+											last_down_sbi = ChanSBI(last_down_bi, len(down_sbi_list), last_down_bi.dir)
+											down_sbi_list.append(last_down_sbi)
+											last_seg.add_bi(bi)
+											#down_sbi_list.append(last_down_sbi)
+											#print(last_down_bi.start_time, last_down_sbi.start_bi.start_time, "Reset down sbi list 2")
+											#print(bi.start_time, look_for_top, "DOWN 3")
+										else:
+											last_seg.set_end_bi(bi_list[last_up_sbi.start_bi.index - 1], bi)
+											seg = ChanSEG(last_up_sbi.start_bi, len(seg_list), Chan_SEG_DIR.UP, bi)
+											#print(last_up_sbi.start_bi.start_time)
+											last_seg.set_next(seg)
+											seg.set_pre(last_seg)
+											seg_list.append(seg)
+											last_seg = seg
+											#print(last_up_sbi.end_bi.start_time, "Normal DOWN SEG", last_down_sbi.start_bi.start_time, bi.start_time)
+											down_sbi_list = []
+											last_down_sbi = ChanSBI(last_down_bi, len(down_sbi_list), last_down_bi.dir)
+											down_sbi_list.append(last_down_sbi)
+											#down_sbi_list.append(last_down_sbi)
+											#print(last_down_bi.start_time, last_down_sbi.start_bi.start_time, "Reset down sbi list 3")
+								last_up_sbi = up_sbi
+							last_seg.add_bi(bi)	
+						else:
+							if len(up_sbi_list) == 1:
+								#last_up_sbi = up_sbi_list[-1]
+								included = last_up_sbi.check_bi_included(bi)
+								if not included:
+									up_sbi = ChanSBI(bi, len(up_sbi_list), bi.dir)
+									last_up_sbi.set_next(up_sbi)
+									last_up_sbi.set_end_bi(last_up_bi)
+									up_sbi.set_pre(last_up_sbi)
+									up_sbi_list.append(up_sbi)
+									last_up_sbi = up_sbi
+								last_seg.add_bi(bi)
+									#print(bi.start_time, look_for_top, "DOWN 4")
+							else:
+								last_up_sbi = ChanSBI(bi, len(up_sbi_list), bi.dir)
+								up_sbi_list.append(last_up_sbi)
+								last_seg.add_bi(bi)
+								#print(bi.start_time, look_for_top, "DOWN 5")
+					else:
+						if last_down_sbi:
+							included = last_down_sbi.check_bi_included(bi)
+							if not included:
+								down_sbi = ChanSBI(bi, len(down_sbi_list), bi.dir)
+								last_down_sbi.set_next(down_sbi)
+								last_down_sbi.set_end_bi(last_down_bi)
+								down_sbi.set_pre(last_down_sbi)
+								down_sbi_list.append(down_sbi)
+								last_down_sbi = down_sbi
+							last_seg.add_bi(bi)
+								#print(bi.start_time, look_for_top, look_for_bottom, "DOWN 6")
+			# len(seg_list) = 0
+			else:
+				if bi.check_overlap():
+					if bi.dir == Chan_BI_DIR.UP:
+						seg = ChanSEG(bi, len(seg_list), Chan_SEG_DIR.UP, bi)
+						last_up_bi = bi
+						last_up_sbi = ChanSBI(bi, len(up_sbi_list), bi.dir)
+						seg_list.append(seg)
+						last_seg = seg
+						#print(bi.start_time, 'Create first UP SEG')
+					else:
+						seg = ChanSEG(bi, len(seg_list), Chan_SEG_DIR.DOWN, bi)
+						last_down_bi = bi
+						last_down_sbi = ChanSBI(bi, len(down_sbi_list), bi.dir)
+						seg_list.append(seg)
+						last_seg = seg
+						#print(bi.start_time, 'Create first DOWN SEG')
+			if bi.dir == Chan_BI_DIR.UP:
+				last_up_bi = bi
+				up_bi_list.append(bi)
+			else:
+				last_down_bi = bi
+				down_bi_list.append(bi)
+		"""
+		if len(seg_list) > 1:
+			seg = seg_list[-1]
+			last_seg = seg_list[-2]
+			last_seg_bi = last_seg.bi_list[-3]
+			bi_index = seg.start_bi.index
+			for i in range(bi_index, len(bi_list) - 1):
+				# last seg is down
+				if seg.dir == Chan_SEG_DIR.UP:
+					if bi_list[i].dir == Chan_BI_DIR.UP:
+						last_seg_peak = last_seg_bi.high
+						if bi_list[i].high > last_seg_peak:
+							# The confirmed
+							print("Last UP seg is broken, create a new seg. 1")
+							seg.pre_set_end_bi(bi_list[i])
+							seg = ChanSEG(bi_list[i+1], len(seg_list), Chan_SEG_DIR.DOWN, bi)
+							seg_list.append(seg)
+							last_seg = seg_list[-2]
+							if len(last_seg.bi_list) > 3:
+								last_seg_bi = last_seg.bi_list[-3]
+
+				else:
+					if bi_list[i].dir == Chan_BI_DIR.DOWN:
+						last_seg_peak = last_seg_bi.low
+						if bi_list[i].low < last_seg_peak:
+							print("Last DOWN seg is broken, create a new seg. 1")
+							seg.pre_set_end_bi(bi_list[i])
+							seg = ChanSEG(bi_list[i+1], len(seg_list), Chan_SEG_DIR.UP, bi)
+							seg_list.append(seg)
+							last_seg = seg_list[-2]
+							if len(last_seg.bi_list) > 3:
+								last_seg_bi = last_seg.bi_list[-3]
+		else:
+			if len(seg_list) == 1:
+				last_seg = seg_list[-1]
+				bi_index = last_seg.bi_list[0].index
+				for i in range(bi_index, len(bi_list) - 1):
+					if i > bi_index + 2:
+						last_seg_peak = bi_list[i-2].high
+						# last seg is down
+						if last_seg.dir == Chan_SEG_DIR.DOWN:
+							if bi_list[i].dir == Chan_BI_DIR.UP:
+								if bi_list[i].high > last_seg_peak:
+									print("Last seg is broken, create a new seg. 2")
+									last_seg.pre_set_end_bi(bi_list[i-1])
+									seg = ChanSEG(bi_list[i], len(seg_list), Chan_SEG_DIR.UP, bi)
+									seg_list.append(seg)
+									last_seg = seg
+									last_seg_bi = bi_list[i]
+									break
+		"""
+		#self.cal_bi_zs(seg_list)
+		return seg_list

chanlun/pipeline/builders/zs.py

@@ -0,0 +1,702 @@
+"""TF_DF builder mixin — 由 split_tfdf_builders 自动生成，逻辑与原 TF_DF 一致。"""
+from __future__ import annotations
+
+from datetime import timedelta
+from decimal import Decimal
+
+import numpy as np
+import pandas as pd
+from pandas import DataFrame
+
+from chanlun.core.ChanBI import ChanBI
+from chanlun.core.ChanBIZS import ChanBIZS
+from chanlun.core.ChanBSP import ChanBSP
+from chanlun.core.ChanEnum import (
+    Chan_BI_DIR,
+    Chan_BSP_DIR,
+    Chan_BSP_TYPE,
+    Chan_FX_TYPE,
+    Chan_K_DIR,
+    Chan_KLC_FX,
+    Chan_KLC_STATE,
+    Chan_KLINE_DIR,
+    Chan_KLU_PATTERN,
+    Chan_PRICE_TREND,
+    Chan_SEG_DIR,
+    Chan_ZS_DIR,
+)
+from chanlun.core.ChanKLC import ChanKLC
+from chanlun.core.ChanKLU import ChanKLU
+from chanlun.core.ChanSBI import ChanSBI
+from chanlun.core.ChanSEG import ChanSEG
+from chanlun.core.ChanZS import ChanZS, ChanZS_Big
+from chanlun.indicators.ChanMACD import ChanMACD
+
+
+class ZsBuilderMixin:
+	def get_zs_state(self, df):
+		bi_list = self.cal_bi_list(self.get_klc_list(self.get_kl_data(df)))
+		seg_list = self.get_seg_list(bi_list)
+		zs_list = self.calculate_zs(seg_list)
+		for zs in zs_list:
+			last_zs = zs
+		return zs_list
+
+	def cal_bi_zs(self, seg_list):
+		bi_zs_list = []
+		for seg in seg_list:
+			zs_list = seg.cal_bi_zs()
+			if len(zs_list) > 0:
+				bi_zs_list = list(bi_zs_list) + list(zs_list)
+		return bi_zs_list
+	# 跨段不相连的中枢
+
+	def cal_bi_zs_list(self, bi_list):
+		"""
+		根据缠论笔中枢定义计算中枢（参照 get_zs_list 线段中枢判断规则）
+		从第4根笔开始（索引3），每3根笔为一组检查
+		上涨中枢：后中枢 zd > 前中枢 zg（不重叠上移）
+		下跌中枢：后中枢 zg < 前中枢 zd（不重叠下移）
+		中枢可按两笔一组继续扩展到5根、7根...
+		"""
+		bi_zs_list = []
+		if len(bi_list) < 3:
+			return bi_zs_list
+
+		last_zs = None
+		start_idx = 3
+
+		while start_idx < len(bi_list):
+			if start_idx + 2 >= len(bi_list):
+				break
+
+			bi1 = bi_list[start_idx]
+			bi2 = bi_list[start_idx + 1]
+			bi3 = bi_list[start_idx + 2]
+
+			if not (bi1.is_sure and bi2.is_sure and bi3.is_sure):
+				start_idx += 1
+				continue
+
+			zg = min(bi1.high, bi2.high, bi3.high)
+			zd = max(bi1.low, bi2.low, bi3.low)
+
+			if zg <= zd:
+				start_idx += 1
+				continue
+
+			valid = False
+			if last_zs is None:
+				if bi1.dir == Chan_BI_DIR.DOWN:
+					zs_dir = Chan_ZS_DIR.UP
+					valid = (bi2.dir == Chan_BI_DIR.UP and bi3.dir == Chan_BI_DIR.DOWN)
+				else:
+					zs_dir = Chan_ZS_DIR.DOWN
+					valid = (bi2.dir == Chan_BI_DIR.DOWN and bi3.dir == Chan_BI_DIR.UP)
+			else:
+				is_up_zs = zg > last_zs.zg
+				is_down_zs = zd < last_zs.zd
+
+				if is_up_zs:
+					zs_dir = Chan_ZS_DIR.UP
+					valid = (bi1.dir == Chan_BI_DIR.DOWN and bi2.dir == Chan_BI_DIR.UP and bi3.dir == Chan_BI_DIR.DOWN)
+				elif is_down_zs:
+					zs_dir = Chan_ZS_DIR.DOWN
+					valid = (bi1.dir == Chan_BI_DIR.UP and bi2.dir == Chan_BI_DIR.DOWN and bi3.dir == Chan_BI_DIR.UP)
+
+			if not valid:
+				start_idx += 1
+				continue
+			gg = max(bi1.high, bi2.high, bi3.high)
+			dd = min(bi1.low, bi2.low, bi3.low)
+			zs = ChanBIZS(bi1, len(bi_zs_list), zs_dir)
+			zs.set_zg(zg)
+			zs.set_zd(zd)
+			zs.set_gg(gg)
+			zs.set_dd(dd)
+			zs.is_sure = False
+			zs.bi_list = [bi1, bi2, bi3]
+
+			added_after_leave = []
+			leave_index = start_idx + 4
+			while leave_index < len(bi_list):
+				b = bi_list[leave_index]
+				if not b.is_sure:
+					break
+				if b.high >= zs.zd and b.low <= zs.zg:
+					added_after_leave.append(b.pre)
+					added_after_leave.append(b)
+				else:
+					break
+				leave_index += 2
+
+			if added_after_leave:
+				bis_for_zs = list(zs.bi_list) + list(added_after_leave)
+				bi_highs = [bi.high for bi in bis_for_zs]
+				bi_lows = [bi.low for bi in bis_for_zs]
+				zs.set_gg(max(bi_highs))
+				zs.set_dd(min(bi_lows))
+				zs.bi_list = bis_for_zs
+				bi = bis_for_zs[-1]
+				if bi.is_sure:
+					zs.set_end_bi(bi, bi.sure_time)
+
+				start_idx = start_idx + len(added_after_leave)
+			else:
+				zs.set_end_bi(bi3, bi3.sure_time)
+
+			if last_zs:
+				last_zs.set_next(zs)
+				zs.set_pre(last_zs)
+
+			bi_zs_list.append(zs)
+			last_zs = zs
+
+			start_idx += 4
+
+		if last_zs:
+			last_zs.is_sure = bi_list[-1].is_sure
+
+		if last_zs and not last_zs.is_sure:
+			if last_zs.bi_list and len(last_zs.bi_list) > 0:
+				last_bi_of_zs = last_zs.bi_list[-1]
+				last_bi_idx = -1
+				for i, bi in enumerate(bi_list):
+					if bi == last_bi_of_zs:
+						last_bi_idx = i
+						break
+
+				has_leave = False
+				if last_bi_idx >= 0 and last_bi_idx + 1 < len(bi_list):
+					for i in range(last_bi_idx + 1, len(bi_list)):
+						bi = bi_list[i]
+						if bi.is_sure:
+							leave = (bi.low > last_zs.zg and bi.high > last_zs.zg) or \
+									(bi.high < last_zs.zd and bi.low < last_zs.zd)
+							if leave:
+								has_leave = True
+								break
+
+				if has_leave:
+					if last_bi_of_zs.is_sure:
+						last_zs.set_end_bi(last_bi_of_zs, last_bi_of_zs.sure_time)
+		return bi_zs_list
+
+	def get_bi_zs_list(self, bi_list):
+		"""
+		根据缠论笔中枢定义计算中枢（完全参照 get_seg_zs_list 线段中枢判断规则）
+		从第4根笔开始（索引3），每3根笔为一组检查
+		上涨中枢：后中枢 zd > 前中枢 zg（不重叠上移）
+		下跌中枢：后中枢 zg < 前中枢 zd（不重叠下移）
+		盘整/扩张：后中枢与前中枢整体区间有交集 → 合并扩展
+		中枢可按两笔一组继续扩展到5根、7根...
+		"""
+		bi_zs_list = []
+		if len(bi_list) < 3:
+			return bi_zs_list
+
+		last_zs = None
+		start_idx = 3
+
+		while start_idx < len(bi_list):
+			if start_idx + 2 >= len(bi_list):
+				break
+
+			bi1 = bi_list[start_idx]
+			bi2 = bi_list[start_idx + 1]
+			bi3 = bi_list[start_idx + 2]
+
+			if not (bi1.is_sure and bi2.is_sure and bi3.is_sure):
+				start_idx += 1
+				continue
+
+			zg = min(bi1.high, bi2.high, bi3.high)
+			zd = max(bi1.low, bi2.low, bi3.low)
+
+			if zg <= zd:
+				start_idx += 1
+				continue
+
+			valid = False
+			if last_zs is None:
+				if bi1.dir == Chan_BI_DIR.DOWN:
+					zs_dir = Chan_ZS_DIR.UP
+					valid = (bi2.dir == Chan_BI_DIR.UP and bi3.dir == Chan_BI_DIR.DOWN)
+				else:
+					zs_dir = Chan_ZS_DIR.DOWN
+					valid = (bi2.dir == Chan_BI_DIR.DOWN and bi3.dir == Chan_BI_DIR.UP)
+			else:
+				is_up_zs = zd > last_zs.zg
+				is_down_zs = zg < last_zs.zd
+
+				if is_up_zs:
+					zs_dir = Chan_ZS_DIR.UP
+					valid = (bi1.dir == Chan_BI_DIR.DOWN and bi2.dir == Chan_BI_DIR.UP and bi3.dir == Chan_BI_DIR.DOWN)
+				elif is_down_zs:
+					zs_dir = Chan_ZS_DIR.DOWN
+					valid = (bi1.dir == Chan_BI_DIR.UP and bi2.dir == Chan_BI_DIR.DOWN and bi3.dir == Chan_BI_DIR.UP)
+
+			create_new_zs = False
+			if not valid:
+				# 如果新中枢和前一个中枢的中枢区间有重叠，不形成新中枢，合并扩展
+				if last_zs is not None:
+					is_in_last_zs = (zd > last_zs.zd and zd < last_zs.zg) or \
+									(zg < last_zs.zg and zg > last_zs.zd) or \
+									(zg > last_zs.zg and zd < last_zs.zd) or \
+									(zg < last_zs.zg and zd > last_zs.zd)
+					if is_in_last_zs:
+						# 扩展当前中枢：将 bi1-bi3 加入 last_zs
+						for bi in [bi1, bi2, bi3]:
+							if bi not in last_zs.bi_list:
+								last_zs.add_bi(bi)
+						create_new_zs = False
+					else:
+						start_idx += 1
+						continue
+				else:
+					start_idx += 1
+					continue
+			else:
+				create_new_zs = True
+
+			# 新中枢形成时确认前一个中枢
+			if last_zs and create_new_zs:
+				last_bi = last_zs.bi_list[-1]
+				if last_bi and last_bi.is_sure:
+					last_zs.is_sure = True
+					last_zs.set_end_bi(last_bi, last_bi.sure_time)
+
+			zs = last_zs
+			if create_new_zs:
+				gg = max(bi1.high, bi2.high, bi3.high)
+				dd = min(bi1.low, bi2.low, bi3.low)
+				zs = ChanBIZS(bi1, len(bi_zs_list), zs_dir)
+				zs.set_zg(zg)
+				zs.set_zd(zd)
+				zs.set_gg(gg)
+				zs.set_dd(dd)
+				zs.is_sure = False
+				zs.bi_list = [bi1, bi2, bi3]
+
+			# 离开后回抽扩展检查
+			added_after_leave = []
+			leave_index = start_idx + 4
+			while leave_index < len(bi_list):
+				b = bi_list[leave_index]
+				if not b.is_sure:
+					break
+				if b.high >= zs.zd and b.low <= zs.zg:
+					added_after_leave.append(b.pre)
+					added_after_leave.append(b)
+				else:
+					break
+				leave_index += 2
+
+			if added_after_leave:
+				bis_for_zs = list(zs.bi_list) + list(added_after_leave)
+				bi_highs = [bi.high for bi in bis_for_zs]
+				bi_lows = [bi.low for bi in bis_for_zs]
+				zs.set_gg(max(bi_highs))
+				zs.set_dd(min(bi_lows))
+				zs.bi_list = bis_for_zs
+				bi = bis_for_zs[-1]
+				if bi.is_sure:
+					zs.set_end_bi(bi, bi.sure_time)
+				start_idx = start_idx + len(added_after_leave)
+			else:
+				if create_new_zs:
+					zs.set_end_bi(bi3, bi3.sure_time)
+
+			if create_new_zs:
+				if last_zs:
+					last_zs.set_next(zs)
+					zs.set_pre(last_zs)
+				bi_zs_list.append(zs)
+				last_zs = zs
+
+			start_idx += 4
+
+		# 最后一个中枢：根据 bi_list 最后一笔确认状态
+		if last_zs:
+			last_zs.is_sure = bi_list[-1].is_sure
+
+		if last_zs and not last_zs.is_sure:
+			if last_zs.bi_list and len(last_zs.bi_list) > 0:
+				last_bi_of_zs = last_zs.bi_list[-1]
+				last_bi_idx = -1
+				for i, bi in enumerate(bi_list):
+					if bi == last_bi_of_zs:
+						last_bi_idx = i
+						break
+
+				has_leave = False
+				if last_bi_idx >= 0 and last_bi_idx + 1 < len(bi_list):
+					for i in range(last_bi_idx + 1, len(bi_list)):
+						bi = bi_list[i]
+						if bi.is_sure:
+							leave = (bi.low > last_zs.zg and bi.high > last_zs.zg) or \
+									(bi.high < last_zs.zd and bi.low < last_zs.zd)
+							if leave:
+								has_leave = True
+								break
+
+				if has_leave:
+					if last_bi_of_zs.is_sure:
+						last_zs.set_end_bi(last_bi_of_zs, last_bi_of_zs.sure_time)
+
+		return bi_zs_list
+
+
+	def cal_bi_zs_list_pure(self, bi_list):
+		bi_zs_list = []
+		if len(bi_list) < 3:
+			return bi_zs_list
+
+		def get_zs_range(bis):
+			bis_list = bis[0:3]
+			zg = min(bi.high for bi in bis_list)
+			zd = max(bi.low for bi in bis_list)
+			dd = min(bi.low for bi in bis_list)
+			gg = max(bi.high for bi in bis_list)
+			return zg, zd, dd, gg
+
+		def is_bi_overlap_range(bi, zg, zd):
+			return bi.high >= zd and bi.low <= zg
+
+		def check_zs_position_filter(last_zs, zg, zd, bis):
+			if last_zs is None:
+				return True
+			if zg <= last_zs.zd:
+				return bis[0].dir == Chan_BI_DIR.UP and bis[-1].dir == Chan_BI_DIR.UP
+			if zd >= last_zs.zg:
+				return bis[0].dir == Chan_BI_DIR.DOWN and bis[-1].dir == Chan_BI_DIR.DOWN
+			return True
+
+		def set_zs_bi_list(zs, bis):
+			zs.bi_list = list(bis)
+			for bi in zs.bi_list:
+				bi.set_bi_zs(zs)
+			#zs.set_gg(max(bi.high for bi in zs.bi_list))
+			#zs.set_dd(min(bi.low for bi in zs.bi_list))
+			zs.classify_zs()
+
+		last_zs = None
+		start_idx = 0
+		while start_idx + 2 < len(bi_list):
+			bi1 = bi_list[start_idx]
+			bi2 = bi_list[start_idx + 1]
+			bi3 = bi_list[start_idx + 2]
+
+			if not (bi1.is_sure and bi2.is_sure and bi3.is_sure):
+				start_idx += 1
+				continue
+
+			if not (bi1.dir != bi2.dir and bi1.dir == bi3.dir):
+				start_idx += 1
+				continue
+
+			zg, zd, dd, gg = get_zs_range([bi1, bi2, bi3])
+			if zg <= zd:
+				start_idx += 1
+				continue
+
+			bis_for_zs = [bi1, bi2, bi3]
+			extend_idx = start_idx + 3
+			while extend_idx + 1 < len(bi_list):
+				leave_bi = bi_list[extend_idx]
+				back_bi = bi_list[extend_idx + 1]
+				if not (leave_bi.is_sure and back_bi.is_sure):
+					break
+				if not is_bi_overlap_range(back_bi, zg, zd):
+					break
+				bis_for_zs.append(leave_bi)
+				bis_for_zs.append(back_bi)
+				extend_idx += 2
+
+			if not check_zs_position_filter(last_zs, zg, zd, bis_for_zs):
+				start_idx += 1
+				continue
+
+			zs_dir = Chan_ZS_DIR.UP if bi1.dir == Chan_BI_DIR.DOWN else Chan_ZS_DIR.DOWN
+			zs = ChanBIZS(bi1, len(bi_zs_list), zs_dir)
+			zs.set_zg(zg)
+			zs.set_zd(zd)
+			zs.set_dd(dd)
+			zs.set_gg(gg)
+
+			set_zs_bi_list(zs, bis_for_zs)
+			zs.set_end_bi(bis_for_zs[-1], bis_for_zs[-1].sure_time)
+
+			if last_zs:
+				last_zs.set_next(zs)
+				zs.set_pre(last_zs)
+
+			bi_zs_list.append(zs)
+			last_zs = zs
+			start_idx = start_idx + len(bis_for_zs)
+
+		# 与 cal_bi_zs_list 一致：最后一笔未确认时末中枢标为未完成；若其后已出现确认的离开笔，仍按离开前最后一笔确认中枢结束
+		if last_zs:
+			last_zs.is_sure = bi_list[-1].is_sure
+
+		if last_zs and not last_zs.is_sure:
+			if last_zs.bi_list and len(last_zs.bi_list) > 0:
+				last_bi_of_zs = last_zs.bi_list[-1]
+				last_bi_idx = -1
+				for i, bi in enumerate(bi_list):
+					if bi == last_bi_of_zs:
+						last_bi_idx = i
+						break
+
+				has_leave = False
+				if last_bi_idx >= 0 and last_bi_idx + 1 < len(bi_list):
+					for i in range(last_bi_idx + 1, len(bi_list)):
+						bi = bi_list[i]
+						if bi.is_sure:
+							leave = (bi.low > last_zs.zg and bi.high > last_zs.zg) or \
+									(bi.high < last_zs.zd and bi.low < last_zs.zd)
+							if leave:
+								has_leave = True
+								break
+
+				if has_leave:
+					if last_bi_of_zs.is_sure:
+						last_zs.set_end_bi(last_bi_of_zs, last_bi_of_zs.sure_time)
+
+		return bi_zs_list
+
+	def get_zs_list(self, bi_list, seg_list):
+		"""兼容历史 API：线段中枢列表。"""
+		return self.get_seg_zs_list(seg_list)
+
+	def calculate_seg_zs(self, seg_list):
+		return self.get_seg_zs_list(seg_list)
+
+	def get_seg_zs_list(self, seg_list):
+		"""
+		根据缠论线段中枢定义计算中枢
+		从第4根线段开始（索引3），每3根线段为一组检查
+		上涨中枢：后中枢 zd > 前中枢 zg（不重叠上移）
+		下跌中枢：后中枢 zg < 前中枢 zd（不重叠下移）
+		盘整/扩张：后中枢与前中枢整体区间（GG/DD）有交集
+		中枢可按两段一组继续扩展到5根、7根...
+		"""
+		zs_list = []
+		if len(seg_list) < 3:
+			return zs_list
+
+		last_zs = None
+
+		# 从第4根线段开始（索引3），每3根为一组
+		start_idx = 3
+
+		while start_idx < len(seg_list):
+			# 取连续3个线段
+			if start_idx + 2 >= len(seg_list):
+				break
+
+			seg1 = seg_list[start_idx]
+			seg2 = seg_list[start_idx + 1]
+			seg3 = seg_list[start_idx + 2]
+
+			# 三个线段都必须是已确认的
+			if not (seg1.is_sure and seg2.is_sure and seg3.is_sure):
+				start_idx += 1
+				continue
+
+			# 计算这3个线段的中枢区间
+			zg = min(seg1.high, seg2.high, seg3.high)
+			zd = max(seg1.low, seg2.low, seg3.low)
+
+			if zg <= zd:
+				start_idx += 1
+				#print(seg1.start_bi.start_klc.end_time, "not valid", zg, zd)
+				continue
+
+			# 判断中枢类型（按注释定义）
+			# 上涨中枢：后中枢 zd > 前中枢 zg（不重叠上移）
+			# 下跌中枢：后中枢 zg < 前中枢 zd（不重叠下移）
+			# 盘整/扩张：后中枢与前中枢区间有交集
+			if last_zs is None:
+				# 第一个中枢仅按线段形态判定方向
+				if seg1.dir == Chan_SEG_DIR.DOWN:
+					# 下跌+上涨+下跌，对应上涨中枢
+					zs_dir = Chan_ZS_DIR.UP
+					valid = (seg2.dir == Chan_SEG_DIR.UP and seg3.dir == Chan_SEG_DIR.DOWN)
+				else:
+					# 上涨+下跌+上涨，对应下跌中枢
+					zs_dir = Chan_ZS_DIR.DOWN
+					valid = (seg2.dir == Chan_SEG_DIR.DOWN and seg3.dir == Chan_SEG_DIR.UP)
+			else:
+				is_up_zs = zd > last_zs.zg
+				is_down_zs = zg < last_zs.zd
+
+				if is_up_zs:
+					# 不重叠上移
+					zs_dir = Chan_ZS_DIR.UP
+					valid = (seg1.dir == Chan_SEG_DIR.DOWN and seg2.dir == Chan_SEG_DIR.UP and seg3.dir == Chan_SEG_DIR.DOWN)
+				elif is_down_zs:
+					# 不重叠下移
+					zs_dir = Chan_ZS_DIR.DOWN
+					valid = (seg1.dir == Chan_SEG_DIR.UP and seg2.dir == Chan_SEG_DIR.DOWN and seg3.dir == Chan_SEG_DIR.UP)
+			create_new_zs = False
+			# 验证是否有效
+			if not valid:
+				# 如果新中枢和前一个中枢的中枢区间有重叠，不行成新中枢需要合并两个中枢
+				is_in_last_zs = (zd > last_zs.zd and zd < last_zs.zg) or (zg < last_zs.zg and zg > last_zs.zd) or (zg > last_zs.zg and zd < last_zs.zd) or (zg < last_zs.zg and zd > last_zs.zd)
+				if is_in_last_zs:
+					#print(seg1.start_time, "New zs is in last zs, not valid")
+					last_zs.extend_zs(seg_list[last_zs.seg_list[-1].index:(seg3.index + 1)])
+					create_new_zs = False
+				else:
+					start_idx += 1
+					continue
+			else:
+				create_new_zs = True
+			if last_zs and create_new_zs:
+				last_seg = last_zs.seg_list[-1]
+				last_bi = last_seg.end_bi
+				if last_bi:
+					last_zs.is_sure = True
+					last_zs.set_end_klc(last_bi.end_klc, last_bi.sure_time, 0, last_seg)
+					last_zs.set_end_seg(last_seg)
+			zs = last_zs
+			if create_new_zs:
+				# 创建新中枢
+				gg = max(seg1.high, seg2.high, seg3.high)
+				dd = min(seg1.low, seg2.low, seg3.low)
+
+				zs = ChanZS(seg1, len(zs_list), zs_dir)
+				zs.set_zg(zg)
+				zs.set_zd(zd)
+				zs.set_gg(gg)
+				zs.set_dd(dd)
+				zs.is_sure = False
+				zs.seg_list = [seg1, seg2, seg3]
+			# 若第二线段与 [zd,zg] 重叠（如离开后回抽回到前中枢）则并入扩展
+			added_after_leave = []
+			leave_index = start_idx + 4
+			is_break = False
+			while leave_index < len(seg_list):
+				s = seg_list[leave_index]
+				if not s.is_sure:
+					break
+				sh = max(s.start_bi.high, s.end_bi.high) if s.end_bi else s.start_bi.high
+				sl = min(s.start_bi.low, s.end_bi.low) if s.end_bi else s.start_bi.low
+				if sh >= zs.zd and sl <= zs.zg:
+					added_after_leave.append(s.pre)
+					added_after_leave.append(s)
+					leave_index += 2
+				else:
+					next_seg = s.next
+					if next_seg and next_seg.is_sure:
+						if next_seg.dir == Chan_SEG_DIR.UP:
+							if next_seg.high <= zs.zg and next_seg.low >= zs.zd:
+								leave_index += 2
+								continue
+							else:
+								is_break = True
+						else:
+							if next_seg.low >= zs.zd and next_seg.low <= zs.zg:
+								leave_index += 2
+								continue
+							else:
+								is_break = True
+					else:
+						break
+				if is_break:
+					break
+			if added_after_leave:
+				#print(len(added_after_leave))
+				segs_for_zs = list(zs.seg_list) + list(added_after_leave)
+				seg_highs = [s.high for s in segs_for_zs]
+				seg_lows = [s.low for s in segs_for_zs]
+				zs.set_gg(max(seg_highs))
+				zs.set_dd(min(seg_lows))
+				zs.seg_list = segs_for_zs
+				seg = segs_for_zs[-1]
+				#if seg.end_bi:
+					#zs.set_end_klc(seg.end_bi.end_klc, seg.sure_time, 0, seg)
+					#zs.set_end_seg(seg)
+					#zs.is_sure = True
+				start_idx = start_idx + len(added_after_leave)
+			if last_zs and last_zs.index != zs.index:
+				last_zs.set_next(zs)
+				zs.set_pre(last_zs)
+
+			zs_list.append(zs)
+			last_zs = zs
+
+			# 移动到下一组
+			start_idx += 4
+		if last_zs:
+			last_zs.is_sure = seg_list[-1].is_sure
+		"""
+		# 处理最后一个未确认的中枢 - 不自动扩展，保持未完成状态
+		if last_zs and not last_zs.is_sure:
+			# 获取中枢最后一个线段的索引
+			if last_zs.seg_list and len(last_zs.seg_list) > 0:
+				last_seg_of_zs = last_zs.seg_list[-1]
+				# 找到这个线段在seg_list中的索引
+				last_seg_idx = -1
+				for i, seg in enumerate(seg_list):
+					if seg == last_seg_of_zs:
+						last_seg_idx = i
+						break
+
+				# 从中枢最后一个线段之后检查是否有离开
+				has_leave = False
+				if last_seg_idx >= 0 and last_seg_idx + 1 < len(seg_list):
+					for i in range(last_seg_idx + 1, len(seg_list)):
+						seg = seg_list[i]
+						if seg.is_sure:
+							# 检查是否离开中枢
+							leave = (seg.low > last_zs.zg and seg.high > last_zs.zg) or \
+									(seg.high < last_zs.zd and seg.low < last_zs.zd)
+							if leave:
+								has_leave = True
+								break
+
+				if not has_leave:
+					# 没有离开，保持未完成状态
+					pass
+				else:
+					# 有离开，确认中枢
+					if last_seg_of_zs.end_bi:
+						#print(last_seg_of_zs.start_time, "last_seg_of_zs.end_time", last_seg_of_zs.end_time)
+						last_zs.set_end_klc(last_seg_of_zs.end_bi.end_klc, last_seg_of_zs.sure_time, 0, last_seg_of_zs)
+						last_zs.set_end_seg(last_seg_of_zs)
+						last_zs.is_sure = True
+		"""
+		return zs_list
+
+
+	def get_big_zs_list(self, zs_list):
+		"""
+		中枢扩张：将区间重叠的连续中枢合并为大级别中枢，便于显示更大级别的震荡区间。
+		重叠定义：两中枢 [zd,zg] 有交集，即 (zs_i.zg >= zs_j.zd and zs_i.zd <= zs_j.zg)。
+		"""
+		big_list = []
+		if len(zs_list) < 2:
+			return big_list
+		i = 0
+		while i < len(zs_list):
+			group = [zs_list[i]]
+			j = i + 1
+			while j < len(zs_list):
+				cur = zs_list[j]
+				# 与当前组内任一中枢有重叠即算扩张（通常只需与组内最后一个比）
+				last_in_group = group[-1]
+				overlap = (last_in_group.zg >= cur.zd and last_in_group.zd <= cur.zg)
+				if overlap:
+					group.append(cur)
+					j += 1
+				else:
+					break
+			if len(group) >= 2:
+				big = ChanZS_Big(group)
+				big.index = len(big_list)
+				big_list.append(big)
+			i = j if len(group) >= 2 else i + 1
+		return big_list
+

chanlun/pipeline/orchestrator.py

@@ -9,21 +9,20 @@ warnings.filterwarnings(
 
 from datetime import timedelta
 from pandas import DataFrame
-from ChanEnum import Chan_FX_TYPE, Chan_KLINE_DIR, Chan_BI_DIR, Chan_SEG_DIR, Chan_ZS_DIR, Chan_BSP_DIR, Chan_BSP_TYPE, Chan_KLC_FX, Chan_MACD_STATE, Chan_PRICE_TREND, Chan_KLU_PATTERN
-from ChanKLU import ChanKLU
-from ChanKLC import ChanKLC
-from ChanBI import ChanBI
-from ChanSBI import ChanSBI
-from ChanSEG import ChanSEG
-from ChanZS import ChanZS
-from ChanBSP import ChanBSP
-import talib.abstract as ta
+from chanlun.core.ChanEnum import Chan_FX_TYPE, Chan_KLINE_DIR, Chan_BI_DIR, Chan_SEG_DIR, Chan_ZS_DIR, Chan_BSP_DIR, Chan_BSP_TYPE, Chan_KLC_FX, Chan_MACD_STATE, Chan_PRICE_TREND, Chan_KLU_PATTERN
+from chanlun.core.ChanKLU import ChanKLU
+from chanlun.core.ChanKLC import ChanKLC
+from chanlun.core.ChanBI import ChanBI
+from chanlun.core.ChanSBI import ChanSBI
+from chanlun.core.ChanSEG import ChanSEG
+from chanlun.core.ChanZS import ChanZS
+from chanlun.core.ChanBSP import ChanBSP
 import pandas as pd
-from technical.util import resample_to_interval
 from decimal import Decimal
 import numpy as np
-from ChanMACD import ChanMACD
-from TF_DF import TF_DF
+from chanlun.indicators.ChanMACD import ChanMACD
+from chanlun.pipeline.timeframe import TF_DF
+from chanlun.analysis.ChanZone import StructureZone, StructureZoneConfig, analyze_structure_zones
 
 class ChanLun():
 	def __init__(self):
@@ -125,7 +124,18 @@ class ChanLun():
  
  
  
- 
+	def get_bsp_state(self, dataframe):
+		return self.tf_df.get_bsp_state(dataframe)
+
+	def get_structure_zones(self, current_price=None, config=None):
+		if config is None:
+			config = StructureZoneConfig()
+		return analyze_structure_zones(
+			self.tf_df_dict,
+			self.ema_symbols,
+			current_price=current_price,
+			config=config,
+		)
  	# TF_DF methods ------------------------------------------
 	def get_ema_state(self, dataframe):
 		return self.tf_df.get_ema_state(dataframe)
@@ -159,6 +169,8 @@ class ChanLun():
 		return self.tf_df.find_second_bsp(bi_list, first_bsp_list)
 	def find_all_bsp(self, bi_list, bi_zs_list):
 		return self.tf_df.find_all_bsp(bi_list, bi_zs_list)
+	def cal_fast_bsp(self, df=None, bi_zs_list=None, htf_chan=None, with_htf=True, timeframe=None, **kw):
+		return self.tf_df.cal_fast_bsp(df, bi_zs_list, htf_chan, with_htf, timeframe, **kw)
 	def get_zs_list(self, bi_list, seg_list):
 		return self.tf_df.get_zs_list(bi_list, seg_list)
 	def cal_bi_zs(self, seg_list):
@@ -166,6 +178,17 @@ class ChanLun():
 	def cal_bi_zs_list(self, bi_list):
 		#return self.tf_df.cal_bi_zs(bi_list)
 		return self.tf_df.cal_bi_zs_list(bi_list)
+	def cal_bi_zs_list_pure(self, bi_list):
+		return self.tf_df.cal_bi_zs_list_pure(bi_list)
+	def init_stream(self, dataframe, interval=1, timeframe=None):
+		self.tf_df.init_stream(dataframe, interval, timeframe)
+		return self.tf_df
+	def append_bar(self, row):
+		return self.tf_df.append_bar(row)
+	def replace_last_bar(self, row):
+		return self.tf_df.replace_last_bar(row)
+	def get_bi_zs_list(self, bi_list):
+		return self.tf_df.get_bi_zs_list(bi_list)
 	def get_decimal(self, value):
 		return Decimal("{:.2f}".format(value))
 	def get_klc_list(self, klu_list):

chanlun/pipeline/resample.py

@@ -0,0 +1,52 @@
+"""OHLCV resampling — replaces `technical.util.resample_to_interval`.
+
+That was the only symbol this project imported from `technical`, which in turn
+pulled in the freqtrade dependency chain. Behaviour is preserved exactly,
+including the left-labelled bins (rows are candle *open* times) and the
+`dropna()` that drops empty intervals.
+"""
+
+from __future__ import annotations
+
+import pandas as pd
+
+__all__ = ["TICKER_INTERVAL_MINUTES", "resample_to_interval"]
+
+TICKER_INTERVAL_MINUTES: dict[str, int] = {
+    "1m": 1,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+    "60m": 60,
+    "2h": 120,
+    "4h": 240,
+    "6h": 360,
+    "12h": 720,
+    "1d": 1440,
+    "1w": 10080,
+}
+
+_OHLC_AGG = {
+    "open": "first",
+    "high": "max",
+    "low": "min",
+    "close": "last",
+    "volume": "sum",
+}
+
+
+def resample_to_interval(dataframe: pd.DataFrame, interval: int | str) -> pd.DataFrame:
+    """Resample OHLCV rows to `interval` minutes (or a timeframe string).
+
+    Merging the result back onto a finer frame requires care to avoid lookahead
+    bias; this function only resamples.
+    """
+    if isinstance(interval, str):
+        interval = TICKER_INTERVAL_MINUTES[interval]
+
+    df = dataframe.copy()
+    df = df.set_index(pd.DatetimeIndex(df["date"]))
+    df = df.resample(f"{interval}min", label="left").agg(_OHLC_AGG).dropna()
+    df.reset_index(inplace=True)
+    return df

chanlun/pipeline/timeframe.py

@@ -0,0 +1,97 @@
+from datetime import timedelta
+
+import numpy as np
+import pandas as pd
+from pandas import DataFrame
+from chanlun.pipeline.resample import resample_to_interval
+
+from chanlun.core.ChanBI import ChanBI
+from chanlun.core.ChanBIZS import ChanBIZS
+from chanlun.core.ChanBSP import ChanBSP
+from chanlun.core.ChanEnum import (
+    Chan_BI_DIR,
+    Chan_BSP_DIR,
+    Chan_BSP_TYPE,
+    Chan_FX_TYPE,
+    Chan_K_DIR,
+    Chan_KLC_FX,
+    Chan_KLC_STATE,
+    Chan_KLINE_DIR,
+    Chan_KLU_PATTERN,
+    Chan_PRICE_TREND,
+    Chan_SEG_DIR,
+    Chan_ZS_DIR,
+)
+from chanlun.core.ChanKLC import ChanKLC
+from chanlun.core.ChanKLU import ChanKLU
+from chanlun.core.ChanSBI import ChanSBI
+from chanlun.core.ChanSEG import ChanSEG
+from chanlun.core.ChanZS import ChanZS, ChanZS_Big
+from chanlun.indicators.ChanMACD import ChanMACD
+from chanlun.pipeline.builders.bi import BiBuilderMixin
+from chanlun.pipeline.builders.bsp import BspBuilderMixin
+from chanlun.pipeline.builders.fast_bsp import FastBspBuilderMixin
+from chanlun.pipeline.builders.incremental import IncrementalBuilderMixin
+from chanlun.pipeline.builders.indicators import IndicatorsBuilderMixin
+from chanlun.pipeline.builders.kline import KlineBuilderMixin
+from chanlun.pipeline.builders.seg import SegBuilderMixin
+from chanlun.pipeline.builders.zs import ZsBuilderMixin
+
+class TF_DF(IndicatorsBuilderMixin, KlineBuilderMixin, BiBuilderMixin, SegBuilderMixin, ZsBuilderMixin, BspBuilderMixin, FastBspBuilderMixin, IncrementalBuilderMixin):
+	def __init__(self, df=None, interval=0, timeframe=None, lean=False):
+		"""lean=True 只构建到中枢，跳过线段/走势中枢/MACD 状态机。
+
+		研究与实盘只吃 bi_list → 中枢 → fast_bsp 这条链；线段、zs、big_zs 和整套
+		MACD 背驰状态机是 web 展示与 bsp_list 才用的。实测这些占全量构建的约四成。
+		注意 lean 下 bsp_list/seg_list/chanmacd 均为空，**不要给 web 用**。
+		"""
+		self.lean = lean
+		if df is not None:
+			self.init_TF_DF(df, interval, timeframe, lean=lean)
+	def init_TF_DF(self, df, interval, timeframe, lean=False):
+		self.lean = lean
+		self.timeframe = timeframe
+		self.interval = interval
+		# 检查 DataFrame 是否为空或没有 date 列
+		if df is None or df.empty:
+			raise ValueError(f"DataFrame for {timeframe} is empty. Please download data first.")
+		if 'date' not in df.columns:
+			raise ValueError(f"DataFrame for {timeframe} missing 'date' column. Columns: {df.columns.tolist()}")
+		# interval=1 时不需要重采样
+		if interval == 1:
+			self.dataframe = df.copy()
+		else:
+			self.dataframe = resample_to_interval(df, interval)
+		#print(self.timeframe, len(self.dataframe))
+		self.dataframe = self.add_indicators(self.dataframe)
+		self.klu_list = []
+		self.klc_list = []
+		self.bi_list = []
+		self.zs_list = []
+		self.bi_zs_list = []
+		self.bsp_list = []
+		self.fast_bsp_list = []
+		self.seg_list = []
+		self.klc_fx_list = []
+		self.klu_list = self.cal_kl_data(self.dataframe)
+		self.klc_list = self.get_klc_list(self.klu_list)
+		self.bi_list = self.cal_bi_list(self.klc_list)
+		self.bi_zs_list = self.cal_bi_zs_list_pure(self.bi_list)
+		if self.lean:
+			self.big_zs_list = []
+			self.chanmacd = None
+			return
+		self.seg_list = self.get_seg_list(self.bi_list)
+		self.zs_list = self.get_zs_list(self.bi_list, self.seg_list)
+		self.big_zs_list = self.get_big_zs_list(self.zs_list)
+		# get_klc_list 内已算过 ChanMACD，直接复用
+		self.chanmacd = getattr(self, '_last_chan_macd', None)
+		if self.chanmacd is None:
+			self.chanmacd = ChanMACD(self.klu_list)
+		self.klu_list = self.chanmacd.klu_list
+	
+						
+	def get_current_klc(self):
+		if len(self.klc_list) > 0:
+			return self.klc_list[-2]
+		return None

chanlun/tests/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

chanlun/tests/test_incremental.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import sys
+import unittest
+from pathlib import Path
+
+import pandas as pd
+
+_CHAN = Path(__file__).resolve().parents[2]
+if str(_CHAN) not in sys.path:
+	sys.path.insert(0, str(_CHAN))
+
+from chanlun.pipeline.timeframe import TF_DF  # noqa: E402
+
+
+def _zigzag_df(n=160, step=8):
+	dates = pd.date_range("2024-01-01", periods=n, freq="5min")
+	rows = []
+	price = 100.0
+	for i, date in enumerate(dates):
+		up = (i // step) % 2 == 0
+		if up:
+			o = price
+			c = price + 1.5
+			h = c + 0.3
+			l = o - 0.2
+		else:
+			o = price
+			c = price - 1.5
+			h = o + 0.2
+			l = c - 0.3
+		price = c
+		rows.append(
+			{
+				"date": date,
+				"open": o,
+				"high": h,
+				"low": l,
+				"close": c,
+				"volume": 1.0,
+			}
+		)
+	return pd.DataFrame(rows)
+
+
+def _sure_bi_key(bi):
+	return (str(bi.start_time), bi.dir.name, round(float(bi.high), 6), round(float(bi.low), 6))
+
+
+def _zs_key(zs):
+	return (
+		str(zs.start_time),
+		round(float(zs.zg), 6),
+		round(float(zs.zd), 6),
+		len(zs.bi_list),
+	)
+
+
+class TestIncremental(unittest.TestCase):
+	def test_init_stream_matches_batch_push(self):
+		df = _zigzag_df()
+		stream = TF_DF()
+		stream.init_stream(df, 1, "5m")
+
+		batch = TF_DF()
+		indexed = batch.add_indicators(df.copy())
+		klu = batch.cal_kl_data(indexed)
+		klc = []
+		last = None
+		for k in klu:
+			batch._push_klu_into_klc_list(klc, k, last)
+			last = k
+		batch.klc_list = klc
+		batch.rebuild_bi_zs()
+
+		self.assertEqual(len(stream.klu_list), len(klu))
+		self.assertEqual(len(stream.klc_list), len(klc))
+		self.assertEqual(
+			[_sure_bi_key(b) for b in stream.bi_list if b.is_sure],
+			[_sure_bi_key(b) for b in batch.bi_list if b.is_sure],
+		)
+		self.assertEqual(
+			[_zs_key(z) for z in stream.bi_zs_list],
+			[_zs_key(z) for z in batch.bi_zs_list],
+		)
+
+	def test_append_bar_matches_init_stream(self):
+		df = _zigzag_df()
+		stream = TF_DF()
+		stream.init_stream(df, 1, "5m")
+
+		inc = TF_DF()
+		for _, row in df.iterrows():
+			inc.append_bar(row)
+
+		self.assertEqual(len(inc.klu_list), len(stream.klu_list))
+		self.assertEqual(len(inc.klc_list), len(stream.klc_list))
+		self.assertEqual(
+			[_sure_bi_key(b) for b in inc.bi_list if b.is_sure],
+			[_sure_bi_key(b) for b in stream.bi_list if b.is_sure],
+		)
+		self.assertEqual(
+			[_zs_key(z) for z in inc.bi_zs_list],
+			[_zs_key(z) for z in stream.bi_zs_list],
+		)
+
+	def test_replace_last_bar_keeps_count(self):
+		df = _zigzag_df(n=80)
+		tf = TF_DF()
+		tf.init_stream(df, 1, "5m")
+		n_klu = len(tf.klu_list)
+		last = df.iloc[-1].copy()
+		last["close"] = float(last["close"]) + 0.01
+		last["high"] = max(float(last["high"]), float(last["close"]))
+		tf.replace_last_bar(last)
+		self.assertEqual(len(tf.klu_list), n_klu)
+		self.assertGreater(len(tf.klc_list), 0)
+
+	def test_check_fx_skips_forming_right_wing(self):
+		from types import SimpleNamespace
+
+		from chanlun.core.ChanEnum import Chan_FX_TYPE
+
+		tf = TF_DF()
+		pre = SimpleNamespace(high=10, low=8)
+		nxt_open = SimpleNamespace(high=11, low=7, end_klu=None)
+		nxt_done = SimpleNamespace(high=11, low=7, end_klu=object())
+		center = SimpleNamespace(
+			pre=pre,
+			next=nxt_open,
+			high=12,
+			low=9,
+			set_fx=lambda *_a, **_k: None,
+		)
+		self.assertEqual(tf.check_fx(center), Chan_FX_TYPE.UNKNOWN)
+		center.next = nxt_done
+		self.assertEqual(tf.check_fx(center), Chan_FX_TYPE.TOP)
+
+
+if __name__ == "__main__":
+	unittest.main()

chanlun/tests/test_ta_compat.py

@@ -0,0 +1,198 @@
+"""Pin chanlun.indicators.ta to TA-Lib's output, bar for bar.
+
+These indicators feed the Chan structure builders, so a one-bar shift in the
+warm-up or a different smoothing seed silently changes every downstream
+bi/seg/zs. Equality against the reference implementation is the only check
+that catches that.
+
+Skipped when talib is unavailable — which is the point of the replacement, so
+the suite still has to pass without it. Run in an environment that has talib
+whenever chanlun/indicators/ta.py changes.
+"""
+
+from __future__ import annotations
+
+import sys
+import unittest
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+
+from chanlun.indicators import ta  # noqa: E402
+from chanlun.pipeline.resample import resample_to_interval  # noqa: E402
+
+try:
+    import talib.abstract as reference
+except ImportError:  # pragma: no cover
+    reference = None
+
+requires_talib = unittest.skipIf(reference is None, "talib not installed")
+
+
+def make_ohlcv(n: int = 900, seed: int = 7) -> pd.DataFrame:
+    """Random walk with enough range for BBANDS(365) and EMA(208) to warm up."""
+    rng = np.random.default_rng(seed)
+    close = 100.0 + np.cumsum(rng.normal(0.0, 1.0, n))
+    spread = np.abs(rng.normal(0.0, 0.6, n)) + 0.05
+    high = close + spread
+    low = close - spread
+    open_ = np.concatenate([[close[0]], close[:-1]])
+    return pd.DataFrame(
+        {
+            "date": pd.date_range("2024-01-01", periods=n, freq="1min", tz="UTC"),
+            "open": open_,
+            "high": np.maximum.reduce([high, open_, close]),
+            "low": np.minimum.reduce([low, open_, close]),
+            "close": close,
+            "volume": rng.uniform(1.0, 100.0, n),
+        }
+    )
+
+
+class TAEquivalence(unittest.TestCase):
+    def setUp(self) -> None:
+        self.df = make_ohlcv()
+
+    def assertSameSeries(self, got, expected, label: str) -> None:
+        g = np.asarray(got, dtype=float)
+        e = np.asarray(expected, dtype=float)
+        self.assertEqual(g.shape, e.shape, f"{label}: shape")
+        np.testing.assert_array_equal(
+            np.isnan(g), np.isnan(e), err_msg=f"{label}: NaN warm-up differs"
+        )
+        mask = ~np.isnan(e)
+        np.testing.assert_allclose(
+            g[mask], e[mask], rtol=1e-9, atol=1e-8, err_msg=f"{label}: values differ"
+        )
+
+    @requires_talib
+    def test_sma(self) -> None:
+        for period in (5, 20, 90, 250):
+            self.assertSameSeries(
+                ta.SMA(self.df, timeperiod=period),
+                reference.SMA(self.df, timeperiod=period),
+                f"SMA({period})",
+            )
+
+    @requires_talib
+    def test_ma(self) -> None:
+        for period in (5, 10, 250):
+            self.assertSameSeries(
+                ta.MA(self.df, timeperiod=period),
+                reference.MA(self.df, timeperiod=period),
+                f"MA({period})",
+            )
+
+    @requires_talib
+    def test_ema(self) -> None:
+        for period in (5, 7, 10, 13, 24, 26, 30, 52, 104, 156, 208):
+            self.assertSameSeries(
+                ta.EMA(self.df, timeperiod=period),
+                reference.EMA(self.df, timeperiod=period),
+                f"EMA({period})",
+            )
+
+    @requires_talib
+    def test_rsi(self) -> None:
+        for period in (7, 14, 21):
+            self.assertSameSeries(
+                ta.RSI(self.df, timeperiod=period),
+                reference.RSI(self.df, timeperiod=period),
+                f"RSI({period})",
+            )
+
+    @requires_talib
+    def test_atr(self) -> None:
+        for period in (7, 14, 30):
+            self.assertSameSeries(
+                ta.ATR(self.df, timeperiod=period),
+                reference.ATR(self.df, timeperiod=period),
+                f"ATR({period})",
+            )
+
+    @requires_talib
+    def test_macd(self) -> None:
+        for fast, slow, signal in ((12, 26, 9), (26, 52, 9), (5, 35, 5)):
+            got = ta.MACD(self.df, fastperiod=fast, slowperiod=slow, signalperiod=signal)
+            exp = reference.MACD(self.df, fastperiod=fast, slowperiod=slow, signalperiod=signal)
+            for col in ("macd", "macdsignal", "macdhist"):
+                self.assertSameSeries(got[col], exp[col], f"MACD({fast},{slow},{signal}).{col}")
+
+    @requires_talib
+    def test_bbands(self) -> None:
+        cases = (
+            (365, 3.0, 3.0),
+            (120, 3.0, 3.0),
+            (41, 2.3, 2.3),
+            (41, 2.0, 2.0),
+            (26, 3.0, 3.0),
+            (20, 2.0, 2.0),
+            (14, 2.0, 2.0),
+        )
+        for period, up, dn in cases:
+            got = ta.BBANDS(self.df, timeperiod=period, nbdevup=up, nbdevdn=dn, matype=0)
+            exp = reference.BBANDS(self.df, timeperiod=period, nbdevup=up, nbdevdn=dn, matype=0)
+            for col in ("upperband", "middleband", "lowerband"):
+                self.assertSameSeries(got[col], exp[col], f"BBANDS({period},{up},{dn}).{col}")
+
+    @requires_talib
+    def test_bbands_is_more_accurate_than_talib_on_tiny_windows(self) -> None:
+        """A deliberate divergence, documented so nobody "fixes" it back.
+
+        TA-Lib derives the variance from sumsq/n - mean**2, which cancels
+        catastrophically when the window is short and prices are far from zero;
+        at timeperiod=2 it drifts ~1e-6. Rolling std is accurate there, so the
+        two disagree. No timeperiod below 14 is used in this codebase, and the
+        periods that are used agree to ~1e-10 (covered by test_bbands).
+        """
+        got = ta.BBANDS(self.df, timeperiod=2, nbdevup=1.0, nbdevdn=1.0, matype=0)["upperband"]
+        exp = reference.BBANDS(self.df, timeperiod=2, nbdevup=1.0, nbdevdn=1.0, matype=0)["upperband"]
+
+        window = self.df["close"].rolling(2)
+        truth = window.mean() + window.std(ddof=0)
+        ours = np.nanmax(np.abs((got - truth).to_numpy()))
+        theirs = np.nanmax(np.abs((exp - truth).to_numpy()))
+        self.assertLess(ours, 1e-9)
+        self.assertLess(ours, theirs)
+
+    @requires_talib
+    def test_matches_on_real_price_scale(self) -> None:
+        """Guard against tolerances that only hold near 100."""
+        df = self.df.copy()
+        for col in ("open", "high", "low", "close"):
+            df[col] *= 900.0
+        self.assertSameSeries(
+            ta.ATR(df, timeperiod=14), reference.ATR(df, timeperiod=14), "ATR@scale"
+        )
+        self.assertSameSeries(
+            ta.RSI(df, timeperiod=14), reference.RSI(df, timeperiod=14), "RSI@scale"
+        )
+
+
+class ResampleEquivalence(unittest.TestCase):
+    @unittest.skipIf(
+        __import__("importlib").util.find_spec("technical") is None,
+        "technical not installed",
+    )
+    def test_matches_technical(self) -> None:
+        from technical.util import resample_to_interval as ref_resample
+
+        df = make_ohlcv(600)
+        for interval in (5, 15, 60, "5m", "1h"):
+            got = resample_to_interval(df, interval)
+            exp = ref_resample(df, interval)
+            pd.testing.assert_frame_equal(got, exp, check_exact=False, rtol=1e-12)
+
+    def test_shapes_without_reference(self) -> None:
+        df = make_ohlcv(120)
+        out = resample_to_interval(df, 5)
+        self.assertEqual(list(out.columns), ["date", "open", "high", "low", "close", "volume"])
+        self.assertLessEqual(len(out), 120 // 5 + 1)
+        self.assertTrue((out["high"] >= out["low"]).all())
+
+
+if __name__ == "__main__":
+    unittest.main()

config/BTC_Chan.json

@@ -1,84 +0,0 @@
-
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.btc_chan.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "SOL/USDT:USDT",
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800,
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8882,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/BTC_Perpetual_Futures.json

@@ -1,83 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.btc_perpetual.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short": true,
-    "timeframe": "1m",
-    "process_only_new_candles": false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "YOUR_BINANCE_API_KEY",
-        "secret": "YOUR_BINANCE_API_SECRET",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": true,
-        "token": "YOUR_TELEGRAM_BOT_TOKEN",
-        "chat_id": "YOUR_TELEGRAM_CHAT_ID"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "0.0.0.0",
-        "listen_port": 8820,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "change_me_to_a_random_secret_key",
-        "ws_token": "change_me_to_a_random_ws_token",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "BTC_Perpetual_Bot",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/Chan.json

@@ -1,84 +0,0 @@
-
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chan.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT",
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800,
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8800,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/ChanLun_BTC_15.json

@@ -1,83 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chanlun_btc_15.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8811,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/ChanLun_BTC_30.json

@@ -1,83 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chanlun_btc_15.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": true,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "0.0.0.0",
-        "listen_port": 8813,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/ChanLun_BTC_60.json

@@ -1,83 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chanlun_btc_60.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": true,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "0.0.0.0",
-        "listen_port": 8814,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/ChanLun_BTC_K.json

@@ -1,83 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chanlun_btc_k.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8815,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-} 

config/ChanLun_BTC_K_protect.json

@@ -1,87 +0,0 @@
-{
-  "$schema": "https://schema.freqtrade.io/schema.json",
-  "max_open_trades": 1,
-  "stake_currency": "USDT",
-  "stake_amount": "unlimited",
-  "tradable_balance_ratio": 0.99,
-  "fiat_display_currency": "USD",
-  "dry_run": true,
-  "db_url": "sqlite:///tradesv3.chanlun_btc_k.sqlite",
-  "dry_run_wallet": 1000,
-  "cancel_open_orders_on_exit": true,
-  "trading_mode": "futures",
-  "margin_mode": "isolated",
-  "can_short": true,
-  "timeframe": "1m",
-  "process_only_new_candles": false,
-  "unfilledtimeout": {
-    "entry": 1,
-    "exit": 1,
-    "exit_timeout_count": 5,
-    "unit": "minutes"
-  },
-  "entry_pricing": {
-    "price_side": "same",
-    "use_order_book": true,
-    "order_book_top": 1,
-    "price_last_balance": 0.0,
-    "check_depth_of_market": {
-      "enabled": false,
-      "bids_to_ask_delta": 1
-    }
-  },
-  "exit_pricing": {
-    "price_side": "same",
-    "use_order_book": true,
-    "order_book_top": 1
-  },
-  "exchange": {
-    "name": "binance",
-    "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-    "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-    "ccxt_config": {},
-    "ccxt_async_config": {},
-    "pair_whitelist": [
-      "BTC/USDT:USDT"
-    ],
-    "pair_blacklist": [
-      "BNB/.*"
-    ]
-  },
-  "pairlists": [
-    {
-      "method": "StaticPairList",
-      "number_assets": 1,
-      "sort_key": "quoteVolume",
-      "min_value": 0,
-      "refresh_period": 1800
-    }
-  ],
-  
-  "telegram": {
-    "enabled": false,
-    "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-    "chat_id": "580807463"
-  },
-  "api_server": {
-    "enabled": true,
-    "listen_ip_address": "127.0.0.1",
-    "listen_port": 8815,
-    "verbosity": "error",
-    "enable_openapi": false,
-    "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-    "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-    "CORS_origins": [],
-    "username": "freqtrader",
-    "password": "FreqTrade007"
-  },
-  "bot_name": "freqtrade",
-  "initial_state": "running",
-  "force_entry_enable": false,
-  "internals": {
-    "process_throttle_secs": 2
-  }
-}
-
-
-

config/ChanLun_EMA52.json

@@ -1,83 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chanlun_btc_15.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "0.0.0.0",
-        "listen_port": 8820,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/ChanLun_EMA_Align.json

@@ -1,83 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chanlun_btc_15.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": true,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "0.0.0.0",
-        "listen_port": 8820,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/ChanLun_ETH_60.json

@@ -1,83 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chanlun_eth_60.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "ETH/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": true,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8813,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/ChanLun_MACD.json

@@ -1,83 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chanlun_btc_15.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "5m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "other",
-        "use_order_book": false,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "other",
-        "use_order_book": false,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": true,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8813,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/ChanLun_SOL.json

@@ -1,83 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chanlun_sol.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8811,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/ChanLun_SOL_Optimized.json

@@ -1,151 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 2,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.95,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chanlun_sol_optimized.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short": true,
-    "timeframe": "5m",
-    "process_only_new_candles": false,
-    "unfilledtimeout": {
-        "entry": 2,
-        "exit": 2,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "other",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "",
-        "secret": "",
-        "ccxt_config": {
-            "options": {"defaultType": "swap"}
-        },
-        "ccxt_async_config": {
-            "enableRateLimit": true,
-            "rateLimit": 1000,
-            "timeout": 30000
-        },
-        "pair_whitelist": [
-            "SOL/USDT:USDT"
-        ],
-        "pair_blacklist": []
-    },
-    "telegram": {
-        "enabled": false,
-        "token": "",
-        "chat_id": ""
-    },
-    "api_server": {
-        "enabled": false,
-        "listen_ip_address": "0.0.0.0",
-        "listen_port": 8080,
-        "verbosity": "error",
-        "jwt_secret_key": "",
-        "username": "",
-        "password": ""
-    },
-    "discord": {
-        "enabled": false,
-        "webhook": "",
-        "webhook_avatar": "",
-        "poll_delay_seconds": 10
-    },
-    "notification_settings": {
-        "status": "on",
-        "status_inactive_after": 7,
-        "timeframe_condition_change": "on",
-        "telegram": { },
-        "discord": { },
-        "notify_all": true
-    },
-    "bot_name": "SOL_Chan_Optimized",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 5
-    },
-    "edge": {
-        "enabled": false,
-        "process_throttle_secs": 3600,
-        "calculate_since_number_of_days": 7,
-        "allowed_risk": 0.01,
-        "stoploss_range_min": -0.01,
-        "stoploss_range_max": -0.007,
-        "stoploss_range_step": 0.001,
-        "minimum_winrate": 0.60,
-        "minimum_expectancy": 0.20,
-        "min_trade_number": 10,
-        "max_trade_duration_minute": 1440,
-        "remove_pumps": false
-    },
-    "order_types": {
-        "entry": "limit",
-        "exit": "market",
-        "emergency_exit": "market",
-        "force_exit": "market",
-        "force_entry": "market",
-        "stoploss": "market",
-        "stoploss_on_exchange": false,
-        "stoploss_on_exchange_interval": 60
-    },
-    "order_time_in_force": {
-        "entry": "GTC",
-        "exit": "GTC"
-    },
-    "strategy_path": "./user_data/Chan/strategies/",
-    "strategy": "ChanLun_SOL_Optimized",
-    "minimal_roi": {
-        "0": 0.012,
-        "120": 0.010,
-        "240": 0.007,
-        "360": 0.005
-    },
-    "stoploss": -0.007,
-    "trailing_stop": true,
-    "trailing_stop_positive": 0.003,
-    "trailing_stop_positive_offset": 0.005,
-    "trailing_only_offset_is_reached": true,
-    "use_custom_stoploss": true,
-    "max_open_trades_per_pair": 1,
-    "dry_run_wallet_refresh_time": 5,
-    "caches": {
-        "dataframe": {
-            "enabled": true,
-            "refresh_period": 60
-        },
-        "strategy": {
-            "enabled": true,
-            "refresh_period": 300
-        }
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "config": {
-                "pairs": ["SOL/USDT:USDT"]
-            }
-        }
-    ]
-} 

config/ChanLun_XGB.json

@@ -1,125 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chanlun_sol.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : true,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "SOL/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "freqai": {
-        "enabled": true,
-        "purge_old_models": true,
-        "train_period_days": 30,
-        "backtest_period_days": 7,
-        "identifier": "chanLun1",
-        "live_retrain_hours": 1,
-        "expiration_hours": 48,
-        "fit_live_predictions_candles": 0,
-        "data_kitchen_thread_count": 4,
-        "save_backtest_models": true,
-        "save_metadata": true,
-        "feature_parameters": {
-            "include_timeframes": [
-                "1m",
-                "5m",
-                "15m"
-            ],
-            "include_corr_pairlist": [
-                "BTC/USDT:USDT",
-                "ETH/USDT:USDT"
-            ],
-            "label_period_candles": 24,
-            "include_shifted_candles": 2,
-            "indicator_periods_candles": [10, 20, 30],
-            "allow_duplicate_train": true
-        },
-        "data_split_parameters": {
-            "test_size": 0.25
-        },
-        "model_training_parameters": {
-            "n_estimators": 100, 
-            "learning_rate": 0.1,
-            "max_depth": 5,
-            "subsample": 0.8, 
-            "colsample_bytree": 0.8, 
-            "use_label_for_weight": true,
-            "booster": "gbtree",
-            "num_class": 2
-        }
-    },
-    "freqaimodel": "XGBoostClassifier",
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8811,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/Chan_5m.json

@@ -1,103 +0,0 @@
-
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 3,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.btc_chan.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "30m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "ocQUqAPSD9PDhIL2lTMlMan0wMFwvvu5Fv8eYF3wUM8yPytm2jBgz51cgiHXw7J6",
-        "secret": "yHIc6FOnSoOI2FvygpRKKku4FKaZGI5DSwC83Ip4wRfUcxszennF6hy2vhbVuLYJ",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT", 
-            "ETH/USDT:USDT", 
-            "SOL/USDT:USDT", 
-            "WIF/USDT:USDT", 
-            "1000PEPE/USDT:USDT", 
-            "DOGS/USDT:USDT", 
-            "ORDI/USDT:USDT", 
-            "AAVE/USDT:USDT", 
-            "REEF/USDT:USDT", 
-            "1000SATS/USDT:USDT", 
-            "SUI/USDT:USDT", 
-            "1INCH/USDT:USDT", 
-            "DOGE/USDT:USDT", 
-            "TON/USDT:USDT", 
-            "UNI/USDT:USDT", 
-            "XRP/USDT:USDT", 
-            "SUN/USDT:USDT", 
-            "NOT/USDT:USDT", 
-            "RARE/USDT:USDT", 
-            "RDNT/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "VolumePairList",
-            "number_assets": 10,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": true,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8088,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/Chan_BTC_30m.json

@@ -1,83 +0,0 @@
-
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "5m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT",   
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "5985766683:AAEx2Nm_4y2IC0Tj4Hhz7djVRJRso0JKaj0",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8088,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/Chan_ETH.json

@@ -1,84 +0,0 @@
-
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.btc_chan.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "SOL/USDT:USDT",
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800,
-        }
-    ],
-    "telegram": {
-        "enabled": true,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": false,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8888,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/Chan_SOL.json

@@ -1,84 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "strategy": "ChanStrategy",
-    "db_url": "sqlite:///tradesv3.btc_chan.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "SOL/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": false,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8818,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/Chan_SOL_15.json

@@ -1,84 +0,0 @@
-
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chan.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "SOL/USDT:USDT",
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800,
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8815,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/Chan_SOL_15_HL.json

@@ -1,84 +0,0 @@
-
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDC",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chan.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "hyperliquid",
-        "walletAddress": "0xA834b6d3Fa1D8A55ea8e502685ef5cbD2b2D3343",
-        "privateKey": "0xa399cea4c01be67c16b88e1d2121ed6e72bab6b4e8d81684ed03ce78f8b4f827",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "PURR/USDC:USDC",
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800,
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8815,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/Chan_SOL_30.json

@@ -1,84 +0,0 @@
-
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chan_sol_30.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "SOL/USDT:USDT",
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800,
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8818,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/Chan_SOL_Day.json

@@ -1,84 +0,0 @@
-
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chan.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT",
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800,
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8801,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/Deepseek_Trader.json

@@ -1,93 +0,0 @@
-
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 3,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "db_url": "sqlite:///tradesv3.deepseek_trader.sqlite",
-    "dry_run": true,
-    "dry_run_wallet": 10000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 0,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT",
-            "ETH/USDT:USDT", 
-            "SOL/USDT:USDT", 
-            "WIF/USDT:USDT", 
-            "1000PEPE/USDT:USDT", 
-            "DOGS/USDT:USDT", 
-            "ORDI/USDT:USDT", 
-            "AAVE/USDT:USDT", 
-            "REEF/USDT:USDT", 
-            "1000SATS/USDT:USDT",   
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 10,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": true,
-        "token": "5985766683:AAEx2Nm_4y2IC0Tj4Hhz7djVRJRso0JKaj0",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8001,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": true,
-    "internals": {
-        "process_throttle_secs": 15
-    }
-}

config/EMA26_EMA52_Cross.json

@@ -1,83 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.ema26_ema52_cross.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "SOL/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": true,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "0.0.0.0",
-        "listen_port": 8820,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/EMA_Pattern.json

@@ -1,83 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.ema_pattern.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1h",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "0.0.0.0",
-        "listen_port": 8888,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/ElliottWaveBTC.json

@@ -1,70 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 2,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.elliottwave_btc.sqlite",
-    "dry_run_wallet": 10000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "unfilledtimeout": {
-        "entry": 5,
-        "exit": 5,
-        "exit_timeout_count": 3,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "",
-        "secret": "",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "",
-        "chat_id": ""
-    },
-    "api_server": {
-        "enabled": false,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8080,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "freqtrade_secret",
-        "ws_token": "freqtrade_ws",
-        "username": "freqtrade",
-        "password": "freqtrade"
-    },
-    "bot_name": "ElliottWaveBTC"
-}

config/FreqAI_Test.json

@@ -1,123 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.freqai_sol.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short": true,
-    "timeframe": "5m",
-    "process_only_new_candles": true,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "",
-        "secret": "",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "SOL/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList"
-        }
-    ],
-    "freqai": {
-        "enabled": true,
-        "purge_old_models": 2,
-        "train_period_days": 10,
-        "backtest_period_days": 7,
-        "live_retrain_hours": 1,
-        "identifier": "sol_futures_lgbm_v1",
-        "feature_parameters": {
-            "include_timeframes": [
-                "5m",
-                "15m"
-            ],
-            "include_corr_pairlist": [
-                "BTC/USDT:USDT"
-            ],
-            "label_period_candles": 12,
-            "include_shifted_candles": 1,
-            "DI_threshold": 0.9,
-            "weight_factor": 0.9,
-            "principal_component_analysis": false,
-            "use_SVM_to_remove_outliers": true,
-            "indicator_periods_candles": [
-                14
-            ],
-            "plot_feature_importances": 0
-        },
-        "data_split_parameters": {
-            "test_size": 0.15,
-            "random_state": 42
-        },
-        "model_training_parameters": {
-            "n_estimators": 300,
-            "learning_rate": 0.05,
-            "max_depth": 5,
-            "num_leaves": 31,
-            "min_child_samples": 20,
-            "subsample": 0.8,
-            "colsample_bytree": 0.8,
-            "reg_alpha": 0.1,
-            "reg_lambda": 0.1,
-            "n_jobs": 1,
-            "verbosity": -1
-        }
-    },
-    "telegram": {
-        "enabled": false,
-        "token": "",
-        "chat_id": ""
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "0.0.0.0",
-        "listen_port": 8822,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqai_sol",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 5
-    }
-}

config/HeikinAshi_BTC.json

@@ -1,83 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.heikinashi_btc.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "1m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": true,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "0.0.0.0",
-        "listen_port": 8814,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/Local_Test.json

@@ -1,83 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.ema26_ema52_cross.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "timeframe": "1m",
-    "can_short" : true,
-    "process_only_new_candles" : true,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "other",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "other",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "BTC/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "0.0.0.0",
-        "listen_port": 8821,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

config/SOL5m.json

@@ -1,81 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.sol5m.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short": true,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "other",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing": {
-        "price_side": "other",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "SOL/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "0.0.0.0",
-        "listen_port": 8822,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "SOL5m",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 5
-    }
-}

config/ThreeFilterEMA_BTC_15.json

@@ -1,83 +0,0 @@
-{
-    "$schema": "https://schema.freqtrade.io/schema.json",
-    "max_open_trades": 1,
-    "stake_currency": "USDT",
-    "stake_amount": "unlimited",
-    "tradable_balance_ratio": 0.99,
-    "fiat_display_currency": "USD",
-    "dry_run": true,
-    "db_url": "sqlite:///tradesv3.chanlun_btc_15.sqlite",
-    "dry_run_wallet": 1000,
-    "cancel_open_orders_on_exit": true,
-    "trading_mode": "futures",
-    "margin_mode": "isolated",
-    "can_short" : true,
-    "timeframe" : "15m",
-    "process_only_new_candles" : false,
-    "unfilledtimeout": {
-        "entry": 1,
-        "exit": 1,
-        "exit_timeout_count": 5,
-        "unit": "minutes"
-    },
-    "entry_pricing": {
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1,
-        "price_last_balance": 0.0,
-        "check_depth_of_market": {
-            "enabled": false,
-            "bids_to_ask_delta": 1
-        }
-    },
-    "exit_pricing":{
-        "price_side": "same",
-        "use_order_book": true,
-        "order_book_top": 1
-    },
-    "exchange": {
-        "name": "binance",
-        "key": "hvoXanRExQvcN4tyGFvEnsSF4gqxXp6ZJnBu5lnhvlVuHaDbj2PhLBQGCLkkyeI8",
-        "secret": "3UKA2oyDj7OoXrausmnaLwLlNfXmlNf2imBdmQqqKHArcJfk6X9xjaUF19wzu82l",
-        "ccxt_config": {},
-        "ccxt_async_config": {},
-        "pair_whitelist": [
-            "WIF/USDT:USDT"
-        ],
-        "pair_blacklist": [
-            "BNB/.*"
-        ]
-    },
-    "pairlists": [
-        {
-            "method": "StaticPairList",
-            "number_assets": 1,
-            "sort_key": "quoteVolume",
-            "min_value": 0,
-            "refresh_period": 1800
-        }
-    ],
-    "telegram": {
-        "enabled": false,
-        "token": "7677670958:AAFL_jgZvNUTPR3R3vWieREX_tDVi9w2C1Y",
-        "chat_id": "580807463"
-    },
-    "api_server": {
-        "enabled": true,
-        "listen_ip_address": "127.0.0.1",
-        "listen_port": 8811,
-        "verbosity": "error",
-        "enable_openapi": false,
-        "jwt_secret_key": "14d3510740e2c39a973a8895f1aa2704d98d08b86170260085709fa5ea48251d",
-        "ws_token": "dtKKDnafBrX4icq_ZCw7acJTahTK4h_yvg",
-        "CORS_origins": [],
-        "username": "freqtrader",
-        "password": "FreqTrade007"
-    },
-    "bot_name": "freqtrade",
-    "initial_state": "running",
-    "force_entry_enable": false,
-    "internals": {
-        "process_throttle_secs": 2
-    }
-}

data_provider/Dockerfile

@@ -1,20 +0,0 @@
-FROM python:3.11-slim
-
-ENV PYTHONUNBUFFERED=1 \
-    PIP_NO_CACHE_DIR=1
-
-WORKDIR /app
-
-COPY requirements.txt /app/requirements.txt
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY . /app
-
-ENV CONFIG_PATH=/app/config.json \
-    UVICORN_HOST=0.0.0.0 \
-    UVICORN_PORT=9009
-
-EXPOSE 9009
-
-CMD ["python", "-m", "main"]
-

data_provider/config.json

@@ -1,18 +0,0 @@
-{
-  "exchange": "binance",
-  "symbols": [
-    "BTC/USDT:USDT", 
-    "ETH/USDT:USDT", 
-    "SOL/USDT:USDT",
-    "WIF/USDT:USDT",  
-    "AAVE/USDT:USDT", 
-    "SUI/USDT:USDT", 
-    "1INCH/USDT:USDT", 
-    "DOGE/USDT:USDT", 
-    "UNI/USDT:USDT"
-  ],
-  "start_time": "2024-01-01T00:00:00Z",
-  "timeframes": ["1m", "1h", "1d", "1w"],
-  "data_dir": "./data"
-}
-

data_provider/docker-compose.yml

@@ -1,15 +0,0 @@
-services:
-  data_provider:
-    build: .
-    container_name: data-provider
-    restart: unless-stopped
-    environment:
-      CONFIG_PATH: /app/config.json
-      UVICORN_HOST: 0.0.0.0
-      UVICORN_PORT: "9009"
-    volumes:
-      - ./config.json:/app/config.json:ro
-      - ./data:/app/data
-    ports:
-      - "9009:9009"
-

data_provider/main.py

@@ -1,947 +0,0 @@
-"""
-Chan 数据服务：用 ccxt 从交易所拉取 K 线，内存缓存 + CSV 落盘；
-后台线程定期增量刷新，断线时记录 resume_since 以免漏 K；
-配置中的基础周期（如 1m/1h）可合成 DERIVED_TIMEFRAME_PLAN 中的衍生周期。
-"""
-import asyncio
-import csv
-import json
-import logging
-import os
-import threading
-import time
-from contextlib import asynccontextmanager
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Dict, Iterable, List, Optional
-
-import ccxt  # type: ignore
-import pandas as pd  # type: ignore
-from fastapi import FastAPI, HTTPException, Query, WebSocket, WebSocketDisconnect
-from fastapi.middleware.cors import CORSMiddleware
-import uvicorn
-from technical.util import resample_to_interval
-
-# docker compose logs --tail=200
-# docker compose down && docker compose build --no-cache && docker compose up -d
-
-# 基础周期枚举顺序（用于衍生周期展示顺序）；仅允许集合内周期作为交易所直接拉取的 tf
-TIMEFRAME_ORDER = ["1m", "1h", "1d", "1w"]
-ALLOWED_TIMEFRAMES = set(TIMEFRAME_ORDER)
-# 各基础周期一根 K 线的毫秒长度（用于历史分页与断线回退）
-TIMEFRAME_TO_MS: Dict[str, int] = {
-    "1m": 60_000,
-    "1h": 3_600_000,
-    "1d": 86_400_000,
-    "1w": 604_800_000,
-}
-# 每个基础周期可派生出的合成周期列表（由该基础周期 K 线 resample 得到）
-DERIVED_TIMEFRAME_PLAN: Dict[str, List[str]] = {
-    "1m": ["2m", "3m", "4m", "5m", "10m", "15m", "20m", "25m", "30m", "45m"],
-    "1h": ["2h", "3h", "4h", "5h", "6h", "7h", "8h", "9h", "10", "11h", "12h", "16h", "20h"],
-    "1d": ["2d", "3d", "4d", "5d", "6d"],
-    "1w": ["2w", "3w"],
-}
-CSV_FIELDNAMES = ["timestamp", "datetime", "open", "high", "low", "close", "volume"]
-DEFAULT_LIMIT = 500
-RECENT_CANDLE_LIMIT = 10
-RECENT_FETCH_INTERVAL = 5  # 后台刷新循环休眠秒数
-PERSIST_INTERVAL = 600  # 全量落盘周期（秒）
-WS_UPDATE_CANDLE_COUNT = 2  # WebSocket 增量推送最近 K 线根数
-
-
-logger = logging.getLogger("data_provider")
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
-)
-
-
-def to_utc_iso(timestamp_ms: int) -> str:
-    """将毫秒时间戳格式化为 UTC ISO 字符串（末尾 Z）。"""
-    dt = datetime.fromtimestamp(timestamp_ms / 1000, tz=timezone.utc)
-    return dt.isoformat().replace("+00:00", "Z")
-
-
-def parse_timestamp(value: Optional[object]) -> Optional[int]:
-    """解析查询参数中的时间为 UTC 毫秒时间戳；支持数字或 ISO 字符串。"""
-    if value is None:
-        return None
-    if isinstance(value, (int, float)):
-        return int(value)
-    if isinstance(value, str):
-        text = value.strip()
-        if not text:
-            return None
-        if text.isdigit():
-            return int(text)
-        if text.endswith("Z"):
-            text = text[:-1] + "+00:00"
-        try:
-            dt = datetime.fromisoformat(text)
-        except ValueError as exc:  # pragma: no cover - informative logging
-            raise ValueError(f"无法解析时间字符串: {value}") from exc
-        if dt.tzinfo is None:
-            dt = dt.replace(tzinfo=timezone.utc)
-        else:
-            dt = dt.astimezone(timezone.utc)
-        return int(dt.timestamp() * 1000)
-    raise ValueError(f"不支持的时间格式: {value}")
-
-
-def candle_to_dict(candle: Iterable[float]) -> Dict[str, float]:
-    """ccxt OHLCV 单根 [ts, o, h, l, c, v] 转为内部字典结构。"""
-    ts = int(candle[0])
-    return {
-        "timestamp": ts,
-        "datetime": to_utc_iso(ts),
-        "open": float(candle[1]),
-        "high": float(candle[2]),
-        "low": float(candle[3]),
-        "close": float(candle[4]),
-        "volume": float(candle[5]),
-    }
-
-
-def timeframe_to_minutes(tf: str) -> Optional[int]:
-    """将如 15m、2h 转为「分钟数」，供 resample 与衍生周期计算。"""
-    if not tf:
-        return None
-    unit = tf[-1]
-    try:
-        value = int(tf[:-1])
-    except ValueError:
-        return None
-    multiplier = {
-        "m": 1,
-        "h": 60,
-        "d": 1_440,
-        "w": 10_080,
-    }.get(unit)
-    if multiplier is None:
-        return None
-    return value * multiplier
-
-
-class WebSocketManager:
-    """管理 WebSocket 连接及订阅，线程安全地广播 K 线更新。"""
-
-    def __init__(self) -> None:
-        self._subscriptions: Dict[tuple, set] = {}
-        self._async_lock = asyncio.Lock()
-        self._loop: Optional[asyncio.AbstractEventLoop] = None
-
-    def set_loop(self, loop: asyncio.AbstractEventLoop) -> None:
-        self._loop = loop
-
-    async def connect(self, ws: WebSocket) -> None:
-        await ws.accept()
-        logger.info("WebSocket 客户端已连接")
-
-    async def disconnect(self, ws: WebSocket) -> None:
-        async with self._async_lock:
-            for key in list(self._subscriptions):
-                self._subscriptions[key].discard(ws)
-                if not self._subscriptions[key]:
-                    del self._subscriptions[key]
-        logger.info("WebSocket 客户端已断开")
-
-    async def subscribe(self, ws: WebSocket, symbol: str, timeframe: str) -> None:
-        key = (symbol, timeframe)
-        async with self._async_lock:
-            self._subscriptions.setdefault(key, set()).add(ws)
-        logger.info("WebSocket 订阅: %s %s", symbol, timeframe)
-
-    async def unsubscribe(self, ws: WebSocket, symbol: str, timeframe: str) -> None:
-        key = (symbol, timeframe)
-        async with self._async_lock:
-            if key in self._subscriptions:
-                self._subscriptions[key].discard(ws)
-                if not self._subscriptions[key]:
-                    del self._subscriptions[key]
-
-    def has_subscribers(self, symbol: str, timeframe: str) -> bool:
-        """非异步快速检查（供同步线程调用）。"""
-        return bool(self._subscriptions.get((symbol, timeframe)))
-
-    async def broadcast(
-        self, symbol: str, timeframe: str, candles: List[Dict], msg_type: str = "kline",
-    ) -> None:
-        key = (symbol, timeframe)
-        async with self._async_lock:
-            subscribers = list(self._subscriptions.get(key, set()))
-        if not subscribers:
-            return
-        message = json.dumps(
-            {"type": msg_type, "symbol": symbol, "timeframe": timeframe, "data": candles},
-            ensure_ascii=False,
-        )
-        dead: list = []
-        for ws in subscribers:
-            try:
-                await ws.send_text(message)
-            except Exception:
-                dead.append(ws)
-        if dead:
-            async with self._async_lock:
-                for ws in dead:
-                    self._subscriptions.get(key, set()).discard(ws)
-
-    def broadcast_from_thread(
-        self, symbol: str, timeframe: str, candles: List[Dict], msg_type: str = "kline",
-    ) -> None:
-        """供同步后台线程调用，将广播提交到 asyncio 事件循环。"""
-        if self._loop is None or self._loop.is_closed():
-            return
-        asyncio.run_coroutine_threadsafe(
-            self.broadcast(symbol, timeframe, candles, msg_type),
-            self._loop,
-        )
-
-
-class DataProvider:
-    """封装交易所连接、本地 CSV、内存缓存、断线恢复与衍生周期聚合。"""
-
-    def __init__(self, config_path: Path) -> None:
-        self.config_path = config_path
-        self.config = self._load_config()
-        self.exchange_name: str = self.config["exchange"]
-        self.symbols: List[str] = self._load_symbols(self.config)
-        self.timeframes: List[str] = self._validate_timeframes(self.config.get("timeframes"))
-        self.data_dir = Path(self.config.get("data_dir", "./data")).expanduser()
-        start = parse_timestamp(self.config.get("start_time"))
-        if start is None:
-            raise ValueError("配置文件必须包含 start_time 字段")
-        self.start_time_ms: int = start
-        self.exchange = self._init_exchange()
-        self.data: Dict[str, Dict[str, List[Dict[str, float]]]] = {
-            symbol: {tf: [] for tf in self.timeframes} for symbol in self.symbols
-        }
-        # 衍生周期 -> 用于合成的交易所基础周期（每个衍生只对应一个 base）
-        self.derived_map: Dict[str, str] = {}
-        for base_tf in self.timeframes:
-            for derived_tf in DERIVED_TIMEFRAME_PLAN.get(base_tf, []):
-                self.derived_map.setdefault(derived_tf, base_tf)
-        # 衍生周期展示顺序：按 TIMEFRAME_ORDER 中的基础周期依次展开
-        derived_order: List[str] = []
-        for base_tf in TIMEFRAME_ORDER:
-            if base_tf not in self.timeframes:
-                continue
-            for derived_tf in DERIVED_TIMEFRAME_PLAN.get(base_tf, []):
-                if derived_tf in self.derived_map and derived_tf not in derived_order:
-                    derived_order.append(derived_tf)
-        self.available_timeframes: List[str] = list(self.timeframes) + derived_order
-        self._lock = threading.RLock()
-        self._ready = threading.Event()
-        self._stop_event = threading.Event()
-        self._fetch_thread: Optional[threading.Thread] = None
-        self._persist_thread: Optional[threading.Thread] = None
-        # 记录断线后需要从哪个 since 重新拉取（symbol -> timeframe -> since_ms）
-        self._resume_since: Dict[str, Dict[str, int]] = {}
-        # 恢复点持久化文件
-        self._resume_file: Path = self.data_dir / "resume_since.json"
-        # 尝试加载历史恢复点
-        self._load_resume_since()
-        self._update_callbacks: List = []
-
-    def _load_config(self) -> Dict[str, object]:
-        """读取 JSON 配置文件。"""
-        if not self.config_path.exists():
-            raise FileNotFoundError(f"未找到配置文件: {self.config_path}")
-        with self.config_path.open("r", encoding="utf-8") as fp:
-            return json.load(fp)
-
-    def _load_symbols(self, config: Dict[str, object]) -> List[str]:
-        """从 symbols 列表、逗号分隔字符串或单字段 symbol 解析交易对，去重保序。"""
-        raw_symbols: List[str] = []
-        symbols_value = config.get("symbols")
-        if isinstance(symbols_value, list):
-            raw_symbols = [str(item).strip() for item in symbols_value if isinstance(item, str) and item.strip()]
-        elif isinstance(symbols_value, str) and symbols_value.strip():
-            raw_symbols = [item.strip() for item in symbols_value.split(",") if item.strip()]
-        symbol_single = config.get("symbol")
-        if not raw_symbols and isinstance(symbol_single, str) and symbol_single.strip():
-            raw_symbols = [symbol_single.strip()]
-        if not raw_symbols:
-            raise ValueError("配置文件必须提供 symbols（列表或逗号分隔字符串）或 symbol 字段")
-        unique: List[str] = []
-        for item in raw_symbols:
-            if item not in unique:
-                unique.append(item)
-        return unique
-
-    def _validate_timeframes(self, configured: Optional[Iterable[str]]) -> List[str]:
-        """校验周期在允许集合内；未配置则默认 TIMEFRAME_ORDER 全部；顺序优先按 TIMEFRAME_ORDER。"""
-        if not configured:
-            return list(TIMEFRAME_ORDER)
-        invalid = [tf for tf in configured if tf not in ALLOWED_TIMEFRAMES]
-        if invalid:
-            raise ValueError(f"不支持的时间周期: {invalid}. 允许值: {sorted(ALLOWED_TIMEFRAMES)}")
-        unique = []
-        seen = set()
-        for tf in TIMEFRAME_ORDER:
-            if tf in configured and tf not in seen:
-                unique.append(tf)
-                seen.add(tf)
-        for tf in configured:
-            if tf not in seen:
-                unique.append(tf)
-                seen.add(tf)
-        return unique
-
-    def _init_exchange(self):
-        """实例化 ccxt 交易所，币安期货默认 defaultType=future，并 load_markets。"""
-        if not hasattr(ccxt, self.exchange_name):
-            raise ValueError(f"不支持的交易所: {self.exchange_name}")
-        exchange_class = getattr(ccxt, self.exchange_name)
-        exchange = exchange_class({"enableRateLimit": True})
-        if exchange.id == "binance":
-            exchange.options.setdefault("defaultType", "future")
-        exchange.load_markets()
-        logger.info("已初始化交易所 %s", exchange.id)
-        return exchange
-
-    def _data_file_path(self, symbol: str, timeframe: str) -> Path:
-        """单交易对单周期的 CSV 路径：data_dir/tf/exchange_symbol_tf.csv。"""
-        symbol_safe = symbol.replace("/", "_").replace(":", "_")
-        return self.data_dir / timeframe / f"{self.exchange.id}_{symbol_safe}_{timeframe}.csv"
-
-    def _load_local(self, symbol: str, timeframe: str) -> List[Dict[str, float]]:
-        """启动时从磁盘加载已有 K 线，损坏行跳过，按时间排序。"""
-        path = self._data_file_path(symbol, timeframe)
-        if not path.exists():
-            return []
-        loaded: List[Dict[str, float]] = []
-        with path.open("r", encoding="utf-8", newline="") as fp:
-            reader = csv.DictReader(fp)
-            for row in reader:
-                try:
-                    loaded.append(
-                        {
-                            "timestamp": int(row["timestamp"]),
-                            "datetime": row.get("datetime") or to_utc_iso(int(row["timestamp"])),
-                            "open": float(row["open"]),
-                            "high": float(row["high"]),
-                            "low": float(row["low"]),
-                            "close": float(row["close"]),
-                            "volume": float(row["volume"]),
-                        }
-                    )
-                except (KeyError, ValueError):
-                    logger.warning("忽略损坏的行: %s", row)
-        loaded.sort(key=lambda item: item["timestamp"])
-        logger.info("交易对 %s 时间周期 %s 加载本地K线数量: %s", symbol, timeframe, len(loaded))
-        return loaded
-
-    def _merge_candles(
-        self,
-        timeframe: str,
-        base: List[Dict[str, float]],
-        new_candles: Iterable[Iterable[float]],
-    ) -> List[Dict[str, float]]:
-        """按 timestamp 去重合并，新数据覆盖同时间戳旧数据。"""
-        merged = {entry["timestamp"]: entry for entry in base}
-        for candle in new_candles:
-            entry = candle_to_dict(candle)
-            merged[entry["timestamp"]] = entry
-        ordered = list(sorted(merged.values(), key=lambda item: item["timestamp"]))
-        logger.debug("时间周期 %s 合并后K线数量: %s", timeframe, len(ordered))
-        return ordered
-
-    def _write_to_disk(self, symbol: str, timeframe: str, data: List[Dict[str, float]]) -> None:
-        """先写临时文件再 replace，避免写入中断导致 CSV 损坏。"""
-        path = self._data_file_path(symbol, timeframe)
-        path.parent.mkdir(parents=True, exist_ok=True)
-        tmp_path = path.with_suffix(path.suffix + ".tmp")
-        try:
-            with tmp_path.open("w", encoding="utf-8", newline="") as fp:
-                writer = csv.DictWriter(fp, fieldnames=CSV_FIELDNAMES)
-                writer.writeheader()
-                writer.writerows(data)
-            os.replace(tmp_path, path)
-        finally:
-            if tmp_path.exists():
-                try:
-                    tmp_path.unlink()
-                except OSError:
-                    pass
-        logger.info("交易对 %s 时间周期 %s 已写入磁盘 (%s 根K线)", symbol, timeframe, len(data))
-
-    def _fetch_history(self, symbol: str, timeframe: str, since_ms: int) -> List[List[float]]:
-        """从 since_ms 分页拉取直到接近当前时间；遇限频则 sleep 重试。"""
-        results: List[List[float]] = []
-        limit = 1500
-        now_ms = self.exchange.milliseconds()
-        tf_ms = TIMEFRAME_TO_MS[timeframe]
-        fetch_since = since_ms
-        max_rounds = 5000
-        rounds = 0
-        while fetch_since < now_ms and rounds < max_rounds:
-            rounds += 1
-            try:
-                candles = self.exchange.fetch_ohlcv(
-                    symbol,
-                    timeframe=timeframe,
-                    since=fetch_since,
-                    limit=limit,
-                )
-            except ccxt.RateLimitExceeded as exc:
-                logger.warning("触发频率限制，等待: %s", exc)
-                time.sleep(self.exchange.rateLimit / 1000 if self.exchange.rateLimit else 1)
-                continue
-            except ccxt.BaseError as exc:
-                logger.error("拉取历史K线失败 (%s, %s): %s", timeframe, fetch_since, exc)
-                time.sleep(5)
-                continue
-            if not candles:
-                break
-            results.extend(candles)
-            last_ts = candles[-1][0]
-            fetch_since = last_ts + tf_ms
-            if last_ts >= now_ms - tf_ms:
-                break
-            time.sleep(self.exchange.rateLimit / 1000 if self.exchange.rateLimit else 0.2)
-        logger.info("交易对 %s 时间周期 %s 拉取历史K线数量: %s", symbol, timeframe, len(results))
-        return results
-
-    def initialize(self) -> None:
-        """阻塞式启动：加载本地、从倒数第二根或配置起点补历史、写盘并 set _ready。"""
-        logger.info("开始初始化数据提供商")
-        for symbol in self.symbols:
-            for timeframe in self.timeframes:
-                existing = self._load_local(symbol, timeframe)
-                tf_ms = TIMEFRAME_TO_MS[timeframe]
-                last_ts = existing[-1]["timestamp"] if existing else None
-                if last_ts is not None:
-                    if len(existing) >= 2:
-                        # 从倒数第二根起拉，避免最后一根未收盘重复/缺口
-                        fetch_since = existing[-2]["timestamp"]
-                    else:
-                        fetch_since = max(0, last_ts - tf_ms)
-                else:
-                    fetch_since = self.start_time_ms
-                logger.debug(
-                    "初始化拉取参数",
-                    extra={
-                        "symbol": symbol,
-                        "timeframe": timeframe,
-                        "existing_last": last_ts,
-                        "fetch_since": fetch_since,
-                        "tf_ms": tf_ms,
-                    },
-                )
-                history = self._fetch_history(symbol, timeframe, fetch_since)
-                merged = self._merge_candles(timeframe, existing, history)
-                with self._lock:
-                    self.data.setdefault(symbol, {})[timeframe] = merged
-                self._write_to_disk(symbol, timeframe, merged)
-        self._ready.set()
-        logger.info("数据初始化完成")
-        
-    def resample_df(self, df: pd.DataFrame, interval: int) -> pd.DataFrame:
-        """将基础周期 DataFrame 聚合为 interval 分钟周期（freqtrade technical.util）。"""
-        return resample_to_interval(df, interval)
-    
-    def _save_resume_since(self) -> None:
-        """将断线恢复点持久化到 resume_since.json（原子替换）。"""
-        path = self._resume_file
-        path.parent.mkdir(parents=True, exist_ok=True)
-        tmp_path = path.with_suffix(path.suffix + ".tmp")
-        with self._lock:
-            snapshot = {
-                symbol: {tf: int(since) for tf, since in tf_map.items()}
-                for symbol, tf_map in self._resume_since.items()
-            }
-        try:
-            with tmp_path.open("w", encoding="utf-8") as fp:
-                json.dump(snapshot, fp, ensure_ascii=False, separators=(",", ":"))
-            os.replace(tmp_path, path)
-        finally:
-            if tmp_path.exists():
-                try:
-                    tmp_path.unlink()
-                except OSError:
-                    pass
-        logger.debug("恢复点已保存到磁盘: %s", path)
-    
-    def _load_resume_since(self) -> None:
-        """启动时加载恢复点；与内存合并时取更早的 since，避免漏拉。"""
-        path = self._resume_file
-        if not path.exists():
-            return
-        try:
-            with path.open("r", encoding="utf-8") as fp:
-                raw = json.load(fp)
-        except Exception as exc:
-            logger.warning("恢复点文件读取失败，忽略: %s (%s)", path, exc)
-            return
-        if not isinstance(raw, dict):
-            logger.warning("恢复点文件格式错误，忽略: %s", path)
-            return
-        loaded: Dict[str, Dict[str, int]] = {}
-        for symbol, tf_map in raw.items():
-            if not isinstance(tf_map, dict):
-                continue
-            per_symbol: Dict[str, int] = {}
-            for timeframe, since in tf_map.items():
-                try:
-                    per_symbol[str(timeframe)] = int(since)
-                except Exception:
-                    continue
-            if per_symbol:
-                loaded[str(symbol)] = per_symbol
-        if not loaded:
-            return
-        with self._lock:
-            # 合并为更早的 since，避免遗漏
-            for symbol, tf_map in loaded.items():
-                cur = self._resume_since.setdefault(symbol, {})
-                for timeframe, since in tf_map.items():
-                    prev = cur.get(timeframe)
-                    if prev is None or since < prev:
-                        cur[timeframe] = since
-        logger.info("已加载恢复点: %s", path)
-    
-    def _get_resume_since(self, symbol: str, timeframe: str) -> Optional[int]:
-        """若曾断线，返回应从哪一毫秒起补拉该 symbol/tf。"""
-        with self._lock:
-            return self._resume_since.get(symbol, {}).get(timeframe)
-    
-    def _set_resume_since(self, symbol: str, timeframe: str, since_ms: int) -> None:
-        """断线时写入恢复点（取更早的 since 以免漏数据），并持久化到磁盘。"""
-        with self._lock:
-            per_symbol = self._resume_since.setdefault(symbol, {})
-            prev = per_symbol.get(timeframe)
-            # 取更早的 since，避免跳过数据
-            if prev is None or since_ms < prev:
-                per_symbol[timeframe] = since_ms
-                logger.warning(
-                    "记录断线恢复点: %s %s since=%s (%s)",
-                    symbol,
-                    timeframe,
-                    since_ms,
-                    to_utc_iso(since_ms),
-                )
-        # 同步写盘
-        self._save_resume_since()
-    
-    def _clear_resume_since(self, symbol: str, timeframe: str) -> None:
-        """补数成功后清除该 symbol/tf 的恢复点。"""
-        with self._lock:
-            if symbol in self._resume_since and timeframe in self._resume_since[symbol]:
-                del self._resume_since[symbol][timeframe]
-                if not self._resume_since[symbol]:
-                    del self._resume_since[symbol]
-                logger.info("清除断线恢复点: %s %s", symbol, timeframe)
-        # 同步写盘
-        self._save_resume_since()
-    
-    def on_update(self, callback) -> None:
-        """注册数据更新回调（签名: callback(symbol, timeframe)）。"""
-        self._update_callbacks.append(callback)
-
-    def _notify_update(self, symbol: str, timeframe: str) -> None:
-        """通知所有回调：某 symbol/timeframe 数据已更新。"""
-        for cb in self._update_callbacks:
-            try:
-                cb(symbol, timeframe)
-            except Exception as exc:
-                logger.error("数据更新回调异常: %s", exc)
-
-    def start_background_workers(self) -> None:
-        """启动增量刷新线程与周期性落盘线程。"""
-        if self._fetch_thread and self._fetch_thread.is_alive():
-            return
-        self._stop_event.clear()
-        self._fetch_thread = threading.Thread(target=self._refresh_loop, name="refresh-loop", daemon=True)
-        self._persist_thread = threading.Thread(target=self._persist_loop, name="persist-loop", daemon=True)
-        self._fetch_thread.start()
-        self._persist_thread.start()
-        logger.info("后台线程已启动")
-
-    def stop(self) -> None:
-        """停止后台线程（应用关闭时 lifespan finally 调用）。"""
-        self._stop_event.set()
-        if self._fetch_thread:
-            self._fetch_thread.join(timeout=5)
-        if self._persist_thread:
-            self._persist_thread.join(timeout=5)
-        logger.info("数据提供商已停止")
-
-    def _refresh_loop(self) -> None:
-        """轮询各 symbol/tf：有恢复点则先补历史，否则 fetch 最近 RECENT_CANDLE_LIMIT 根。"""
-        while not self._stop_event.is_set():
-            for symbol in self.symbols:
-                for timeframe in self.timeframes:
-                    try:
-                        # 若存在断线恢复点，则优先从该 since 补齐历史数据
-                        resume_since = self._get_resume_since(symbol, timeframe)
-                        if resume_since is not None:
-                            logger.info(
-                                "开始断线后补数: %s %s since=%s (%s)",
-                                symbol,
-                                timeframe,
-                                resume_since,
-                                to_utc_iso(resume_since),
-                            )
-                            history = self._fetch_history(symbol, timeframe, resume_since)
-                            with self._lock:
-                                current = self.data.setdefault(symbol, {}).get(timeframe, [])
-                                merged = self._merge_candles(timeframe, current, history)
-                                self.data[symbol][timeframe] = merged
-                            self._notify_update(symbol, timeframe)
-                            self._clear_resume_since(symbol, timeframe)
-                        else:
-                            # 正常增量获取最近若干根K线
-                            candles = self.exchange.fetch_ohlcv(
-                                symbol,
-                                timeframe=timeframe,
-                                limit=RECENT_CANDLE_LIMIT,
-                            )
-                            if not candles:
-                                continue
-                            with self._lock:
-                                current = self.data.setdefault(symbol, {}).get(timeframe, [])
-                                merged = self._merge_candles(timeframe, current, candles)
-                                self.data[symbol][timeframe] = merged
-                            self._notify_update(symbol, timeframe)
-                    except ccxt.BaseError as exc:
-                        logger.error("更新最新K线失败 (%s %s): %s", symbol, timeframe, exc)
-                        # 记录应当从何时恢复拉取，避免重连后从当前时间开始导致丢K
-                        with self._lock:
-                            current = self.data.get(symbol, {}).get(timeframe, [])
-                        if current:
-                            last_ts = int(current[-1]["timestamp"])
-                        else:
-                            last_ts = self.start_time_ms
-                        tf_ms = TIMEFRAME_TO_MS[timeframe]
-                        # 回退一个周期，确保包含可能未完全收盘的K线，去重由 _merge_candles 处理
-                        since_ms = max(self.start_time_ms, last_ts - tf_ms)
-                        self._set_resume_since(symbol, timeframe, since_ms)
-                        time.sleep(2)
-                        continue
-            if self._stop_event.wait(RECENT_FETCH_INTERVAL):
-                break
-
-    def _persist_loop(self) -> None:
-        """每隔 PERSIST_INTERVAL 秒把内存快照写 CSV 并保存恢复点。"""
-        while not self._stop_event.wait(PERSIST_INTERVAL):
-            self._persist_all()
-
-    def _persist_all(self) -> None:
-        """在锁内复制 data 后落盘，避免长时间持锁。"""
-        if not self._ready.is_set():
-            return
-        with self._lock:
-            snapshot = {
-                symbol: {tf: list(data) for tf, data in tf_map.items()}
-                for symbol, tf_map in self.data.items()
-            }
-        for symbol, tf_map in snapshot.items():
-            for timeframe, data in tf_map.items():
-                self._write_to_disk(symbol, timeframe, data)
-        # 周期性也保存一次恢复点，保证一致性
-        self._save_resume_since()
-
-    def is_ready(self) -> bool:
-        return self._ready.is_set()
-
-    def wait_ready(self, timeout: Optional[float] = None) -> bool:
-        return self._ready.wait(timeout)
-
-    def get_available_timeframes(self) -> List[str]:
-        return list(self.available_timeframes)
-
-    def get_derived_timeframes(self) -> List[str]:
-        return list(self.derived_map.keys())
-
-    def _get_base_klines(
-        self,
-        symbol: str,
-        timeframe: str,
-        start_ms: Optional[int],
-        end_ms: Optional[int],
-        limit: Optional[int],
-    ) -> List[Dict[str, float]]:
-        """从内存读取已缓存的基础周期 K 线并按时间/limit 裁剪。"""
-        with self._lock:
-            candles = list(self.data.get(symbol, {}).get(timeframe, []))
-        if start_ms is not None:
-            candles = [row for row in candles if row["timestamp"] >= start_ms]
-        if end_ms is not None:
-            candles = [row for row in candles if row["timestamp"] <= end_ms]
-        if limit:
-            candles = candles[-limit:]
-        return candles
-
-    def get_klines(
-        self,
-        symbol: str,
-        timeframe: str,
-        start_time: Optional[object] = None,
-        end_time: Optional[object] = None,
-        limit: Optional[int] = None,
-    ) -> List[Dict[str, float]]:
-        """对外查询：基础周期直接返回；衍生周期从 derived_map 取 base，resample 后对齐时间戳再裁剪。"""
-        if symbol not in self.symbols:
-            raise HTTPException(status_code=404, detail=f"symbol {symbol} 不可用")
-        self.wait_ready()
-        start_ms = parse_timestamp(start_time)
-        end_ms = parse_timestamp(end_time)
-        if timeframe in self.timeframes:
-            return self._get_base_klines(symbol, timeframe, start_ms, end_ms, limit)
-        base_tf = self.derived_map.get(timeframe)
-        if not base_tf:
-            raise HTTPException(status_code=404, detail=f"{symbol} 时间周期 {timeframe} 不可用")
-        target_minutes = timeframe_to_minutes(timeframe)
-        if target_minutes is None:
-            raise HTTPException(status_code=400, detail=f"不支持的时间周期: {timeframe}")
-        target_ms = target_minutes * 60_000
-        # 起点前移一根目标周期长度，保证首根合成 K 边界完整
-        adjusted_start = None if start_ms is None else max(0, start_ms - target_ms)
-        base_candles = self._get_base_klines(symbol, base_tf, adjusted_start, end_ms, None)
-        if not base_candles:
-            return []
-        df = pd.DataFrame(base_candles)
-        if df.empty:
-            return []
-        df = df.drop_duplicates(subset=["timestamp"], keep="last").sort_values("timestamp")
-        df["date"] = pd.to_datetime(df["timestamp"], unit="ms", utc=True)
-        # resample_to_interval 按「分钟」目标周期聚合 OHLCV
-        resampled = self.resample_df(df, target_minutes)
-        if resampled is None or resampled.empty:
-            return []
-        # 统一得到毫秒 timestamp 列（resample 可能返回 date 或 DatetimeIndex）
-        if "timestamp" in resampled.columns:
-            resampled_df = resampled.copy()
-        else:
-            resampled_df = resampled.copy()
-            if "date" in resampled_df.columns:
-                dates = pd.to_datetime(resampled_df["date"], utc=True, errors="coerce")
-                resampled_df["timestamp"] = (dates.astype("int64", copy=False) // 1_000_000).astype("int64")
-            elif isinstance(resampled_df.index, pd.DatetimeIndex):
-                idx = resampled_df.index
-                if idx.tz is None:
-                    idx = idx.tz_localize("UTC")
-                else:
-                    idx = idx.tz_convert("UTC")
-                resampled_df["timestamp"] = (idx.astype("int64", copy=False) // 1_000_000).astype("int64")
-            else:
-                raise HTTPException(status_code=500, detail=f"聚合结果缺少 timestamp 列 ({timeframe})")
-        resampled_df = resampled_df.dropna(subset=["timestamp"]).sort_values("timestamp")
-        if start_ms is not None:
-            resampled_df = resampled_df[resampled_df["timestamp"] >= start_ms]
-        if end_ms is not None:
-            resampled_df = resampled_df[resampled_df["timestamp"] <= end_ms]
-        if resampled_df.empty:
-            return []
-        resampled_df["datetime"] = resampled_df["timestamp"].apply(to_utc_iso)
-        for column in ["open", "high", "low", "close", "volume"]:
-            if column not in resampled_df.columns:
-                resampled_df[column] = 0.0
-        resampled_df = resampled_df[["timestamp", "datetime", "open", "high", "low", "close", "volume"]]
-        result = resampled_df.to_dict("records")
-        if limit:
-            result = result[-limit:]
-        logger.debug(
-            "衍生周期返回",
-            extra={
-                "symbol": symbol,
-                "timeframe": timeframe,
-                "base_timeframe": base_tf,
-                "count": len(result),
-            },
-        )
-        return result
-
-
-def create_app(provider: DataProvider) -> FastAPI:
-    """构造 FastAPI 应用：lifespan 内同步 initialize 并启动后台拉数；WebSocket 实时推送。"""
-    ws_manager = WebSocketManager()
-
-    def _on_data_update(symbol: str, base_tf: str) -> None:
-        """后台刷新线程回调：广播基础及衍生周期更新给 WebSocket 订阅者。"""
-        with provider._lock:
-            base_data = list(provider.data.get(symbol, {}).get(base_tf, []))
-        recent = base_data[-WS_UPDATE_CANDLE_COUNT:] if base_data else []
-        if recent:
-            ws_manager.broadcast_from_thread(symbol, base_tf, recent)
-        for derived_tf, src_base in provider.derived_map.items():
-            if src_base != base_tf or not ws_manager.has_subscribers(symbol, derived_tf):
-                continue
-            try:
-                target_min = timeframe_to_minutes(derived_tf)
-                if target_min is None:
-                    continue
-                now_ms = int(time.time() * 1000)
-                window_ms = target_min * 60_000 * (WS_UPDATE_CANDLE_COUNT + 2)
-                derived = provider.get_klines(
-                    symbol, derived_tf, start_time=now_ms - window_ms, limit=WS_UPDATE_CANDLE_COUNT,
-                )
-                if derived:
-                    ws_manager.broadcast_from_thread(symbol, derived_tf, derived)
-            except Exception as exc:
-                logger.debug("衍生周期广播失败 %s %s: %s", symbol, derived_tf, exc)
-
-    @asynccontextmanager
-    async def lifespan(app: FastAPI):
-        loop = asyncio.get_running_loop()
-        ws_manager.set_loop(loop)
-        provider.on_update(_on_data_update)
-        await loop.run_in_executor(None, provider.initialize)
-        provider.start_background_workers()
-        try:
-            yield
-        finally:
-            provider.stop()
-
-    app = FastAPI(title="Chan 数据提供商", version="1.0.0", lifespan=lifespan)
-
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=["*"],
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
-
-    @app.get("/health")
-    async def health() -> Dict[str, object]:
-        """存活检查：交易所、交易对、基础/衍生周期、是否已完成冷启动。"""
-        return {
-            "status": "ok",
-            "exchange": provider.exchange_name,
-            "symbols": provider.symbols,
-            "base_timeframes": provider.timeframes,
-            "derived_timeframes": provider.get_derived_timeframes(),
-            "timeframes": provider.get_available_timeframes(),
-            "ready": provider.is_ready(),
-        }
-
-    @app.get("/timeframes")
-    async def list_timeframes() -> Dict[str, List[str]]:
-        """返回配置的基础周期与可合成的衍生周期列表。"""
-        provider.wait_ready()
-        return {
-            "base_timeframes": provider.timeframes,
-            "derived_timeframes": provider.get_derived_timeframes(),
-            "timeframes": provider.get_available_timeframes(),
-        }
-
-    @app.get("/api/candles")
-    async def api_candles(
-        symbol: str = Query(..., description="如 BTC/USDT"),
-        tf: str = Query("1m", description="时间周期"),
-        start: Optional[int] = Query(None, description="开始时间戳(ms)"),
-        end: Optional[int] = Query(None, description="结束时间戳(ms)"),
-        limit: Optional[int] = Query(None, description="可选，限制返回数量"),
-    ):
-        """按交易对与时间周期返回 OHLCV；tf 支持配置的基础周期及衍生合成周期。"""
-        data = provider.get_klines(symbol=symbol, timeframe=tf, start_time=start, end_time=end, limit=limit)
-        return data
-
-    @app.get("/")
-    async def root() -> Dict[str, object]:
-        """根路径：服务名、交易所、交易对与可用周期（含 ready 标志）。"""
-        return {
-            "service": "Data Provider",
-            "exchange": provider.exchange_name,
-            "symbols": provider.symbols,
-            "base_timeframes": provider.timeframes,
-            "derived_timeframes": provider.get_derived_timeframes(),
-            "timeframes": provider.get_available_timeframes(),
-            "ready": provider.is_ready(),
-        }
-
-    @app.websocket("/ws")
-    async def websocket_endpoint(ws: WebSocket):
-        """WebSocket 实时 K 线推送。
-
-        客户端发送 JSON:
-            {"action": "subscribe",   "symbol": "BTC/USDT:USDT", "timeframe": "1m"}
-            {"action": "unsubscribe", "symbol": "BTC/USDT:USDT", "timeframe": "1m"}
-            {"action": "ping"}
-        服务端推送:
-            {"type": "subscribed",   "symbol": "...", "timeframe": "..."}
-            {"type": "snapshot",     "symbol": "...", "timeframe": "...", "data": [...]}
-            {"type": "kline",        "symbol": "...", "timeframe": "...", "data": [...]}
-            {"type": "pong"}
-            {"type": "error",        "message": "..."}
-        """
-        await ws_manager.connect(ws)
-        try:
-            while True:
-                raw = await ws.receive_text()
-                try:
-                    msg = json.loads(raw)
-                except json.JSONDecodeError:
-                    await ws.send_text(json.dumps({"type": "error", "message": "invalid JSON"}))
-                    continue
-
-                action = msg.get("action", "")
-                symbol = str(msg.get("symbol", "")).strip()
-                timeframe = str(msg.get("timeframe", "")).strip()
-
-                if action == "ping":
-                    await ws.send_text(json.dumps({"type": "pong"}))
-
-                elif action == "subscribe":
-                    if not symbol or not timeframe:
-                        await ws.send_text(json.dumps(
-                            {"type": "error", "message": "需要 symbol 和 timeframe 字段"}
-                        ))
-                        continue
-                    await ws_manager.subscribe(ws, symbol, timeframe)
-                    await ws.send_text(json.dumps(
-                        {"type": "subscribed", "symbol": symbol, "timeframe": timeframe},
-                        ensure_ascii=False,
-                    ))
-                    try:
-                        snapshot = provider.get_klines(symbol, timeframe, limit=DEFAULT_LIMIT)
-                        if snapshot:
-                            await ws.send_text(json.dumps(
-                                {"type": "snapshot", "symbol": symbol, "timeframe": timeframe, "data": snapshot},
-                                ensure_ascii=False,
-                            ))
-                    except Exception as exc:
-                        await ws.send_text(json.dumps({"type": "error", "message": str(exc)}))
-
-                elif action == "unsubscribe":
-                    await ws_manager.unsubscribe(ws, symbol, timeframe)
-                    await ws.send_text(json.dumps(
-                        {"type": "unsubscribed", "symbol": symbol, "timeframe": timeframe},
-                        ensure_ascii=False,
-                    ))
-
-                else:
-                    await ws.send_text(json.dumps({"type": "error", "message": f"未知 action: {action}"}))
-
-        except WebSocketDisconnect:
-            pass
-        finally:
-            await ws_manager.disconnect(ws)
-
-    return app
-
-
-def build_app() -> FastAPI:
-    """默认入口：从环境变量 CONFIG_PATH（或 config.json）加载配置并创建 FastAPI app。"""
-    config_path = Path(os.getenv("CONFIG_PATH", "config.json"))
-    provider = DataProvider(config_path)
-    return create_app(provider)
-
-
-app = build_app()
-
-
-def main() -> None:
-    """直接运行本模块时启动 uvicorn（监听 UVICORN_HOST / UVICORN_PORT）。"""
-    host = os.getenv("UVICORN_HOST", "0.0.0.0")
-    port = int(os.getenv("UVICORN_PORT", "9009"))
-
-    uvicorn.run(app, host=host, port=port, log_level=os.getenv("UVICORN_LOG_LEVEL", "info"))
-
-
-if __name__ == "__main__":
-    main()
-

data_provider/requirements.txt

@@ -1,5 +0,0 @@
-ccxt>=4.0.0,<5.0.0
-fastapi>=0.110.0,<1.0.0
-uvicorn[standard]>=0.23.0,<1.0.0
-pandas>=2.0.0,<3.0.0
-technical==1.5.0

deploy.sh

@@ -1,82 +0,0 @@
-#!/bin/bash
-# 缠论分析系统生产环境部署脚本
-
-# 显示执行的命令
-set -x
-
-# 确保脚本在错误时停止
-set -e
-
-# 项目根目录
-PROJECT_DIR=$(pwd)
-echo "项目将部署在: $PROJECT_DIR"
-
-# 创建虚拟环境
-echo "创建Python虚拟环境..."
-python3 -m venv venv
-source venv/bin/activate
-
-# 安装依赖
-echo "安装依赖包..."
-pip install --upgrade pip
-pip install flask pandas matplotlib ccxt pytz talib-binary gunicorn
-
-# 安装任何额外的系统依赖
-# sudo apt-get update
-# sudo apt-get install -y python3-dev
-
-# 检查目录结构
-echo "检查目录结构..."
-mkdir -p web/templates
-
-# 创建日志目录
-mkdir -p logs
-
-# 创建启动脚本
-echo "创建启动脚本..."
-cat > start_service.sh << 'EOF'
-#!/bin/bash
-# 缠论分析系统启动脚本
-
-# 项目根目录
-PROJECT_DIR=$(pwd)
-cd $PROJECT_DIR
-
-# 激活虚拟环境
-source venv/bin/activate
-
-# 启动服务
-cd web
-echo "启动缠论分析系统服务..."
-gunicorn app:app --bind=0.0.0.0:8123 --workers=4 --timeout=120 --log-level=info --log-file=logs/chanlun.log --daemon
-
-echo "服务已启动，端口8123"
-echo "日志文件位置: $PROJECT_DIR/web/logs/chanlun.log"
-EOF
-
-# 创建停止脚本
-echo "创建停止脚本..."
-cat > stop_service.sh << 'EOF'
-#!/bin/bash
-# 停止缠论分析系统服务
-
-echo "停止缠论分析系统服务..."
-pkill -f "gunicorn app:app"
-echo "服务已停止"
-EOF
-
-# 添加执行权限
-chmod +x start_service.sh
-chmod +x stop_service.sh
-
-# 修改app.py中的调试模式（生产环境应关闭调试模式）
-if [ -f web/app.py ]; then
-    echo "配置app.py为生产环境模式..."
-    sed -i 's/app.run(debug=True, host='\''0.0.0.0'\'', port=8123)/# 在生产环境中，使用gunicorn启动服务\n# app.run(debug=False, host='\''0.0.0.0'\'', port=8124)/' user_data/Chan/web/app.py
-else
-    echo "警告: 未找到app.py文件"
-fi
-
-echo "部署完成！"
-echo "使用 ./start_service.sh 启动服务"
-echo "使用 ./stop_service.sh 停止服务"

fx_strength_example.py

@@ -1,162 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-分型强度检测使用示例
-该文件展示如何使用ChanKLC类中新增的分型强度检测功能
-"""
-
-from ChanKLC import ChanKLC
-from ChanEnum import Chan_FX_TYPE
-import ChanKLU
-
-
-def demo_fx_strength_detection():
-    """
-    演示分型强度检测功能
-    """
-    print("=== 分型强度检测功能演示 ===\n")
-    
-    # 假设我们有一个已经确定为分型的KLC对象
-    # 这里仅为演示，实际使用中KLC对象应该通过正常流程创建
-    
-    print("1. 分型强度计算方法:")
-    print("   - calculate_fx_strength(): 返回0-100的强度分数")
-    print("   - get_fx_strength_level(): 返回强度等级描述")
-    print("   - is_strong_fx(threshold): 判断是否为强分型")
-    print()
-    
-    print("2. 强度评分维度 (总分100分):")
-    print("   - 价格差异强度: 40分 (与相邻K线的价格差异)")
-    print("   - 突破历史点位: 20分 (是否突破重要高低点)")
-    print("   - 成交量确认: 15分 (分型形成时的成交量)")
-    print("   - RSI背离确认: 15分 (价格与RSI的背离)")
-    print("   - MACD背离确认: 10分 (价格与MACD的背离)")
-    print()
-    
-    print("3. 强度等级分类:")
-    print("   - 极强: 80-100分")
-    print("   - 强: 60-79分")  
-    print("   - 中等: 40-59分")
-    print("   - 弱: 20-39分")
-    print("   - 极弱: 0-19分")
-    print()
-    
-    print("4. 在特征数据中的应用:")
-    print("   分型强度会自动集成到get_feature_data()方法返回的特征中:")
-    print("   - klc_fx_strength: 强度分数")
-    print("   - klc_fx_strength_level: 强度等级")
-    print("   - klc_is_strong_fx: 是否为强分型(布尔值)")
-    print("   - klc_fx_strength_extreme: 是否为极强分型")
-    print("   - klc_fx_strength_strong: 是否为强分型")
-    print("   - klc_fx_strength_medium: 是否为中等分型")
-    print("   - klc_fx_strength_weak: 是否为弱分型")
-    print("   - klc_fx_strength_very_weak: 是否为极弱分型")
-    print()
-
-
-def analyze_fx_strength(klc):
-    """
-    分析单个KLC的分型强度
-    
-    Args:
-        klc: ChanKLC对象
-    """
-    if klc.fx == Chan_FX_TYPE.UNKNOWN:
-        print(f"时间: {klc.start_time} - 无分型")
-        return
-    
-    fx_type = "顶分型" if klc.fx == Chan_FX_TYPE.TOP else "底分型"
-    strength = klc.calculate_fx_strength()
-    strength_level = klc.get_fx_strength_level()
-    is_strong = klc.is_strong_fx()
-    
-    print(f"时间: {klc.start_time}")
-    print(f"分型类型: {fx_type}")
-    print(f"强度分数: {strength}")
-    print(f"强度等级: {strength_level}")
-    print(f"是否强分型: {'是' if is_strong else '否'}")
-    print("-" * 30)
-
-
-def filter_strong_fractals(klc_list, min_strength=60):
-    """
-    筛选强分型
-    
-    Args:
-        klc_list: KLC对象列表
-        min_strength: 最小强度阈值
-        
-    Returns:
-        强分型列表
-    """
-    strong_fractals = []
-    
-    for klc in klc_list:
-        if klc.fx != Chan_FX_TYPE.UNKNOWN and klc.is_strong_fx(min_strength):
-            strong_fractals.append(klc)
-    
-    return strong_fractals
-
-
-def get_fractal_statistics(klc_list):
-    """
-    获取分型强度统计信息
-    
-    Args:
-        klc_list: KLC对象列表
-        
-    Returns:
-        统计信息字典
-    """
-    stats = {
-        'total_fractals': 0,
-        'top_fractals': 0,
-        'bottom_fractals': 0,
-        'extreme_strength': 0,  # 极强
-        'strong_strength': 0,   # 强
-        'medium_strength': 0,   # 中等
-        'weak_strength': 0,     # 弱
-        'very_weak_strength': 0,# 极弱
-        'avg_strength': 0
-    }
-    
-    strengths = []
-    
-    for klc in klc_list:
-        if klc.fx != Chan_FX_TYPE.UNKNOWN:
-            stats['total_fractals'] += 1
-            
-            if klc.fx == Chan_FX_TYPE.TOP:
-                stats['top_fractals'] += 1
-            else:
-                stats['bottom_fractals'] += 1
-            
-            strength = klc.calculate_fx_strength()
-            strengths.append(strength)
-            
-            if strength >= 80:
-                stats['extreme_strength'] += 1
-            elif strength >= 60:
-                stats['strong_strength'] += 1
-            elif strength >= 40:
-                stats['medium_strength'] += 1
-            elif strength >= 20:
-                stats['weak_strength'] += 1
-            else:
-                stats['very_weak_strength'] += 1
-    
-    if strengths:
-        stats['avg_strength'] = sum(strengths) / len(strengths)
-    
-    return stats
-
-
-if __name__ == "__main__":
-    demo_fx_strength_detection()
-    
-    print("=== 使用建议 ===")
-    print("1. 在交易策略中，可以只关注强度>=60的分型")
-    print("2. 极强分型(>=80分)通常是重要的转折点")
-    print("3. 结合成交量和技术指标背离的分型更可靠")
-    print("4. 可以用分型强度来设置止损和止盈位置")
-    print("5. 分型强度可以作为机器学习模型的重要特征") 

gunicorn_start.sh

@@ -1,4 +0,0 @@
-#!/bin/bash
-cd /path/to/your/project/user_data/Chan/web
-source /path/to/your/virtualenv/bin/activate  # 如果使用虚拟环境
-exec gunicorn app:app -b 0.0.0.0:8123 --workers=4 --timeout 120

realtime_fx_example.py

@@ -1,220 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-实时K线分型强弱判断示例
-解决KLC滞后问题，提供即时的分型信号
-"""
-
-from ChanKLU import ChanKLU
-from ChanEnum import Chan_FX_TYPE
-import pandas as pd
-from datetime import datetime, timedelta
-
-class RealtimeFxAnalyzer:
-    """实时分型分析器"""
-    
-    def __init__(self):
-        self.klu_list = []
-        self.latest_signals = []
-        
-    def add_kline(self, time, open_price, high, low, close, volume, indicators=None):
-        """
-        添加新的K线数据并进行实时分析
-        
-        Args:
-            time: 时间
-            open_price, high, low, close, volume: K线数据
-            indicators: 技术指标字典 {'macd': xx, 'rsi': xx, 'ma5': xx, ...}
-        """
-        # 创建新的KLU对象
-        new_klu = ChanKLU(time, open_price, high, low, close, volume)
-        
-        # 设置技术指标
-        if indicators:
-            new_klu.set_indicators(indicators)
-        
-        # 设置索引
-        new_klu.set_idx(len(self.klu_list))
-        
-        # 建立前后关系链
-        if len(self.klu_list) >= 1:
-            prev_klu = self.klu_list[-1]
-            new_klu.set_pre(prev_klu)
-            prev_klu.set_next(new_klu)
-            
-        # 如果有足够的数据，设置前一根K线的next关系
-        if len(self.klu_list) >= 2:
-            prev_prev_klu = self.klu_list[-2]
-            prev_prev_klu.set_next(self.klu_list[-1])
-            
-        self.klu_list.append(new_klu)
-        
-        # 实时分析最近的K线分型
-        self._analyze_recent_fractals()
-        
-        return new_klu
-        
-    def _analyze_recent_fractals(self):
-        """分析最近的分型情况"""
-        if len(self.klu_list) < 3:
-            return
-            
-        # 检查倒数第二根K线的分型（因为需要左右两根K线确认）
-        target_idx = len(self.klu_list) - 2
-        if target_idx >= 1:
-            target_klu = self.klu_list[target_idx]
-            
-            # 进行实时分型分析
-            target_klu.update_realtime_analysis()
-            
-            # 如果发现分型，记录信号
-            if target_klu.fx_confirmed:
-                signal = target_klu.get_fx_signal()
-                signal_info = {
-                    'time': target_klu.time,
-                    'price': target_klu.close,
-                    'signal_type': signal[0],
-                    'strength': signal[1],
-                    'suggestion': signal[2],
-                    'fx_type': target_klu.fx_type
-                }
-                
-                self.latest_signals.append(signal_info)
-                
-                # 保持最近20个信号
-                if len(self.latest_signals) > 20:
-                    self.latest_signals.pop(0)
-                    
-                print(f"🔔 分型信号: {signal_info['time']} - {signal_info['signal_type']} "
-                      f"(强度: {signal_info['strength']}) - {signal_info['suggestion']}")
-    
-    def get_latest_signal(self):
-        """获取最新的分型信号"""
-        return self.latest_signals[-1] if self.latest_signals else None
-        
-    def get_current_fx_status(self):
-        """获取当前分型状态统计"""
-        if len(self.klu_list) < 10:
-            return {"status": "数据不足"}
-            
-        recent_10 = self.klu_list[-10:]
-        
-        top_fx_count = sum(1 for klu in recent_10 if klu.fx_type == Chan_FX_TYPE.TOP)
-        bottom_fx_count = sum(1 for klu in recent_10 if klu.fx_type == Chan_FX_TYPE.BOTTOM)
-        
-        strong_fx_count = sum(1 for klu in recent_10 if klu.fx_strength >= 65)
-        
-        return {
-            "最近10根K线": len(recent_10),
-            "顶分型数量": top_fx_count,
-            "底分型数量": bottom_fx_count,
-            "强分型数量": strong_fx_count,
-            "最新K线时间": recent_10[-1].time,
-            "最新信号": self.get_latest_signal()
-        }
-
-def simulate_realtime_trading():
-    """模拟实时交易场景"""
-    
-    print("=== 实时K线分型分析示例 ===\n")
-    
-    # 创建分析器
-    analyzer = RealtimeFxAnalyzer()
-    
-    # 模拟实时K线数据流
-    base_time = datetime.now()
-    base_price = 100.0
-    
-    print("开始接收K线数据...\n")
-    
-    for i in range(20):
-        # 模拟价格波动
-        if i < 5:  # 上涨阶段
-            price_change = 0.5
-        elif i < 10:  # 下跌阶段  
-            price_change = -0.8
-        elif i < 15:  # 震荡阶段
-            price_change = 0.3 * ((-1) ** i)
-        else:  # 再次上涨
-            price_change = 0.6
-            
-        current_price = base_price + price_change
-        
-        # 构造K线数据
-        open_price = base_price
-        high = max(open_price, current_price) + abs(price_change) * 0.2
-        low = min(open_price, current_price) - abs(price_change) * 0.2
-        close = current_price
-        volume = 1000 + i * 50
-        
-        # 模拟技术指标
-        indicators = {
-            'ma5': base_price + (i - 10) * 0.1,
-            'ma10': base_price + (i - 10) * 0.05,
-            'rsi': 50 + (i % 7 - 3) * 10,
-            'macd': (i % 6 - 3) * 0.01,
-            'macdhist': (i % 4 - 2) * 0.005,
-            'volume_ratio': 1.0 + (i % 3 - 1) * 0.2
-        }
-        
-        # 添加K线数据
-        kline_time = base_time + timedelta(minutes=i)
-        analyzer.add_kline(
-            time=kline_time.strftime("%Y-%m-%d %H:%M:%S"),
-            open_price=open_price,
-            high=high,
-            low=low,
-            close=close,
-            volume=volume,
-            indicators=indicators
-        )
-        
-        base_price = current_price
-        
-        # 每5根K线显示一次状态
-        if (i + 1) % 5 == 0:
-            status = analyzer.get_current_fx_status()
-            print(f"\n--- 第{i+1}根K线后的状态 ---")
-            for key, value in status.items():
-                if key != "最新信号":
-                    print(f"{key}: {value}")
-            
-            if "最新信号" in status and status["最新信号"]:
-                signal = status["最新信号"]
-                print(f"最新信号: {signal['signal_type']} (强度: {signal['strength']})")
-            print()
-    
-    print("\n=== 所有分型信号汇总 ===")
-    for signal in analyzer.latest_signals:
-        print(f"{signal['time']} | {signal['signal_type']} | 强度: {signal['strength']} | {signal['suggestion']}")
-
-def compare_latency():
-    """对比KLC和KLU方法的延迟差异"""
-    
-    print("\n=== 延迟对比分析 ===")
-    print("假设场景：连续包含关系的K线序列")
-    print("原始K线: K1, K2(包含K1), K3(包含K2), K4(突破), K5, K6")
-    print()
-    
-    print("KLC方法:")
-    print("- 需要等待K4确认包含关系结束")
-    print("- KLC1 = [K1+K2+K3], 在K4完成时才确定")
-    print("- 分型检测: 需要等待KLC1, KLC2, KLC3")
-    print("- 实际延迟: 可能6-8根原始K线")
-    print()
-    
-    print("KLU实时方法:")
-    print("- 每根K线完成时立即检测")
-    print("- K3完成时就能检测K2的分型状态")
-    print("- 实际延迟: 最多1根K线")
-    print()
-    
-    print("延迟改善: 从6-8根K线缩短到1根K线")
-    print("时间价值: 在5分钟K线下，可节省25-40分钟的反应时间")
-
-if __name__ == "__main__":
-    # 运行模拟
-    simulate_realtime_trading()
-    
-    # 显示延迟对比
-    compare_latency() 

requirements-dev.txt

@@ -0,0 +1,32 @@
+# Tests and research/ — everything beyond the core runtime.
+#
+#   .venv/bin/pip install -r requirements.txt -r requirements-dev.txt
+#   .venv/bin/python -m pytest chanlun/tests web/tests
+
+-r requirements.txt
+
+# --- tests -----------------------------------------------------------------
+pytest>=8.0
+
+# --- research/ -------------------------------------------------------------
+# pyarrow reads the data/binance/*.feather klines (research/lib/data.py) and
+# writes the parquet cache. Needed for research/, not by the web app.
+pyarrow>=15.0
+
+# Only research/step10_direct_return_label.py and step11_breakout_follow.py.
+# Neither is installed by default; skip this pair unless running those steps.
+scikit-learn>=1.4
+lightgbm>=4.3
+
+# --- indicator parity check (optional) -------------------------------------
+# chanlun/indicators/ta.py replaced TA-Lib and technical, so nothing here needs
+# them at runtime. chanlun/tests/test_ta_compat.py pins our output against
+# TA-Lib bar for bar and SKIPS SILENTLY when they are absent — meaning a change
+# to ta.py can look tested when it was not. Install these and re-run that file
+# whenever ta.py changes.
+#
+# TA-Lib needs the C library first:
+#   sudo apt-get install -y libta-lib0 ta-lib-dev
+#
+# TA-Lib>=0.6
+# technical>=1.7

requirements.txt

@@ -0,0 +1,29 @@
+# Core runtime — what `web/` and `chanlun/` need to run.
+#
+#   python -m venv .venv && .venv/bin/pip install -r requirements.txt
+#
+# Tests and research/ pull in more; see requirements-dev.txt.
+#
+# Requires Python >= 3.11 (imposed by pandas 3.x / numpy 2.x, not by our code).
+#
+# Lower bounds are the oldest versions believed safe. Verified set as of
+# 2026-08-27 on Python 3.14.4:
+#   pandas 3.0.5 · numpy 2.5.2 · Flask 3.1.3 · requests 2.34.2
+#   python-dateutil 2.9.0 · pytz 2026.3 · ccxt 4.5.75 · akshare 1.18.94
+
+# chanlun/ — kline pipeline and indicators.
+# pandas >= 2.2 for the "5min" offset alias used by chanlun/pipeline/resample.py.
+pandas>=2.2
+numpy>=1.26
+
+# web/ — Flask API and templates.
+Flask>=3.0
+requests>=2.31
+python-dateutil>=2.9
+pytz>=2024.1
+
+# Market data. ccxt drives the live websocket/REST state in
+# web/services/runtime/state.py; akshare only backs the A-share endpoints in
+# web/services/cn_stock.py.
+ccxt>=4.4
+akshare>=1.16

research/download_oos.py

@@ -0,0 +1,94 @@
+"""下载样本外验证用的新币种数据，存成与 freqtrade 一致的 feather。
+
+现有结论全部建立在 BTC/ETH/SOL 三个币上，参数（级别对、tol、SL/TP）也是
+在这三个币上挑的，存在选择偏差。本脚本补齐一批完全没参与过调参的品种。
+
+只拉 30m/2h：那是实测最强的一对，用它做样本外足够，且请求量只有全级别的四成。
+
+限速要点（踩过的坑）：
+  klines(limit=1500) 权重 30，上限 2400/分钟 = 80 次/分钟 = 0.75s/次，
+  0.8s 间隔正好卡在边缘，一旦触发 429，短退避跨不过计数窗口就会连续失败。
+  故间隔放到 1.3s、权重阈值压到 1400、429 时等满一个窗口。
+  另外分页失败不再丢弃整只币，已抓到的部分照样落盘。
+"""
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+
+import pandas as pd
+import requests
+
+OUT = Path(__file__).resolve().parents[1] / "data" / "binance" / "futures"
+BASE = "https://fapi.binance.com/fapi/v1/klines"
+PROXY = {"http": "http://127.0.0.1:7897", "https": "http://127.0.0.1:7897"}
+SYMBOLS = ["BNB", "XRP", "DOGE", "ADA", "AVAX", "LINK", "LTC", "TRX"]
+TFS = ["2h", "30m"]
+START_MS = int(pd.Timestamp("2019-01-01", tz="UTC").timestamp() * 1000)
+COLS = ["date", "open", "high", "low", "close", "volume"]
+GAP = 1.3
+WEIGHT_CAP = 1400
+
+
+def fetch(sess: requests.Session, symbol: str, tf: str) -> pd.DataFrame | None:
+    rows: list[list] = []
+    cur = START_MS
+    while True:
+        batch = None
+        for attempt in range(6):
+            try:
+                r = sess.get(BASE, params={"symbol": f"{symbol}USDT", "interval": tf,
+                                           "startTime": cur, "limit": 1500}, timeout=40)
+                if r.status_code in (418, 429):
+                    time.sleep(65)
+                    continue
+                if r.status_code == 400:
+                    return None
+                r.raise_for_status()
+                batch = r.json()
+                if int(r.headers.get("X-MBX-USED-WEIGHT-1M", 0) or 0) > WEIGHT_CAP:
+                    time.sleep(40)
+                break
+            except Exception:
+                time.sleep(5 * (attempt + 1))
+        if not batch:
+            break                      # 抓不动或抓完了，保留已有部分
+        rows.extend(batch)
+        nxt = int(batch[-1][0]) + 1
+        if nxt <= cur or len(batch) < 1500:
+            break
+        cur = nxt
+        time.sleep(GAP)
+    if len(rows) < 1000:
+        return None
+    df = pd.DataFrame(rows).iloc[:, :6]
+    df.columns = ["ts", "open", "high", "low", "close", "volume"]
+    df["date"] = pd.to_datetime(pd.to_numeric(df["ts"]), unit="ms", utc=True)
+    for c in ("open", "high", "low", "close", "volume"):
+        df[c] = pd.to_numeric(df[c])
+    return df[COLS].drop_duplicates("date").sort_values("date").reset_index(drop=True)
+
+
+def main() -> None:
+    OUT.mkdir(parents=True, exist_ok=True)
+    sess = requests.Session()
+    sess.proxies.update(PROXY)
+    jobs = [(s, tf) for tf in TFS for s in SYMBOLS]
+    print(f"[下载] {len(jobs)} 个任务，单线程 {GAP}s 间隔", flush=True)
+    for i, (sym, tf) in enumerate(jobs, 1):
+        path = OUT / f"{sym}_USDT_USDT-{tf}-futures.feather"
+        if path.exists():
+            print(f"  [{i}/{len(jobs)}] {sym} {tf} 已存在", flush=True)
+            continue
+        df = fetch(sess, sym, tf)
+        if df is None:
+            print(f"  [{i}/{len(jobs)}] {sym} {tf} 失败", flush=True)
+            continue
+        df.to_feather(path)
+        print(f"  [{i}/{len(jobs)}] {sym} {tf} {len(df)} 根 "
+              f"{df['date'].min():%Y-%m-%d}~{df['date'].max():%Y-%m-%d}", flush=True)
+
+
+if __name__ == "__main__":
+    sys.exit(main())