openfund-taker 1.0.12__py3-none-any.whl → 1.0.14__py3-none-any.whl

{openfund_taker-1.0.12.dist-info → openfund_taker-1.0.14.dist-info}/METADATA

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

{openfund_taker-1.0.12.dist-info → openfund_taker-1.0.14.dist-info}/RECORD

@@ -1,4 +1,4 @@
-taker/MultiAssetNewTradingBot.py,sha256=tPalEDPge_lfXP7yOdoYpgT8Mo-GGkoOhRhWdSg6mPY,26459
+taker/MultiAssetNewTradingBot.py,sha256=KLwSZmrrrMX78pFlbZz51j3C_i7wZtQF8kjbEAIWzEM,35044
 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=3Wr5YzL3BliXCqwXBVQET4lhVNusmUhheWXyQQkGN1o,1975
-openfund_taker-1.0.12.dist-info/METADATA,sha256=ht_-aBM6Kcf6Vmc4AesUVyG3Pjmcfo1wDy_Uc7l-Qv8,7503
-openfund_taker-1.0.12.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-openfund_taker-1.0.12.dist-info/entry_points.txt,sha256=a7mG8F7aOA5-Gk2vPWuAR4537faxaHUgM_jwIDBZoEc,50
-openfund_taker-1.0.12.dist-info/RECORD,,
+taker/main.py,sha256=8cLWzEvQDeELbY5Av7JqkEyYbaNqSbAbVl1tQHXzU8s,1954
+openfund_taker-1.0.14.dist-info/METADATA,sha256=-24dsmCAqfnFGh9mZVYMe4qzQRqWYpbYM6iFHsPUQKc,7503
+openfund_taker-1.0.14.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+openfund_taker-1.0.14.dist-info/entry_points.txt,sha256=a7mG8F7aOA5-Gk2vPWuAR4537faxaHUgM_jwIDBZoEc,50
+openfund_taker-1.0.14.dist-info/RECORD,,

taker/MultiAssetNewTradingBot.py

@@ -2,37 +2,42 @@
 import ccxt
 import time
 import requests
+import traceback
+import pandas as pd
 
 class MultiAssetNewTradingBot:
-    def __init__(self, config, feishu_webhook=None, monitor_interval=4,logger=None):
-        self.stop_loss_pct = config["all_stop_loss_pct"]  # 全局止损百分比
+    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.low_trail_stop_loss_pct = config["all_low_trail_stop_loss_pct"] # 第一档
-        self.trail_stop_loss_pct = config["all_trail_stop_loss_pct"]# 第二档
-        self.higher_trail_stop_loss_pct = config["all_higher_trail_stop_loss_pct"]# 第三档
+        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"]# 第三档
         # 止盈阈值
-        self.low_trail_profit_threshold = config["all_low_trail_profit_threshold"]# 第一档
-        self.first_trail_profit_threshold = config["all_first_trail_profit_threshold"]# 第二档
-        self.second_trail_profit_threshold = config["all_second_trail_profit_threshold"]# 第三档
+        self.low_trail_profit_threshold = platform_config["all_low_trail_profit_threshold"]# 第一档
+        self.first_trail_profit_threshold = platform_config["all_first_trail_profit_threshold"]# 第二档
+        self.second_trail_profit_threshold = platform_config["all_second_trail_profit_threshold"]# 第三档
         
         self.feishu_webhook = feishu_webhook
         self.monitor_interval = monitor_interval  # 监控循环时间是分仓监控的3倍
-        self.highest_total_profit = 0  # 记录最高总盈利
-        self.current_tier = "无"
-        
         
+        self.highest_total_profit = 0  # 记录最高总盈利
+        self.current_tier = "无" # 记录当前的仓位模式
+                
         self.global_symbol_stop_loss_flag = {} # 记录每个symbol是否设置全局止损
         self.global_symbol_take_profit_price = {} # 记录每个symbol的止盈价格
         # 保留在止盈挂单中最高最低两个价格，计算止盈价格。
         self.max_market_price = 0.0
         self.min_market_price = float('inf')  # 初始化为浮点数最大值
+        
+        self.cross_directions = {} # 持仓期间，存储每个交易对的交叉方向 
 
         # 配置交易所
         self.exchange = ccxt.okx({
-            'apiKey': config["apiKey"],
-            'secret': config["secret"],
-            'password': config["password"],
+            'apiKey': platform_config["apiKey"],
+            'secret': platform_config["secret"],
+            'password': platform_config["password"],
             'timeout': 3000,
             'rateLimit': 50,
             'options': {'defaultType': 'future'},
@@ -40,8 +45,18 @@ class MultiAssetNewTradingBot:
         })
         self.logger = logger
         self.position_mode = self.get_position_mode()  # 获取持仓模式
-
-
+    # 获取市场信息
+    def getMarket(self,symbol):
+        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_precision_length(self,symbol) -> int:
+        tick_size = self.get_tick_size(symbol)
+        return len(f"{tick_size:.10f}".rstrip('0').split('.')[1]) if '.' in f"{tick_size:.10f}" else 0
+    # 获取当前持仓模式
     def get_position_mode(self):
         try:
             # 假设获取账户持仓模式的 API
@@ -89,29 +104,186 @@ class MultiAssetNewTradingBot:
             self.logger.error(f"Error fetching open orders: {e}")
             return []
 
-    # def cancel_all_orders(self,symbol):
-    #     params = {}
-    #     orders = self.fetch_open_orders(symbol=symbol,params=params)
-    #     # 如果没有委托订单则直接返回
-    #     if not orders:
-    #         self.global_symbol_stop_loss_flag.clear()
-    #         self.logger.debug(f"{symbol} 无挂单列表。")
-    #         return
+    def get_historical_klines(self,symbol, bar='1m', limit=241):
+        # response = market_api.get_candlesticks(instId, bar=bar, limit=limit)
+        params = {
+            # 'instId': instId,
+        }
+        klines = self.exchange.fetch_ohlcv(symbol, timeframe=bar,limit=limit,params=params)
+        # if 'data' in response and len(response['data']) > 0:
+        if klines :
+            # return response['data']
+            return klines
+        else:
+            raise ValueError("Unexpected response structure or missing candlestick data")
+
+    def judge_cross_direction(self,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
+        
+        # 判断最近的交叉类型
+        if last_golden is None and last_death is None:
+            return {
+                'cross': -1,  # 无交叉
+                'index': None
+            }
+        
+        # 如果金叉更近或只有金叉
+        if last_golden is not None and (last_death is None or last_golden > last_death):
+            return {
+                'cross': 1,  # 金叉
+                'index': last_golden
+            }
+        # 如果死叉更近或只有死叉
+        else:
+            return {
+                'cross': 0,  # 死叉
+                'index': last_death
+            }
+    
+        
+    def judge_ma_apex(self,symbol, fastklines,slowklines) -> bool:
+        df = pd.DataFrame({
+            'ema': fastklines,
+            'sma': slowklines
+        })
+           
+        # 快线和慢线的差值
+        df['diff'] = df['ema']-df['sma']
+        # 计算斜率，【正】表示两线距离扩张，【负】表示两线距离收缩
+        df['slope'] = df['diff'].abs().diff().round(4)
+        df['flag'] = df['slope'] <= 0.0
+        
+        self.logger.debug(f"{symbol}: slopes = \n{df[['ema','sma','diff','slope','flag']].iloc[-6:-1]}  ")
+        # 检查最后两个斜率是否都为负
+        # 取slopes最新的第2个和第3个值进行判断
+        # 20250213 因为有持仓，因此判定条件更严谨，只有收缩才平仓
+        return all(slope < 0.0 for slope in df['slope'].iloc[-3:-1])
+    
+        # 定义根据均线斜率判断 K 线方向的函数： 0 空 1 多 -1 平
+    
+    # 定义根据均线斜率判断 K 线方向的函数： 0 空 1 多 -1 平
+    def judge_k_line_direction(self,symbol, pair_config, ema:pd.Series) -> int:
+        """
+        判断K线方向
+        Args:
+            symbol: 交易对
+            pair_config: 配置参数
+            ema: EMA数据
+        Returns:
+            int: -1:平, 0:空, 1:多
+        """
+        def check_ema_range(ema_data: pd.Series, period: int, limit: float, tick_size: float) -> bool:
+            """检查EMA是否在指定范围内震荡"""
+            ema_window = ema_data[-period:]
+            price_range = ema_window.max() - ema_window.min()
+            return abs(price_range) <= limit * tick_size
+            
+        def get_trend_direction(slope: float) -> int:
+            """根据斜率判断趋势方向"""
+            if slope > 0:
+                return 1    # 上升趋势
+            elif slope < 0:
+                return 0    # 下降趋势
+            return -1       # 震荡趋势
+            
+        # 获取配置参数
+        tick_size = self.get_tick_size(symbol)
+        ema_range_period = int(pair_config.get('ema_range_period', 3))
+        ema_range_limit = float(pair_config.get('ema_range_limit', 1))
         
-    #     # 提取所有订单ID，包括普通订单和策略订单
-    #     order_ids = []
-    #     for order in orders:
-    #         # 处理订单ID
-    #         if 'id' in order:
-    #             order_ids.append(order['id'])
-
-    #     try:
-    #         # 批量取消订单
-    #         self.exchange.cancel_orders(order_ids, symbol=symbol)
-    #         self.logger.info(f"Orders {order_ids} cancelled for {symbol}")
-    #     except Exception as e:
-    #         self.logger.error(f"Error cancelling orders for {symbol}: {e}")
+        # 判断是否在震荡区间
+        if check_ema_range(ema, ema_range_period, ema_range_limit, tick_size):
+            direction = -1
+        else:
+            # 计算最新斜率并判断方向
+            latest_slope = ema.diff().iloc[-1]
+            direction = get_trend_direction(latest_slope)
+            
+        self.logger.debug(f"{symbol}: 极差={abs(ema[-ema_range_period:].max() - ema[-ema_range_period:].min()):.9f} "
+                         f"斜率={ema.diff().iloc[-1]:.9f}, K线方向 {direction}")
+        
+        return direction
+  
+    def check_reverse_position(self,symbol,position,pair_config):
+        side = position['side']
+        try:
+            klines = self.get_historical_klines(symbol=symbol)
 
+            # 计算 快线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(fastklines=fastk,slowklines=slowk)
+            # 更新交叉状态
+            if cross_direction['cross'] != -1 :  #本次不一定有交叉
+                self.cross_directions[symbol] = cross_direction
+            
+            # 最新交叉方向
+            last_cross_direction = self.exchange.safe_dict(self.cross_directions,symbol,None)
+            # 计算 快线EMA & 慢线SMA
+            # 结合金叉死叉判断是否是周期顶部和底部
+            is_apex = self.judge_ma_apex(symbol=symbol,fastklines=fastk,slowklines=slowk)
+            
+            self.logger.debug(f"{symbol} cross={last_cross_direction['cross']},见顶={is_apex}，持仓方向={side}")
+            # 金叉逻辑
+            if last_cross_direction and last_cross_direction['cross'] == 1 and is_apex and side == 'long': # 金叉
+                self.logger.debug(f"{symbol} 金叉:{last_cross_direction['cross']},见顶={is_apex}，持仓方向={side},开始清理多单！！")
+                self.close_all_positions(symbol=symbol, position=position)
+       
+            # 死叉逻辑        
+            elif last_cross_direction and last_cross_direction['cross'] == 0 and is_apex and side == 'short':
+                self.logger.debug(f"{symbol} 死叉:{last_cross_direction['cross']},见顶={is_apex}，持仓方向={side},开始清理空单！！")
+                self.close_all_positions(symbol=symbol, position=position)
+
+        except KeyboardInterrupt:
+            self.logger.info("程序收到中断信号，开始退出...")
+        except Exception as e:
+            error_message = f"程序异常退出: {str(e)}"
+            self.logger.error(error_message,exc_info=True)
+            traceback.print_exc()
+            self.send_feishu_notification(error_message)
+    
+    def calculate_sma_pandas(self,symbol,kLines,period):
+        """
+        使用 pandas 计算 SMA
+        :param KLines K线
+        :param period: SMA 周期
+        :return: SMA 值
+        """
+        precision= self.get_precision_length(symbol)
+        df = pd.DataFrame(kLines, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+        sma = df['close'].rolling(window=period).mean().round(precision)
+        return sma 
+            
+    def calculate_ema_pandas(self,symbol,kLines, period):
+        """
+        使用 pandas 计算 EMA
+        :param KLines K线
+        :param period: EMA 周期
+        :return: EMA 值
+        """
+        precision= self.get_precision_length(symbol)
+        df = pd.DataFrame(kLines, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+        # 计算EMA
+        ema = df['close'].ewm(span=period, adjust=False).mean().round(precision)
+        return ema 
+    
    # 计算平均利润
     def calculate_average_profit(self,symbol,position):
         # positions = self.fetch_positions()
@@ -148,15 +320,15 @@ class MultiAssetNewTradingBot:
         self.current_tier = "无"
         self.global_symbol_stop_loss_flag.clear()
         # self.logger.debug("已重置最高总盈利和档位状态")
-        
+    # FIXME 目前只支持 单symbol
     def reset_take_profie(self):
         self.global_symbol_take_profit_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 round_price_to_tick(self,symbol, price):
         tick_size = float(self.exchange.market(symbol)['info']['tickSz'])
         # 计算 tick_size 的小数位数
@@ -166,6 +338,7 @@ class MultiAssetNewTradingBot:
         adjusted_price = round(price / tick_size) * tick_size
         return f"{adjusted_price:.{tick_decimals}f}"
         # 放弃当前委托
+    
     def cancel_all_algo_orders(self,symbol):
         
         params = {
@@ -331,6 +504,7 @@ class MultiAssetNewTradingBot:
         return take_profit_price
     
      # 平仓
+    
     def close_all_positions(self,symbol,position):
 
         amount = abs(float(position['contracts']))
@@ -364,35 +538,52 @@ class MultiAssetNewTradingBot:
                     params=params
                 )
                 time.sleep(0.1)  # 短暂延迟后再试
-                self.self.reset_take_profie()
+                self.reset_take_profie()
                 self.logger.info(f"{symbol} Close position response for {symbol}: {order}")
                 self.send_feishu_notification(f"{symbol} 平仓订单完全成交 -{symbol} side: {side}")
 
             except Exception as e:
                 self.logger.error(f"{symbol} Error closing position for {symbol}: {e}")
-                self.send_feishu_notification(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:
+            """
+            检查是否触发止盈条件
+            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} 未设置止盈价格，执行平仓")
+                return True
                 
-
-    def check_position(self,symbol, position):
-        # 检查是否全局止损没有被触发的问题,处理持仓没有被执行的情况。
-        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.close_all_positions(symbol, position)
+            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}，触发全局止盈")
+                return True
+            elif side == 'short' and mark_price > latest_take_profit_price:
+                self.logger.warning(f"!![非正常关闭]: {symbol} 方向 {side} - 市场价格 {mark_price} 高于止盈价 {latest_take_profit_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)
+        
+        # 检查是否触发止盈
+        if self.check_take_profit_trigger(symbol, position):
+            self.close_all_positions(symbol=symbol, position=position)
             return
         
-        if position['side'] == 'long':
-            if position['markPrice'] < latest_take_profit_price:
-                self.logger.warning(f"!![非正常关闭]: {symbol} 方向 {position['side']} - 市场价格 {position['markPrice']} 低于止止盈 {latest_take_profit_price}，触发全局止盈")
-                self.close_all_positions(symbol, position)
-                return
-        elif position['side'] =='short':
-            if position['markPrice'] > latest_take_profit_price:
-                self.logger.warning(f"!![非正常关闭]: {symbol} 方向 {position['side']} - 市场价格 {position['markPrice']} 高于止盈价 {latest_take_profit_price}，触发全局止盈")
-                self.close_all_positions(symbol, position)
-                return
     
-    def total_profit(self, symbol, position):
-
+    def check_total_profit(self, symbol, position):
 
         total_profit = self.calculate_average_profit(symbol, position)
         if total_profit > 0.0 :
@@ -488,8 +679,6 @@ class MultiAssetNewTradingBot:
 
             return
         
-
-
     def monitor_total_profit(self):
         self.logger.info("启动主循环，开始监控总盈利...")
         previous_position_size = sum(
@@ -513,12 +702,11 @@ class MultiAssetNewTradingBot:
                     previous_position_size = current_position_size
                     time.sleep(0.1)
                     continue  # 跳过本次循环
-                
-          
 
                 for position in positions:
                     symbol = position['symbol']
-                    self.total_profit(symbol, position)
+                    self.check_total_profit(symbol, position)
+                    # 对有错误的仓位进行处理
                     self.check_position(symbol, position)
 
 

taker/main.py

@@ -31,7 +31,7 @@ def main():
     import importlib.metadata
     version = importlib.metadata.version("openfund-taker")
     
-    openfund_config_path = os.getenv('openfund_config_path','config.json')
+    openfund_config_path = 'config.json'
     
     with open(openfund_config_path, 'r') as f:
         config_data = json.load(f)
@@ -43,7 +43,7 @@ def main():
     package_name = __package__ or "taker"
     
     logger.info(f" ++ {package_name}:{version} is doing...")
-    bot = MultiAssetNewTradingBot(platform_config, feishu_webhook=feishu_webhook_url, monitor_interval=monitor_interval,logger=logger)
+    bot = MultiAssetNewTradingBot(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()