openfund-taker 2.2.6__py3-none-any.whl → 2.2.7__py3-none-any.whl

{openfund_taker-2.2.6.dist-info → openfund_taker-2.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openfund-taker
-Version: 2.2.6
+Version: 2.2.7
 Summary: Openfund-taker
 Requires-Python: >=3.9,<4.0
 Classifier: Programming Language :: Python :: 3

openfund_taker-2.2.7.dist-info/RECORD

@@ -0,0 +1,16 @@
+taker/SMCSLAndTPTaker.py,sha256=zJCtwyzIuDtbxMdLOwRbpUE60o9fKe-tNWuiuej4RGs,27621
+taker/ThreeLineTradingTaker.py,sha256=NGEXd4baCfzF4ToGb9tQWXRMweFBpImyh2v4WcKLK3A,20580
+taker/TrailingSLAndTPTaker.py,sha256=W-kj0BhPXqusO8z4zlDU_nb1L6L7TT8jEhCSgMkEF9U,2831
+taker/TrailingSLTaker.py,sha256=j-qAy8qwqYP9lXiYp-p_qWN6hH-x7nsg80g6o8Sc2KI,53456
+taker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+taker/history_code/chua_bitget.py,sha256=YY6XK5Bd-wlArsN5BnAfiqE0h1DPkti6i4TEB4F5zDA,12918
+taker/history_code/chua_bn.py,sha256=GnTePWlgDwdHgroBbEp1Ajcsf5_m_Vn_RV63SYzu2jI,10668
+taker/history_code/chua_ok.py,sha256=5pPAoEYbFuKxfZwqNvOO890s-2cy6n69QiI0ZA0GTCQ,12474
+taker/history_code/chua_ok_all.py,sha256=2XnZM6QdB3juSE1pqQIJyh2x1XuhlTlnBKNA3owlJ9E,15267
+taker/history_code/chua_ok_bot.py,sha256=9SW0ujhi6PfN4yR1JZ9NaA37HtnXJ2QAWUfW52NG68w,13109
+taker/history_code/config.py,sha256=YPxghO5i0vgRg9Cja8kGj9O7pgSbbtzOgf3RexqXXwY,1188
+taker/main.py,sha256=gud7NagfxDrB4FrggmO4nKNEHbcn0_4jThCOaeGEJuw,2101
+openfund_taker-2.2.7.dist-info/METADATA,sha256=2eaMRyEdfUjQ9VSlskgYA5ayYPYxNMXTfTptE9uDILM,7529
+openfund_taker-2.2.7.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+openfund_taker-2.2.7.dist-info/entry_points.txt,sha256=a7mG8F7aOA5-Gk2vPWuAR4537faxaHUgM_jwIDBZoEc,50
+openfund_taker-2.2.7.dist-info/RECORD,,

taker/SMCSLAndTPTaker.py

@@ -1,4 +1,5 @@
 from typing import override
+from ccxt.base import precise
 import pandas as pd
 from decimal import Decimal
 
@@ -6,14 +7,14 @@ from decimal import Decimal
 from taker.TrailingSLTaker import TrailingSLTaker
 
 class SMCSLAndTPTaker(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)
+    def __init__(self,g_config, platform_config, common_config=None, feishu_webhook=None, monitor_interval=4,logger=None):
+        super().__init__(g_config, platform_config, common_config, feishu_webhook, monitor_interval,logger)
         self.global_symbol_take_profit_flag = {} # 记录每个symbol是否设置全局止盈标志
         self.global_symbol_take_profit_price = {} # 记录每个symbol的止盈价格
         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)) # 开仓是否设置止盈
+        # 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)) # 开仓是否设置止盈
        
     @override  
     def check_reverse_position(self,symbol,position,pair_config):
@@ -45,8 +46,13 @@ class SMCSLAndTPTaker(TrailingSLTaker):
 
         for index in range(1, len(data)):
       
-            data.at[index, 'Up'] = max(data.at[index - 1, 'Up'], data.at[index, 'high'])
-            data.at[index, 'Dn'] = min(data.at[index - 1, 'Dn'], data.at[index, 'low'])
+            prev_up = self.toDecimal(data.at[index - 1, 'Up'])
+            curr_high = self.toDecimal(data.at[index, 'high'])
+            prev_dn = self.toDecimal(data.at[index - 1, 'Dn'])
+            curr_low = self.toDecimal(data.at[index, 'low'])
+            
+            data.at[index, 'Up'] = max(prev_up, curr_high)
+            data.at[index, 'Dn'] = min(prev_dn, curr_low)
             data.at[index, 'pos'] = data.at[index - 1, 'pos']
             data.at[index, 'iUp'] = data.at[max(0,index - 1), 'iUp'] if data.at[max(0,index - 1), 'iUp'] is not None else index
             data.at[index, 'iDn'] = data.at[max(0,index - 1), 'iDn'] if data.at[max(0,index - 1), 'iDn'] is not None else index
@@ -56,10 +62,10 @@ class SMCSLAndTPTaker(TrailingSLTaker):
             pvtLo = self.is_pivot_low(data, index, prd, check_bounds)
 
             if pvtHi:
-                data.at[index, 'Up'] = data.at[index, 'high']
+                data.at[index, 'Up'] = self.toDecimal(data.at[index, 'high'])
                 data.at[index, 'iUp'] = index
             if pvtLo:
-                data.at[index, 'Dn'] = data.at[index, 'low']
+                data.at[index, 'Dn'] = self.toDecimal(data.at[index, 'low'])
                 data.at[index, 'iDn'] = index
             # 寻找Bullish结构
             if data.at[index, 'Up'] > data.at[index - 1, 'Up']:
@@ -207,6 +213,8 @@ class SMCSLAndTPTaker(TrailingSLTaker):
             pair_config: 交易对配置
             kLines: K线数据
         """
+
+
         
         if self.open_trail_profit and self.global_symbol_stop_loss_flag.get(symbol,False):
             
@@ -227,10 +235,13 @@ class SMCSLAndTPTaker(TrailingSLTaker):
             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}")
 
+            marketPrice = self.toDecimal(position['markPrice'])
+
+
             # 寻找流动性
             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'])
+                htf_liquidity_SL = self.detect_liquidity_for_SL(symbol, ctf_df_with_struct, position['side'], marketPrice)
                 self.htf_liquidities_SL[symbol] = htf_liquidity_SL
             
             if len(htf_liquidity_SL) == 0:
@@ -238,46 +249,7 @@ class SMCSLAndTPTaker(TrailingSLTaker):
                 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_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.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)),
-                         
-        #     },
-        #     "中档": {
-        #         "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)),
-
-        #     }
-        # }
-
-        # 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']
-        #     )
+       
             
             # 检查价格是否变化
             latest_sl_price = self.global_symbol_stop_loss_price.get(symbol,0.0)
@@ -334,7 +306,7 @@ class SMCSLAndTPTaker(TrailingSLTaker):
         
         return df[df.index == df[col_prefix]].sort_index(ascending=False)
     
-    def detect_liquidity_for_TP(self, symbol, data, side , market_price) -> pd.DataFrame:
+    def detect_liquidity_for_TP(self, symbol, data, side , market_price: Decimal) -> pd.DataFrame:
         """
         TP校对流动性，用市场价格校验流动性是否有效,做多则流动性在市场价格之上，做空流动性要在市场价格之下。
         Args:
@@ -374,7 +346,7 @@ class SMCSLAndTPTaker(TrailingSLTaker):
                     
         return df_valid_liquidities.loc[result_indices].sort_index(ascending=False)
     
-    def detect_liquidity_for_SL(self, symbol, data, side, market_price) -> pd.DataFrame:
+    def detect_liquidity_for_SL(self, symbol, data, side, market_price:Decimal) -> pd.DataFrame:
         """
         SL校对流动性，用市场价格校验流动性是否有效,做多则流动性在市场价格之下，做空流动性要在市场价格之上。
         Args:
@@ -449,7 +421,7 @@ class SMCSLAndTPTaker(TrailingSLTaker):
         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:
+    def calculate_trailing_sl_price_by_liquidity(self, symbol, position, df_liquidities, stop_loss_pct=2, offset=1) -> Decimal:
         """
         计算回撤止损价格，根据流动性，做多则回撤止损价格在流动性之下，做空则回撤止损价格在流动性之上。
         Args:
@@ -459,19 +431,21 @@ class SMCSLAndTPTaker(TrailingSLTaker):
             stop_loss_pct (int, optional): 回撤百分比. Defaults to 2.
             offset (int, optional): 偏移量. Defaults to 1.
         Returns:
-            float: 回撤止损价格
+            Decimal: 回撤止损价格
         """
         sl_price =  self.calculate_sl_price_by_pct(symbol, position, stop_loss_pct)
+        precision = self.get_precision_length(symbol)
+
                
         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']]}")
+        self.logger.debug(f"{symbol} : SL side={position['side']} sl_price={sl_price:.{precision}} \n 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]
+        # 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())
+        trailing_sl = self.toDecimal(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)
@@ -482,7 +456,7 @@ class SMCSLAndTPTaker(TrailingSLTaker):
             
         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:
+    def calculate_tp_price_by_liquidity(self, symbol, position, df_liquidities, stop_loss_pct=2, tp_sl_ratio=1.5, offset=1) -> Decimal:
         """_summary_
         计算止盈价格，根据流动性，做多则止盈价格在流动性之上，做空则止盈价格在流动性之下。
         Args:
@@ -494,10 +468,10 @@ class SMCSLAndTPTaker(TrailingSLTaker):
             offset (int, optional): _description_. Defaults to 1.
 
         Returns:
-            float: _description_
+            Decimal: _description_
         """        
         
-        tp_price = 0.0
+        tp_price = Decimal('0.0')
         # market_price = float(position['markPrice'])
         
         is_buy = position['side'] == 'long'
@@ -505,34 +479,34 @@ class SMCSLAndTPTaker(TrailingSLTaker):
         
         # sl_price = self.global_symbol_stop_loss_price.get(symbol, float(position['markPrice']))
         # 获取开仓价格和止损价格
-        entry_price = Decimal(position['entryPrice'])
+        entry_price = self.toDecimal(position['entryPrice'])
         sl_price = self.calculate_sl_price_by_pct(symbol, position, stop_loss_pct)
         
         # 计算止盈阈值
-        threshold = 0.0
+        threshold = Decimal('0.0')
         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))
-         
+     
+        # 计算开仓价格和止损价格的差值
+        price_diff = abs(entry_price - sl_price)
+        
+        # 根据方向计算止盈阈值
+        target_price = entry_price + price_diff * self.toDecimal(tp_sl_ratio) if is_buy else entry_price - price_diff * self.toDecimal(tp_sl_ratio)
+        threshold = self.round_price_to_tick(symbol, target_price)
 
-        # 过滤有效的流动性价格
+        precision = self.get_precision_length(symbol)
+         
+        # 根据方向过滤有效的流动性价格
+        df_liquidities[price_col] = df_liquidities[price_col].apply(self.toDecimal)
         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} : TP threshold={threshold} sl_price={sl_price} 有效的流动=\n {df_valid_liquidities[['timestamp','Up','Dn']]}")
-        # 获取止盈价格
+        
+        self.logger.debug(f"{symbol} : TP threshold={threshold:.{precision}} sl_price={sl_price:.{precision}} 有效的流动=\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 = Decimal(max(tp_price, threshold))
-        else:
-            tp_price = Decimal(min(tp_price, threshold))
+        tp_price = self.toDecimal(max(tp_price, threshold) if is_buy else min(tp_price, threshold))
         tick_size = self.get_tick_size(symbol)
         
         # 计算止盈价格 , 做多则止盈价格在流动性之下tick_size，做空则止盈价格在流动性之上tick_size。
@@ -565,9 +539,12 @@ class SMCSLAndTPTaker(TrailingSLTaker):
         """
         根据结构设置止盈
         """
+
+        presision = self.get_precision_length(symbol)
+       
         # 如果已经触发过全局止盈，则跳过 
         if self.global_symbol_take_profit_flag.get(symbol, False):            
-            self.logger.info(f"{symbol} : 已经设置过全局止盈 tp_price={self.global_symbol_take_profit_price[symbol]}")
+            self.logger.info(f"{symbol} : 已经设置过全局止盈 tp_price={self.global_symbol_take_profit_price[symbol]:.{presision}}")
             return
 
         smc_strategy = pair_config.get('smc_strategy',{})
@@ -583,7 +560,7 @@ class SMCSLAndTPTaker(TrailingSLTaker):
         # 寻找流动性
         htf_liquidity = self.htf_liquidities_TP.get(symbol,None)
         if htf_liquidity is None:
-            htf_liquidity = self.detect_liquidity_for_TP(symbol, htf_df_with_struct, position['side'], position['markPrice'])
+            htf_liquidity = self.detect_liquidity_for_TP(symbol, htf_df_with_struct, position['side'], self.toDecimal(position['markPrice']))
             self.htf_liquidities_TP[symbol] = htf_liquidity
         
         if len(htf_liquidity) <= 0:
@@ -597,7 +574,7 @@ class SMCSLAndTPTaker(TrailingSLTaker):
         if self.set_take_profit(symbol, position, tp_price):
             self.global_symbol_take_profit_flag[symbol] = True
             self.global_symbol_take_profit_price[symbol] = tp_price
-            self.logger.info(f"{symbol} : [{position['side']}] 设置全局止盈价={tp_price}")
+            self.logger.info(f"{symbol} : [{position['side']}] 设置全局止盈价={tp_price:.{presision}}")
     
  
     def check_total_profit(self, symbol, position):
@@ -610,7 +587,10 @@ class SMCSLAndTPTaker(TrailingSLTaker):
         if total_profit > cur_highest_total_profit:            
             self.highest_total_profit[symbol] = total_profit
         
-        msg = f"{symbol} : 盈利={total_profit:.2f}% 方向={position['side']} 开仓={position['entryPrice']:.6f} 市价={position['markPrice']:.6f}"
+        precision = self.get_precision_length(symbol)
+        entryPrice = self.toDecimal(position['entryPrice'])
+        marketPrice = self.toDecimal(position['markPrice'])
+        msg = f"{symbol} : 盈利={total_profit:.2f}% 方向={position['side']} 开仓={entryPrice:.{precision}f} 市价={marketPrice:.{precision}f}"
         self.logger.info(msg)
         self.send_feishu_notification(msg)    
         

taker/ThreeLineTradingTaker.py

@@ -5,7 +5,9 @@ import logging
 import requests
 from logging.handlers import TimedRotatingFileHandler
 
-
+'''
+三线策略 废弃
+'''
 class ThreeLineTradingTaker:
     def __init__(self, config, feishu_webhook=None, monitor_interval=60):
         self.stop_loss_pct = config["all_stop_loss_pct"]  # 全局止损百分比

taker/TrailingSLAndTPTaker.py

@@ -1,18 +1,20 @@
 
+from decimal import Decimal
 from typing import override
 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)
+    def __init__(self,g_config, platform_config, common_config, feishu_webhook=None, monitor_interval=4,logger=None):
+        super().__init__(g_config, platform_config, common_config, feishu_webhook, monitor_interval,logger)
         self.global_symbol_take_profit_flag = {} # 记录每个symbol是否设置全局止盈标志
         self.global_symbol_take_profit_price = {} # 记录每个symbol的止盈价格
-        self.all_TP_SL_ratio = float(platform_config.get("all_TP_SL_ratio",1.5)) #The profit-loss ratio 盈亏比
+        # self.all_TP_SL_ratio = float(platform_config.get("all_TP_SL_ratio",1.5)) #The profit-loss ratio 盈亏比
+        
         self.all_take_profit_pct = self.stop_loss_pct *  self.all_TP_SL_ratio
    
-    def set_stop_loss_take_profit(self, symbol, position, stop_loss_price=None, take_profit_price=None) -> bool:
+    def set_stop_loss_take_profit(self, symbol, position, stop_loss_price:Decimal=None, take_profit_price:Decimal=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