openfund-maker 1.3.2__tar.gz → 1.3.4__tar.gz

{openfund_maker-1.3.2 → openfund_maker-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openfund-maker
-Version: 1.3.2
+Version: 1.3.4
 Summary: Openfund-maker.
 Requires-Python: >=3.9,<4.0
 Classifier: Programming Language :: Python :: 3

{openfund_maker-1.3.2 → openfund_maker-1.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "openfund-maker"
-version = "1.3.2"
+version = "1.3.4"
 description = "Openfund-maker."
 authors = []
 readme = "README.md"

openfund_maker-1.3.2/src/maker/MACDOrderBot.py → openfund_maker-1.3.4/src/maker/MACDStrategyMaker.py

@@ -1,44 +1,28 @@
 # -*- coding: utf-8 -*-
-import time
-import ccxt
 import traceback
-import requests
 import pandas as pd
 import talib as ta
 
-from logging.handlers import TimedRotatingFileHandler
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from maker.ThreeLineOrderBot import ThreeLineOrdergBot
+from maker.ThreeLineStrategyMaker import ThreeLineStrategyMaker
 
 
-class MACDOrdergBot(ThreeLineOrdergBot):
+class MACDStrategyMaker(ThreeLineStrategyMaker):
     def __init__(self, config, platform_config, feishu_webhook=None,logger=None):
         super().__init__(config, platform_config, feishu_webhook, logger)
         
-    def judge_order_side(self, symbol, pair_config, kLines) -> str:
-        order_side = 'none'
-
-        '''
-        零轴之上的macd与signal形成金叉
-        零轴之下的死叉
-        零轴之上的死叉-金叉-死叉
-        零轴之下的金叉-死叉-金叉
-        '''
-
-           
+    def get_macd_cross_direction(self, symbol, kLines, strategy=None) -> dict:
         # 计算最近三个交叉点
         last_up_crosses = []
         last_down_crosses = []
         other_crosses = []
         all_cross = []
-        
         macd = pd.DataFrame(kLines, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
         # 将时间戳转换为日期时间格式
         macd['timestamp'] = pd.to_datetime(macd['timestamp'], unit='ms').dt.strftime('%m-%d %H:%M')
             
         # 使用 TA-Lib 计算 MACD
         macd[['macd', 'signal', 'hist']] = pd.DataFrame(ta.MACD(macd['close'], fastperiod=12, slowperiod=26, signalperiod=9)).T
-        
         # 从最新K(排除最后一根K线可能没走完)开始往前遍历
         for i in range(len(macd)-1, 2, -1):
             # 检查是否发生死叉（MACD从上方穿过Signal）
@@ -70,14 +54,48 @@ class MACDOrdergBot(ThreeLineOrdergBot):
                 break
             
         self.logger.debug(f"{symbol} : \n- 所有cross {all_cross} \n- 零轴之上cross {last_up_crosses} \n- 零轴之下cross {last_down_crosses} \n- 其他corss {other_crosses}。")
-        valid_klines = pair_config.get('valid_klines', 5)
+        
+        cross_direction = {
+            "all_cross": all_cross,
+            "last_up_crosses": last_up_crosses,
+            "last_down_crosses": last_down_crosses,
+            "other_crosses": other_crosses,
+        }
+        
+        return cross_direction
+        
+        
+    def judge_order_side(self, symbol, kLines, valid_klines=5 ,strategy=None) -> str:
+
+        '''
+        零轴之上的macd与signal形成金叉
+        零轴之下的死叉
+        零轴之上的死叉-金叉-死叉
+        零轴之下的金叉-死叉-金叉
+        '''
+
+        order_side = 'none'
+        crosses = self.get_macd_cross_direction(symbol, kLines, strategy)
+        
+        last_up_crosses = crosses.get('last_up_crosses',[])
+        last_down_crosses = crosses.get('last_down_crosses',[])
+        other_crosses = crosses.get('other_crosses',[])
+        all_cross = crosses.get('all_cross',[])
+        
+        # valid_klines = strategy.get('valid_klines', 5)
         # 如果最新的交叉是金叉，且又是零轴上方的金叉
-        if len(last_up_crosses) > 0 and all_cross[0][0] == 'golden' and all_cross[0][1] == last_up_crosses[0][1] and len(macd) - all_cross[0][1] <= valid_klines:
+        if (len(last_up_crosses) > 0 and 
+            all_cross[0][0] == 'golden' and 
+            all_cross[0][1] == last_up_crosses[0][1] and 
+            len(kLines) - all_cross[0][1] <= valid_klines):
             order_side =  'buy'
             self.logger.debug(f"{symbol} : 零轴之上的macd与signal形成金叉{all_cross[0]} 。") 
             
         # 如果最新的交叉是死叉，且又是零轴下方的死叉
-        elif len(last_down_crosses) > 0 and all_cross[0][0] == 'death' and all_cross[0][1] == last_down_crosses[0][1] and len(macd) - all_cross[0][1] <= valid_klines:
+        elif (len(last_down_crosses) > 0 and 
+              all_cross[0][0] == 'death' and 
+              all_cross[0][1] == last_down_crosses[0][1] and 
+              len(kLines) - all_cross[0][1] <= valid_klines):
             order_side ='sell'
             self.logger.debug(f"{symbol} : 零轴之下的macd与signal形成死叉{all_cross[0]} 。")
         # 分析交叉点模式，要满足连续的三个交叉都是零上
@@ -87,7 +105,7 @@ class MACDOrdergBot(ThreeLineOrdergBot):
             if (last_up_crosses[0][0] == 'death' and 
                 last_up_crosses[1][0] == 'golden' and 
                 last_up_crosses[2][0] == 'death' and
-                len(macd) - last_up_crosses[0][1] <= valid_klines
+                len(kLines) - last_up_crosses[0][1] <= valid_klines
                 ):
                 order_side = 'sell'
                 self.logger.debug(f"{symbol} : 零轴之上的死叉-金叉-死叉模式 {order_side}。")
@@ -97,25 +115,43 @@ class MACDOrdergBot(ThreeLineOrdergBot):
             if (last_down_crosses[0][0] == 'golden' and 
                   last_down_crosses[1][0] == 'death' and 
                   last_down_crosses[2][0] == 'golden' and
-                  len(macd) - last_down_crosses[0][1] <= valid_klines
+                  len(kLines) - last_down_crosses[0][1] <= valid_klines
                   ):
                 order_side = 'buy'
                 self.logger.debug(f"{symbol} : 零轴之下的金叉-死叉-金叉模式 {order_side}。")
-                
+
         
         
-        # # 零轴之上的macd与signal形成金叉
-        # if macd.iloc[-1]['macd'] > 0 and macd.iloc[-1]['signal'] > 0 and macd.iloc[-1]['macd'] >= macd.iloc[-1]['signal'] and macd.iloc[-2]['macd'] < macd.iloc[-2]['signal']:
-        #     order_side =  'buy'
-        #     self.logger.debug(f"{symbol} : 零轴之上的macd与signal形成金叉 {order_side}。")
-        # elif macd.iloc[-1]['macd'] < 0 and macd.iloc[-1]['signal'] < 0 and macd.iloc[-1]['macd'] <= macd.iloc[-1]['signal'] and macd.iloc[-2]['macd'] > macd.iloc[-2]['signal']:
-        #     order_side = 'sell'
-        #     self.logger.debug(f"{symbol} : 零轴之下的macd与signal形成死叉 {order_side}。")
-        # else:
-        #     order_side = 'none'
+        return order_side
+    
+    def judge_HTF_side(self,symbol,strategy=None) -> str:
         
+        order_side = 'none'
+        try:
+            htf = str(strategy.get('HTF', '1h')) 
+            htf_kLines = self.get_historical_klines(symbol=symbol, bar=htf)
+            
+            crosses = self.get_macd_cross_direction(symbol, htf_kLines, strategy)
+            all_cross = crosses.get('all_cross',[])
+            if len(all_cross) > 1:
+                if all_cross[0][0] == 'golden':
+                    order_side = 'buy'
+                else:
+                    order_side = 'sell'
+       
+                self.logger.debug(f"{symbol} : HTF={htf} , {order_side}。")
+
+            else:
+                self.logger.debug(f"{symbol} : HTF={htf} ,没有满足条件的交叉点。")
+
+        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)
         
         return order_side
+            
 
        
     def process_pair(self,symbol,pair_config):
@@ -127,15 +163,22 @@ class MACDOrdergBot(ThreeLineOrdergBot):
             return 
         
         self.cancel_all_orders(symbol=symbol)  
-        klines_period = str(pair_config.get('klines_period', '1m')) 
+        macd_strategy = pair_config.get('macd_strategy',{})
         
         try:
+            klines_period = str(pair_config.get('klines_period', '1m')) 
             kLines = self.get_historical_klines(symbol=symbol, bar=klines_period)
             self.logger.debug(f"开始监控 {symbol} : klines {klines_period} - {len(kLines)}")
             
- 
+            valid_klines = pair_config.get('valid_klines', 5)
             # self.logger.debug(f"{symbol} : MACD Values = \n {df.tail(5)}")
-            side = self.judge_order_side(symbol, pair_config , kLines)
+            side = self.judge_order_side(symbol, kLines,valid_klines, macd_strategy)
+            
+            htf_side = self.judge_HTF_side(symbol, macd_strategy)
+            if htf_side != 'none' and side != htf_side:
+                self.logger.debug(f"{symbol} :  下单方向 {side} 与HTF方向 {htf_side} 不一致，不进行下单。")
+                return
+         
             
             long_amount_usdt = pair_config.get('long_amount_usdt', 5)
             short_amount_usdt = pair_config.get('short_amount_usdt', 5) 

openfund_maker-1.3.2/src/maker/ThreeLineOrderBot.py → openfund_maker-1.3.4/src/maker/ThreeLineStrategyMaker.py

@@ -5,11 +5,10 @@ import traceback
 import requests
 import pandas as pd
 
-from logging.handlers import TimedRotatingFileHandler
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
 
-class ThreeLineOrdergBot:
+class ThreeLineStrategyMaker:
     def __init__(self, config, platform_config, feishu_webhook=None,logger=None):
 
         self.g_config = config
@@ -233,7 +232,7 @@ class ThreeLineOrdergBot:
         return float(self.round_price_to_tick(place_order_price,tick_size))
      
     # 定义根据均线斜率判断 K 线方向的函数： 0 空 1 多 -1 平
-    def judge_k_line_direction(self, symbol, pair_config, ema: pd.Series, klines) -> int:
+    def judge_k_line_direction(self, symbol, ema: pd.Series, klines, period=3) -> int:
         """
         判断K线方向
         Args:
@@ -243,8 +242,7 @@ class ThreeLineOrdergBot:
         Returns:
             int: -1:平, 0:空, 1:多
         """
-        # 获取配置参数
-        period = int(pair_config.get('ema_range_period', 3))
+
         
         # precision= self.get_precision_length(symbol)
 
@@ -263,7 +261,7 @@ class ThreeLineOrdergBot:
         self.logger.debug(f"{symbol}: K线极差={ema_diff.map('{:.9f}'.format).values}  ,K线方向={direction}")
         return direction
     
-    def judge_ema_direction(self, symbol, pair_config, ema: pd.Series) -> int:
+    def judge_ema_direction(self, symbol, ema: pd.Series, period=3) -> int:
         """
         判断EMA方向
         Args:
@@ -273,8 +271,6 @@ class ThreeLineOrdergBot:
         Returns:
             int: -1:平, 0:空, 1:多
         """
-        # 获取配置参数
-        period = int(pair_config.get('ema_range_period', 3))
         
         precision= self.get_precision_length(symbol)
 
@@ -329,8 +325,8 @@ class ThreeLineOrdergBot:
                 'index': last_death
             }
         
-    def judge_ma_apex(self,symbol,pair_config,cross_index, fastklines,slowklines) -> bool:
-        period = int(pair_config.get('ema_range_period', 3))
+    def judge_ma_apex(self,symbol,cross_index, fastklines,slowklines,period=3) -> bool:
+
         precision= self.get_precision_length(symbol)
         
         # 获取交叉点的索引,从交叉点之后进行判断
@@ -362,7 +358,7 @@ class ThreeLineOrdergBot:
             
         return is_expanding_or_contracting 
     
-    def judge_range_diff(self,symbol,pair_config,prices:pd.Series) -> bool:
+    def judge_range_diff(self,symbol,prices:pd.Series,limit = 1,period=3) -> bool:
         """
         计算价格列表中最后一个价格与第一个价格的差值。
         Args:
@@ -371,8 +367,8 @@ class ThreeLineOrdergBot:
             diff: 计算最高价列的最大值与最小值的差值
 。
         """
-        limit = int(pair_config.get('ema_range_limit', 1))
-        period = int(pair_config.get('ema_range_period', 3))
+        # limit = int(pair_config.get('ema_range_limit', 1))
+        # period = int(pair_config.get('ema_range_period', 3))
         tick_size = self.get_tick_size(symbol)
         if prices.empty:
             return None     
@@ -525,6 +521,7 @@ class ThreeLineOrdergBot:
             return 
         # 取消之前的挂单
         self.cancel_all_orders(symbol=symbol)  
+        three_line_strategy = pair_config.get('three_line_strategy',{})
         klines_period = str(pair_config.get('klines_period', '1m'))   
         try:
             klines = self.get_historical_klines(symbol=symbol,bar=klines_period)
@@ -552,16 +549,20 @@ class ThreeLineOrdergBot:
             cross_index = self.exchange.safe_dict(last_cross_direction,'index',None)
                 
             # 判断趋势：多头趋势或空头趋势
-            direction = self.judge_k_line_direction(symbol=symbol, pair_config=pair_config,ema=fastk,klines=klines) 
+            ema_range_period = int(three_line_strategy.get('ema_range_period', 3))
+            direction = self.judge_k_line_direction(symbol=symbol,ema=fastk,klines=klines,period=ema_range_period) 
             if direction == 1:
                 is_bullish_trend = True     
             elif direction == 0:
                 is_bearish_trend = True
      
             # 结合金叉死叉判断是否是周期顶部和底部
-            ema_direction = self.judge_ema_direction(symbol=symbol, pair_config=pair_config,ema=fastk)
-            is_apex = self.judge_ma_apex(symbol=symbol,pair_config=pair_config,cross_index=cross_index, fastklines=fastk,slowklines=slowk)
-            # if_inner_range = self.judge_range_diff(symbol=symbol, pair_config=pair_config, prices=fastk)
+            ema_direction = self.judge_ema_direction(symbol=symbol,ema=fastk,period=ema_range_period)
+            is_apex = self.judge_ma_apex(symbol=symbol,cross_index=cross_index, fastklines=fastk,slowklines=slowk,period=ema_range_period)
+            
+            # ema_range_limit = int(pair_config.get('ema_range_limit', 1))
+            # if_inner_range = self.judge_range_diff(symbol=symbol, prices=fastk,limit=ema_range_limit, period=ema_range_period)
+            
             # 金叉死叉逻辑
             if last_cross_direction and last_cross_direction['cross'] == 1 : # 金叉
                 # 强校验下单条件
@@ -612,13 +613,14 @@ class ThreeLineOrdergBot:
             min_low = low_prices.min()
       
             # 计算当前 振幅是否超过amplitude_limit
+            long_amount_usdt = pair_config.get('long_amount_usdt', 5)
+            short_amount_usdt = pair_config.get('short_amount_usdt', 5)     
             
-            amplitude_limit = pair_config.get('amplitude_limit', 0.32)
+
+            amplitude_limit = three_line_strategy.get('amplitude_limit', 0.32)
             
             self.logger.debug(f"{symbol} 当前K线的前三根K线 最高价: {max_high}, 最低价: {min_low}")    
             
-            long_amount_usdt = pair_config.get('long_amount_usdt', 5)
-            short_amount_usdt = pair_config.get('short_amount_usdt', 5)     
                             
             '''
             挂单线都是三线中最高/低，如果打到下单线说明趋势反转，所以应该挂和反方向的单，

openfund_maker-1.3.2/src/maker/WickReversalOrderBot.py → openfund_maker-1.3.4/src/maker/WickReversalStrategyMaker.py

@@ -9,7 +9,7 @@ import pandas as pd
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
 
-class WickReversalOrderBot:
+class WickReversalStrategyMaker:
     def __init__(self, config, platform_config, feishu_webhook=None , logger=None):
 
         self.g_config = config
@@ -320,8 +320,8 @@ class WickReversalOrderBot:
                 is_bearish_trend = close_prices[-1] < ema  # 收盘价在 EMA 之下
                 self.logger.info(f"{symbol} EMA: {ema:.6f}, 当前价格: {close_prices[-1]:.6f}, 多头趋势: {is_bullish_trend}, 空头趋势: {is_bearish_trend}")
             # 接针挂单逻辑
-        
-            use_market_price = pair_config.get('use_market_price', 1)
+            wick_reversal_strategy = pair_config.get('wick_reversal_strategy', {})
+            use_market_price = wick_reversal_strategy.get('use_market_price', 1)
             if use_market_price == 1 :
                 base_price = self.get_mark_price(symbol=symbol) #最新价格
             else :
@@ -336,7 +336,7 @@ class WickReversalOrderBot:
             self.logger.info(f"{symbol} 平均振幅: {average_amplitude:.2f}%")
 
             # 接针的挂单距离，默认计算逻辑是atr/close 跟 振幅ma的区间求最小值 *系数，如果周期小这样其实大部分时候都是采用的振幅，
-            value_multiplier = pair_config.get('value_multiplier', 2)
+            value_multiplier = wick_reversal_strategy.get('value_multiplier', 2)
             '''
                 接针的挂单距离，默认计算逻辑是atr/close 跟 振幅ma的区间求最小值 *系数，如果周期小这样其实大部分时候都是采用的振幅，
                 其实可以多试试其他方案，比如改成atr/close 跟 振幅ma的平均值，这样的话atr权重实际会更大，大部分行情还是atr反应更直接。
@@ -344,7 +344,7 @@ class WickReversalOrderBot:
             # selected_value = (average_amplitude + price_atr_ratio)/2 * value_multiplier
             
             selected_value = min(average_amplitude, price_atr_ratio) * value_multiplier
-            amplitude_limit = float(pair_config.get('amplitude_limit', 0.8))
+            amplitude_limit = float(wick_reversal_strategy.get('amplitude_limit', 0.8))
             selected_value = max(selected_value, amplitude_limit)
             self.logger.info(f"{symbol} selected_value: {selected_value} ")
 

{openfund_maker-1.3.2 → openfund_maker-1.3.4}/src/maker/main.py

@@ -5,13 +5,13 @@ from apscheduler.triggers.interval import IntervalTrigger
 from apscheduler.schedulers.blocking import BlockingScheduler
 from datetime import datetime
 
-from maker.WickReversalOrderBot import WickReversalOrderBot
-from maker.ThreeLineOrderBot import ThreeLineOrdergBot
-from maker.MACDOrderBot import MACDOrdergBot
+from maker.WickReversalStrategyMaker import WickReversalStrategyMaker
+from maker.ThreeLineStrategyMaker import ThreeLineStrategyMaker
+from maker.MACDStrategyMaker import MACDStrategyMaker
 
 def build_logger(log_config) -> logging.Logger:
-            # 配置日志
-        # log_file = "log/okx_MultiAssetNewTradingBot.log"
+        # 配置日志
+
         log_file = log_config["file"] 
         logger = logging.getLogger(__name__)
         logger.setLevel(log_config["level"])
@@ -60,7 +60,7 @@ def main():
     package_name = __package__ or "maker"
     logger.info(f" ++ {package_name}:{version} is doing...")
     logger.info("开始执行交易任务...")
-    bot = MACDOrdergBot(config_data, platform_config, feishu_webhook=feishu_webhook_url, logger=logger)
+    bot = MACDStrategyMaker(config_data, platform_config, feishu_webhook=feishu_webhook_url, logger=logger)
     
     # 获取计划配置
     schedule_config = config_data.get('schedule', {})