openfund-taker 2.1.15__py3-none-any.whl → 2.2.2__py3-none-any.whl

{openfund_taker-2.1.15.dist-info → openfund_taker-2.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openfund-taker
-Version: 2.1.15
+Version: 2.2.2
 Summary: Openfund-taker
 Requires-Python: >=3.9,<4.0
 Classifier: Programming Language :: Python :: 3
@@ -9,9 +9,9 @@ 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.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: pyfiglet (>=1.0.2,<2.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Description-Content-Type: text/markdown
 

{openfund_taker-2.1.15.dist-info → openfund_taker-2.2.2.dist-info}/RECORD

@@ -1,8 +1,8 @@
 taker/MultiAssetOldTradingBot.py,sha256=uBh_BxglvcbaHIsWHM7GI9Qa_QjzsxXaXJAAWEOMO5c,15315
-taker/SMCSLAndTPTaker.py,sha256=7Gfq4v6nnK-zVdXKe1-lhLlzfTg8BOEmhlRJ81vjDLA,20743
+taker/SMCSLAndTPTaker.py,sha256=rKt_TDT8kKiyYjfz0rC77MDygvuvjsmAO_hXoLDd8dU,28432
 taker/ThreeLineTradingTaker.py,sha256=ElD9pKDO4nxw5VKNRrvXqyiU0gkV_1Mg_zk-hftfaPs,20553
 taker/TrailingSLAndTPTaker.py,sha256=OPD1ZNqyM8jZ7Im-bWm_6Cu4_qfwKmNZ30XpbP6-l00,2746
-taker/TrailingSLTaker.py,sha256=CIjlYqIM_1h4GTMGnCV67SQnk0QryPDL3u_kXJ3qioc,47853
+taker/TrailingSLTaker.py,sha256=WmgWfQim1cu5l2NQT4dfmSYaerhjYUUMKVKTF54W_y4,48884
 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
@@ -10,8 +10,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=-EdrzLG6xK0nauItj3eRC8_xva2PnS9CQdzeFJI-6Wc,2769
-openfund_taker-2.1.15.dist-info/METADATA,sha256=TbLpFl75HpRslZyTGhxBjoDl_QlZ242l_nU8KnUfDEQ,7528
-openfund_taker-2.1.15.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-openfund_taker-2.1.15.dist-info/entry_points.txt,sha256=a7mG8F7aOA5-Gk2vPWuAR4537faxaHUgM_jwIDBZoEc,50
-openfund_taker-2.1.15.dist-info/RECORD,,
+taker/main.py,sha256=3M1y_1sRIfkYNGWP0Wb3DfZFgHb0y4Cd45ERPnc1J9w,2927
+openfund_taker-2.2.2.dist-info/METADATA,sha256=UrFYvntwGqdn1STVAn8ieZ0LrXNARrrhSvGqIemP2fE,7529
+openfund_taker-2.2.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+openfund_taker-2.2.2.dist-info/entry_points.txt,sha256=a7mG8F7aOA5-Gk2vPWuAR4537faxaHUgM_jwIDBZoEc,50
+openfund_taker-2.2.2.dist-info/RECORD,,

taker/SMCSLAndTPTaker.py

@@ -1,5 +1,7 @@
 from typing import override
 import pandas as pd
+from decimal import Decimal
+
 
 from taker.TrailingSLTaker import TrailingSLTaker
 
@@ -8,7 +10,8 @@ class SMCSLAndTPTaker(TrailingSLTaker):
         super().__init__(g_config, platform_config, feishu_webhook, monitor_interval,logger)
         self.global_symbol_take_profit_flag = {} # 记录每个symbol是否设置全局止盈标志
         self.global_symbol_take_profit_price = {} # 记录每个symbol的止盈价格
-        self.htf_liquidities = {}
+        self.htf_liquidities_TP = {}
+        self.htf_liquidities_SL = {}
         self.all_TP_SL_ratio = float(platform_config.get("all_TP_SL_ratio",1.5)) #The profit-loss ratio 盈亏比
         self.open_trail_profit = bool(platform_config.get("open_trail_profit",True)) # 开仓是否设置止盈
        
@@ -80,7 +83,7 @@ class SMCSLAndTPTaker(TrailingSLTaker):
         
             # # 寻找Bearish结构
             if data.at[index, 'Dn'] < data.at[index - 1, 'Dn']:
-                data.at[index, 'iDn'] = index # TODO
+                data.at[index, 'iDn'] = index 
                 if data.at[index - 1, 'pos'] >= 0:
                 
                     data.at[index, 'pattern'] = 'Bearish_CHoCH'
@@ -174,8 +177,8 @@ class SMCSLAndTPTaker(TrailingSLTaker):
             return False
         current_high = data.at[index, 'high']
         prev_highs = data['high'].iloc[max(0,index - period):index]
-        next_highs = data['high'].iloc[index :min(len(data),index + period + 1)]
-        return all(current_high >= prev_highs) and all(current_high >= next_highs)
+        next_highs = data['high'].iloc[index+1 :min(len(data),index + period )+1]
+        return all(current_high >= prev_highs) and all(current_high > next_highs)
 
     def is_pivot_low(self, data, index, period, check_bounds=False):
         """
@@ -189,67 +192,103 @@ class SMCSLAndTPTaker(TrailingSLTaker):
             return False
         current_low = data.at[index, 'low']
         prev_lows = data['low'].iloc[max(0,index - period):index]
-        next_lows = data['low'].iloc[index :min(len(data),index + period + 1)]
-        return all(current_low <= prev_lows) and all(current_low <= next_lows)
+        next_lows = data['low'].iloc[index+1 :min(len(data),index + period)+1]
+        return all(current_low <= prev_lows) and all(current_low < next_lows)
 
               
     def set_sl_by_profit(self, symbol, position, profit, pair_config, kLines=None):
         
         """
-        根据利润设置止损价
+        根据扫过的流动性移动止损
         Args:
             symbol: 交易对
             position: 仓位信息
             profit: 利润
             pair_config: 交易对配置
+            kLines: K线数据
         """
+        
+        if self.open_trail_profit and self.global_symbol_stop_loss_flag.get(symbol,False):
+            
+            smc_strategy = pair_config.get('smc_strategy',{})
+            htf = str(smc_strategy.get('HTF','15m')) 
+            htf_prd = int(smc_strategy.get('HTF_swing_points_length',3))           
+            ltf = str(smc_strategy.get('LTF','1m'))
+            ltf_prd = int(smc_strategy.get('LTF_swing_points_length',3))
+           
+            
+            ctf = ltf
+            ctf_prd = ltf_prd
+            # ctf_Klines = kLines
+            
+            # 寻找LTF的流动性，作为移动止损位置
+            ctf_Klines = self.get_historical_klines(symbol=symbol, bar=ctf)
+            ctf_df = self.format_klines(ctf_Klines)
+            ctf_df_with_struct = self.build_struct(df=ctf_df,prd=ctf_prd)
+            # self.logger.debug(f"{symbol} : {ctf} ctf_df_with_struct\n{ctf_df_with_struct}")
 
-        total_profit = profit      
+            # 寻找流动性
+            htf_liquidity_SL = self.htf_liquidities_SL.get(symbol,None)
+            if htf_liquidity_SL is None:
+                htf_liquidity_SL = self.detect_liquidity_for_SL(symbol, ctf_df_with_struct, position['side'], position['markPrice'])
+                self.htf_liquidities_SL[symbol] = htf_liquidity_SL
+            
+            if len(htf_liquidity_SL) == 0:
+                self.logger.info(f"{symbol} : {ctf} 没有找到扫荡的流动性，不重设止损")
+                return
+        
+            sl_price = self.calculate_trailing_sl_price_by_liquidity(symbol, position, htf_liquidity_SL, self.stop_loss_pct)
+        # total_profit = profit      
 
-        current_tier = '无'
-        # 各档止盈逻辑
-        # 确定当前盈利档位
-        if self.open_trail_profit and total_profit >= self.second_trail_profit_threshold:
-            current_tier = "高档"
+        # current_tier = '无'
+        # # 各档止盈逻辑
+        # # 确定当前盈利档位
+        # if self.open_trail_profit and total_profihtf_liquidities_SLt >= self.second_trail_profit_threshold:
+        #     current_tier = "高档"
      
-        elif self.open_trail_profit and total_profit>= self.first_trail_profit_threshold:
-            current_tier = "中档"
+        # elif self.open_trail_profit and total_profit>= self.first_trail_profit_threshold:
+        #     current_tier = "中档"
          
-        elif self.open_trail_profit and total_profit >= self.low_trail_profit_threshold:
-            current_tier = "低档"
+        # elif self.open_trail_profit and total_profit >= self.low_trail_profit_threshold:
+        #     current_tier = "低档"
          
-        # 根据不同档位设置止损价格,没有单独为交易对设置，用全局参数代替
-        tier_config = {
-            "低档": {
-                "stop_loss_pct": float(pair_config.get('low_trail_stop_loss_pct',self.low_trail_stop_loss_pct)),
+        # # 根据不同档位设置止损价格,没有单独为交易对设置，用全局参数代替
+        # tier_config = {
+        #     "低档": {
+        #         "stop_loss_pct": float(pair_config.get('low_trail_stop_loss_pct',self.low_trail_stop_loss_pct)),
                          
-            },
-            "中档": {
-                "stop_loss_pct": float(pair_config.get('trail_stop_loss_pct',self.trail_stop_loss_pct)),
+        #     },
+        #     "中档": {
+        #         "stop_loss_pct": float(pair_config.get('trail_stop_loss_pct',self.trail_stop_loss_pct)),
             
-            },
-            "高档": {
-                "stop_loss_pct": float(pair_config.get('higher_trail_stop_loss_pct',self.higher_trail_stop_loss_pct)),
+        #     },
+        #     "高档": {
+        #         "stop_loss_pct": float(pair_config.get('higher_trail_stop_loss_pct',self.higher_trail_stop_loss_pct)),
 
-            }
-        }
+        #     }
+        # }
 
-        if current_tier in tier_config:
-            config = tier_config[current_tier]        
+        # if current_tier in tier_config and self.open_trail_profit:
+        #     config = tier_config[current_tier]        
 
             
-            # 计算回撤止损价格
-            sl_price = self.calculate_stop_loss_price(
-                symbol=symbol, 
-                position=position,
-                stop_loss_pct=config['stop_loss_pct']
-            )
+        #     # 计算回撤止损价格
+        #     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)
+            latest_sl_price = self.global_symbol_stop_loss_price.get(symbol,0.0)
+            side = position['side']
             if sl_price == latest_sl_price:
-                self.logger.debug(f"{symbol}: 回撤止损价格{latest_sl_price}未变化，不设置")
+                self.logger.debug(f"{symbol}: 移动止损价格{latest_sl_price}未变化，不设置")
+                return
+            elif (side == 'long' and sl_price < latest_sl_price) or (side == 'short' and sl_price > latest_sl_price):
+                self.logger.debug(f"{symbol}: [{side}] 新移动止损价格{sl_price} 不能替换 {latest_sl_price}，不设置")                
                 return
+                
             
             self.cancel_all_algo_orders(symbol=symbol, attachType='SL')
                 
@@ -261,12 +300,13 @@ class SMCSLAndTPTaker(TrailingSLTaker):
          
                 self.global_symbol_stop_loss_price[symbol] = sl_price
                 self.global_symbol_stop_loss_flag[symbol] = True
-                cur_highest_total_profit = self.highest_total_profit.get(symbol, 0.0) 
+                # cur_highest_total_profit = self.highest_total_profit.get(symbol, 0.0) 
                 
                 # 发送通知
-                msg = (f"{symbol}: 盈利达到【{current_tier}】阈值，最高总盈利: {cur_highest_total_profit:.2f}%,"
-                      f"当前盈利回撤到: {total_profit:.2f}%，市场价格:{position['markPrice']},"
-                      f"设置回撤止损位: {sl_price:.9f}")
+                # msg = (f"{symbol}: 盈利达到【{current_tier}】阈值，最高总盈利: {cur_highest_total_profit:.2f}%,"
+                #       f"当前盈利回撤到: {total_profit:.2f}%，市场价格:{position['markPrice']},"
+                #       f"设置回撤止损位: {sl_price:.9f}")
+                msg = (f"{symbol}: {ctf}移动止损，找到扫荡的流动性位置，设置止损: {sl_price:.9f}")
                 self.logger.info(msg)
                 self.send_feishu_notification(msg)
                 
@@ -278,26 +318,25 @@ class SMCSLAndTPTaker(TrailingSLTaker):
                 # 更新回撤止损价格
                 self.global_symbol_take_profit_flag[symbol] = False
         
-    def find_liquidity(self, symbol, data, side) -> pd.DataFrame:
+    def find_liquidity(self, symbol, data, liquidity_type="BSL") -> pd.DataFrame:
         """
         寻找流动性，根据side判断是做多还是做空，做多则寻找iUp，做空则寻找iDn
         Args:
             symbol (str): 交易对
             data (pd.DataFrame): 数据
-            side (str): 交易方向，'long' 或'short'
+            liquidity_type (str): 流动性类型，'BSL' 或 'BSL'
+            
         """
         df = data.copy()
         
-        is_buy = side == 'long'
-
-        col_prefix = 'iUp' if is_buy else 'iDn'
-        price_col = 'Up' if is_buy else 'Dn'
+        is_buy = liquidity_type == 'BSL'
+        col_prefix = 'iDn' if is_buy else 'iUp'
         
         return df[df.index == df[col_prefix]].sort_index(ascending=False)
     
-    def detect_liquidity(self, symbol, data, side , market_price) -> pd.DataFrame:
+    def detect_liquidity_for_TP(self, symbol, data, side , market_price) -> pd.DataFrame:
         """
-        校对流动性，用市场价格校验流动性是否有效,做多则流动性在市场价格之上，做空流动性要在市场价格之下。
+        TP校对流动性，用市场价格校验流动性是否有效,做多则流动性在市场价格之上，做空流动性要在市场价格之下。
         Args:
             symbol (str): 交易对
             side (str): 交易方向，'long' 或 'short'
@@ -305,13 +344,17 @@ class SMCSLAndTPTaker(TrailingSLTaker):
             market_price (float): 当前市场价格
             
         """
-        df_liquidities = self.find_liquidity(symbol, data, side)
-
-        df_valid_liquidities = df_liquidities.copy()
         is_buy = side == 'long'
         col_prefix = 'iUp' if is_buy else 'iDn'
         price_col = 'Up' if is_buy else 'Dn'
         
+        # 设置TP,long寻找SSL,short寻找BSL
+        liquidity_type = 'SSL' if is_buy else 'BSL'
+        
+        df_liquidities = self.find_liquidity(symbol, data, liquidity_type=liquidity_type)
+
+        df_valid_liquidities = df_liquidities.copy()     
+                 
         result_indices = []
         current_price = float('-inf') if is_buy else float('inf')
         current_i = float('inf') 
@@ -330,7 +373,115 @@ class SMCSLAndTPTaker(TrailingSLTaker):
                     current_i = row[col_prefix]
                     
         return df_valid_liquidities.loc[result_indices].sort_index(ascending=False)
+    
+    def detect_liquidity_for_SL(self, symbol, data, side, market_price) -> pd.DataFrame:
+        """
+        SL校对流动性，用市场价格校验流动性是否有效,做多则流动性在市场价格之下，做空流动性要在市场价格之上。
+        Args:
+            symbol (str): 交易对
+            side (str): 交易方向，'long' 或'short'
+            df_liquidities (pd.DataFrame): 流动性数据
+            market_price (float): 当前市场价格
+
+        """
+        is_buy = side == 'long'
+        col_prefix = 'iDn' if is_buy else 'iUp'
+        price_col = 'Dn' if is_buy else 'Up'
+        df = data.copy()  
+        
+
+        # 初始化新列
+
+        df['pivot_price'] = pd.NA
+        df['is_extreme'] = False
+
+        # 1. 根据pos值分组（连续相同pos为一个区间）
+
+        groups = df['pos'].gt(0).ne(df['pos'].gt(0).shift()).cumsum()
+
+        # 2. 对每个pos区间处理
+        for group_id, group_data in df.groupby(groups):
+            pos_val = group_data['pos'].iloc[0]
+            
+            if pos_val > 0:
+                # 找high最大值及其第一次出现的位置
+                max_high = group_data['high'].max()
+                max_idx = group_data['high'].idxmax()
+                df.at[max_idx, 'pivot_price'] = max_high
+                df.at[max_idx, 'is_extreme'] = True
+                
+            elif pos_val < 0:
+                # 找low最小值及其第一次出现的位置
+                min_low = group_data['low'].min()
+                min_idx = group_data['low'].idxmin()
+                df.at[min_idx, 'pivot_price'] = min_low
+                df.at[min_idx, 'is_extreme'] = True
+
+
+        # self.logger.debug(f"{df[['timestamp', 'pattern','high','low','pivot_price','is_extreme']]}")
         
+        struct_siginfo = "Bullish" if is_buy else "Bearish"
+
+        # 3. 筛选CHoCH后符合条件的行
+        result_indices = []
+        # 倒序遍历数据
+        found_choch = False
+        for idx in reversed(df.index):
+           
+            # 检查是否有新的pattern
+            current_pattern = df.at[idx, 'pattern']
+            
+            
+            # 如果找到对应的CHoCH结构
+            if current_pattern and f"{struct_siginfo}_CHoCH" == current_pattern:
+                found_choch = True
+                continue
+   
+            # 在找到CHoCH结构后,记录极值点
+            if found_choch and df.at[idx, 'is_extreme']:
+                result_indices.append(idx)
+                found_choch = False
+                
+        self.logger.debug(f"result_indices = {result_indices}")
+        took_out_df = df.loc[result_indices].copy()
+        valid_mast = took_out_df['pivot_price'] < market_price if is_buy else took_out_df['pivot_price'] > market_price
+        took_out_df = took_out_df[valid_mast]
+        return took_out_df.sort_index(ascending=False)
+    
+   
+    def calculate_trailing_sl_price_by_liquidity(self, symbol, position, df_liquidities, stop_loss_pct=2, offset=1) -> float:
+        """
+        计算回撤止损价格，根据流动性，做多则回撤止损价格在流动性之下，做空则回撤止损价格在流动性之上。
+        Args:
+            symbol (str): 交易对
+            position (dict): 仓位信息
+            df_liquidities (pd.DataFrame): 流动性数据
+            stop_loss_pct (int, optional): 回撤百分比. Defaults to 2.
+            offset (int, optional): 偏移量. Defaults to 1.
+        Returns:
+            float: 回撤止损价格
+        """
+        sl_price =  self.calculate_sl_price_by_pct(symbol, position, stop_loss_pct)
+               
+        is_buy = position['side'] == 'long'
+        price_col = 'Dn' if is_buy else 'Up'
+        self.logger.debug(f"{symbol} : SL side={position['side']} sl_price={sl_price} SL的扫荡流动性=\n {df_liquidities[['timestamp',price_col, 'is_extreme']]}")
+        
+        valid_mask = df_liquidities[price_col] > sl_price if is_buy else df_liquidities[price_col] < sl_price
+        df_valid_liquidities = df_liquidities[valid_mask]
+        # 获取止损价格
+        # trailing_sl = df_valid_liquidities.iloc[0][price_col] if len(df_valid_liquidities) > 0 else sl_price
+        trailing_sl = Decimal(df_liquidities[price_col].max() if is_buy else df_liquidities[price_col].min())
+                
+        # 计算移动止损价格 , 做多则止损价格在流动性之下tick_size，做空则止损价格在流动性之上tick_size。
+        tick_size = self.get_tick_size(symbol)
+        if is_buy:
+            trailing_sl = trailing_sl - offset * tick_size
+        else:   
+            trailing_sl = trailing_sl + offset * tick_size
+            
+        return self.round_price_to_tick(symbol, trailing_sl)
+    
     def calculate_tp_price_by_liquidity(self, symbol, position, df_liquidities, stop_loss_pct=2, tp_sl_ratio=1.5, offset=1) -> float:
         """_summary_
         计算止盈价格，根据流动性，做多则止盈价格在流动性之上，做空则止盈价格在流动性之下。
@@ -353,25 +504,35 @@ class SMCSLAndTPTaker(TrailingSLTaker):
         price_col = 'Up' if is_buy else 'Dn'
         
         # sl_price = self.global_symbol_stop_loss_price.get(symbol, float(position['markPrice']))
-        entry_price = float(position['entryPrice'])
-        sl_price =  self.calculate_sl_price_by_pct(symbol, position, stop_loss_pct)
+        # 获取开仓价格和止损价格
+        entry_price = Decimal(position['entryPrice'])
+        sl_price = self.calculate_sl_price_by_pct(symbol, position, stop_loss_pct)
+        
+        # 计算止盈阈值
         threshold = 0.0
-        if is_buy and sl_price > 0 :
-            threshold = float(self.round_price_to_tick(symbol, (entry_price - sl_price ) * tp_sl_ratio + entry_price))
-        elif not is_buy and sl_price > 0:
-            threshold = float(self.round_price_to_tick(symbol, entry_price - (sl_price - entry_price ) * tp_sl_ratio))
+        if sl_price <= 0:
+            return threshold
+            
+        # 做多时,止盈阈值 = 开仓价格 + (开仓价格-止损价格)*止盈止损比率 
+        if is_buy:
+            price_diff = entry_price - sl_price
+            threshold = self.round_price_to_tick(symbol, entry_price + price_diff * Decimal(tp_sl_ratio))
+        # 做空时,止盈阈值 = 开仓价格 - (止损价格-开仓价格)*止盈止损比率
+        else:
+            price_diff = sl_price - entry_price  
+            threshold = self.round_price_to_tick(symbol, entry_price - price_diff * Decimal(tp_sl_ratio))
          
 
         # 过滤有效的流动性价格
         valid_mask = df_liquidities[price_col] > threshold if is_buy else df_liquidities[price_col] < threshold
         df_valid_liquidities = df_liquidities[valid_mask]
-        self.logger.debug(f"{symbol} : threshold={threshold} sl_price={sl_price} 有效的流动=\n {df_valid_liquidities[['timestamp','Up','Dn']]}")
+        self.logger.debug(f"{symbol} : TP threshold={threshold} sl_price={sl_price} 有效的流动=\n {df_valid_liquidities[['timestamp','Up','Dn']]}")
         # 获取止盈价格
         tp_price = df_valid_liquidities.iloc[0][price_col] if len(df_valid_liquidities) > 0 else threshold
         if is_buy:
-            tp_price = max(tp_price, threshold)
+            tp_price = Decimal(max(tp_price, threshold))
         else:
-            tp_price = min(tp_price, threshold)
+            tp_price = Decimal(min(tp_price, threshold))
         tick_size = self.get_tick_size(symbol)
         
         # 计算止盈价格 , 做多则止盈价格在流动性之下tick_size，做空则止盈价格在流动性之上tick_size。
@@ -381,12 +542,13 @@ class SMCSLAndTPTaker(TrailingSLTaker):
             tp_price = tp_price + offset * tick_size
             
         
-        return tp_price
+        return self.round_price_to_tick(symbol, tp_price)
     
     @override
     def close_all_cache(self):
         super().close_all_cache()
-        self.htf_liquidities.clear()
+        self.htf_liquidities_TP.clear()
+        self.htf_liquidities_SL.clear()
         self.global_symbol_take_profit_flag.clear()
         self.global_symbol_take_profit_price.clear()
 
@@ -394,7 +556,8 @@ class SMCSLAndTPTaker(TrailingSLTaker):
     @override
     def reset_all_cache(self, symbol):
         super().reset_all_cache(symbol)
-        self.htf_liquidities[symbol] = None
+        self.htf_liquidities_TP[symbol] = None
+        self.htf_liquidities_SL[symbol] = None
         self.global_symbol_take_profit_flag[symbol] = False
         self.global_symbol_take_profit_price[symbol] = None
            
@@ -418,10 +581,10 @@ class SMCSLAndTPTaker(TrailingSLTaker):
         htf_df_with_struct = self.build_struct(df=htf_df,prd=htf_prd)  
 
         # 寻找流动性
-        htf_liquidity = self.htf_liquidities.get(symbol,None)
+        htf_liquidity = self.htf_liquidities_TP.get(symbol,None)
         if htf_liquidity is None:
-            htf_liquidity = self.detect_liquidity(symbol, htf_df_with_struct, position['side'], position['markPrice'])
-            self.htf_liquidities[symbol] = htf_liquidity
+            htf_liquidity = self.detect_liquidity_for_TP(symbol, htf_df_with_struct, position['side'], position['markPrice'])
+            self.htf_liquidities_TP[symbol] = htf_liquidity
         
         if len(htf_liquidity) <= 0:
             self.logger.info(f"{symbol} : 没有找到流动性，不设置止盈")

taker/TrailingSLTaker.py

@@ -4,7 +4,8 @@ import time
 import requests
 import traceback
 import pandas as pd
-import talib as ta
+# import talib as ta
+from decimal import Decimal
 '''
 自动设置移动止损单
 '''
@@ -55,7 +56,7 @@ class TrailingSLTaker:
             'timeout': 3000,
             'rateLimit': 50,
             'options': {'defaultType': 'future'},
-            'proxies': {'http': 'http://127.0.0.1:7890', 'https': 'http://127.0.0.1:7890'},
+            # 'proxies': {'http': 'http://127.0.0.1:7890', 'https': 'http://127.0.0.1:7890'},
         })
         self.logger = logger
         self.position_mode = self.get_position_mode()  # 获取持仓模式
@@ -67,8 +68,20 @@ class TrailingSLTaker:
         self.exchange.load_markets()
         return self.exchange.market(symbol)
     # 获取tick_size
-    def get_tick_size(self,symbol):
-        return float(self.getMarket(symbol)['precision']['price'])
+    def get_tick_size(self,symbol) -> Decimal:
+      
+        try:
+            market = self.getMarket(symbol)
+            if market and 'precision' in market and 'price' in market['precision']:
+                
+                return Decimal(str(market['precision']['price']))
+            else:
+                self.logger.warn(f"{symbol}: 无法从市场数据中获取价格精度")
+                return Decimal(0.00001)  # 返回默认精度
+        except Exception as e:
+            self.logger.warn(f"{symbol}: 获取市场价格精度时发生错误: {str(e)}")
+            return Decimal(0.00001)   # 发生异常时返回默认精度
+        # return float(self.getMarket(symbol)['precision']['price'])
     # 获取价格精度
     def get_precision_length(self,symbol) -> int:
         tick_size = self.get_tick_size(symbol)
@@ -97,21 +110,16 @@ class TrailingSLTaker:
                 headers = {'Content-Type': 'application/json'}
                 payload = {"msg_type": "text", "content": {"text": message}}
                 response = requests.post(self.feishu_webhook, json=payload, headers=headers)
-                if response.status_code == 200:
-                    self.logger.debug("飞书通知发送成功")
-                else:
-                    self.logger.warn("飞书通知发送失败，状态码: %s", response.status_code)
+                # if response.status_code == 200:
+                #     self.logger.debug("飞书通知发送成功")
+                # else:
+                #     self.logger.warn("飞书通知发送失败，状态码: %s", response.status_code)
             except Exception as e:
                 self.logger.error("发送飞书通知时出现异常: %s", str(e))
 
-    def fetch_positions(self):
-        try:
-            positions = self.exchange.fetch_positions()
-            return positions
-        except Exception as e:
-            self.logger.warning(f"Warn fetching positions: {e}")
-            return []
-
+    def fetch_positions(self):     
+        return self.exchange.fetch_positions()
+  
     # 获取当前委托
     def fetch_open_orders(self,symbol,params={}):
         try:
@@ -232,7 +240,16 @@ class TrailingSLTaker:
         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
+        # macd[['macd', 'signal', 'hist']] = pd.DataFrame(ta.MACD(macd['close'], fastperiod=12, slowperiod=26, signalperiod=9)).T
+        # 计算EMA12和EMA26
+        exp1 = macd['close'].ewm(span=12, adjust=False).mean()
+        exp2 = macd['close'].ewm(span=26, adjust=False).mean()
+        # 计算MACD线
+        macd['macd'] = exp1 - exp2
+        # 计算信号线
+        macd['signal'] = macd['macd'].ewm(span=9, adjust=False).mean()
+        # 计算柱状图
+        macd['hist'] = macd['macd'] - macd['signal']
         # self.logger.debug(f"{symbol} : MACD Values = \n {macd.tail(5)}")
         
         
@@ -379,7 +396,7 @@ class TrailingSLTaker:
     
    # 计算平均利润
     def calculate_average_profit(self,symbol,position):
-        # positions = self.fetch_positions()
+  
         total_profit_pct = 0.0
         num_positions = 0
 
@@ -433,15 +450,15 @@ class TrailingSLTaker:
             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'])
+    def round_price_to_tick(self,symbol, price) -> Decimal:
+        tick_size = self.get_tick_size(symbol)
         # 计算 tick_size 的整数倍
-        tick_decimals = len(f"{tick_size:.10f}".rstrip('0').split('.')[1]) if '.' in f"{tick_size:.10f}" else 0
+        # tick_decimals = len(f"{tick_size:.10f}".rstrip('0').split('.')[1]) if '.' in f"{tick_size:.10f}" else 0
 
         # 调整价格为 tick_size 的整数倍
-        adjusted_price = round(price / tick_size) * tick_size
-        return f"{adjusted_price:.{tick_decimals}f}"
-        # 放弃当前委托
+        adjusted_price = round(Decimal(price) / tick_size) * tick_size
+        return adjusted_price
+        
     
     def cancel_all_algo_orders(self, symbol, attachType=None) -> bool:
         """_summary_
@@ -515,13 +532,13 @@ class TrailingSLTaker:
 
         
        # 止损单逻辑 
-        adjusted_price = float(self.round_price_to_tick(symbol, take_profit_price))
+        adjusted_price = self.round_price_to_tick(symbol, take_profit_price)
          
         tp_params = {
    
             
-            'tpTriggerPx':adjusted_price,
-            'tpOrdPx' : adjusted_price,
+            'tpTriggerPx':str(adjusted_price),
+            'tpOrdPx' : str(adjusted_price),
             'tpOrdKind': 'condition',
             'tpTriggerPxType':'last',
             
@@ -604,11 +621,11 @@ class TrailingSLTaker:
             return
 
         # 止损单逻辑 
-        adjusted_price = float(self.round_price_to_tick(symbol, stop_loss_price))
+        adjusted_price = self.round_price_to_tick(symbol, stop_loss_price)
         
         # 默认市价止损，委托价格为-1时，执行市价止损。
         sl_params = {
-            'slTriggerPx':adjusted_price , 
+            'slTriggerPx':str(adjusted_price) , 
             'slOrdPx':'-1', # 委托价格为-1时，执行市价止损
             # 'slOrdPx' : adjusted_price,
             'slTriggerPxType':'last',
@@ -673,7 +690,7 @@ class TrailingSLTaker:
         return True
 
 
-    def calculate_sl_price_by_pct(self, symbol, position, sl_pct) -> float:
+    def calculate_sl_price_by_pct(self, symbol, position, sl_pct) -> Decimal:
         side = position['side']
         if side == 'long':           
             sl_price = position['entryPrice'] * (1 - sl_pct/100)  
@@ -682,7 +699,7 @@ class TrailingSLTaker:
             sl_price = position['entryPrice'] * (1 + sl_pct/100)
        
             
-        sl_order_price = float(self.round_price_to_tick(symbol, sl_price)) 
+        sl_order_price = self.round_price_to_tick(symbol, sl_price)
         
         return sl_order_price   
             
@@ -712,16 +729,13 @@ class TrailingSLTaker:
         
         # 验证止损价格是否合理20250312
         mark_price = float(position['markPrice'])
-        if side == 'long':
-            if sl_order_price >= mark_price:
-                self.close_all_positions(symbol,position)
-                self.logger.warning(f"{symbol}: !! 多头止损价格= {sl_order_price} 大于等于市场价格= {mark_price}，触发止损")
-                return
-        else:  # side == 'short'
-            if sl_order_price <= mark_price:
-                self.close_all_positions(symbol,position)
-                self.logger.warning(f"{symbol}: !! 空头止损价格= {sl_order_price} 小于等于市场价格= {mark_price}，触发止损")
-                return
+        # 验证止损价格是否合理,如果止损价格已经触发则直接平仓
+        if (side == 'long' and sl_order_price >= mark_price) or \
+           (side == 'short' and sl_order_price <= mark_price):
+            self.close_all_positions(symbol, position)
+            direction = "多头" if side == "long" else "空头"
+            self.logger.warning(f"{symbol}: !! {direction}止损价格= {sl_order_price} {'大于等于' if side=='long' else '小于等于'}市场价格= {mark_price}，触发止损")
+            return
                 
         # 250228 没有指定止损回撤阈值stop_loss_pct...
         open_swing_point = pair_config.get('open_swing_point', False)
@@ -736,12 +750,12 @@ class TrailingSLTaker:
             if len(isolated_points) > 0 :
                 last_isolated_point = isolated_points[0]
                                     
+                # 多头仓位，取孤立点的低点和原止损价的最小值作为新的止损价
                 if side == 'long':
-                
-                    sl_order_price = min(last_isolated_point['low'],sl_order_price)
+                    sl_order_price = min(last_isolated_point['low'], sl_order_price)
+                # 空头仓位，取孤立点的高点和原止损价的最大值作为新的止损价 
                 else:
-                
-                    sl_order_price = max(last_isolated_point['high'],sl_order_price)
+                    sl_order_price = max(last_isolated_point['high'], sl_order_price)
                     
                 self.logger.debug(f"{symbol} : {side} 止损价={sl_order_price} 孤立点=\n{last_isolated_point} ")
 
@@ -775,7 +789,7 @@ class TrailingSLTaker:
             traceback.print_exc()
             self.send_feishu_notification(error_msg)  
     
-    def calculate_take_profile_price(self, symbol, position, take_profile_pct, offset=1) -> float:
+    def calculate_take_profile_price(self, symbol, position, take_profile_pct, offset=1) -> Decimal:
         tick_size = self.get_tick_size(symbol)
 
         entry_price = position['entryPrice']
@@ -784,15 +798,15 @@ class TrailingSLTaker:
         # 计算止盈价格。
 
         if side == 'long':
-            take_profile_price = entry_price * (1+take_profile_pct/100) - offset * tick_size
+            take_profile_price = Decimal(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 * (1-take_profile_pct/100) + offset * tick_size
+            take_profile_price = Decimal(entry_price * (1-take_profile_pct/100)) + offset * tick_size
      
-        return float(self.round_price_to_tick(symbol,take_profile_price))
+        return Decimal(self.round_price_to_tick(symbol,take_profile_price))
     
     # 计算回撤止盈价格
     def calculate_stop_loss_price(self, symbol, position, stop_loss_pct, offset=1) -> float:
@@ -807,7 +821,7 @@ class TrailingSLTaker:
             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
+            stop_loss_price = Decimal(entry_price + base_price) - offset * tick_size
             if latest_stop_loss_price :
                 stop_loss_price = max(stop_loss_price,latest_stop_loss_price)
 
@@ -815,7 +829,7 @@ class TrailingSLTaker:
             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
+            stop_loss_price = Decimal(entry_price - base_price) + offset * tick_size
             if latest_stop_loss_price :
                 stop_loss_price = min(stop_loss_price,latest_stop_loss_price)
         return float(self.round_price_to_tick(symbol,stop_loss_price))
@@ -1025,14 +1039,19 @@ class TrailingSLTaker:
         
     def monitor_total_profit(self):
         self.logger.info("启动主循环，开始监控总盈利...")
-        # previous_position_size = sum(
-        #     abs(float(position['contracts'])) for position in self.fetch_positions())  # 初始总仓位大小
+
         while True:
             try:
-                
                 positions = self.fetch_positions()
+        
+            except Exception as e:
+                self.logger.warning(f"获取仓位信息时发生错误: {e}")
+                time.sleep(1)
+                continue
+            
+            try:
                 # 检查是否有仓位
-                if not positions:
+                if len(positions) == 0:
                     # self.logger.debug("没有持仓，等待下一次检查...")
                     self.close_all_cache()
                     time.sleep(1)
@@ -1077,6 +1096,7 @@ class TrailingSLTaker:
                 traceback.print_exc()
                 self.logger.error(error_message)
                 self.send_feishu_notification(error_message)
+                self.logger.info("-" * 60)
                 continue
             except KeyboardInterrupt:
                 self.logger.info("程序收到中断信号，开始退出...")

taker/main.py

@@ -6,6 +6,7 @@ from taker.TrailingSLTaker import TrailingSLTaker
 from taker.TrailingSLAndTPTaker import TrailingSLAndTPTaker
 from taker.ThreeLineTradingTaker import ThreeLineTradingTaker
 from taker.SMCSLAndTPTaker import SMCSLAndTPTaker
+from pyfiglet import Figlet
 
 def build_logger(log_config) -> logging.Logger:
             # 配置日志
@@ -64,6 +65,8 @@ def main():
     bot = strategy_class(config_data, platform_config, feishu_webhook=feishu_webhook_url, monitor_interval=monitor_interval,logger=logger)
     logger.info(f" ++ {package_name}.{taker}:{version} is doing...")
 
+    f = Figlet(font="standard")  # 字体可选（如 "block", "bubble"）
+    logger.info(f"\n{f.renderText("OpenFund Taker")}")
     bot.monitor_total_profit()
     # bot = ThreeLineTradingBot(platform_config, feishu_webhook=feishu_webhook_url, monitor_interval=monitor_interval)
     # bot.monitor_klines()