openfund-maker 2.2.9__py3-none-any.whl → 2.3.2__py3-none-any.whl

maker/BestTopDownStrategyMaker.py

@@ -0,0 +1,404 @@
+# -*- coding: utf-8 -*-
+import traceback
+from typing import override
+
+from maker.StrategyMaker import StrategyMaker
+
+class BestTopDownStrategyMaker(StrategyMaker):
+    def __init__(self, config, platform_config, common_config, logger=None, exchangeKey='okx'):
+        super().__init__(config, platform_config, common_config, logger, exchangeKey)
+        self.htf_last_struct = {} # 缓存HTF的最后一个结构
+        self.logger = logger
+        
+    @override
+    def reset_all_cache(self, symbol):
+        """
+        重置所有缓存
+        """
+        super().reset_all_cache(symbol)    
+        self.htf_last_struct.pop(symbol, None) 
+        self.clear_cache_historical_klines_df(symbol)
+        
+    @override
+    def process_pair(self,symbol,pair_config):
+        self.logger.info("-" * 60)
+        """_summary_
+        HTF (Daily & 4H)
+            1.1. Price's Current Trend 市场趋势
+            1.2. Who's In Control 供需控制
+            1.3. Key Support & Resistance Levels 关键位置
+        ATF (1H & 30 Min & 15 Min)
+            2.1. Market Condition
+            2.2. PD Arrays
+            2.3. Liquidity Areas
+        ETF (5 Min & 1 Min)
+            1. Reversal Signs
+            2. PD Arrays
+            3. Place Order 
+
+        """
+        try:
+            # 是否有持仓，有持仓不进行下单
+            if self.fetch_position(symbol=symbol) :
+                self.reset_all_cache(symbol)
+                self.logger.info(f"{symbol} : 有持仓合约，不进行下单。")          
+                return           
+            precision = self.get_precision_length(symbol)
+            
+            top_down_strategy = pair_config.get('top_down_strategy',{})
+
+            """
+            获取策略配置
+            """
+            htf = str(top_down_strategy.get('HTF','4h'))  
+            atf = str(top_down_strategy.get('ATF','15m'))
+            etf = str(top_down_strategy.get('ETF', '1m')) 
+
+            self.logger.info(f"{symbol} : TopDownSMC策略 {htf}|{atf}|{etf} \n")
+            market_price = self.get_market_price(symbol=symbol)
+            
+            """
+            step 1 : Higher Time Frame Analysis
+            """
+            step = "1"
+            # 初始化HTF趋势相关变量
+            htf_side, htf_struct, htf_trend = None, None, None
+            # HTF 缓存，减小流量损耗            
+            htf_df = self.get_historical_klines_df_by_cache(symbol=symbol, tf=htf)
+            htf_struct =self.build_struct(symbol=symbol, data=htf_df)
+            
+            htf_latest_struct = self.get_latest_struct(symbol=symbol, data=htf_struct)
+            htf_trend = htf_latest_struct[self.STRUCT_DIRECTION_COL]
+            htf_side = self.BUY_SIDE if htf_trend == self.BULLISH_TREND else self.SELL_SIDE
+            # 1.1. Price's Current Trend 市场趋势（HTF）
+            step = "1.1"
+            self.logger.info(f"{symbol} : {step}. HTF {htf} Price's Current Trend is {htf_trend}。")
+            # 1.2. Who's In Control 供需控制，Bullish 或者 Bearish ｜ Choch 或者 BOS
+            step = "1.2"
+            self.logger.info(f"{symbol} : {step}. HTF {htf} struct is {htf_latest_struct[self.STRUCT_COL]}。")
+
+            # 1.3. HTF Key Support & Resistance Levels 支撑或阻力关键位置(HTF 看上下的供需区位置）
+            step = "1.3"
+            htf_OBs_df = self.find_OBs(symbol=symbol,struct=htf_struct)
+
+            if htf_OBs_df is None or len(htf_OBs_df) == 0:
+                self.logger.debug(f"{symbol} : {step}. HTF {htf} 未找到OB。")
+                return
+            else:
+                # self.logger.debug(f"{symbol} : {step}. HTF {htf} 找到OB。")
+            
+                htf_support_OB = self.get_latest_OB(symbol=symbol,data=htf_OBs_df,trend=self.BULLISH_TREND)
+                if htf_support_OB :
+                    htf_support_price = htf_support_OB.get(self.OB_MID_COL)
+                else:
+                    htf_support_price = htf_struct.at[htf_struct.index[-1], self.STRUCT_LOW_COL]
+            
+                htf_resistance_OB = self.get_latest_OB(symbol=symbol,data=htf_OBs_df,trend=self.BEARISH_TREND)
+                if htf_resistance_OB :
+                    htf_resistance_price = htf_resistance_OB.get(self.OB_MID_COL)
+                else:
+                    htf_resistance_price = htf_struct.at[htf_struct.index[-1], self.STRUCT_HIGH_COL]
+                self.logger.info(f"{symbol} : {step}. HTF {htf}, Key Support={htf_support_price:.{precision}f} & Key Resistance={htf_resistance_price:.{precision}f} ")
+            #1.4. 检查关键支撑位和阻力位之间是否有利润空间。
+            step = "1.4"
+            # 计算支撑位和阻力位之间的利润空间百分比
+            htf_profit_percent = abs((htf_resistance_price - htf_support_price) / htf_support_price * 100)
+            min_profit_percent = pair_config.get('min_profit_percent', 4) # 默认最小利润空间为0.5%
+
+            if htf_profit_percent < min_profit_percent:
+                self.logger.info(f"{symbol} : {step}. HTF {htf} 支撑位={htf_support_price:.{precision}f} 与阻力位={htf_resistance_price:.{precision}f} 之间利润空间{htf_profit_percent:.2f}% < {min_profit_percent}%，等待...")
+                return
+            else:
+                self.logger.info(f"{symbol} : {step}. HTF {htf} 支撑位={htf_support_price:.{precision}f} 与阻力位={htf_resistance_price:.{precision}f} 之间利润空间{htf_profit_percent:.2f}% >= {min_profit_percent}%")
+                            
+            # 1.5. 检查当前价格是否在关键支撑位和阻力位，支撑位可以做多，阻力位可以做空。
+            step = "1.5"
+            htf_support_OB_top = None
+            if htf_support_OB :
+                htf_support_OB_top = htf_support_OB.get(self.OB_HIGH_COL)
+            htf_resistance_OB_bottom = None    
+            if htf_resistance_OB :
+                htf_resistance_OB_bottom = htf_resistance_OB.get(self.OB_LOW_COL)
+            
+            # 检查支撑位做多条件
+            if htf_support_OB_top is not None:
+                if market_price <= htf_support_OB_top:
+                    # 价格进入支撑OB，可以开始做多
+                    if htf_side != self.BUY_SIDE: 
+                        htf_side = self.BUY_SIDE         
+                    self.logger.info(f"{symbol} : {step}. HTF {htf} 当前价格{market_price:.{precision}f} <= HTF_OB_TOP{htf_support_OB_top:.{precision}f}, 开始做多{htf_side}。")
+                else:
+                    self.logger.info(f"{symbol} : {step}. HTF {htf} 当前价格{market_price:.{precision}f} > HTF_OB_TOP{htf_support_OB_top:.{precision}f}, 无需做多{htf_side}。")
+            else:
+                self.logger.info(f"{symbol} : {step}. HTF {htf} 未找到HTF_OB_TOP。")
+            
+            # 检查阻力位做空条件
+            if htf_resistance_OB_bottom is not None:
+                if market_price >= htf_resistance_OB_bottom:
+                    # 价格进入阻力OB，可以开始做空
+                    if htf_side != self.SELL_SIDE: 
+                        htf_side = self.SELL_SIDE         
+                    self.logger.info(f"{symbol} : {step}. HTF {htf} 当前价格{market_price:.{precision}f} >= HTF_OB_BOTTOM{htf_resistance_OB_bottom:.{precision}f}, 开始做空{htf_side}。")
+                else:
+                    self.logger.info(f"{symbol} : {step}. HTF {htf} 当前价格{market_price:.{precision}f} < HTF_OB_BOTTOM{htf_resistance_OB_bottom:.{precision}f}, 无需做空{htf_side}。")
+            else:
+                self.logger.info(f"{symbol} : {step}. HTF {htf} 未找到HTF_OB_BOTTOM。")
+      
+            """
+            step 2 : Analysis Time Frames
+            """
+            # 2. ATF Step 
+            # 2.1 Market Condition 市场状况（ATF 看上下的供需区位置）
+            
+            atf_side, atf_struct, atf_trend = None, None, None
+            atf_df = self.get_historical_klines_df(symbol=symbol, tf=atf)
+            atf_struct =self.build_struct(symbol=symbol, data=atf_df)            
+            # 获取最新的市场结构,如果为空则返回None
+            atf_latest_struct = self.get_latest_struct(symbol=symbol, data=atf_struct)
+            if atf_latest_struct is None:
+                self.logger.info(f"{symbol} : {step}. ATF {atf} 未形成结构，等待... ")
+                return
+            atf_trend = atf_latest_struct[self.STRUCT_DIRECTION_COL]
+            atf_side = self.BUY_SIDE if atf_trend == self.BULLISH_TREND else self.SELL_SIDE
+            # 2.1. Price's Current Trend 市场趋势（HTF ）
+            step = "2.1"
+            self.logger.info(f"{symbol} : {step}. ATF {atf} Price's Current Trend is {atf_trend}。")
+            # 2.2. Who's In Control 供需控制，Bullish 或者 Bearish ｜ Choch 或者 BOS
+            step = "2.2"
+            self.logger.info(f"{symbol} : {step}. ATF {atf} struct is {atf_latest_struct[self.STRUCT_COL]}。")
+            # 2.3. 检查关键支撑位和阻力位之间是否有利润空间。
+            step = "2.3"
+            atf_OBs_df = self.find_OBs(symbol=symbol,struct=atf_struct)
+            atf_support_OB = self.get_latest_OB(symbol=symbol,data=atf_OBs_df,trend=self.BULLISH_TREND)
+            if atf_support_OB :
+                atf_support_price = atf_support_OB.get(self.OB_MID_COL)
+            else:
+                atf_support_price = atf_struct.at[atf_struct.index[-1], self.STRUCT_LOW_COL]
+        
+            atf_resistance_OB = self.get_latest_OB(symbol=symbol,data=atf_OBs_df,trend=self.BEARISH_TREND)
+            if atf_resistance_OB :
+                atf_resistance_price = atf_resistance_OB.get(self.OB_MID_COL)
+            else:
+                atf_resistance_price = atf_struct.at[atf_struct.index[-1], self.STRUCT_HIGH_COL]
+                
+            self.logger.info(f"{symbol} : {step}.1 ATF {atf}, Key Support={atf_support_price:.{precision}f} "
+                            f"& Key Resistance={atf_resistance_price:.{precision}f} ")
+            # 计算支撑位和阻力位之间的利润空间百分比
+            atf_profit_percent = abs((atf_resistance_price - atf_support_price) / atf_support_price * 100)
+
+            if atf_profit_percent < min_profit_percent:
+                self.logger.info(f"{symbol} : {step}.2 ATF {atf} 支撑位={atf_support_price:.{precision}f} 与阻力位={atf_resistance_price:.{precision}f} "
+                    f"之间利润空间{atf_profit_percent:.2f}% < {min_profit_percent}%，等待...")
+                return
+            else:
+                self.logger.info(f"{symbol} : {step}.2 ATF {atf} 支撑位={atf_support_price:.{precision}f} 与阻力位={atf_resistance_price:.{precision}f} "
+                    f"之间利润空间{atf_profit_percent:.2f}% >= {min_profit_percent}%，允许下单...")
+                
+            
+            
+            # 2.4. ATF 方向要和 HTF方向一致
+            step = "2.4"
+     
+            if htf_side != atf_side:
+                self.logger.info(f"{symbol} : {step}. ATF {atf} is {atf_side} 与 HTF {htf} is {htf_side} 不一致，等待...")
+                return
+            else:
+                self.logger.info(f"{symbol} : {step}. ATF {atf} is {atf_side} 与 HTF {htf} is {htf_side} 一致。")
+
+            #2.5. 反转结构CHOCH， check Liquidity Areas ，检查当前结构是否是流动性摄取。
+            step = "2.5"
+            # if "CHOCH" in atf_struct[self.STRUCT_COL] or "BOS" in atf_struct[self.STRUCT_COL]:
+            # 2.5.1. Equal Lows & Equal Highs
+            end_idx = atf_latest_struct[self.STRUCT_HIGH_INDEX_COL] if atf_side == self.BUY_SIDE else atf_latest_struct[self.STRUCT_LOW_INDEX_COL]
+            last_EQ = self.find_EQH_EQL(symbol=symbol, data=atf_df, trend=atf_trend, end_idx=end_idx, pair_config=pair_config)
+            if last_EQ and last_EQ[self.HAS_EQ_KEY]:
+                price_eq = last_EQ[self.EQUAL_HIGH_COL] if atf_side == self.BUY_SIDE else last_EQ[self.EQUAL_LOW_COL]
+                self.logger.info(f"{symbol} : {step}.1 ATF {atf} {atf_side} find EQ {price_eq}")
+                # 检查是否Liquidity Sweeps
+                if (atf_side == self.BUY_SIDE and atf_latest_struct[self.STRUCT_HIGH_COL] > price_eq) \
+                    or (atf_side == self.SELL_SIDE and atf_latest_struct[self.STRUCT_LOW_COL] < price_eq):
+            
+                    atf_side = self.SELL_SIDE if atf_side == self.BUY_SIDE else self.BUY_SIDE
+                    self.logger.info(f"{symbol} : {step}.1 ATF {atf} Liquidity Sweeps , Reverse the ATF {atf} {atf_side} side。")
+                else:
+                    self.logger.info(f"{symbol} : {step}.1 ATF {atf} is not found Liquidity Sweeps .")                
+            else:    
+                self.logger.info(f"{symbol} : {step}.1 ATF {atf} is not found EQ .") 
+        
+            # FIXME 2.5.2. Dynamic Trendlines and Channels
+            # atf_pre_struct = atf_struct[atf_struct[self.STRUCT_DIRECTION_COL].notna()].iloc[-2]  # 看前一个结构是否为动态趋势           
+            # atf_start_index = min(atf_pre_struct[self.STRUCT_LOW_INDEX_COL] ,atf_pre_struct[self.STRUCT_HIGH_INDEX_COL])
+            # atf_end_index = max(atf_latest_struct[self.STRUCT_LOW_INDEX_COL] ,atf_latest_struct[self.STRUCT_HIGH_INDEX_COL]) 
+
+            # is_dynamic_trendlines = self.identify_dynamic_trendlines(symbol=symbol, data=atf_struct, trend=atf_trend, start_idx=atf_start_index, end_idx=atf_end_index)
+            # if is_dynamic_trendlines :
+            #     self.logger.info(f"{symbol} : {step}.2 ATF {atf} {atf_trend} find Dynamic Trendlines .")
+            # else:
+            #     self.logger.info(f"{symbol} : {step}.2 ATF {atf} {atf_trend} not find Dynamic Trendlines .")
+
+
+            # 2.6. 在HTF供需区范围，找ATF的PDArray，FVG和OB，供需区，计算监测下单区域范围。
+            step = "2.6"
+            atf_pdArrays_df = self.find_PDArrays(symbol=symbol,struct=atf_struct,side=atf_side)
+            
+            # 不同的结构，不同位置，如果是Choch则等待价格进入PDArray，如果是BOS则等待价格进入折价区
+            # 划分 折价(discount)区和溢价(premium)区
+            atf_struct_high = atf_latest_struct[self.STRUCT_HIGH_COL]
+            atf_struct_low = atf_latest_struct[self.STRUCT_LOW_COL]            
+            atf_struct_mid = atf_latest_struct[self.STRUCT_MID_COL]
+            
+            if "CHOCH" in atf_struct[self.STRUCT_COL]:
+                # 找PDArray,Bullish 则PDArray的mid要小于 atf_struct_mid，Bearish 则PDArray的mid要大于 atf_struct_mid
+                # atf_discount_mid = (atf_struct_mid + atf_struct_high) / 2  if atf_trend == self.BEARISH_TREND else (atf_struct_mid + atf_struct_low) / 2
+                mask = atf_pdArrays_df[self.PD_MID_COL] >= atf_struct_mid if atf_side == self.BUY_SIDE else atf_pdArrays_df[self.PD_MID_COL] <= atf_struct_mid
+                atf_pdArrays_df = atf_pdArrays_df[mask]
+                if len(atf_pdArrays_df) == 0:
+                    self.logger.info(f"{symbol} : {step}.1. ATF {atf} 未找到PDArray，不下单")
+                    return
+                else:
+                    # 找到最新的PDArray              
+                    atf_vaild_pdArray = atf_pdArrays_df.iloc[-1]
+                    self.logger.info(f"{symbol} : {step}.1. ATF {atf} 找到PDArray\n"
+                        f"{atf_vaild_pdArray[[self.TIMESTAMP_COL,self.PD_TYPE_COL,self.PD_HIGH_COL,self.PD_LOW_COL,self.PD_MID_COL]]}。")
+               
+            
+            #SMS
+            elif "SMS" in atf_struct[self.STRUCT_COL]:
+                mask = atf_pdArrays_df[self.PD_MID_COL] >= atf_struct_mid if atf_side == self.BUY_SIDE else atf_pdArrays_df[self.PD_MID_COL] <= atf_struct_mid
+                atf_pdArrays_df = atf_pdArrays_df[mask]
+                if len(atf_pdArrays_df) == 0:
+                    self.logger.info(f"{symbol} : {step}.1. ATF {atf} 在{atf_struct_mid:.{precision}f}未找到PDArray，不下单")
+                    return
+                else:
+                    # 找到最新的PDArray              
+                    atf_vaild_pdArray = atf_pdArrays_df.iloc[-1]
+                    self.logger.info(f"{symbol} : {step}.1. ATF {atf} 找到PDArray\n"
+                        f"{atf_vaild_pdArray[[self.TIMESTAMP_COL,self.PD_TYPE_COL,self.PD_HIGH_COL,self.PD_LOW_COL,self.PD_MID_COL]]}。")
+               
+
+            #BMS   
+            else:
+                atf_premium_mid = (atf_struct_mid + atf_struct_low) / 2  if atf_side == self.BUY_SIDE else (atf_struct_mid + atf_struct_high) / 2
+                mask = atf_pdArrays_df[self.PD_HIGH_COL] >= atf_premium_mid if atf_side == self.BUY_SIDE else atf_pdArrays_df[self.PD_LOW_COL] <= atf_premium_mid
+                atf_pdArrays_df = atf_pdArrays_df[mask]
+                if len(atf_pdArrays_df) == 0:
+                    self.logger.info(f"{symbol} : {step}.1. ATF {atf} ,在{atf_premium_mid:.{precision}f}未找到PDArray，不下单")
+                    return
+                else:
+                    # 找到最新的PDArray              
+                    atf_vaild_pdArray = atf_pdArrays_df.iloc[-1]
+                    self.logger.info(f"{symbol} : {step}.1. ATF {atf} 找到PDArray\n"
+                        f"{atf_vaild_pdArray[[self.TIMESTAMP_COL,self.PD_TYPE_COL,self.PD_HIGH_COL,self.PD_LOW_COL,self.PD_MID_COL]]}")
+               
+              
+            
+            step = "2.7"
+
+            # 2.7. 等待价格进入 PDArray
+       
+            if not (market_price <= atf_vaild_pdArray[self.PD_HIGH_COL] and market_price >= atf_vaild_pdArray[self.PD_LOW_COL]):
+                self.logger.info(f"{symbol} : {step}. ATF {atf} market_price={market_price:.{precision}f} 未达到PDArray范围。"
+                                f"PD_HIGH={atf_vaild_pdArray[self.PD_LOW_COL]:.{precision}f} "
+                                f"PD_LOW={atf_vaild_pdArray[self.PD_HIGH_COL]:.{precision}f} ")
+
+                return 
+            else:
+                self.logger.info(f"{symbol} : {step}. ATF {atf} market_price={market_price:.{precision}f} 已到达PDArray范围。"
+                                f"PD_HIGH={atf_vaild_pdArray[self.PD_LOW_COL]:.{precision}f} "
+                                f"PD_LOW={atf_vaild_pdArray[self.PD_HIGH_COL]:.{precision}f} ")
+
+
+            # 3. ETF Step 
+            step = "3.1"
+            etf_side, etf_struct, etf_trend = None, None, None
+            etf_df = self.get_historical_klines_df(symbol=symbol, tf=etf)                   
+            etf_struct =self.build_struct(symbol=symbol, data=etf_df)            
+            etf_latest_struct = self.get_latest_struct(symbol=symbol, data=etf_struct)
+
+            # 初始化ETF趋势相关变量
+            if etf_latest_struct is None:
+                self.logger.info(f"{symbol} : {step}. ETF {etf} 未形成结构，等待... ")
+                return
+            etf_trend = etf_latest_struct[self.STRUCT_DIRECTION_COL]            
+            etf_side = self.BUY_SIDE if etf_trend == self.BULLISH_TREND else self.SELL_SIDE
+
+            # 3.1. Price's Current Trend 市场趋势（ETF ）
+            step = "3.1"
+            self.logger.info(f"{symbol} : {step}. ETF {etf} Price's Current Trend is {etf_trend}。")
+            # 3.2. Who's In Control 供需控制，Bullish 或者 Bearish ｜ Choch 或者 BOS
+            step = "3.2"
+            self.logger.info(f"{symbol} : {step}. ETF {etf} struct is {etf_latest_struct[self.STRUCT_COL]}。")
+            
+
+            # 3.3 Reversal Signs 反转信号
+            step = "3.3"
+    
+            if atf_side != etf_side:
+        
+                self.logger.info(f"{symbol} : {step}. ETF {etf} 市场结构{etf_latest_struct[self.STRUCT_COL]}未反转,等待...")
+                return
+            else:
+                self.logger.info(f"{symbol} : {step}. ETF {etf} 市场结构{etf_latest_struct[self.STRUCT_COL]}已反转。")
+
+            # TODO "CHOCH"|"BOS" 的PDArray 入场位置不一样
+
+            # 3.4 找 PD Arrays 价格区间（ETF 看上下的供需区位置）
+            step = "3.4"
+            etf_pdArrays_df = self.find_PDArrays(symbol=symbol,struct=etf_struct,side=etf_side)
+            # 划分 折价(discount)区和溢价(premium)区
+            etf_struct_high = etf_latest_struct[self.STRUCT_HIGH_COL]
+            etf_struct_low = etf_latest_struct[self.STRUCT_LOW_COL]            
+            etf_struct_mid = etf_latest_struct[self.STRUCT_MID_COL]
+            mask = etf_pdArrays_df[self.PD_MID_COL] >= etf_struct_mid if etf_side == self.SELL_SIDE else etf_pdArrays_df[self.PD_MID_COL] <= etf_struct_mid
+            etf_pdArrays_df = etf_pdArrays_df[mask]
+            if len(etf_pdArrays_df) == 0:
+                self.logger.info(f"{symbol} : {step}.1. ETF {etf} 未找到PDArray，不下单")
+                return
+            else:
+                # 找到最新的PDArray              
+                etf_vaild_pdArray = etf_pdArrays_df.iloc[-1]
+                self.logger.info(f"{symbol} : {step}.1. ETF {etf} 找到PDArray.\n"
+                                f"{etf_vaild_pdArray[[self.TIMESTAMP_COL,self.PD_TYPE_COL,self.PD_HIGH_COL,self.PD_LOW_COL,self.PD_MID_COL]]}。")
+               
+       
+            if not (market_price <= etf_vaild_pdArray[self.PD_HIGH_COL] and market_price >= etf_vaild_pdArray[self.PD_LOW_COL]):
+                self.logger.info(f"{symbol} : {step}.2. ETF {etf} market_price={market_price:.{precision}f} 未达到PDArray范围。"
+                                  f"PD_HIGH={etf_vaild_pdArray[self.PD_HIGH_COL]:.{precision}f} "
+                                  f"PD_LOW={etf_vaild_pdArray[self.PD_LOW_COL]:.{precision}f}")
+
+                return 
+            else:
+                self.logger.info(f"{symbol} : {step}.2. ETF {etf} market_price={market_price:.{precision}f} 已到达PDArray范围。"
+                                  f"PD_HIGH={etf_vaild_pdArray[self.PD_HIGH_COL]:.{precision}f} "
+                                  f"PD_LOW={etf_vaild_pdArray[self.PD_LOW_COL]:.{precision}f}")    
+
+            # 3.5 Place Order 下单
+            step = "3.5"
+            # order_price = self.toDecimal(etf_vaild_pdArray[self.PD_HIGH_COL] if etf_trend == self.BULLISH_TREND else etf_vaild_pdArray[self.PD_LOW_COL] )
+            order_price = self.toDecimal(etf_vaild_pdArray[self.PD_MID_COL])  
+            
+            latest_order_price = self.toDecimal(self.place_order_prices.get(symbol,0))
+            if order_price == latest_order_price:
+                self.logger.info(f"{symbol} : {step}. ETF {etf}, 下单价格 {order_price:.{precision}} 未变化，不进行下单。")
+                return
+            
+            self.cancel_all_orders(symbol=symbol) 
+            self.place_order(symbol=symbol, price=order_price, side=etf_side, pair_config=pair_config)
+            self.place_order_prices[symbol] = order_price # 记录下单价格,过滤重复下单
+            self.logger.info(f"{symbol} : {step}. ETF {etf}, {etf_side} 价格={order_price:.{precision}}")
+
+
+        except KeyboardInterrupt:
+            self.logger.info("程序收到中断信号，开始退出...")
+        except Exception as e:
+            error_message = f"程序异常退出: {str(e)}"
+            # 记录错误信息和堆栈跟踪
+            self.logger.error(f"{error_message}\n{traceback.format_exc()}")
+            traceback.print_exc()
+            self.send_feishu_notification(symbol, error_message)
+        finally:
+            self.logger.info("=" * 60 + "\n")
+  
+            
+
+        

maker/StrategyMaker.py

@@ -0,0 +1,487 @@
+# -*- coding: utf-8 -*-
+from functools import lru_cache
+import pandas as pd
+from datetime import datetime, timedelta
+from decimal import Decimal
+from abc import abstractmethod
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from core.utils.OPTools import OPTools
+from core.Exchange import Exchange
+# 导入SMC相关模块
+from core.smc import (
+    SMCBase,
+    SMCPDArray,
+    SMCStruct, 
+    SMCOrderBlock,
+    SMCFVG,
+    SMCLiquidity
+)
+
+class StrategyMaker():
+    BUY_SIDE = 'buy'
+    SELL_SIDE = 'sell'
+    BULLISH_TREND = 'Bullish'
+    BEARISH_TREND = 'Bearish'
+
+    HIGH_COL = SMCBase.SMCBase.HIGH_COL
+    LOW_COL = SMCBase.SMCBase.LOW_COL
+    CLOSE_COL = SMCBase.SMCBase.CLOSE_COL
+    OPEN_COL = SMCBase.SMCBase.OPEN_COL
+    TIMESTAMP_COL = SMCBase.SMCBase.TIMESTAMP_COL
+    VOLUME_COL = SMCBase.SMCBase.VOLUME_COL
+    
+    STRUCT_COL = SMCStruct.SMCStruct.STRUCT_COL
+    STRUCT_HIGH_COL = SMCStruct.SMCStruct.STRUCT_HIGH_COL
+    STRUCT_LOW_COL = SMCStruct.SMCStruct.STRUCT_LOW_COL 
+    STRUCT_MID_COL = SMCStruct.SMCStruct.STRUCT_MID_COL
+    STRUCT_HIGH_INDEX_COL = SMCStruct.SMCStruct.STRUCT_HIGH_INDEX_COL
+    STRUCT_LOW_INDEX_COL = SMCStruct.SMCStruct.STRUCT_LOW_INDEX_COL
+    STRUCT_DIRECTION_COL = SMCStruct.SMCStruct.STRUCT_DIRECTION_COL
+    HIGH_START_COL = SMCStruct.SMCStruct.HIGH_START_COL
+    LOW_START_COL = SMCStruct.SMCStruct.LOW_START_COL
+    
+    OB_HIGH_COL = SMCOrderBlock.SMCOrderBlock.OB_HIGH_COL
+    OB_LOW_COL = SMCOrderBlock.SMCOrderBlock.OB_LOW_COL
+    OB_MID_COL = SMCOrderBlock.SMCOrderBlock.OB_MID_COL
+    OB_VOLUME_COL = SMCOrderBlock.SMCOrderBlock.OB_VOLUME_COL
+    OB_DIRECTION_COL = SMCOrderBlock.SMCOrderBlock.OB_DIRECTION_COL
+    OB_ATR = SMCOrderBlock.SMCOrderBlock.OB_ATR
+    OB_IS_COMBINED = SMCOrderBlock.SMCOrderBlock.OB_IS_COMBINED
+    OB_WAS_CROSSED = SMCOrderBlock.SMCOrderBlock.OB_WAS_CROSSED
+    
+    PD_HIGH_COL = SMCPDArray.SMCPDArray.PD_HIGH_COL
+    PD_LOW_COL = SMCPDArray.SMCPDArray.PD_LOW_COL
+    PD_MID_COL = SMCPDArray.SMCPDArray.PD_MID_COL 
+    PD_TYPE_COL = SMCPDArray.SMCPDArray.PD_TYPE_COL
+
+    LIQU_HIGH_COL = SMCLiquidity.SMCLiquidity.LIQU_HIGH_COL
+    LIQU_LOW_COL = SMCLiquidity.SMCLiquidity.LIQU_LOW_COL
+    EQUAL_HIGH_COL = SMCLiquidity.SMCLiquidity.EQUAL_HIGH_COL
+    EQUAL_LOW_COL = SMCLiquidity.SMCLiquidity.EQUAL_LOW_COL
+    EQH_INDEX_KEY = SMCLiquidity.SMCLiquidity.EQUAL_HIGH_INDEX_KEY
+    EQL_INDEX_KEY = SMCLiquidity.SMCLiquidity.EQUAL_LOW_INDEX_KEY
+    HAS_EQ_KEY = SMCLiquidity.SMCLiquidity.HAS_EQ_KEY
+    
+    def __init__(self, config,  platform_config, common_config, feishu_webhook=None, logger=None ,exchangeKey='okx'):
+        """_summary_
+            初始化
+        Args:
+            config (_type_): _description_
+            platform_config (_type_): _description_
+            common_config (_type_): _description_
+            feishu_webhook (_type_, optional): _description_. Defaults to None.
+            logger (_type_, optional): _description_. Defaults to None.
+        """
+        self.logger = logger
+        self.g_config = config
+        
+        self.common_config = common_config
+        self.feishu_webhook = self.common_config.get('feishu_webhook',"")
+      
+        self.strategy_config = self.g_config.get('strategy', {})
+        self.trading_pairs_config = self.g_config.get('tradingPairs', {})
+        
+        self.leverage_value = self.strategy_config.get('leverage', 20)
+        self.is_demo_trading = self.common_config.get('is_demo_trading', 1)  # live trading: 0, demo trading: 1
+        proxies = {
+            "http": self.common_config.get('proxy', "http://localhost:7890"),
+            "https": self.common_config.get('proxy', "http://localhost:7890")
+        }
+        try:
+            self.exchange = Exchange({
+                'apiKey': platform_config["apiKey"],
+                'secret': platform_config["secret"],
+                'password': platform_config["password"],
+                'timeout': 3000,
+                'rateLimit': 50,
+                'options': {'defaultType': 'future'},
+                'proxies': proxies
+            }, exchangeKey)
+        except Exception as e:
+            self.logger.error(f"连接交易所失败: {e}")
+            raise Exception(f"连接交易所失败: {e}")
+        
+        self.smcPDArray = SMCPDArray.SMCPDArray()
+        self.smcStruct = SMCStruct.SMCStruct()
+        self.smcOB = SMCOrderBlock.SMCOrderBlock()
+        self.smcFVG = SMCFVG.SMCFVG()
+        self.smcLiqu = SMCLiquidity.SMCLiquidity()
+        
+        self.interval_map = {
+            '1d': 24 * 60 * 60 ,  # 1天
+            '4h': 4 * 60 * 60 ,   # 4小时
+            '1h': 60 * 60 ,        # 1小时
+            '30m': 30 * 60 ,       # 30分钟
+            '15m': 15 * 60 ,       # 15分钟
+            '5m': 5 * 60 ,         # 5分钟
+        }
+        
+        self.place_order_prices = {} # 记录每个symbol的挂单价格
+        self.cache_time = {}  # 记录缓存时间的字典
+
+    
+    def toDecimal(self, price):
+        """_summary_
+            将价格转换为Decimal类型
+        Args:
+            price (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        return OPTools.toDecimal(price)
+        
+    def get_pair_config(self,symbol):
+        # 获取交易对特定配置,如果没有则使用全局策略配置
+        pair_config = self.trading_pairs_config.get(symbol, {})
+        
+        # 使用字典推导式合并配置,trading_pairs_config优先级高于strategy_config
+        pair_config = {
+            **self.strategy_config,  # 基础配置
+            **pair_config  # 交易对特定配置会覆盖基础配置
+        }
+        return pair_config
+        
+    
+    def send_feishu_notification(self, symbol, message):
+        if self.feishu_webhook:
+            try:
+                OPTools.send_feishu_notification(self.feishu_webhook,message)
+            except Exception as e:
+                self.logger.warning(f"{symbol} 发送飞书消息失败: {e}")
+
+    def get_precision_length(self, symbol):
+        """_summary_
+            获取价格的精度长度
+        Args:
+            price (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        tick_size = self.exchange.get_tick_size(symbol)
+        return self.smcStruct.get_precision_length(tick_size)
+    
+    def get_market_price(self, symbol):
+        """_summary_
+            获取最新成交价
+        Args:
+            symbol (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        return self.exchange.get_market_price(symbol)
+    
+    def place_order(self, symbol, price:Decimal, side,  pair_config, leverage:int=0, order_type='limit'):
+        """_summary_
+            下单
+        Args:
+            symbol (_type_): _description_
+            price (_type_): _description_
+            amount_usdt (_type_): _description_
+            side (_type_): _description_
+            order_type (_type_): _description_
+        """
+        # 获取做多和做空的下单金额配置
+        long_amount_usdt = pair_config.get('long_amount_usdt', 5)
+        short_amount_usdt = pair_config.get('short_amount_usdt', 5)
+        
+        # 设置杠杆倍数
+        leverage = leverage or self.leverage_value
+        
+        # 根据交易方向设置下单金额
+        order_amount_usdt = short_amount_usdt if side == self.SELL_SIDE else long_amount_usdt
+        
+        # 记录下单日志
+        direction = self.BULLISH_TREND if side == self.BUY_SIDE else self.BEARISH_TREND
+        self.logger.info(f"{symbol} : 触发{direction}下单条件. 下单价格: {price}")
+        
+        # 执行下单
+        try :
+            self.exchange.place_order(
+                symbol=symbol,
+                price=price,
+                amount_usdt=order_amount_usdt,
+                side=side,
+                leverage=leverage,
+                order_type=order_type
+            )
+        except Exception as e:
+            error_message = f"{symbol} 下单失败: {e}"
+            self.logger.warning(error_message)
+            self.send_feishu_notification(symbol, error_message)
+      
+    def cancel_all_orders(self, symbol):
+        """_summary_
+            取消所有挂单
+        Args:
+            symbol (_type_): _description_
+        """
+        try:
+            self.exchange.cancel_all_orders(symbol=symbol)
+        except Exception as e:
+            error_message = f"{symbol} 取消所有挂单失败: {e}"
+            self.logger.warning(error_message)
+            self.send_feishu_notification(symbol, error_message)
+            
+    def get_historical_klines(self, symbol, tf='15m'):
+        """_summary_
+            获取历史K线数据
+        Args:
+            symbol (_type_): _description_
+            bar (_type_, optional): _description_. Defaults to '15m'.
+        Returns:
+            _type_: _description_
+        """
+        return self.exchange.get_historical_klines(symbol=symbol, bar=tf)
+    
+    @lru_cache(maxsize=32)  # 缓存最近32个不同的请求
+    def _get_cache_historical_klines_df(self, symbol, tf):
+        """被缓存的获取K线数据的方法"""
+        return self.get_historical_klines_df(symbol, tf)
+    def clear_cache_historical_klines_df(self, symbol=None):
+        """
+        清除指定交易对和时间周期的缓存
+        
+        参数:
+            symbol (str, optional): 交易对符号，如为None则清除所有缓存
+            tf (str, optional): 时间周期，如为None则清除所有缓存
+        """
+        if symbol is None:
+            # 清除所有缓存
+            self._get_cache_historical_klines_df.cache_clear()
+            self.cache_time.clear()
+            # print("已清除所有K线数据缓存")
+        else:
+            # 删除所有包含cache_key的缓存
+            keys_to_delete = [k for k in self.cache_time.keys() if symbol in k]
+            if keys_to_delete:
+                for k in keys_to_delete:
+                    del self.cache_time[k]
+                # 由于lru_cache无法单独清除特定键，这里只能清除所有缓存
+                self._get_cache_historical_klines_df.cache_clear()
+        
+
+    def get_historical_klines_df_by_cache(self, symbol, tf='15m'):
+        """_summary_
+            获取历史K线数据
+        Args:
+            symbol (_type_): _description_
+            bar (_type_, optional): _description_. Defaults to '15m'.
+        Returns:
+            _type_: _description_
+        """
+        # cache_key = (symbol, tf)
+        cache_valid_second = self.interval_map.get(tf, 4 * 60 * 60)  # 默认缓存时间为60分钟
+        cache_key = (symbol, tf)
+        
+        # 检查缓存是否存在且未过期
+        current_time = datetime.now()
+        if cache_key in self.cache_time:
+            # 计算缓存时间与当前时间的差值(秒)
+            cache_age = (current_time - self.cache_time[cache_key]).total_seconds()
+            if cache_age <= cache_valid_second:
+                # 缓存有效，直接返回
+                # print(f"使用缓存数据: {symbol} {tf} (缓存时间: {cache_age:.2f} 分钟前)")
+                return self._get_cache_historical_klines_df(symbol, tf)
+            else:
+                # 缓存过期，清除缓存
+                self.logger.debug(f"{symbol} : 缓存已过期: {symbol} {tf} (缓存时间: {cache_age:.2f} 秒前)")
+                self._get_cache_historical_klines_df.cache_clear()
+        
+        # 获取新数据并更新缓存时间
+        self.logger.debug(f"{symbol} : 重新获取新数据: {symbol} {tf}")
+        self.cache_time[cache_key] = current_time
+        return self._get_cache_historical_klines_df(symbol, tf)
+
+    
+    def get_historical_klines_df(self, symbol, tf='15m'):
+        """_summary_
+            获取历史K线数据
+        Args:
+            symbol (_type_): _description_
+            bar (_type_, optional): _description_. Defaults to '15m'.
+        Returns:
+            _type_: _description_
+        """
+        return self.exchange.get_historical_klines_df(symbol=symbol, bar=tf)
+    def format_klines(self, klines) -> pd.DataFrame:
+       
+        """_summary_
+            格式化K线数据
+        Args:
+            klines (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        
+        return self.exchange.format_klines(klines)
+    
+    def find_PDArrays(self, symbol, struct, side=None, start_index=-1, pair_config=None) -> pd.DataFrame:
+        """_summary_
+            寻找PDArray
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+            side (_type_): _description_
+            start_index (_type_): _description_ 
+            is_valid (bool, optional): _description_. Defaults to True.
+            pair_config (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        return self.smcPDArray.find_PDArrays(struct=struct, side=side, start_index=start_index)  
+    
+    def find_OBs(self, symbol, struct, side=None, start_index=-1, is_valid=True, pair_config=None) -> pd.DataFrame:
+        """_summary_
+            识别OB
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+            side (_type_): _description_
+            start_index (_type_): _description_
+            is_valid (bool, optional): _description_. Defaults to True.
+            pair_config (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        
+
+        return self.smcOB.find_OBs(struct=struct, side=side, start_index=start_index, is_valid=is_valid)
+    
+    def get_latest_OB(self, symbol, data, trend, start_index=-1) -> dict:
+        """_summary_
+            获取最新的Order Block
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+            trend (_type_): _description_
+            start_index (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+
+        return self.smcOB.get_latest_OB(data=data, trend=trend, start_index=start_index)
+        
+        
+    def find_FVGs(self, symbol, data, side, check_balanced=True, start_index=-1, pair_config=None) -> pd.DataFrame:
+        """_summary_
+            寻找公允价值缺口
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+            side (_type_): _description_
+            check_balanced (bool, optional): _description_. Defaults to True.
+            start_index (_type_): _description_
+            pair_config (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+            
+
+        return self.smcFVG.find_FVGs(data, side, check_balanced, start_index)
+
+    def find_EQH_EQL(self, symbol, data, trend, end_idx=-1, atr_offset=0.1, pair_config=None) -> dict:
+        """_summary_
+            寻找等值高点和等值低点
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+            trend (_type_): _description_
+            end_idx (int, optional): _description_. Defaults to -1.
+            atr_offset (float, optional): _description_. Defaults to 0.1.
+        Returns:
+            _type_: _description_
+        """
+        return self.smcLiqu.find_EQH_EQL(data, trend, end_idx=end_idx, atr_offset=atr_offset)
+
+    def identify_dynamic_trendlines(self, symbol, data, trend, start_idx=-1, end_idx=-1, ratio=0.8) -> bool:
+        """_summary_
+            识别动态趋势线
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+            trend (_type_): _description_
+            start_idx (int, optional): _description_. Defaults to -1.
+            end_idx (int, optional): _description_. Defaults to -1.
+            ratio (float, optional): _description_. Defaults to 0.5.
+        Returns:
+            _type_: _description_
+        """
+        return self.smcLiqu.identify_dynamic_trendlines(data, trend, start_idx, end_idx, ratio)
+
+    def build_struct(self, symbol, data) -> pd.DataFrame:
+        
+        """_summary_
+            构建SMC结构，参考 Tradingview OP@SMC Structures and FVG
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+        Returns:
+            _type_: _description_    
+        """
+        
+                
+        return self.smcStruct.build_struct(data)
+        
+    def get_latest_struct(self, symbol, data) -> dict:
+        """_summary_
+            获取最后一个SMC结构
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        return self.smcStruct.get_latest_struct(data)
+    
+    def reset_all_cache(self, symbol):
+        """_summary_
+            重置所有缓存数据
+        """
+        if symbol in self.place_order_prices:            
+            self.place_order_prices.pop(symbol)
+        self.clear_cache_historical_klines_df(symbol)
+        
+    def fetch_position(self, symbol) -> bool:
+        """
+        检查指定交易对是否有持仓，失败时最多重试3次
+        
+        Args:
+            symbol: 交易对ID
+            
+        Returns:
+            bool: 是否有持仓
+        """
+        try:
+            position = self.exchange.fetch_position(symbol=symbol)
+            return position['contracts'] > 0
+        except Exception as e:
+            error_message = f"{symbol} 检查持仓失败: {e}"
+            self.logger.error(error_message)            
+            self.send_feishu_notification(symbol,error_message)
+            return True
+
+    @abstractmethod
+    def process_pair(self, symbol, pair_config):
+        """
+        处理单个交易对的策略逻辑
+        
+        Args:
+            symbol: 交易对名称
+            pair_config: 交易对配置信息
+            
+        Raises:
+            NotImplementedError: 子类必须实现此方法
+        """
+        raise NotImplementedError("必须在子类中实现process_pair方法")   
+    
+    def monitor_klines(self):
+        symbols = list(self.trading_pairs_config.keys())  # 获取所有币对的ID
+        batch_size = 10  # 每批处理的数量
+        # while True:
+
+        for i in range(0, len(symbols), batch_size):
+            batch = symbols[i:i + batch_size]
+            with ThreadPoolExecutor(max_workers=batch_size) as executor:
+                futures = [executor.submit(self.process_pair, symbol,self.get_pair_config(symbol)) for symbol in batch]
+                for future in as_completed(futures):
+                    future.result()  # Raise any exceptions caught during execution

maker/ThreeLineStrategyMaker.py

@@ -396,7 +396,6 @@ class ThreeLineStrategyMaker:
             prices: 价格列表。
         Returns:
             diff: 计算最高价列的最大值与最小值的差值
-。
         """
         # limit = int(pair_config.get('ema_range_limit', 1))
         # period = int(pair_config.get('ema_range_period', 3))

maker/main.py

@@ -1,98 +1,103 @@
 import logging
 import logging.config
 import yaml
+import importlib
+import importlib.metadata
 from apscheduler.triggers.interval import IntervalTrigger
 from apscheduler.schedulers.blocking import BlockingScheduler
 from datetime import datetime
 from pyfiglet import Figlet
+from typing import Dict, Any
 
-from maker.ThreeLineStrategyMaker import ThreeLineStrategyMaker
-from maker.SMCStrategyMaker import SMCStrategyMaker
-from maker.BestFVGStrategyMaker import BestFVGStrategyMaker
-
-    
-def read_config_file(file_path):
+def read_config_file(file_path: str) -> Dict[str, Any]:
+    """读取并解析YAML配置文件"""
     try:
-        # 打开 YAML 文件
         with open(file_path, 'r', encoding='utf-8') as file:
-            # 使用 yaml.safe_load 方法解析 YAML 文件内容
-            data = yaml.safe_load(file)
-            return data
+            return yaml.safe_load(file)
     except FileNotFoundError:
-        raise Exception(f"文件 {file_path} 未找到。")
+        raise FileNotFoundError(f"文件 {file_path} 未找到。")
     except yaml.YAMLError as e:
-        raise Exception(f"解析 {file_path} 文件时出错: {e}")
-    
-def run_bot(bot, logger):
-    try:
+        raise yaml.YAMLError(f"解析 {file_path} 文件时出错: {e}")
 
+def run_bot(bot: Any, logger: logging.Logger) -> None:
+    """执行机器人监控任务"""
+    try:
         bot.monitor_klines()
     except Exception as e:
         logger.error(f"执行任务时发生错误: {str(e)}", exc_info=True)
 
-def main():   
+def calculate_next_run_time(current_time: datetime, interval: int) -> datetime:
+    """计算下一次运行时间"""
+    next_run = current_time.replace(second=58, microsecond=0)
+    current_minute = next_run.minute
+    next_interval = ((current_minute // interval) + 1) * interval - 1
+    
+    if next_interval >= 60:
+        next_interval %= 60
+        next_run = next_run.replace(hour=next_run.hour + 1)
+    
+    return next_run.replace(minute=next_interval)
 
-    import importlib.metadata
-    package_name = __package__ or "openfund-maker"
+def setup_scheduler(bot: Any, logger: logging.Logger, interval: int) -> None:
+    """设置并启动调度器"""
+    scheduler = BlockingScheduler()
+    next_run = calculate_next_run_time(datetime.now(), interval)
+    
+    scheduler.add_job(
+        run_bot,
+        IntervalTrigger(minutes=interval),
+        args=[bot, logger],
+        next_run_time=next_run
+    )
+    
+    try:
+        logger.info(f"启动定时任务调度器，从 {next_run} 开始每{interval}分钟执行一次...")
+        scheduler.start()
+    except (KeyboardInterrupt, SystemExit):
+        logger.info("程序收到中断信号，正在退出...")
+        scheduler.shutdown()
+def create_strategy_instance(maker_name: str, configs: Dict[str, Any], logger: logging.Logger, exchangeKey:str):
+    """创建策略实例"""
+    module = importlib.import_module(f"maker.{maker_name}")
+    strategy_class = getattr(module, maker_name)
+    return strategy_class(
+        configs, 
+        configs['platform'][exchangeKey],
+        configs['common'],
+        logger=logger,
+        exchangeKey=exchangeKey
+    )
+def main():
+    # 获取包信息
     version = importlib.metadata.version("openfund-maker")
+    package_name = __package__ or "openfund-maker"
     
+    # 读取配置
     maker_config_path = 'maker_config.yaml'
     config_data = read_config_file(maker_config_path)
-        
+    
+    # 设置日志
     logging.config.dictConfig(config_data["Logger"])
     logger = logging.getLogger("openfund-maker")
     
-    f = Figlet(font="standard")  # 字体可选（如 "block", "bubble"）
-    logger.info(f"\n{f.renderText("OpenFund Maker")}")
-
-    common_config = config_data['common']
-    feishu_webhook_url = common_config['feishu_webhook']
-    maker = common_config.get('actived_maker', 'MACDStrategyMaker')
-    logger.info(f" ++ {package_name}.{maker}:{version} is doing...")
+    # 显示启动标题
+    f = Figlet(font="standard")
+    logger.info(f"\n{f.renderText('OpenFund Maker')}")
     
-    platform_config = config_data['platform']['okx']
-    # 根据配置动态创建策略实例
-    strategy_class = globals()[maker]
-    bot = strategy_class(config_data, platform_config, common_config, feishu_webhook=feishu_webhook_url, logger=logger)
-    
-    
-    # 获取计划配置
+    # 获取配置信息
+    common_config = config_data['common']
+    maker_name = common_config.get('actived_maker', 'StrategyMaker')
+    logger.info(f" ++ {package_name}.{maker_name}:{version} is doing...")
+    exchangeKey = common_config.get("exchange_key", "okx")
+    # 创建并运行策略实例
+    bot = create_strategy_instance(maker_name, config_data, logger, exchangeKey)
+
+    # 处理调度
     schedule_config = common_config.get('schedule', {})
     if schedule_config.get('enabled', False):
-        scheduler = BlockingScheduler()
-        
-        # 设置每5分钟执行一次的任务，从整点开始
-        monitor_interval = int(schedule_config.get('monitor_interval', 4)) 
- 
-        # 计算下一个整点分钟
-        now = datetime.now()
-        # 将当前时间的秒和微秒设置为0
-        next_run = now.replace(second=58, microsecond=0)
-        # 计算下一个周期的开始时间
-        current_minute = next_run.minute
-        # 向上取整到下一个周期时间点, 然后再减去2Units,比如秒就是58秒执行。
-        next_interval = ((current_minute // monitor_interval) + 1) * monitor_interval -1
-        # 如果下一个周期时间点超过60分钟，需要调整为下一个小时的对应分钟数
-        if next_interval >= 60:
-            next_interval = next_interval % 60
-            next_run = next_run.replace(hour=next_run.hour + 1)
-        next_run = next_run.replace(minute=next_interval)
-        
-        scheduler.add_job(
-            run_bot,
-            IntervalTrigger(minutes=monitor_interval),
-            args=[bot, logger],
-            next_run_time=next_run  # 从下一个周期整点开始
-        )
-        
-        try:
-            logger.info(f"启动定时任务调度器，从 {next_run} 开始每{monitor_interval}分钟执行一次...")
-            scheduler.start()
-        except (KeyboardInterrupt, SystemExit):
-            logger.info("程序收到中断信号，正在退出...")
-            scheduler.shutdown()
+        monitor_interval = int(schedule_config.get('monitor_interval', 4))
+        setup_scheduler(bot, logger, monitor_interval)
     else:
-        # 如果未启用计划，直接运行
         run_bot(bot, logger)
 
 if __name__ == "__main__":

{openfund_maker-2.2.9.dist-info → openfund_maker-2.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openfund-maker
-Version: 2.2.9
+Version: 2.3.2
 Summary: Openfund-maker.
 Requires-Python: >=3.9,<4.0
 Classifier: Programming Language :: Python :: 3
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: apscheduler (>=3.11.0,<4.0.0)
 Requires-Dist: ccxt (>=4.4.26,<5.0.0)
+Requires-Dist: openfund-core (>=1.0.0,<2.0.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: pyfiglet (>=1.0.2,<2.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)

{openfund_maker-2.2.9.dist-info → openfund_maker-2.3.2.dist-info}/RECORD

@@ -1,15 +1,17 @@
 maker/BestFVGStrategyMaker.py,sha256=a9UfClrfzkgX6jXL2FODzANtawrmGeZ_PVeO1-tweDc,12532
+maker/BestTopDownStrategyMaker.py,sha256=-cyoxGn6ZKFJ4neFKnHHJ84ZvODMR-a_agitHz6VNXI,23735
 maker/MACDStrategyMaker.py,sha256=WX8wqpF9h5W4WclN1NjZ_Bur7KFi_aMTvacfLyHzEcI,12681
 maker/SMCStrategyMaker.py,sha256=hkDqymWnuyYDo1gTYY_uyO4H4yOwCw8NBTM9RcfLRPc,28780
-maker/ThreeLineStrategyMaker.py,sha256=jCdyTvI9oTMixCM0tQF9D_-6ig0-bYstKuRFECE4deE,32099
+maker/StrategyMaker.py,sha256=iJa-9MxuUwPDOZot2YJmT-sdYHnPZbgPsdCaKvw3Sis,18821
+maker/ThreeLineStrategyMaker.py,sha256=K4NZB1rH8IZMVrCFEnzwXctZQbyI9ZdyTMrYObpl-vM,32095
 maker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maker/history_code/WickReversalStrategyMaker.py,sha256=7DqPDVJot4EM0_lSAcFAHrR9rNvkIds9KLMoDOiAHEc,17486
 maker/history_code/config.py,sha256=YPxghO5i0vgRg9Cja8kGj9O7pgSbbtzOgf3RexqXXwY,1188
 maker/history_code/okxapi.py,sha256=_9G0U_o0ZC8NxaT6PqpiLgxBm9gPobC9PsFHZE1c5w0,553
 maker/history_code/zhen.py.bak,sha256=HNkrQbJts8G9umE9chEFsc0cLQApcM9KOVNMYPpkBXM,10918
 maker/history_code/zhen_2.py,sha256=4IaHVtTCMSlrLGSTZrWpW2q-f7HZsUNRkW_-5QgWv24,10509
-maker/main.py,sha256=kumgkgyYj1tVKrHTQmSx0prFs9K4i5KpvcOnqimV2eA,3805
-openfund_maker-2.2.9.dist-info/METADATA,sha256=e62T_JqAp7JrCPPm-sDYnOy0YjWWGy0wMULeQs-X2cI,1955
-openfund_maker-2.2.9.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-openfund_maker-2.2.9.dist-info/entry_points.txt,sha256=gKMytICEKcMRFQDFkHZLnIpID7UQFoTIM_xcpiiV6Ns,50
-openfund_maker-2.2.9.dist-info/RECORD,,
+maker/main.py,sha256=PRCP2qCUiUFPQyi1YbvnmW9KqeCZcc0zGjy9OBvMWbM,3723
+openfund_maker-2.3.2.dist-info/METADATA,sha256=V93SlcoCwKl4tYklrw4SMY_t2LqVZyFB9ZsF2OhOSD4,2001
+openfund_maker-2.3.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+openfund_maker-2.3.2.dist-info/entry_points.txt,sha256=gKMytICEKcMRFQDFkHZLnIpID7UQFoTIM_xcpiiV6Ns,50
+openfund_maker-2.3.2.dist-info/RECORD,,