openfund-taker 1.1.5__py3-none-any.whl → 1.2.7__py3-none-any.whl

{openfund_taker-1.1.5.dist-info → openfund_taker-1.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openfund-taker
-Version: 1.1.5
+Version: 1.2.7
 Summary: Openfund-taker
 Requires-Python: >=3.9,<4.0
 Classifier: Programming Language :: Python :: 3
@@ -9,9 +9,10 @@ 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.3,<0.7.0)
 Requires-Dist: ccxt (>=4.4.26,<5.0.0)
-Requires-Dist: pydantic-settings (>=2.1.0,<3.0.0)
-Requires-Dist: requests (>=2.27.1,<3.0.0)
+Requires-Dist: pandas (>=2.2.3,<3.0.0)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Description-Content-Type: text/markdown
 
 # buou_trail

{openfund_taker-1.1.5.dist-info → openfund_taker-1.2.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-taker/MultiAssetNewTradingBot.py,sha256=O9yhgiZIggSggdtbKsQsmd4sq3tMEarXDZzds0F-tzg,37100
+taker/MultiAssetNewTradingBot.py,sha256=bpgI6eewTwd7-Q5u2Au0UXd-mvFT1UM9S3H4CXPzf4g,42412
 taker/MultiAssetOldTradingBot.py,sha256=uBh_BxglvcbaHIsWHM7GI9Qa_QjzsxXaXJAAWEOMO5c,15315
 taker/ThreeLineTradingBot.py,sha256=oXIoQ8z9AzKzk0z13d0ufj2KGBOk5iHJTJNZQRDKA5U,20625
 taker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -8,8 +8,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=8cLWzEvQDeELbY5Av7JqkEyYbaNqSbAbVl1tQHXzU8s,1954
-openfund_taker-1.1.5.dist-info/METADATA,sha256=rTaexKjlzulJ-bihxUhNKEWJ48wfVxHTY7ZoIestcs4,7502
-openfund_taker-1.1.5.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-openfund_taker-1.1.5.dist-info/entry_points.txt,sha256=a7mG8F7aOA5-Gk2vPWuAR4537faxaHUgM_jwIDBZoEc,50
-openfund_taker-1.1.5.dist-info/RECORD,,
+taker/main.py,sha256=dTi-Innb_DSKp-esWPc6dVQekrGnv7dNHlv49xmVDfo,2516
+openfund_taker-1.2.7.dist-info/METADATA,sha256=rlwEtnPudCYEkzK1SCkCm2AmDB94XV30TfQDkzu_UAk,7527
+openfund_taker-1.2.7.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+openfund_taker-1.2.7.dist-info/entry_points.txt,sha256=a7mG8F7aOA5-Gk2vPWuAR4537faxaHUgM_jwIDBZoEc,50
+openfund_taker-1.2.7.dist-info/RECORD,,

taker/MultiAssetNewTradingBot.py

@@ -26,7 +26,7 @@ class MultiAssetNewTradingBot:
         self.current_tier = "无" # 记录当前的仓位模式
                 
         self.global_symbol_stop_loss_flag = {} # 记录每个symbol是否设置全局止损
-        self.global_symbol_take_profit_price = {} # 记录每个symbol的止盈价格
+        self.global_symbol_stop_loss_price = {} # 记录每个symbol的止损价格
         # 保留在止盈挂单中最高最低两个价格，计算止盈价格。
         self.max_market_price = 0.0
         self.min_market_price = float('inf')  # 初始化为浮点数最大值
@@ -231,7 +231,8 @@ class MultiAssetNewTradingBot:
     def check_reverse_position(self,symbol,position,pair_config):
         side = position['side']
         try:
-            klines = self.get_historical_klines(symbol=symbol)
+            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)
@@ -352,7 +353,7 @@ class MultiAssetNewTradingBot:
         # self.logger.debug("已重置最高总盈利和档位状态")
     # FIXME 目前只支持 单symbol
     def reset_take_profie(self):
-        self.global_symbol_take_profit_price.clear()
+        self.global_symbol_stop_loss_price.clear()
         self.global_symbol_stop_loss_flag.clear()
         # 保留在止盈挂单中最高最低两个价格，计算止盈价格。
         self.max_market_price = 0.0
@@ -392,32 +393,131 @@ class MultiAssetNewTradingBot:
             # self.logger.debug(f"Order {algo_ids} cancelled:{rs}")
         except Exception as e:
             self.logger.error(f"{symbol} Error cancelling order {algo_ids}: {e}")
-            
-    def set_stop_loss_take_profit(self, symbol, position, stop_loss_price=None, take_profit_price=None) -> bool:
-        self.cancel_all_algo_orders(symbol=symbol)
-        stop_params = {}
-            
+      
+    def set_stop_loss_take_profit(self, symbol, position, stop_loss_price=None,take_profit_price=None) -> bool:
+        if not stop_loss_price and not take_profit_price:
+            self.logger.warning(f"{symbol}: No stop loss price or take profit price provided for {symbol}")
+            return False   
         if not position:
             self.logger.warning(f"{symbol}: No position found for {symbol}")
-            return
+            return False
+        
+        if_stop_loss_success = False
+        if_take_profit_success = False
+        
+        if stop_loss_price :
+            if_stop_loss_success = self.set_stop_loss(symbol=symbol, position=position, stop_loss_price=stop_loss_price)
+        if take_profit_price :
+            if_take_profit_success = self.set_take_profit(symbol=symbol, position=position, take_profit_price=take_profit_price)
             
+        return if_stop_loss_success or if_take_profit_success
+          
+    def set_take_profit(self, symbol, position, take_profit_price=None) -> bool:
+
+        # 计算下单数量
         amount = abs(float(position['contracts']))
-        
+    
         if amount <= 0:
             self.logger.warning(f"{symbol}: amount is 0 for {symbol}")
             return
 
-        adjusted_price = self.round_price_to_tick(symbol, stop_loss_price)
+        # 取消所有策略订单
+        # self.cancel_all_algo_orders(symbol=symbol)
+        
+       # 止损单逻辑 
+        adjusted_price = self.round_price_to_tick(symbol, take_profit_price)
+         
+        tp_params = {
+   
             
-        # 设置止损单 ccxt 只支持单向（conditional）不支持双向下单（oco、conditional）
-        if not stop_loss_price:
+            'tpTriggerPx':adjusted_price,
+            'tpOrdPx' : adjusted_price,
+            'tpOrdKind': 'condition',
+            'tpTriggerPxType':'last',
+            
+            'tdMode':position['marginMode'],
+            'sz': str(amount),
+            # 'closeFraction': '1',
+            'cxlOnClosePos': True,
+            'reduceOnly':True
+        }
+        
+        side = 'short' 
+        if position['side'] == side: # 和持仓反向相反下单
+            side ='long'
+            
+        orderSide = 'buy' if side == 'long' else 'sell'
+    
+        max_retries = 3
+        retry_count = 0
+
+        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.exchange.create_order(
+                    symbol=symbol,
+                    type='optimal_limit_ioc',
+  
+                    price=adjusted_price,
+                    side=orderSide,
+                    amount=amount,
+                    params=tp_params
+                )
+                self.logger.debug(f"{symbol} - {orderSide}: Take profit order set for {symbol} at {take_profit_price} Done.")
+                break
+                
+               
+            except ccxt.NetworkError as e:
+                # 处理网络相关错误
+                retry_count += 1
+                self.logger.warning(f"!! 设置止盈单时发生网络错误,正在进行第{retry_count}次重试: {str(e)}")
+                time.sleep(0.1)  # 重试前等待1秒
+                continue
+            except ccxt.ExchangeError as e:
+                # 处理交易所API相关错误
+                retry_count += 1
+                self.logger.warning(f"!! 设置止盈单时发生交易所错误,正在进行第{retry_count}次重试: {str(e)}")
+                time.sleep(0.1)
+                continue
+            except Exception as e:
+                # 处理其他未预期的错误
+                retry_count += 1
+                self.logger.warning(f"!! 设置止盈单时发生未知错误,正在进行第{retry_count}次重试: {str(e)}")
+                time.sleep(0.1)
+                continue
+            
+        if retry_count >= max_retries:
+            # 重试次数用完仍未成功设置止损单
+            self.logger.warning(f"!! {symbol} 设置止盈单时重试次数用完仍未成功设置成功。 ")
             return False
+        return True 
+        
+
+            
+    def set_stop_loss(self, symbol, position, stop_loss_price=None) -> bool:
         
-        stop_params = {
+
+        # 计算下单数量
+        amount = abs(float(position['contracts']))
+    
+        if amount <= 0:
+            self.logger.warning(f"{symbol}: amount is 0 for {symbol}")
+            return
+
+        # 取消所有策略订单
+        self.cancel_all_algo_orders(symbol=symbol)
+
+
+        # 止损单逻辑 
+        adjusted_price = self.round_price_to_tick(symbol, stop_loss_price)
+         
+        sl_params = {
             'slTriggerPx':adjusted_price , 
             # 'slOrdPx':'-1', # 委托价格为-1时，执行市价止损
             'slOrdPx' : adjusted_price,
-            'slTriggerPxType':'mark',
+            'slTriggerPxType':'last',
             'tdMode':position['marginMode'],
             'sz': str(amount),
             # 'closeFraction': '1',
@@ -433,21 +533,26 @@ class MultiAssetNewTradingBot:
     
         max_retries = 3
         retry_count = 0
-        
+
         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.exchange.create_order(
                     symbol=symbol,
-                    type='conditional',
+                    type='optimal_limit_ioc',
+                    # type='conditional',
                     # type='limit',
                     price=adjusted_price,
                     side=orderSide,
                     amount=amount,
-                    params=stop_params
+                    params=sl_params
                 )
                 self.logger.debug(f"{symbol} - {orderSide}: Stop loss order set for {symbol} at {stop_loss_price} Done.")
-                return True
+                break
+                
+               
             except ccxt.NetworkError as e:
                 # 处理网络相关错误
                 retry_count += 1
@@ -466,10 +571,14 @@ class MultiAssetNewTradingBot:
                 self.logger.warning(f"!! 设置止损单时发生未知错误,正在进行第{retry_count}次重试: {str(e)}")
                 time.sleep(0.1)
                 continue
+            
+        if retry_count >= max_retries:
+            # 重试次数用完仍未成功设置止损单
+            self.logger.warning(f"!! {symbol} 设置止损单时重试次数用完仍未成功设置成功。 ")
+            return False
+        
+        return True
 
-        # 重试次数用完仍未成功设置止损单
-        self.logger.warning(f"!! {symbol} 设置止损单时重试次数用完仍未成功设置成功。 ")
-        return False
             
     def set_global_stop_loss(self, symbol, position, stop_loss_pct=None):
         """设置全局止损
@@ -482,7 +591,7 @@ class MultiAssetNewTradingBot:
         """
         # 如果已经触发过全局止损并且有止损单，则跳过
         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)} ")   
@@ -492,55 +601,85 @@ class MultiAssetNewTradingBot:
         # 根据持仓方向计算止损价格
         side = position['side'] 
         if side == 'long':
-            stop_loss_price = position['entryPrice'] * (1 - stop_loss_pct/100)
+            sl_price = position['entryPrice'] * (1 - stop_loss_pct/100)
+            tp_price = position['entryPrice'] * (1 + stop_loss_pct*2/100)
         elif side == 'short': 
-            stop_loss_price = position['entryPrice'] * (1 + stop_loss_pct/100)
+            sl_price = position['entryPrice'] * (1 + stop_loss_pct/100)
+            tp_price = position['entryPrice'] * (1 - stop_loss_pct*2/100)
             
-        order_price = float(self.round_price_to_tick(symbol, stop_loss_price))
+        sl_order_price = float(self.round_price_to_tick(symbol, sl_price))
+        tp_order_price = float(self.round_price_to_tick(symbol, tp_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}")
+            return 
             
         try:
             # 设置止损单
             if_success = self.set_stop_loss_take_profit(
                 symbol=symbol,
                 position=position,
-                stop_loss_price=order_price
+                stop_loss_price=sl_order_price,
+                take_profit_price=tp_order_price
             )
             if if_success:
                 # 设置全局止损标志
-                self.logger.debug(f"{symbol} - {side} 设置全局止损价: {order_price}")
+                self.logger.debug(f"{symbol} - {side} 设置全局止损价: {sl_order_price}")
                 self.global_symbol_stop_loss_flag[symbol] = True
-                self.global_symbol_take_profit_price[symbol] = order_price
+                self.global_symbol_stop_loss_price[symbol] = sl_order_price
                 
         except Exception as e:
             error_msg = f"{symbol} - 设置止损时发生错误: {str(e)}"
             self.logger.error(error_msg)
             self.send_feishu_notification(error_msg)  
     
-    def calculate_take_profit_price(self, symbol, position, stop_loss_pct, offset=1) -> float:
+    def calculate_take_profile_price(self, symbol, position, take_profile_pct, offset=1) -> float:
+        tick_size = float(self.exchange.market(symbol)['precision']['price'])
+        # market_price = position['markPrice']
+        entry_price = position['entryPrice']
+        side = position['side']
+
+        # 计算止盈价格。
+
+        if side == 'long':
+     
+            base_price = entry_price * (1-take_profile_pct)
+            take_profile_price = entry_price + base_price - offset * tick_size
+
+
+        elif side == 'short':
+        
+            base_price = entry_price * (1-take_profile_pct)
+            take_profile_price = entry_price - base_price + offset * tick_size
+     
+        return 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']
         entry_price = position['entryPrice']
         side = position['side']
         # base_price = abs(market_price-entry_price) * (1-stop_loss_pct)
         # 计算止盈价格，用市场价格（取持仓期间历史最高）减去开仓价格的利润，再乘以不同阶段的止盈百分比。
-        latest_take_profit_price = self.exchange.safe_float(self.global_symbol_take_profit_price,symbol,None)
+        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)
-            take_profit_price = entry_price + base_price - offset * tick_size
-            if latest_take_profit_price :
-                take_profit_price = max(take_profit_price,latest_take_profit_price)
+            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)
-            take_profit_price = entry_price - base_price + offset * tick_size
-            if latest_take_profit_price :
-                take_profit_price = min(take_profit_price,latest_take_profit_price)
-        return take_profit_price
-    
-     # 平仓
+            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
     
+    # 市价仓位平仓    
     def close_all_positions(self,symbol,position):
 
         amount = abs(float(position['contracts']))
@@ -563,6 +702,7 @@ class MultiAssetNewTradingBot:
                     
                     'mgnMode': td_mode,
                     'posSide': pos_side,
+                    # 当市价全平时，平仓单是否需要自动撤销,默认为false. false：不自动撤单 true：自动撤单
                     'autoCxl': 'true'
             
                 }
@@ -582,39 +722,39 @@ class MultiAssetNewTradingBot:
                 self.logger.error(f"{symbol} Error closing position for {symbol}: {e}")
                 self.send_feishu_notification(f"{symbol} Error closing position for {symbol}: {e}")             
 
-    def check_take_profit_trigger(self, symbol: str, position: dict) -> bool:
+    def check_stop_loss_trigger(self, symbol: str, position: dict) -> bool:
             """
-            检查是否触发止盈条件
+            检查是否触发止损条件
             Args:
                 symbol: 交易对
                 position: 持仓信息
             Returns:
                 bool: 是否需要平仓
             """
-            latest_take_profit_price = self.exchange.safe_float(self.global_symbol_take_profit_price, symbol, 0.0)
-            if latest_take_profit_price == 0.0:
-                self.logger.warning(f"{symbol} 未设置止盈价格，执行平仓")
+            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} 未设置止损价格，执行平仓")
                 return True
                 
             mark_price = position['markPrice']
             side = position['side']
             
-            if side == 'long' and mark_price < latest_take_profit_price:
-                self.logger.warning(f"!![非正常关闭]: {symbol} 方向 {side} - 市场价格 {mark_price} 低于止盈 {latest_take_profit_price}，触发全局止盈")
+            if side == 'long' and mark_price < latest_stop_loss_price:
+                self.logger.warning(f"!![非正常关闭]: {symbol} 方向 {side} - 市场价格 {mark_price} 低于止盈 {latest_stop_loss_price}，触发全局止盈")
                 return True
-            elif side == 'short' and mark_price > latest_take_profit_price:
-                self.logger.warning(f"!![非正常关闭]: {symbol} 方向 {side} - 市场价格 {mark_price} 高于止盈价 {latest_take_profit_price}，触发全局止盈")
+            elif side == 'short' and mark_price > latest_stop_loss_price:
+                self.logger.warning(f"!![非正常关闭]: {symbol} 方向 {side} - 市场价格 {mark_price} 高于止盈价 {latest_stop_loss_price}，触发全局止盈")
                 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_take_profit_trigger(symbol, position):
+        # 检查止损是否触发止盈
+        if self.check_stop_loss_trigger(symbol, position):
             self.close_all_positions(symbol=symbol, position=position)
             return
         
@@ -655,57 +795,58 @@ class MultiAssetNewTradingBot:
             self.logger.info(f"{symbol} 低档回撤止盈阈值: {self.low_trail_stop_loss_pct:.2f}%")
             if total_profit >= self.low_trail_stop_loss_pct:
                 
-                take_profit_price = self.calculate_take_profit_price(symbol=symbol, position=position,stop_loss_pct=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_take_profit_price = self.exchange.safe_float(self.global_symbol_take_profit_price,symbol,0.0)
-                if take_profit_price == latest_take_profit_price:
+                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=take_profit_price)
+                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']},设置止盈位: {take_profit_price:.9f}")
-                    self.global_symbol_take_profit_price[symbol] = take_profit_price
+                    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']},设置止盈位: {take_profit_price:.9f}")
+                    self.send_feishu_notification(f"{symbol} 总盈利触发低档保护止盈，当前回撤到: {total_profit:.2f}%，市场价格:{position['markPrice']},设置止盈位: {sl_price:.9f}")
                 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:
-                take_profit_price = self.calculate_take_profit_price(symbol=symbol, position=position,stop_loss_pct=self.trail_stop_loss_pct )                
+                sl_price = self.calculate_stop_loss_price(symbol=symbol, position=position,stop_loss_pct=self.trail_stop_loss_pct )                
                 # 判断止盈价格是否变化，无变化不需要设置
-                latest_take_profit_price = self.exchange.safe_float(self.global_symbol_take_profit_price,symbol,0.0)
-                if take_profit_price == latest_take_profit_price :
+                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=take_profit_price)
+                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']},设置止盈位: {take_profit_price:.9f}")
+                        f"{symbol} 总盈利达到第一档回撤阈值，最高总盈利: {self.highest_total_profit:.2f}%,当前回撤到: {total_profit:.2f}%，市场价格: {position['markPrice']},设置止盈位: {sl_price:.9f}")
                     # 记录一下止盈价格
-                    self.global_symbol_take_profit_price[symbol] = float(take_profit_price)
+                    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']}, 设置止盈位: {take_profit_price:.9f}")
+                        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:
-                take_profit_price = self.calculate_take_profit_price(symbol=symbol, position=position,stop_loss_pct=self.higher_trail_stop_loss_pct)                
+                sl_price = self.calculate_stop_loss_price(symbol=symbol, position=position,stop_loss_pct=self.higher_trail_stop_loss_pct)                
                 # 判断止盈价格是否变化，无变化不需要设置
-                latest_take_profit_price = self.exchange.safe_float(self.global_symbol_take_profit_price,symbol,0.0)
-                if take_profit_price == latest_take_profit_price:
+                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=take_profit_price)
+                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']},设置止盈位: {take_profit_price:.9f}")
+                    self.logger.info(f"{symbol} 总盈利达到第二档回撤阈值，最高总盈利: {self.highest_total_profit:.2f}%，当前回撤到: {total_profit:.2f}%，市场价格: {position['markPrice']},设置止盈位: {sl_price:.9f}")
                     # 记录一下止盈价格
-                    self.global_symbol_take_profit_price[symbol] = take_profit_price
+                    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']},设置止盈位: {take_profit_price:.9f}")
+                    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}%")

taker/main.py

@@ -1,6 +1,5 @@
-import os
-import json
 import logging
+import yaml
 from logging.handlers import TimedRotatingFileHandler
 
 from taker.MultiAssetNewTradingBot import MultiAssetNewTradingBot
@@ -24,17 +23,31 @@ def build_logger(log_config) -> logging.Logger:
         logger.addHandler(console_handler)
         
         return logger
-
+    
+def read_config_file(file_path):
+    try:
+        # 打开 YAML 文件
+        with open(file_path, 'r', encoding='utf-8') as file:
+            # 使用 yaml.safe_load 方法解析 YAML 文件内容
+            data = yaml.safe_load(file)
+            return data
+    except FileNotFoundError:
+        raise Exception(f"文件 {file_path} 未找到。")
+    except yaml.YAMLError as e:
+        raise Exception(f"解析 {file_path} 文件时出错: {e}")
 
 
 def main():
     import importlib.metadata
     version = importlib.metadata.version("openfund-taker")
     
-    openfund_config_path = 'config.json'
+    # openfund_config_path = 'config.json'
+    openfund_config_path = 'taker_config.yaml'
+    config_data = read_config_file(openfund_config_path)
+    
     
-    with open(openfund_config_path, 'r') as f:
-        config_data = json.load(f)
+    # with open(openfund_config_path, 'r') as f:
+    #     config_data = json.load(f)
         
     platform_config = config_data['okx']
     feishu_webhook_url = config_data['feishu_webhook']