openfund-taker 1.2.13__py3-none-any.whl → 1.3.2__py3-none-any.whl

{openfund_taker-1.2.13.dist-info → openfund_taker-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openfund-taker
-Version: 1.2.13
+Version: 1.3.2
 Summary: Openfund-taker
 Requires-Python: >=3.9,<4.0
 Classifier: Programming Language :: Python :: 3
@@ -9,7 +9,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: TA-Lib (>=0.6.0,<0.7.0)
+Requires-Dist: TA-Lib (>=0.5.1,<0.6.0)
 Requires-Dist: ccxt (>=4.4.26,<5.0.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)

{openfund_taker-1.2.13.dist-info → openfund_taker-1.3.2.dist-info}/RECORD

@@ -1,6 +1,7 @@
-taker/MultiAssetNewTradingBot.py,sha256=bpgI6eewTwd7-Q5u2Au0UXd-mvFT1UM9S3H4CXPzf4g,42412
 taker/MultiAssetOldTradingBot.py,sha256=uBh_BxglvcbaHIsWHM7GI9Qa_QjzsxXaXJAAWEOMO5c,15315
 taker/ThreeLineTradingBot.py,sha256=oXIoQ8z9AzKzk0z13d0ufj2KGBOk5iHJTJNZQRDKA5U,20625
+taker/TrailingSLAndTPTaker.py,sha256=gikp-Yahn4nWYk6PmUB02t8Sun--Fo4I7vDEU4U2uso,1263
+taker/TrailingSLTaker.py,sha256=LL6BxJQo6yhkruXRDA0jQMt9K-GxhMZiTmKrWwIuZzo,42277
 taker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 taker/chua_bitget.py,sha256=YY6XK5Bd-wlArsN5BnAfiqE0h1DPkti6i4TEB4F5zDA,12918
 taker/chua_bn.py,sha256=GnTePWlgDwdHgroBbEp1Ajcsf5_m_Vn_RV63SYzu2jI,10668
@@ -8,8 +9,8 @@ taker/chua_ok.py,sha256=5pPAoEYbFuKxfZwqNvOO890s-2cy6n69QiI0ZA0GTCQ,12474
 taker/chua_ok_all.py,sha256=2XnZM6QdB3juSE1pqQIJyh2x1XuhlTlnBKNA3owlJ9E,15267
 taker/chua_ok_bot.py,sha256=9SW0ujhi6PfN4yR1JZ9NaA37HtnXJ2QAWUfW52NG68w,13109
 taker/config.py,sha256=YPxghO5i0vgRg9Cja8kGj9O7pgSbbtzOgf3RexqXXwY,1188
-taker/main.py,sha256=dTi-Innb_DSKp-esWPc6dVQekrGnv7dNHlv49xmVDfo,2516
-openfund_taker-1.2.13.dist-info/METADATA,sha256=z2DHJxiMaYaB001bK4otdTyKukF50r1RuicNbb4_jqc,7528
-openfund_taker-1.2.13.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-openfund_taker-1.2.13.dist-info/entry_points.txt,sha256=a7mG8F7aOA5-Gk2vPWuAR4537faxaHUgM_jwIDBZoEc,50
-openfund_taker-1.2.13.dist-info/RECORD,,
+taker/main.py,sha256=CYibDo9PEOWbhpSXZ5JTmE-NGJXqDdgvhpadXJNRX60,2557
+openfund_taker-1.3.2.dist-info/METADATA,sha256=JG97fvJiR96kRpwabOg1MlIRSTNGoBOX9A2bsymTm94,7527
+openfund_taker-1.3.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+openfund_taker-1.3.2.dist-info/entry_points.txt,sha256=a7mG8F7aOA5-Gk2vPWuAR4537faxaHUgM_jwIDBZoEc,50
+openfund_taker-1.3.2.dist-info/RECORD,,

taker/TrailingSLAndTPTaker.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+import ccxt
+import time
+import requests
+import traceback
+import pandas as pd
+import talib as ta
+from taker.TrailingSLTaker import TrailingSLTaker
+'''
+自动设置移动止损单
+'''
+class TrailingSLAndTPTaker(TrailingSLTaker):
+    def __init__(self,g_config, platform_config, feishu_webhook=None, monitor_interval=4,logger=None):
+        super().__init__(g_config, platform_config, feishu_webhook, monitor_interval,logger)
+        self.all_TP_LS_ratio = float(platform_config.get("all_TP_LS_ratio",1.5)) #The profit-loss ratio 盈亏比
+        self.all_take_profit_pct = self.stop_loss_pct *  self.all_TP_LS_ratio
+   
+    def set_stop_loss_take_profit(self, symbol, position, stop_loss_price=None, take_profit_price=None) -> bool:
+        is_successful = super().set_stop_loss_take_profit(symbol, position, stop_loss_price, take_profit_price)
+        # take_profile_pct = self.stop_loss_pct *  2
+        order_take_profit_price = take_profit_price
+        if take_profit_price is None:
+            order_take_profit_price = self.calculate_take_profile_price(symbol, position, self.all_take_profit_pct)
+            is_successful = self.set_take_profit(symbol, position, order_take_profit_price)
+    
+        
+        return is_successful
+

taker/{MultiAssetNewTradingBot.py → TrailingSLTaker.py}

@@ -4,13 +4,17 @@ import time
 import requests
 import traceback
 import pandas as pd
-
-class MultiAssetNewTradingBot:
+import talib as ta
+'''
+自动设置移动止损单
+'''
+class TrailingSLTaker:
     def __init__(self,g_config, platform_config, feishu_webhook=None, monitor_interval=4,logger=None):
         self.trading_pairs_config = g_config.get('tradingPairs', {})
         
-        self.stop_loss_pct = platform_config["all_stop_loss_pct"]  # 全局止损百分比
-        # 止盈比例
+        
+        self.stop_loss_pct = float(platform_config.get("all_stop_loss_pct",2))  # 全局止损百分比
+        # 回撤比例
         self.low_trail_stop_loss_pct = platform_config["all_low_trail_stop_loss_pct"] # 第一档
         self.trail_stop_loss_pct = platform_config["all_trail_stop_loss_pct"]# 第二档
         self.higher_trail_stop_loss_pct = platform_config["all_higher_trail_stop_loss_pct"]# 第三档
@@ -22,14 +26,17 @@ class MultiAssetNewTradingBot:
         self.feishu_webhook = feishu_webhook
         self.monitor_interval = monitor_interval  # 监控循环时间是分仓监控的3倍
         
-        self.highest_total_profit = 0  # 记录最高总盈利
-        self.current_tier = "无" # 记录当前的仓位模式
+        self.highest_total_profit = {}  # 记录最高总盈利
+        
+        # self.current_tier = {} # 记录当前的仓位模式
+        
+        self.positions_entry_price = {} # 记录每个symbol的开仓价格
                 
         self.global_symbol_stop_loss_flag = {} # 记录每个symbol是否设置全局止损
         self.global_symbol_stop_loss_price = {} # 记录每个symbol的止损价格
         # 保留在止盈挂单中最高最低两个价格，计算止盈价格。
-        self.max_market_price = 0.0
-        self.min_market_price = float('inf')  # 初始化为浮点数最大值
+        self.max_market_price = {}
+        self.min_market_price = {}
         
         self.cross_directions = {} # 持仓期间，存储每个交易对的交叉方向 
 
@@ -104,7 +111,8 @@ class MultiAssetNewTradingBot:
             self.logger.error(f"Error fetching open orders: {e}")
             return []
 
-    def get_historical_klines(self,symbol, bar='1m', limit=241):
+    # 获取历史K线，不包含最新的一条
+    def get_historical_klines_except_last(self,symbol, bar='1m', limit=241):
         # response = market_api.get_candlesticks(instId, bar=bar, limit=limit)
         params = {
             # 'instId': instId,
@@ -113,180 +121,174 @@ class MultiAssetNewTradingBot:
         # if 'data' in response and len(response['data']) > 0:
         if klines :
             # return response['data']
-            return klines
+            return klines[:-1]
         else:
             raise ValueError("Unexpected response structure or missing candlestick data")
 
-    def judge_cross_direction(self,symbol, fastklines ,slowklines) :
-        # 创建DataFrame
-        df = pd.DataFrame({
-            'fast': fastklines,
-            'slow': slowklines
-        })
-        
-        # 判断金叉和死叉
-        df['golden_cross'] = (df['fast'] > df['slow']) & (df['fast'].shift(1) < df['slow'].shift(1))
-        df['death_cross'] = (df['fast'] < df['slow']) & (df['fast'].shift(1) > df['slow'].shift(1))
-        
-        # 从后往前找最近的交叉点
-        last_golden = df['golden_cross'].iloc[::-1].idxmax() if df['golden_cross'].any() else None
-        last_death = df['death_cross'].iloc[::-1].idxmax() if df['death_cross'].any() else None
-        # self.logger.debug(f"golden_cross = {last_golden}, death_cross = {last_death}")
+    def get_last_solated_point(self,symbol,position,kLines):
+        # 将K线数据转换为DataFrame格式,最后一个数据可能未完成。
+        df = pd.DataFrame(kLines, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
         
-        # self.logger.debug(f"df= \n{df[['fast','slow','golden_cross','death_cross']].tail()}")
-        # 判断最近的交叉类型
-        if last_golden is None and last_death is None:
-            return {
-                'cross': -1,  # 无交叉
-                'index': None
-            }
+        # 根据position方向寻找孤立点
+        side = position['side']
+        window = 1  # 设置窗口大小，用于判断局部最值
         
-        # 如果金叉更近或只有金叉
-        if last_golden is not None and (last_death is None or last_golden > last_death):
-            return {
-                'cross': 1,  # 金叉
-                'index': last_golden
-            }
-        # 如果死叉更近或只有死叉
+        if side == 'short':
+            # 找最近的孤立高点
+            # 判断局部最高点:当前点比前后window个点都高
+            df['is_high'] = df['high'].rolling(window=window*2+1, center=True).apply(
+                lambda x: x[window] > max(x[:window]) and x[window] > max(x[window+1:]), raw=True
+            )
+            # 获取最近的孤立高点
+            isolated_points = df[df['is_high']==True]['high'].iloc[-3:]
+            
         else:
-            return {
-                'cross': 0,  # 死叉
-                'index': last_death
-            }
-    
-    def judge_ma_apex(self,symbol,pair_config, fastklines,slowklines) -> bool:
-        period = int(pair_config.get('ema_range_period', 3))
-        precision= self.get_precision_length(symbol)
+            # 找最近的孤立低点 
+            # 判断局部最低点:当前点比前后window个点都低
+            df['is_low'] = df['low'].rolling(window=window*2+1, center=True).apply(
+                lambda x: x[window] < min(x[:window]) and x[window] < min(x[window+1:]), raw=True
+            )
+            # 获取最近的孤立低点
+            isolated_points = df[df['is_low']==True]['low'].iloc[-3:]
+            
+        return isolated_points
+
+
+    def judge_correct_postion_side(self, symbol, pair_config, klines=None) -> str:
+
+        '''
+        零轴之上的macd与signal形成金叉
+        零轴之下的死叉
+        零轴之上的死叉-金叉-死叉
+        零轴之下的金叉-死叉-金叉
+        '''
+
+        order_side = 'none'
+        if 'macd_strategy' not in pair_config :
+            return  order_side
         
-        df = pd.DataFrame({
-            'ema': fastklines,
-            'sma': slowklines
-        })
-        # 快线和慢线的差值
-        # 将ema和sma转换为tick_size精度
-        # df['diff'] = df['ema'].apply(lambda x: float(self.round_price_to_tick(x, tick_size))) - df['sma'].apply(lambda x: float(self.round_price_to_tick(x, tick_size)))
-        df['diff'] = df['ema'].round(precision)-df['sma'].round(precision)
-        df['ema_diff'] = df['ema'] - df['ema'].shift(1)
-        df['sma_diff'] = df['sma'] - df['sma'].shift(1)
-        # 计算斜率，【正】表示两线距离扩张，【负】表示两线距离收缩
-        df['slope'] = df['diff'].abs().diff().round(4)
+        macd = pd.DataFrame(klines, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+        # 将时间戳转换为日期时间格式
+        macd['timestamp'] = pd.to_datetime(macd['timestamp'], unit='ms').dt.strftime('%m-%d %H:%M')
+            
+        # 使用 TA-Lib 计算 MACD
+        macd[['macd', 'signal', 'hist']] = pd.DataFrame(ta.MACD(macd['close'], fastperiod=12, slowperiod=26, signalperiod=9)).T
+        # self.logger.debug(f"{symbol} : MACD Values = \n {macd.tail(5)}")
         
-        self.logger.debug(f"{symbol}: slopes = \n{df[['ema','ema_diff','sma','sma_diff','diff','slope']].iloc[-6:-1]}  ")
         
-        # 两条线的距离是扩张状态还是收缩状态 true 是收缩 flase 是扩张
-        is_expanding_or_contracting = all(df['slope'].tail(period) <= 0 ) and any(df['slope'].tail(period) < 0)
-
-        return is_expanding_or_contracting 
-    
-        # 定义根据均线斜率判断 K 线方向的函数： 0 空 1 多 -1 平
-    
-    def judge_range_diff(self,symbol,pair_config,prices:pd.Series) -> bool:
-        """
-        计算价格列表中最后一个价格与第一个价格的差值。
-        Args:
-            prices: 价格列表。
-        Returns:
-            diff: 计算最高价列的最大值与最小值的差值
-。
-        """
-        limit = int(pair_config.get('ema_range_limit', 1))
-        period = int(pair_config.get('ema_range_period', 3))
-        tick_size = self.get_tick_size(symbol)
-        if prices.empty:
-            return None     
-  
-        diff = prices.tail(period).max() - prices.tail(period).min()   
-        self.logger.debug(f"{symbol}: 最高价列的最大值与最小值的差值 = {diff:.9f}")     
-        return abs(diff) <= tick_size * limit
-    
-    # 定义根据均线斜率判断 K 线方向的函数： 0 空 1 多 -1 平
-    def judge_k_line_direction(self, symbol, pair_config, ema: pd.Series, klines) -> int:
-        """
-        判断K线方向
-        Args:
-            symbol: 交易对
-            pair_config: 配置参数
-            ema: EMA数据
-        Returns:
-            int: -1:平, 0:空, 1:多
-        """
-        # 获取配置参数
-        period = int(pair_config.get('ema_range_period', 3))
+        # 计算最近三个交叉点
+        last_up_crosses = []
+        last_down_crosses = []
+        other_crosses = []
+        all_cross = []
         
-        ema_diff = ema.diff().tail(period)
- 
-        direction = None
-        if ema_diff.iloc[-1] < 0:
-            # 下降趋势
-            direction = 0 
-        elif ema_diff.iloc[-1] > 0:
-            # 上升趋势
-            direction = 1
+        # 从最新K开始往前遍历
+        for i in range(len(macd)-1, 2, -1):
+            # 检查是否发生死叉（MACD从上方穿过Signal）
+            if (macd.iloc[i-1]['macd'] <= macd.iloc[i-1]['signal'] and                 
+                macd.iloc[i]['macd'] > macd.iloc[i]['signal'] 
+                ):
+                all_cross.append(('golden', i))
+                
+                # 判断如果都在零轴之上加入last_up_crosses , 判断如果都在零轴之下加入last_down_crosses
+                if macd.iloc[i]['macd'] > 0 and macd.iloc[i]['signal'] > 0 :
+                    last_up_crosses.append(('golden', i))
+                elif macd.iloc[i]['macd'] < 0 and macd.iloc[i]['signal'] < 0 :
+                    last_down_crosses.append(('golden', i))
+                else:
+                    other_crosses.append(('golden', i))
+   
+            # 检查是否发生死叉（MACD从上方穿过Signal）
+            elif macd.iloc[i-1]['macd'] >= macd.iloc[i-1]['signal'] and macd.iloc[i]['macd'] < macd.iloc[i]['signal']:
+                all_cross.append(('death', i))
+                # 判断如果都在零轴之上加入last_up_crosses , 判断如果都在零轴之下加入last_down_crosses
+                if macd.iloc[i]['macd'] > 0 and macd.iloc[i]['signal'] > 0 :
+                    last_up_crosses.append(('death', i))
+                elif macd.iloc[i]['macd'] < 0 and macd.iloc[i]['signal'] < 0 :
+                    last_down_crosses.append(('death', i))
+                else:
+                    other_crosses.append(('golden', i))
+            # 只保留最后三个交叉点
+            if len(last_up_crosses) == 3 or len(last_down_crosses) == 3:
+                break
+            
+        self.logger.debug(f"{symbol} : \n- 所有cross {all_cross} \n- 零轴之上cross {last_up_crosses} \n- 零轴之下cross {last_down_crosses} \n- 其他corss {other_crosses}。")
+        
+        # valid_klines = pair_config['macd_strategy'].get('valid_klines', 5)
+        # 如果最新的交叉是金叉，且又是零轴上方的金叉
+        if len(last_up_crosses) > 0 and all_cross[0][0] == 'golden' and all_cross[0][1] == last_up_crosses[0][1] :
+            order_side =  'long'
+            self.logger.debug(f"{symbol} : 零轴之上的macd与signal形成金叉{all_cross[0]} 。") 
+            
+        # 如果最新的交叉是死叉，且又是零轴下方的死叉
+        elif len(last_down_crosses) > 0 and all_cross[0][0] == 'death' and all_cross[0][1] == last_down_crosses[0][1] :
+            order_side ='short'
+            self.logger.debug(f"{symbol} : 零轴之下的macd与signal形成死叉{all_cross[0]} 。")
+        # 分析交叉点模式，要满足连续的三个交叉都是零上
+        elif len(last_up_crosses) == 3 and len(all_cross) == 3:
+      
+           # 零轴之上的死叉-金叉-死叉模式
+            if (last_up_crosses[0][0] == 'death' and 
+                last_up_crosses[1][0] == 'golden' and 
+                last_up_crosses[2][0] == 'death' 
+                ):
+                order_side = 'short'
+                self.logger.debug(f"{symbol} : 零轴之上的死叉-金叉-死叉模式 {order_side}。")
+            
+        elif len(last_down_crosses) == 3 and len(all_cross) == 3:
+            # 零轴之下的金叉-死叉-金叉模式
+            if (last_down_crosses[0][0] == 'golden' and 
+                  last_down_crosses[1][0] == 'death' and 
+                  last_down_crosses[2][0] == 'golden' 
+                  ):
+                order_side = 'long'
+                self.logger.debug(f"{symbol} : 零轴之下的金叉-死叉-金叉模式 {order_side}。")
+
+        return order_side
+
+    def is_profitable(self, symbol ,position) -> bool:
+        # 判断是否进入浮赢阶段
+        if position['side'] == 'long':
+            # 多单判断持仓价格是否小于止损价格
+            return position['entryPrice'] < self.global_symbol_stop_loss_price.get(symbol,0.0)
         else:
-            # 震荡趋势
-            direction = -1 
-        self.logger.debug(f"{symbol}: K线极差={ema_diff.map('{:.9f}'.format).values}  ,K线方向={direction}")
-        return direction
-  
+            # 空单判断持仓价格是否大于止损价格
+            return position['entryPrice'] > self.global_symbol_stop_loss_price.get(symbol,0.0)
+
     def check_reverse_position(self,symbol,position,pair_config):
+        if 'entryPrice' not in position or self.is_profitable(symbol,position):
+            self.logger.debug(f"{symbol} : 方向={position['side']} 经进入浮赢阶段，不校验全局止损位置，止损价={self.global_symbol_stop_loss_price} ,开仓价={position['entryPrice']}。")
+            return 
+            
         side = position['side']
         try:
-            klines_period = str(pair_config.get('klines_period', '1m'))
-            klines = self.get_historical_klines(symbol=symbol,bar=klines_period)
 
-            # 计算 快线EMA & 慢线SMA
-            ema_length = pair_config.get('ema', 15)
-            sma_length = pair_config.get('sma', 50)
-            
-            # 增加 金叉死叉 方向确认的 20250209
-            fastk = self.calculate_ema_pandas(symbol, klines, period=ema_length)
-            slowk = self.calculate_sma_pandas(symbol, klines, period=sma_length)
-
-            cross_direction = self.judge_cross_direction(symbol=symbol,fastklines=fastk,slowklines=slowk)
+            klines_period = str(pair_config.get('klines_period', '1m'))
+            klines = self.get_historical_klines_except_last(symbol=symbol,bar=klines_period)
 
-            # 更新交叉状态
-            if cross_direction['cross'] != -1 :  #本次不一定有交叉
-                self.cross_directions[symbol] = cross_direction
+            self.logger.debug(f"开始监控 {symbol} : klines {klines_period} - {len(klines)}")
             
-            # 最新交叉方向
-            last_cross_direction = self.exchange.safe_dict(self.cross_directions,symbol,None)
-            # 计算 快线EMA & 慢线SMA
-            # 结合金叉死叉判断是否是周期顶部和底部
-            is_apex = self.judge_ma_apex(symbol=symbol,pair_config=pair_config, fastklines=fastk,slowklines=slowk)
+            correct_side = self.judge_correct_postion_side(symbol=symbol, pair_config=pair_config, klines=klines)
             
-            kline_direction = self.judge_k_line_direction(symbol=symbol, pair_config=pair_config, ema=fastk, klines=klines)
-            # if_inner_range = self.judge_range_diff(symbol=symbol, pair_config=pair_config, prices=fastk)
-            
-            self.logger.debug(f"{symbol} cross={last_cross_direction},两线收缩={is_apex}，持仓方向={side} ,K线方向={kline_direction}")
             order_stop_loss_pct = None
-            # 20250213 增加趋势顶部/底部判断 
-            # 金叉逻辑 ,如果是金叉，且是周期顶部，且K线方向是空头，
-            if last_cross_direction and last_cross_direction['cross'] == 1 and is_apex and side == 'long' and kline_direction == 0: 
-                self.logger.debug(f"{symbol} 金叉:{last_cross_direction['cross']},两线收缩={is_apex}，持仓方向={side} ,K线方向={kline_direction} ,开始清理多单！！")
-                # self.close_all_positions(symbol=symbol, position=position)
+            # 方向不一致 尽快平仓
+            if correct_side != 'none' and correct_side != side :
+                self.logger.info(f"{symbol}: 持仓方向={side} 与 正确方向={correct_side} 相反 , 减少止损。")
                 order_stop_loss_pct = self.stop_loss_pct / 2
-                self.logger.debug(f"{symbol} 全局止损阈值-修正后= {self.stop_loss_pct:.2f} -> {order_stop_loss_pct:.2f}%")
-
-       
-            # 死叉逻辑 ,如果是死叉，且是周期底部，且K线方向是多头，就清仓空单    
-            if last_cross_direction and last_cross_direction['cross'] == 0 and is_apex and side == 'short' and kline_direction == 1: 
-                self.logger.debug(f"{symbol} 死叉:{last_cross_direction['cross']},两线收缩={is_apex}，持仓方向={side} ,K线方向={kline_direction} ,开始清理空单！！")
-                # self.close_all_positions(symbol=symbol, position=position)
-                order_stop_loss_pct = self.stop_loss_pct / 2
-                self.logger.debug(f"{symbol} 全局止损阈值-修正后= {self.stop_loss_pct:.2f} -> {order_stop_loss_pct:.2f}%")
-
-            # 根据情况 重新修正 止损
-            if order_stop_loss_pct is not None :
-                self.global_symbol_stop_loss_flag[symbol] = False    
-                self.set_global_stop_loss(symbol=symbol,position=position,stop_loss_pct=order_stop_loss_pct)
+                self.logger.info(f"{symbol} 全局止损阈值-修正后= {self.stop_loss_pct:.2f} -> {order_stop_loss_pct:.2f}%")
             else :
-                self.global_symbol_stop_loss_flag[symbol] = False 
+                order_stop_loss_pct = self.stop_loss_pct
+                self.logger.info(f"{symbol}: 持仓方向={side} 与 正确方向={correct_side} 相同 , 恢复正常。") 
 
-        except KeyboardInterrupt:
-            self.logger.info("程序收到中断信号，开始退出...")
+            # 根据情况 重新修正止损         
+            self.global_symbol_stop_loss_flag[symbol] = False    
+            self.set_global_stop_loss(symbol=symbol,position=position,stop_loss_pct=order_stop_loss_pct)
+
+                
         except Exception as e:
             error_message = f"程序异常退出: {str(e)}"
-            self.logger.error(error_message,exc_info=True)
+            self.logger.warning(error_message,exc_info=True)
             traceback.print_exc()
             self.send_feishu_notification(error_message)
     
@@ -345,20 +347,31 @@ class MultiAssetNewTradingBot:
         average_profit_pct = total_profit_pct / num_positions if num_positions > 0 else 0
         return average_profit_pct
 
-    def reset_highest_profit_and_tier(self):
+    def reset_highest_profit_and_tier(self,symbol=None):
         """重置最高总盈利和当前档位状态"""
-        self.highest_total_profit = 0
-        self.current_tier = "无"
-        self.global_symbol_stop_loss_flag.clear()
-        # self.logger.debug("已重置最高总盈利和档位状态")
+        if not symbol:
+            self.highest_total_profit.clear()
+        else :
+            self.highest_total_profit[symbol] = 0.0
+
+        # self.logger.debug("已重置最高总盈利")
     # FIXME 目前只支持 单symbol
-    def reset_take_profie(self):
-        self.global_symbol_stop_loss_price.clear()
-        self.global_symbol_stop_loss_flag.clear()
-        # 保留在止盈挂单中最高最低两个价格，计算止盈价格。
-        self.max_market_price = 0.0
-        self.min_market_price = float('inf')  # 初始化为浮点数最大值
-        self.cross_directions = {}
+    def reset_take_profie(self,symbol=None):
+        if not symbol:
+            self.global_symbol_stop_loss_price.clear()
+            self.global_symbol_stop_loss_flag.clear()
+            # 保留在止盈挂单中最高最低两个价格，计算止盈价格。
+            self.max_market_price.clear()
+            self.min_market_price.clear() 
+            self.cross_directions.clear()
+            
+        else :
+            self.global_symbol_stop_loss_price[symbol] = 0.0
+            self.global_symbol_stop_loss_flag[symbol] = False
+            # 保留在止盈挂单中最高最低两个价格，计算止盈价格。
+            self.max_market_price[symbol] = 0.0
+            self.min_market_price[symbol] = float('inf')  # 初始化为浮点数最大值
+            self.cross_directions[symbol] = None
        
     def round_price_to_tick(self,symbol, price):
         tick_size = float(self.exchange.market(symbol)['info']['tickSz'])
@@ -378,7 +391,7 @@ class MultiAssetNewTradingBot:
         orders = self.fetch_open_orders(symbol=symbol,params=params)
         # 如果没有委托订单则直接返回
         if not orders:
-            self.global_symbol_stop_loss_flag.clear()
+            self.global_symbol_stop_loss_flag[symbol] = False
             self.logger.debug(f"{symbol} 未设置策略订单列表。")
             return
      
@@ -389,7 +402,7 @@ class MultiAssetNewTradingBot:
                 "trigger": 'trigger'
             }
             rs = self.exchange.cancel_orders(ids=algo_ids, symbol=symbol, params=params)
-            self.global_symbol_stop_loss_flag.clear()
+            self.global_symbol_stop_loss_flag[symbol] = False
             # self.logger.debug(f"Order {algo_ids} cancelled:{rs}")
         except Exception as e:
             self.logger.error(f"{symbol} Error cancelling order {algo_ids}: {e}")
@@ -454,7 +467,7 @@ class MultiAssetNewTradingBot:
         while retry_count < max_retries:
             try:
 
-                self.logger.debug(f"{symbol} - {orderSide}:Pre Take profit order set for {symbol} at {take_profit_price} Starting....  ")
+                self.logger.debug(f"{symbol}: {orderSide} - TP at {adjusted_price} Starting....  ")
                 
                 self.exchange.create_order(
                     symbol=symbol,
@@ -465,7 +478,8 @@ class MultiAssetNewTradingBot:
                     amount=amount,
                     params=tp_params
                 )
-                self.logger.debug(f"{symbol} - {orderSide}: Take profit order set for {symbol} at {take_profit_price} Done.")
+          
+                self.logger.info(f"{symbol}: TP at {adjusted_price} Done.")
                 break
                 
                
@@ -497,8 +511,7 @@ class MultiAssetNewTradingBot:
 
             
     def set_stop_loss(self, symbol, position, stop_loss_price=None) -> bool:
-        
-
+  
         # 计算下单数量
         amount = abs(float(position['contracts']))
     
@@ -537,7 +550,7 @@ class MultiAssetNewTradingBot:
         while retry_count < max_retries:
             try:
 
-                self.logger.debug(f"{symbol} - {orderSide}:Pre Stop loss order set for {symbol} at {stop_loss_price} Starting....  ")
+                self.logger.debug(f"{symbol}: {orderSide} - Pre SL at {adjusted_price} Starting....  ")
                 
                 self.exchange.create_order(
                     symbol=symbol,
@@ -549,7 +562,7 @@ class MultiAssetNewTradingBot:
                     amount=amount,
                     params=sl_params
                 )
-                self.logger.debug(f"{symbol} - {orderSide}: Stop loss order set for {symbol} at {stop_loss_price} Done.")
+                self.logger.info(f"{symbol}: SL at {adjusted_price} Done.")
                 break
                 
                
@@ -590,11 +603,11 @@ class MultiAssetNewTradingBot:
             stop_loss_algo: 止损算法信息
         """
         # 如果已经触发过全局止损并且有止损单，则跳过
+        self.logger.debug(f"{symbol} - 是否设置过全局止损 {self.global_symbol_stop_loss_flag.get(symbol, False)} ")  
         if self.global_symbol_stop_loss_flag.get(symbol, False):
-
             return
-        else :
-            self.logger.debug(f"{symbol} - 是否设置过全局止损 {self.global_symbol_stop_loss_flag.get(symbol, False)} ")   
+      
+             
         if stop_loss_pct is None :
             stop_loss_pct = self.stop_loss_pct  
              
@@ -609,11 +622,29 @@ class MultiAssetNewTradingBot:
             
         sl_order_price = float(self.round_price_to_tick(symbol, sl_price))
         tp_order_price = float(self.round_price_to_tick(symbol, tp_price))
+ 
+        # 250228 没有指定止损回撤阈值stop_loss_pct，则参考最新的孤立点设置止损价格
+        if stop_loss_pct is None :
+            pair_config = self.trading_pairs_config.get(symbol, {})
+            klines_period = str(pair_config.get('klines_period', '1m'))
+            kLines = self.get_historical_klines_except_last(symbol=symbol,bar=klines_period)   
+             
+            if kLines:   
+                isolated_point = self.get_last_solated_point(symbol ,position , kLines)  
+            
+                if len(isolated_point) > 0 :
+                    last_isolated_point = float(isolated_point.iloc[-1])
+                    self.logger.debug(f"{symbol}: - {side} ,孤立点={last_isolated_point} ,止损价={sl_order_price}")
+                    if side == 'long':
+                        sl_order_price = max(last_isolated_point, sl_order_price)
+                    elif side =='short':
+                        sl_order_price = min(last_isolated_point, sl_order_price)
+
         
         last_sl_price= self.global_symbol_stop_loss_price.get(symbol,None)  
         if last_sl_price is not None and last_sl_price == sl_order_price:
             self.global_symbol_stop_loss_flag[symbol] = True
-            self.logger.debug(f"{symbol} - {side} 全局止损价没变化: {last_sl_price} = {sl_order_price}")
+            self.logger.debug(f"{symbol}: - {side} ,全局止损价没变化: {last_sl_price} = {sl_order_price}")
             return 
             
         try:
@@ -644,18 +675,17 @@ class MultiAssetNewTradingBot:
         # 计算止盈价格。
 
         if side == 'long':
-     
-            base_price = entry_price * (1-take_profile_pct)
-            take_profile_price = entry_price + base_price - offset * tick_size
+            take_profile_price = entry_price * (1+take_profile_pct/100) - offset * tick_size
 
 
         elif side == 'short':
         
-            base_price = entry_price * (1-take_profile_pct)
-            take_profile_price = entry_price - base_price + offset * tick_size
+            # base_price = entry_price * (1-take_profile_pct)
+            take_profile_price = entry_price * (1-take_profile_pct/100) + offset * tick_size
      
-        return take_profile_price
+        return float(self.round_price_to_tick(symbol,take_profile_price))
     
+    # 计算回撤止盈价格
     def calculate_stop_loss_price(self, symbol, position, stop_loss_pct, offset=1) -> float:
         tick_size = float(self.exchange.market(symbol)['precision']['price'])
         market_price = position['markPrice']
@@ -665,19 +695,21 @@ class MultiAssetNewTradingBot:
         # 计算止盈价格，用市场价格（取持仓期间历史最高）减去开仓价格的利润，再乘以不同阶段的止盈百分比。
         latest_stop_loss_price = self.exchange.safe_float(self.global_symbol_stop_loss_price,symbol,None)
         if side == 'long':
-            self.max_market_price = max(market_price,self.max_market_price)
-            base_price = abs(self.max_market_price - entry_price) * (1-stop_loss_pct)
+            last_max_market_price = self.max_market_price.get(symbol,0.0)
+            self.max_market_price[symbol] = max(market_price,last_max_market_price)
+            base_price = abs(self.max_market_price[symbol] - entry_price) * (1-stop_loss_pct)
             stop_loss_price = entry_price + base_price - offset * tick_size
             if latest_stop_loss_price :
                 stop_loss_price = max(stop_loss_price,latest_stop_loss_price)
 
         elif side == 'short':
-            self.min_market_price = min(market_price,self.min_market_price)
-            base_price = abs(self.min_market_price - entry_price) * (1-stop_loss_pct)
+            last_min_market_price = self.min_market_price.get(symbol,float('inf'))
+            self.min_market_price[symbol] = min(market_price,last_min_market_price)
+            base_price = abs(self.min_market_price[symbol] - entry_price) * (1-stop_loss_pct)
             stop_loss_price = entry_price - base_price + offset * tick_size
             if latest_stop_loss_price :
                 stop_loss_price = min(stop_loss_price,latest_stop_loss_price)
-        return stop_loss_price
+        return float(self.round_price_to_tick(symbol,stop_loss_price))
     
     # 市价仓位平仓    
     def close_all_positions(self,symbol,position):
@@ -714,7 +746,7 @@ class MultiAssetNewTradingBot:
                     params=params
                 )
                 time.sleep(0.1)  # 短暂延迟后再试
-                self.reset_take_profie()
+                self.reset_take_profie(symbol)
                 self.logger.info(f"{symbol} Close position response for {symbol}: {order}")
                 self.send_feishu_notification(f"{symbol} 平仓订单完全成交 -{symbol} side: {side}")
 
@@ -733,25 +765,27 @@ class MultiAssetNewTradingBot:
             """
             latest_stop_loss_price = self.exchange.safe_float(self.global_symbol_stop_loss_price, symbol, 0.0)
             if latest_stop_loss_price == 0.0:
-                self.logger.warning(f"{symbol} 未设置止损价格，执行平仓")
+                self.logger.warning(f"{symbol}: 未设置止损价格，执行平仓")
                 return True
                 
             mark_price = position['markPrice']
             side = position['side']
             
-            if side == 'long' and mark_price < latest_stop_loss_price:
-                self.logger.warning(f"!![非正常关闭]: {symbol} 方向 {side} - 市场价格 {mark_price} 低于止盈 {latest_stop_loss_price}，触发全局止盈")
+            sl_price = float(self.round_price_to_tick(symbol=symbol,price=latest_stop_loss_price))
+            
+            if side == 'long' and mark_price < sl_price:
+                self.logger.warning(f"{'*'*60}\n[非正常关闭]: {symbol} 方向 {side} - 市场价格 {mark_price} 低于止盈 {latest_stop_loss_price}，触发全局止盈\n{'*'*60}")
                 return True
-            elif side == 'short' and mark_price > latest_stop_loss_price:
-                self.logger.warning(f"!![非正常关闭]: {symbol} 方向 {side} - 市场价格 {mark_price} 高于止盈价 {latest_stop_loss_price}，触发全局止盈")
+            elif side == 'short' and mark_price > sl_price:
+                self.logger.warning(f"{'*'*60}\n[非正常关闭]: {symbol} 方向 {side} - 市场价格 {mark_price} 高于止盈价 {latest_stop_loss_price}，触发全局止盈\n{'*'*60}")
                 return True
                 
             return False
     
     def check_position(self, symbol, position):
         # 清理趋势相反的仓位
-        # pair_config = self.trading_pairs_config.get(symbol, {})
-        # self.check_reverse_position(symbol=symbol, position=position, pair_config=pair_config)
+        pair_config = self.trading_pairs_config.get(symbol, {})
+        self.check_reverse_position(symbol=symbol, position=position, pair_config=pair_config)
         
         # 检查止损是否触发止盈
         if self.check_stop_loss_trigger(symbol, position):
@@ -760,105 +794,105 @@ class MultiAssetNewTradingBot:
         
     
     def check_total_profit(self, symbol, position):
-
+        """
+        检查当前总盈利
+        """
+    
         total_profit = self.calculate_average_profit(symbol, position)
         if total_profit > 0.0 :
             self.logger.info(f"{symbol} 当前总盈利: {total_profit:.2f}%")
             self.send_feishu_notification(f"{symbol} 当前总盈利: {total_profit:.2f}%")
-        if total_profit > self.highest_total_profit:
-            self.highest_total_profit = total_profit
+            
+        cur_highest_total_profit = self.highest_total_profit.get(symbol, 0.0)    
+        
+        if total_profit > cur_highest_total_profit:
+            cur_highest_total_profit = total_profit
+            self.highest_total_profit[symbol] = total_profit
+            
+        current_tier = '无'   
         # 确定当前盈利档位
-        if self.highest_total_profit >= self.second_trail_profit_threshold:
-            self.current_tier = "第二档移动止盈"
+        if cur_highest_total_profit >= self.second_trail_profit_threshold:
+            current_tier = "高档"
      
-        elif self.highest_total_profit >= self.first_trail_profit_threshold:
-            self.current_tier = "第一档移动止盈"
+        elif cur_highest_total_profit>= self.first_trail_profit_threshold:
+            current_tier = "中档"
          
-        elif self.highest_total_profit >= self.low_trail_profit_threshold:
-            self.current_tier = "低档保护止盈"
+        elif cur_highest_total_profit >= self.low_trail_profit_threshold:
+            current_tier = "低档"
             
             
         if total_profit > 0.0 :
             self.logger.info(
-                f"{symbol} 档位[{self.current_tier} ]: 当前总盈利: {total_profit:.2f}%，最高总盈利: {self.highest_total_profit:.2f}%")
-            self.send_feishu_notification(
-                f"{symbol} 档位[{self.current_tier} ]: 当前总盈利: {total_profit:.2f}%，最高总盈利: {self.highest_total_profit:.2f}%")
+                f"{symbol} 档位[{current_tier}]: 当前总盈利: {total_profit:.2f}%，最高总盈利: {cur_highest_total_profit:.2f}%")
                 
         '''
-        第一档 低档保护止盈:当盈利达到0.3%触发,要么到第二档,要么回到0.2%止盈
+        第一档:低档保护止盈:当盈利达到0.3%触发,要么到第二档,要么回到0.2%止盈
         第二档:盈利达到1%触发,记录最高价,最高价的80%是止盈位
         第三档:盈利达到3%触发,记录最高价,最高价的75%是止盈位
+        
         '''
         # 各档止盈逻辑
            
-        if self.current_tier == "低档保护止盈":
-            self.logger.info(f"{symbol} 低档回撤止盈阈值: {self.low_trail_stop_loss_pct:.2f}%")
-            if total_profit >= self.low_trail_stop_loss_pct:
-                
-                sl_price = self.calculate_stop_loss_price(symbol=symbol, position=position,stop_loss_pct=self.low_trail_stop_loss_pct )
-                # tp_price = self.calculate_take_profile_price(symbol=symbol, position=position,stop_loss_pct=self.low_trail_stop_loss_pct)  
-                # 判断止盈价格是否变化，无变化不需要设置
-                latest_sl_price = self.exchange.safe_float(self.global_symbol_stop_loss_price,symbol,0.0)
-                if sl_price == latest_sl_price:
-                    self.logger.debug(f"{symbol} 止盈价格未变化，不设置")
-                    return 
-                if_success = self.set_stop_loss_take_profit(symbol, position, stop_loss_price=sl_price )
-                if if_success:
-                    self.logger.info(f"{symbol} 总盈利触发低档保护止盈，当前回撤到: {total_profit:.2f}%，市场价格:{position['markPrice']},设置止盈位: {sl_price:.9f}")
-                    self.global_symbol_stop_loss_price[symbol] = sl_price
-                    self.reset_highest_profit_and_tier()
-                    self.send_feishu_notification(f"{symbol} 总盈利触发低档保护止盈，当前回撤到: {total_profit:.2f}%，市场价格:{position['markPrice']},设置止盈位: {sl_price:.9f}")
+        # 根据不同档位设置止损价格和通知
+        tier_config = {
+            "低档": {
+                "stop_loss_pct": float(self.low_trail_stop_loss_pct)
+            },
+            "中档": {
+                "stop_loss_pct": float(self.trail_stop_loss_pct)
+            },
+            "高档": {
+                "stop_loss_pct": float(self.higher_trail_stop_loss_pct)
+            }
+        }
+
+        if current_tier in tier_config:
+            config = tier_config[current_tier]
+            
+            # 记录日志
+            self.logger.debug(f"{symbol} 回撤止盈阈值: {config['stop_loss_pct']*100}%")
+            
+            # 计算回撤止损价格
+            sl_price = self.calculate_stop_loss_price(
+                symbol=symbol, 
+                position=position,
+                stop_loss_pct=config['stop_loss_pct']
+            )
+            
+            # 检查价格是否变化
+            latest_sl_price = self.exchange.safe_float(self.global_symbol_stop_loss_price, symbol, 0.0)
+            if sl_price == latest_sl_price:
+                self.logger.debug(f"{symbol} 回撤止损价格{latest_sl_price}未变化，不设置")
                 return
-        elif self.current_tier == "第一档移动止盈":
-            trail_stop_loss = self.highest_total_profit * (1 - self.trail_stop_loss_pct)
-            self.logger.info(f"{symbol} 第一档回撤止盈阈值: {trail_stop_loss:.2f}%")
-            if total_profit >= trail_stop_loss:
-                sl_price = self.calculate_stop_loss_price(symbol=symbol, position=position,stop_loss_pct=self.trail_stop_loss_pct )                
-                # 判断止盈价格是否变化，无变化不需要设置
-                latest_sl_price = self.exchange.safe_float(self.global_symbol_stop_loss_price,symbol,0.0)
-                if sl_price == latest_sl_price :
-                    self.logger.debug(f"{symbol} 止盈价格未变化，不设置")
-                    return  
-                if_success = self.set_stop_loss_take_profit(symbol, position, stop_loss_price=sl_price)
-                if if_success:
-                    self.logger.info(
-                        f"{symbol} 总盈利达到第一档回撤阈值，最高总盈利: {self.highest_total_profit:.2f}%,当前回撤到: {total_profit:.2f}%，市场价格: {position['markPrice']},设置止盈位: {sl_price:.9f}")
-                    # 记录一下止盈价格
-                    self.global_symbol_stop_loss_price[symbol] = float(sl_price)
-                    self.reset_highest_profit_and_tier()
-                    self.send_feishu_notification(
-                        f"{symbol} 总盈利达到第一档回撤阈值，最高总盈利: {self.highest_total_profit:.2f}%，当前回撤到: {total_profit:.2f}%，市场价格: {position['markPrice']}, 设置止盈位: {sl_price:.9f}")
-                return 
-
-        elif self.current_tier == "第二档移动止盈":
-            trail_stop_loss = self.highest_total_profit * (1 - self.higher_trail_stop_loss_pct)
-            self.logger.info(f"{symbol} 第二档回撤止盈阈值: {trail_stop_loss:.2f}%")
-            if total_profit >= trail_stop_loss:
-                sl_price = self.calculate_stop_loss_price(symbol=symbol, position=position,stop_loss_pct=self.higher_trail_stop_loss_pct)                
-                # 判断止盈价格是否变化，无变化不需要设置
-                latest_sl_price = self.exchange.safe_float(self.global_symbol_stop_loss_price,symbol,0.0)
-                if sl_price == latest_sl_price:
-                    self.logger.debug(f"{symbol} 止盈价格未变化，不设置")
-                    return   
-                if_success = self.set_stop_loss_take_profit(symbol, position, stop_loss_price=sl_price)
-                if if_success:
-                    self.logger.info(f"{symbol} 总盈利达到第二档回撤阈值，最高总盈利: {self.highest_total_profit:.2f}%，当前回撤到: {total_profit:.2f}%，市场价格: {position['markPrice']},设置止盈位: {sl_price:.9f}")
-                    # 记录一下止盈价格
-                    self.global_symbol_stop_loss_price[symbol] = sl_price
-                    self.reset_highest_profit_and_tier()
-                    self.send_feishu_notification(f"{symbol} 总盈利达到第二档回撤阈值，最高总盈利: {self.highest_total_profit:.2f}%，当前回撤到: {total_profit:.2f}%，市场价格: {position['markPrice']},设置止盈位: {sl_price:.9f}")
-                return 
-        else :
-            self.logger.info(f"{symbol} 全局止损阈值: {self.stop_loss_pct:.2f}%")
+                
+            # 设置止损
+            if_success = self.set_stop_loss_take_profit(symbol, position, stop_loss_price=sl_price)
             
-            self.set_global_stop_loss(symbol, position)
+            if if_success:
+                # 更新回撤止损价格
+         
+                self.global_symbol_stop_loss_price[symbol] = sl_price
+                self.global_symbol_stop_loss_flag[symbol] = True
+                
+                # 发送通知
+                msg = (f"{symbol}: 盈利达到【{current_tier}】阈值，最高总盈利: {cur_highest_total_profit:.2f}%,"
+                      f"当前盈利回撤到: {total_profit:.2f}%，市场价格:{position['markPrice']},"
+                      f"设置回撤止损位: {sl_price:.9f}")
+                self.logger.info(msg)
+                self.send_feishu_notification(msg)
+                
+        else:
 
-            return
+            # 默认全局止损
+            self.set_global_stop_loss(symbol, position)
+            self.logger.info(f"{symbol} 全局止损阈值: {self.stop_loss_pct:.2f}%")
+            
+        return
         
     def monitor_total_profit(self):
         self.logger.info("启动主循环，开始监控总盈利...")
-        previous_position_size = sum(
-            abs(float(position['contracts'])) for position in self.fetch_positions())  # 初始总仓位大小
+        # previous_position_size = sum(
+        #     abs(float(position['contracts'])) for position in self.fetch_positions())  # 初始总仓位大小
         while True:
             try:
                 
@@ -868,21 +902,31 @@ class MultiAssetNewTradingBot:
                     # self.logger.debug("没有持仓，等待下一次检查...")
                     self.reset_highest_profit_and_tier()
                     self.reset_take_profie()
+                    self.positions_entry_price= {}
                     time.sleep(1)
                     continue
+                
                 self.logger.info("+" * 60)
                 # 检查仓位总规模变化
-                current_position_size = sum(abs(float(position['contracts'])) for position in self.fetch_positions())
-                if current_position_size > previous_position_size:
-                    self.send_feishu_notification(f"检测到仓位变化操作，重置最高盈利和档位状态")
-                    self.logger.info("检测到新增仓位操作，重置最高盈利和档位状态")
-                    self.reset_highest_profit_and_tier()
-                    previous_position_size = current_position_size
-                    time.sleep(0.1)
-                    continue  # 跳过本次循环
+                # current_position_size = sum(abs(float(position['contracts'])) for position in self.fetch_positions())
+                # if current_position_size > previous_position_size:
+                #     self.send_feishu_notification(f"检测到仓位变化操作，重置最高盈利和档位状态")
+                #     self.logger.info("检测到新增仓位操作，重置最高盈利和档位状态")
+                #     self.reset_highest_profit_and_tier()
+                #     previous_position_size = current_position_size
+                #     time.sleep(0.1)
+                #     continue  # 跳过本次循环
 
                 for position in positions:
                     symbol = position['symbol']
+                    cur_entry_price = position['entryPrice']
+                    # 检查仓位是否有变化
+                    if symbol in self.positions_entry_price and cur_entry_price != self.positions_entry_price[symbol]:
+                        # 新开仓
+                        self.reset_highest_profit_and_tier(symbol)
+                        self.reset_take_profie(symbol)
+                        self.positions_entry_price[symbol] = cur_entry_price
+                        
                     self.check_total_profit(symbol, position)
                     time.sleep(0.1) 
                     # 检查仓位和挂单是否有问题
@@ -892,8 +936,9 @@ class MultiAssetNewTradingBot:
                 time.sleep(self.monitor_interval)
 
             except Exception as e:
-                print(e)
+                # print(e)
                 error_message = f"程序异常退出: {str(e)}"
+                traceback.print_exc()
                 self.logger.error(error_message)
                 self.send_feishu_notification(error_message)
                 continue

taker/main.py

@@ -2,7 +2,8 @@ import logging
 import yaml
 from logging.handlers import TimedRotatingFileHandler
 
-from taker.MultiAssetNewTradingBot import MultiAssetNewTradingBot
+from taker.TrailingSLTaker import TrailingSLTaker
+from taker.TrailingSLAndTPTaker import TrailingSLAndTPTaker
 from taker.ThreeLineTradingBot import ThreeLineTradingBot
 
 def build_logger(log_config) -> logging.Logger:
@@ -56,7 +57,7 @@ def main():
     package_name = __package__ or "taker"
     
     logger.info(f" ++ {package_name}:{version} is doing...")
-    bot = MultiAssetNewTradingBot(config_data, platform_config, feishu_webhook=feishu_webhook_url, monitor_interval=monitor_interval,logger=logger)
+    bot = TrailingSLAndTPTaker(config_data, platform_config, feishu_webhook=feishu_webhook_url, monitor_interval=monitor_interval,logger=logger)
     bot.monitor_total_profit()
     # bot = ThreeLineTradingBot(platform_config, feishu_webhook=feishu_webhook_url, monitor_interval=monitor_interval)
     # bot.monitor_klines()