openfund-maker 2.2.6__py3-none-any.whl → 2.2.8__py3-none-any.whl

maker/BestFVGStrategyMaker.py

@@ -1,14 +1,14 @@
 # -*- coding: utf-8 -*-
 import traceback
 from typing import override
-import pandas as pd
 
-from maker.SMCStrategyMaker import SMCStrategyMaker
 
+from maker.SMCStrategyMaker import SMCStrategyMaker
 
 class BestFVGStrategyMaker(SMCStrategyMaker):
-    def __init__(self, config, platform_config, feishu_webhook=None,logger=None):
-        super().__init__(config, platform_config, feishu_webhook, logger)
+    def __init__(self, config, platform_config, common_config, feishu_webhook=None,logger=None):
+        super().__init__(config, platform_config, common_config, feishu_webhook, logger)
+  
 
         self.htf_last_CHoCH = {} #记录HTF的CHoCH struct
         
@@ -97,7 +97,7 @@ class BestFVGStrategyMaker(SMCStrategyMaker):
             
             htf_Klines = self.get_historical_klines(symbol=symbol, bar=htf)
             htf_df = self.format_klines(htf_Klines)         
-            
+            precision = self.get_precision_length(symbol)
    
             # 初始化HTF趋势相关变量
             htf_side, valid_htf_struct = None, None
@@ -153,7 +153,7 @@ class BestFVGStrategyMaker(SMCStrategyMaker):
             }
             
             self.logger.info(f"{symbol} : {htf} 趋势={htf_struct_label} 匹配 {htf_entry_struct} struct")
-            self.logger.debug(f"{symbol} : {htf}\npivot_high={htf_pivot_high} pivot_low={htf_pivot_low} mid_line={htf_mid_line}\n溢价区={premium_box}\n折价区={discount_box}")
+            self.logger.debug(f"{symbol} : {htf}\npivot_high={htf_pivot_high:.{precision}} pivot_low={htf_pivot_low:.{precision}} mid_line={htf_mid_line:.{precision}}\n溢价区={premium_box}\n折价区={discount_box}")
 
             # 3. find HTF FVG           
             
@@ -171,7 +171,7 @@ class BestFVGStrategyMaker(SMCStrategyMaker):
                 self.logger.debug(f"{symbol} : 价格[未进入] HTF_FVG区域，不进行下单")
                 return
             else:
-                self.logger.debug(f"{symbol} : 价格[进入] HTF_FVG区域，开始下单。fvgbox={htf_fvg_boxes[-1]}")
+                self.logger.debug(f"{symbol} : 价格[进入] HTF_FVG区域，开始下单。\n fvgbox={htf_fvg_boxes[-1]}")
 
             # 4. LTF 判断struct趋势是否有CHoCH
   
@@ -199,7 +199,7 @@ class BestFVGStrategyMaker(SMCStrategyMaker):
             }
             
             self.logger.info(f"{symbol} : {ltf} 趋势={ltf_struct_label} struct={ltf_struct}")
-            self.logger.debug(f"{symbol} : {ltf} \npivot_high={ltf_last_pivot_high} pivot_low={ltf_last_pivot_low} mid_line={ltf_last_mid_line}\n溢价区={ltf_premium_box}\n折价区={ltf_discount_box}")
+            self.logger.debug(f"{symbol} : {ltf} \npivot_high={ltf_last_pivot_high} pivot_low={ltf_last_pivot_low:.{precision}} mid_line={ltf_last_mid_line:.{precision}}\n溢价区={ltf_premium_box}\n折价区={ltf_discount_box}")
 
 
             # 5. LTF 寻找FVG，下单
@@ -227,11 +227,11 @@ class BestFVGStrategyMaker(SMCStrategyMaker):
         
                 
             # 4. LTF 寻找FVG，下单      
-            order_price = ltf_fvg_boxes[-1]["top"] if ltf_struct_side == "buy" else ltf_fvg_boxes[-1]["bot"]                      
+            order_price = self.toDecimal(ltf_fvg_boxes[-1]["top"] if ltf_struct_side == "buy" else ltf_fvg_boxes[-1]["bot"] )                     
 
-            latest_order_price = self.place_order_prices.get(symbol,0.0)
+            latest_order_price = self.toDecimal(self.place_order_prices.get(symbol,0))
             if order_price == latest_order_price:
-                self.logger.debug(f"{symbol} : 下单价格 {order_price} 未变化，不进行下单。")
+                self.logger.debug(f"{symbol} : 下单价格 {order_price:.{precision}} 未变化，不进行下单。")
                 return
         
               
@@ -239,7 +239,7 @@ class BestFVGStrategyMaker(SMCStrategyMaker):
             self.cancel_all_orders(symbol=symbol) 
             self.place_order(symbol=symbol, price=order_price, side=ltf_struct_side, pair_config=pair_config)
             self.place_order_prices[symbol] = order_price # 记录下单价格,过滤重复下单
-            self.logger.debug(f"{symbol} : {ltf_struct_side}, 下单价格 {order_price}")
+            self.logger.debug(f"{symbol} : {ltf_struct_side}, 下单价格 {order_price:.{precision}}")
             
             
         except KeyboardInterrupt:

maker/MACDStrategyMaker.py

@@ -8,8 +8,8 @@ from maker.ThreeLineStrategyMaker import ThreeLineStrategyMaker
 
 
 class MACDStrategyMaker(ThreeLineStrategyMaker):
-    def __init__(self, config, platform_config, feishu_webhook=None,logger=None):
-        super().__init__(config, platform_config, feishu_webhook, logger)
+    def __init__(self, config, platform_config, common_config, feishu_webhook=None,logger=None):
+        super().__init__(config, platform_config, common_config, feishu_webhook, logger)
         
     def get_macd_cross_direction(self, symbol, kLines, strategy=None) -> dict:
         # 计算最近三个交叉点

maker/SMCStrategyMaker.py

@@ -1,16 +1,18 @@
 # -*- coding: utf-8 -*-
 import traceback
 import pandas as pd
+from decimal import Decimal
 
-from maker.ThreeLineStrategyMaker import ThreeLineStrategyMaker
 
+from maker.ThreeLineStrategyMaker import ThreeLineStrategyMaker
 
 class SMCStrategyMaker(ThreeLineStrategyMaker):
-    def __init__(self, config, platform_config, feishu_webhook=None,logger=None):
-        super().__init__(config, platform_config, feishu_webhook, logger)
+    def __init__(self, config, platform_config, common_config, feishu_webhook=None,logger=None):
+        super().__init__(config, platform_config, common_config, feishu_webhook, logger)
+
         self.place_order_prices = {} # 记录每个symbol的挂单价格
         
-    def place_order(self,symbol, price, side,pair_config):
+    def place_order(self,symbol, price:Decimal, side,pair_config):
         """_summary_
             下单
         Args:
@@ -81,8 +83,8 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
             OB_boxes = [
                 {
                     'index': idx,
-                    'top': float(df.loc[idx, 'low']),  # OB低点为当前K线的最低点
-                    'bot': float(df.loc[idx - 1 if idx > df.index[0] else idx, 'body_high']) # OB高点为前一根K线的实体高点
+                    'top': self.toDecimal(df.loc[idx, 'low']),  # OB低点为当前K线的最低点
+                    'bot': self.toDecimal(df.loc[idx - 1 if idx > df.index[0] else idx, 'body_high']) # OB高点为前一根K线的实体高点
                 }
                 for idx in df.index 
                 # 判断条件：是第一根K线（极值点）或当前下降趋势大于前一个，且前一根K线实体高点小于阈值
@@ -94,8 +96,8 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
             OB_boxes = [
                 {
                     'index': idx,
-                    'top': float(df.loc[idx, 'high']),  # OB高点为当前K线的最高点
-                    'bot': float(df.loc[idx - 1 if idx > df.index[0] else idx, 'body_low'])  # OB低点为前一根K线的实体低点
+                    'top': self.toDecimal(df.loc[idx, 'high']),  # OB高点为当前K线的最高点
+                    'bot': self.toDecimal(df.loc[idx - 1 if idx > df.index[0] else idx, 'body_low'])  # OB低点为前一根K线的实体低点
                 }
                 for idx in df.index
                 # 判断条件：是第一根K线（极值点）或当前上升趋势小于前一个，且前一根K线实体低点大于阈值
@@ -106,7 +108,7 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
         return OB_boxes
         
         
-    def find_fvg_boxes(self, data, side, threshold, check_balanced=True, pivot_index=0, symbol=None, pair_config=None) -> list:
+    def find_fvg_boxes(self, data, side, threshold:Decimal, check_balanced=True, pivot_index=0, symbol=None, pair_config=None) -> list:
         """_summary_
             寻找公允价值缺口
         Args:
@@ -142,8 +144,8 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
             fvg_boxes = [
                 {
                     'index': idx - 2, # FVG的索引
-                    'top': min(float(df.loc[idx - 1, 'low']),threshold),  # FVG高点为右1K线的最低点
-                    'bot': float(df.loc[idx - 3, 'high'])  # FVG低点为左1K线的最高点
+                    'top': min(self.toDecimal(df.loc[idx - 1, 'low']),threshold),  # FVG高点为右1K线的最低点
+                    'bot': self.toDecimal(df.loc[idx - 3, 'high'])  # FVG低点为左1K线的最高点
                 }
                 # [df.loc[idx - 1, 'low'], df.loc[idx - 3, 'high'], idx - 2]
                 for idx in valid_indices 
@@ -167,8 +169,8 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
             fvg_boxes = [
                 {
                     'index': idx - 2, # FVG的索引
-                    'top': float(df.loc[idx - 3, 'low']),  # FVG高点为右1K线的最高点
-                    'bot': max(float(df.loc[idx - 1, 'high']),threshold)  # FVG低点为左1K线的最低点
+                    'top': self.toDecimal(df.loc[idx - 3, 'low']),  # FVG高点为右1K线的最高点
+                    'bot': max(self.toDecimal(df.loc[idx - 1, 'high']),threshold)  # FVG低点为左1K线的最低点
                 }
                 
                 for idx in valid_indices 
@@ -179,153 +181,6 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
 
         return fvg_boxes
 
-        
-    # def detect_struct(self, data, prd=10, struct_key=None, check_valid_range=True, check_bounds=True, global_extremum=False, s1=True, resp=7) -> dict:
-    #     """_summary_    
-    #         识别SMC结构，参考 Tradingview Smart Money Concepts Probability (Expo)@Openfund
- 
-    #     Args:
-    #         data (df): df格式的K线数据
-    #         prd (int): 计算Swing Points的bar数量
-    #         struct_key (str): 结构类型，如 'CHoCH'|'SMS'|'BMS'
-    #         check_valid_range (bool): 结构类型在 pivot_high_index 和 pivot_low_index 之间为有效范围内，默认为False
-    #         check_bounds (bool): 计算Swing Points是否检查边界，默认为True
-    #         global_extremum (bool): 是否使用全局极值点，默认为False
-    #         s1 (bool): 结构响应布尔值
-    #         resp (int): 响应周期
-    #     Returns:
-    #         dict: 包含结构识别结果的字典,包含以下字段:
-    #             "struct": 结构类型,如 'Bullish_CHoCH'|'Bullish_SMS'|'Bullish_BMS'|'Bearish_CHoCH'|'Bearish_SMS'|'Bearish_BMS'
-    #             "index": 结构出现的位置索引
-    #             "pivot_high": 枢轴高点价格
-    #             "pivot_high_index": 枢轴高点索引
-    #             "pivot_low": 枢轴低点价格
-    #             "pivot_low_index": 枢轴低点索引
-    #             "side": 交易方向,'buy'或'sell'
-           
-
-    #     """
-               
-    #     # data = data.copy()
-    #     data['Up'] = None
-    #     data['Dn'] = None
-    #     data['iUp'] = None
-    #     data['iDn'] = None
-    #     data['pos'] = 0
-    #     data['pattern'] = None
-
-    #     # 初始化 Up 和 Dn 的第一个值
-    #     data.at[0, 'Up'] = data.at[0, 'high']
-    #     data.at[0, 'Dn'] = data.at[0, 'low']
-        
-
-    #     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'])
-    #         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
-
-    #         # 寻找枢轴高点和低点
-    #         pvtHi = self.is_pivot_high(data, index, prd, check_bounds)
-    #         pvtLo = self.is_pivot_low(data, index, prd, check_bounds)
-
-    #         if pvtHi:
-    #             data.at[index, 'Up'] = data.at[index, 'high']
-    #             data.at[index, 'iUp'] = index
-    #         if pvtLo:
-    #             data.at[index, 'Dn'] = data.at[index, 'low']
-    #             data.at[index, 'iDn'] = index
-    #         # 寻找Bullish结构
-    #         if data.at[index, 'Up'] > data.at[index - 1, 'Up']:
-                
-    #             data.at[index, 'iUp'] = index 
-    #             if data.at[index - 1, 'pos'] <= 0:
-    #                 # data.at[index, 'pattern'] = 'CHoCH (Bullish)'
-    #                 data.at[index, 'pattern'] = 'Bullish_CHoCH'
-    #                 data.at[index, 'pos'] = 1
-    #             elif data.at[index - 1, 'pos'] == 1 \
-    #                     and data.at[index - 1, 'Up'] == data.at[max(0,index - (resp if s1 else prd)), 'Up']:               
-    #                 data.at[index, 'pattern'] = 'Bullish_SMS'
-    #                 data.at[index, 'pos'] = 2
-                    
-    #             elif data.at[index - 1, 'pos'] > 1 \
-    #                     and data.at[index - 1, 'Up'] == data.at[max(0,index - (resp if s1 else prd)), 'Up']:                
-    #                 data.at[index, 'pattern'] = 'Bullish_BMS'
-    #                 data.at[index, 'pos'] = data.at[index - 1, 'pos'] + 1
-                    
-    #         elif global_extremum and data.at[index, 'Up'] < data.at[index - 1, 'Up']:
-    #             data.at[index, 'iUp'] = data.at[index - 1, 'iUp']
-        
-    #         # # 寻找Bearish结构
-    #         if data.at[index, 'Dn'] < data.at[index - 1, 'Dn']:
-    #             data.at[index, 'iDn'] = index 
-    #             if data.at[index - 1, 'pos'] >= 0:
-                
-    #                 data.at[index, 'pattern'] = 'Bearish_CHoCH'
-    #                 data.at[index, 'pos'] = -1
-    #             elif data.at[index - 1, 'pos'] == -1  \
-    #                     and data.at[index - 1, 'Dn'] == data.at[max(0,index - (resp if s1 else prd)), 'Dn']:
-    #                 data.at[index, 'pattern'] = 'Bearish_SMS'
-    #                 data.at[index, 'pos'] = -2
-    #             elif data.at[index - 1, 'pos'] < -1  \
-    #                     and data.at[index - 1, 'Dn'] == data.at[max(0,index - (resp if s1 else prd)), 'Dn']:
-    #                 data.at[index, 'pattern'] = 'Bearish_BMS'
-    #                 data.at[index, 'pos'] = data.at[index - 1, 'pos'] - 1
-                    
-    #         elif global_extremum and data.at[index, 'Dn'] > data.at[index - 1, 'Dn']:
-    #             data.at[index, 'iDn'] = data.at[index - 1, 'iDn']
-                
-    #     # 获取最后一个结构和位置
-    #     last_struct = {
-    #         "struct": None,
-    #         "index": -1,
-    #         "pivot_high": None,
-    #         "pivot_high_index": -1,
-    #         "pivot_low": None,
-    #         "pivot_low_index": -1,
-    #         "side": None
-            
-    #     }
-        
-        
-    #     for i in range(len(data)-1, -1, -1):
-    #         if check_valid_range:
-    #             # 检查是否在pivot_high_index和pivot_low_index之间的有效范围内
-    #             if data.at[i, 'iUp'] != -1 and data.at[i, 'iDn'] != -1:
-    #                 pivot_high_index = data.at[i, 'iUp'] 
-    #                 pivot_low_index = data.at[i, 'iDn']
-    #                 if i < min(pivot_high_index, pivot_low_index) or i > max(pivot_high_index, pivot_low_index):
-    #                     continue
-                
-    #         if data.at[i, 'pattern'] is not None:
-    #             if struct_key is not None and struct_key not in data.at[i, 'pattern']:
-    #                 continue
-    #             last_struct["struct"] = data.at[i, 'pattern']
-    #             last_struct["index"] = i
-               
-    #             break
-        
-    #     if last_struct['struct'] is not None :
-    #         # 找到最后一个结构的枢轴高点和低点，如果当前是孤立点，则取前一个孤立点
-    #         # 判断交易方向
-    #         if 'Bearish' in last_struct["struct"]:
-    #             last_struct["side"] = 'sell'
-    #         else :
-    #             last_struct["side"] = 'buy'
-            
-    #         last_struct["pivot_high_index"] = int(data["iUp"].iloc[-1])
-    #         last_struct["pivot_low_index"] = int(data["iDn"].iloc[-1])
-            
-    #         last_struct["pivot_high"] = float(data.loc[last_struct["pivot_high_index"], 'high'])
-    #         last_struct["pivot_low"] = float(data.loc[last_struct["pivot_low_index"], 'low'])
-    #     else: 
-    #         last_struct['struct'] = "None"
-    #         last_struct["index"] = -1
-
-            
-    #     return last_struct
     def build_struct(self, df, prd=20, check_bounds=True, global_extremum=False) :
         
         """_summary_
@@ -345,9 +200,16 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
         
 
         for index in range(1, len(data)):
+            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, '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'])
+            # 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'])
             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
@@ -357,10 +219,10 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
             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']:
@@ -444,8 +306,8 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
         pivot_high_index = last_struct["pivot_high_index"] = int(data["iUp"].iloc[-1])
         pivot_low_index = last_struct["pivot_low_index"] = int(data["iDn"].iloc[-1])
         
-        last_struct["pivot_high"] = float(data.loc[last_struct["pivot_high_index"], 'high'])
-        last_struct["pivot_low"] = float(data.loc[last_struct["pivot_low_index"], 'low'])
+        last_struct["pivot_high"] = self.toDecimal(data.loc[last_struct["pivot_high_index"], 'high'])
+        last_struct["pivot_low"] = self.toDecimal(data.loc[last_struct["pivot_low_index"], 'low'])
         
         for i in range(len(data)-1, -1, -1):
             if check_valid_range:
@@ -510,17 +372,12 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
         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 round_price(self,symbol, price):
-        tick_size = self.get_tick_size(symbol)
-        return super().round_price_to_tick(price, tick_size)
+    # def round_price(self,symbol, price: Decimal) -> Decimal:
+    #     return super().round_price_to_tick(symbol, price)
     
-    def calculate_ce(self,symbol,pivot_high , pivot_low) -> float:
+    def calculate_ce(self, symbol, pivot_high:Decimal , pivot_low:Decimal) -> Decimal:
         ce = (pivot_high + pivot_low) / 2
-        return float(self.round_price(symbol, ce))
- 
-    def calculate_pe(self,symbol,pivot_high, pivot_low) -> float:
-        pe = (pivot_high + pivot_low) / 2
-        return float(self.round_price(symbol, pe))
+        return self.round_price_to_tick(symbol, ce)
     
     def reset_all_cache(self, symbol):
         """_summary_
@@ -568,7 +425,7 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
             swing_points_length = smc_strategy.get('swing_points_length',10)    
             htf_last_struct = self.detect_struct(htf_df,prd=swing_points_length)
             htf_last_struct_label = htf_last_struct["struct"]
-            
+            precision = self.get_precision_length(symbol)
          
             if htf_last_struct_label is None:
                 self.logger.debug(f"{symbol} : {htf} 未形成 struct,不下单。{htf_last_struct}。")
@@ -586,8 +443,8 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
 
             
             # 2. HTF 获取最新的两个极值点，设置折价(discount)区和溢价(premium)区
-            pivot_high = htf_last_struct["pivot_high"]
-            pivot_low = htf_last_struct["pivot_low"]            
+            pivot_high = self.toDecimal(htf_last_struct["pivot_high"])
+            pivot_low = self.toDecimal(htf_last_struct["pivot_low"])            
             mid_line = self.calculate_ce(symbol,pivot_high,pivot_low)
        
             # 计算溢价和折价区
@@ -602,13 +459,16 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
                 'ce': self.calculate_ce(symbol,mid_line,pivot_low)
             }
             
-            self.logger.debug(f"{symbol} : {htf} 趋势={htf_last_struct_label}: \npivot_high={pivot_high} pivot_low={pivot_low} mid_line={mid_line}\n溢价区={premium_box}\n折价区={discount_box}")
+            self.logger.debug(f"{symbol} : {htf} 趋势={htf_last_struct_label}: \n" \
+                f"pivot_high={pivot_high:.{precision}} pivot_low={pivot_low:.{precision}} mid_line={mid_line:.{precision}}\n" \
+                f"溢价区={premium_box}\n" 
+                f"折价区={discount_box}")
                 
             # 3. 根据HTF结构来分析下单位置和止盈位置 
-            threshold = 0.0    
+            threshold = self.toDecimal(0.0)   
             order_side = side
             # 获取当前市场价格
-            market_price = ctf_df['close'].iloc[-1]
+            market_price = self.toDecimal(ctf_df['close'].iloc[-1])
 
             if 'CHoCH' in htf_last_struct_label:
                 """
@@ -661,14 +521,14 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
     
     
             if threshold == 0.0:
-                self.logger.debug(f"{symbol} : 价格{market_price}不在目标区域，不下单。")
+                self.logger.debug(f"{symbol} : 价格{market_price:.{precision}}不在目标区域，不下单。")
                 # 取消所有未成交订单
                 self.cancel_all_orders(symbol=symbol) 
                 return
         
                 
             # 4. 在CTF折价区获取FVG的位置       
-            order_price = 0.0                
+            order_price = self.toDecimal(0.0)                
            
             if enable_FVG and order_price == 0.0:               
                 
@@ -694,7 +554,7 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
                 if len(fvg_boxes) != 0 and order_price == 0.0:
                     last_fvg_box = fvg_boxes[-1]
                     ce_price = self.calculate_ce(symbol,last_fvg_box['top'],last_fvg_box['bot'])
-                    self.logger.info(f"{symbol} : 方向={order_side}, FVG_ce={ce_price} FVG={last_fvg_box} ")
+                    self.logger.info(f"{symbol} : 方向={order_side}, FVG_ce={ce_price:.{precision}} FVG={last_fvg_box} ")
                     order_price = ce_price 
             
             # 4. 找OB位置，OB规则孤立高点+实体低点 孤立低点+实体高点
@@ -713,7 +573,7 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
                 if len(OB_boxes) != 0 :                
                     last_OB_box = OB_boxes[-1]
                     ce_price = self.calculate_ce(symbol,last_OB_box['top'],last_OB_box['bot'])
-                    self.logger.info(f"{symbol} : 方向={order_side}, OB_ce={ce_price} , OB={last_OB_box} ")
+                    self.logger.info(f"{symbol} : 方向={order_side}, OB_ce={ce_price:.{precision}} , OB={last_OB_box} ")
                     order_price = ce_price 
                 
             if order_price == 0.0:
@@ -723,7 +583,7 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
 
             latest_order_price = self.place_order_prices.get(symbol,0.0)
             if order_price == latest_order_price:
-                self.logger.debug(f"{symbol} : 下单价格 {order_price} 未变化，不进行下单。")
+                self.logger.debug(f"{symbol} : 下单价格 {order_price:.{precision}} 未变化，不进行下单。")
                 return
         
               
@@ -731,7 +591,7 @@ class SMCStrategyMaker(ThreeLineStrategyMaker):
             self.cancel_all_orders(symbol=symbol) 
             self.place_order(symbol=symbol, price=order_price, side=order_side, pair_config=pair_config)
             self.place_order_prices[symbol] = order_price # 记录下单价格,过滤重复下单
-            self.logger.debug(f"{symbol} : {side}, 下单价格 {order_price}")
+            self.logger.debug(f"{symbol} : {side}, 下单价格 {order_price:.{precision}}")
             
             
         except KeyboardInterrupt:

maker/ThreeLineStrategyMaker.py

@@ -4,25 +4,31 @@ import ccxt
 import traceback
 import requests
 import pandas as pd
+from decimal import Decimal
 
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
 
+
 class ThreeLineStrategyMaker:
-    def __init__(self, config, platform_config, feishu_webhook=None,logger=None):
+    def __init__(self, config, platform_config, common_config, feishu_webhook=None,logger=None):
 
         self.g_config = config
         self.feishu_webhook = feishu_webhook
-        self.monitor_interval = self.g_config.get("monitor_interval", 4)  # 默认值为60秒  # 监控循环时间是分仓监控的3倍
+        self.common_config = common_config
+        self.strategy_config = self.g_config.get('strategy', {})
+      
         self.trading_pairs_config = self.g_config.get('tradingPairs', {})
+        
+        self.leverage_value = self.strategy_config.get('leverage', 20)
+        self.is_demo_trading = self.common_config.get('is_demo_trading', 1)  # live trading: 0, demo trading: 1
+        
         self.highest_total_profit = 0  # 记录最高总盈利
-        self.leverage_value = self.g_config.get('leverage', 2)
-        self.is_demo_trading = self.g_config.get('is_demo_trading', 1)  # live trading: 0, demo trading: 1
         # self.instrument_info_dict = {}
         self.cross_directions = {} # 持仓期间，存储每个交易对的交叉方向 
         proxies = {
-            "http": self.g_config.get('proxy', "http://localhost:7890"),
-            "https": self.g_config.get('proxy', "http://localhost:7890")
+            "http": self.common_config.get('proxy', "http://localhost:7890"),
+            "https": self.common_config.get('proxy', "http://localhost:7890")
         }
 
         # 配置交易所
@@ -35,22 +41,39 @@ class ThreeLineStrategyMaker:
             'options': {'defaultType': 'future'},
             'proxies': proxies
         })
-        
-      
 
         self.logger = logger
         self.position_mode = self.get_position_mode()  # 获取持仓模式
 
+    def format_price(self, symbol, price:Decimal) -> str:
+        precision = self.get_precision_length(symbol)
+        return f"{price:.{precision}f}"
+
+    @staticmethod
+    def toDecimal(value):
+        return Decimal(str(value))
+
+
     def getMarket(self,symbol):
         self.exchange.load_markets()
         return self.exchange.market(symbol)
     
-    def get_tick_size(self,symbol):
-        market = self.getMarket(symbol)
-        marketPrecision = self.exchange.safe_dict(market, 'precision')
-        return self.exchange.safe_float(marketPrecision, '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 self.toDecimal(market['precision']['price'])
+            else:
+                # self.logger.error(f"{symbol}: 无法从市场数据中获取价格精度")
+                # return self.toDecimal("0.00001")  # 返回默认精度
+                raise ValueError(f"{symbol}: 无法从市场数据中获取价格精度")
+        except Exception as e:
+            self.logger.error(f"{symbol}: 获取市场价格精度时发生错误: {str(e)}")
+            self.send_feishu_notification(f"{symbol}: 获取市场价格精度时发生错误: {str(e)}")
     
-    def convert_contract(self, symbol, amount, price:float, direction='cost_to_contract'):
+    def convert_contract(self, symbol, amount, price:Decimal, direction='cost_to_contract'):
         """
         进行合约与币的转换
         :param symbol: 交易对符号，如 'BTC/USDT:USDT'
@@ -60,11 +83,12 @@ class ThreeLineStrategyMaker:
         """
 
         # 获取合约规模
-        market_contractSize = self.getMarket(symbol)['contractSize']
+        market_contractSize = self.toDecimal(self.getMarket(symbol)['contractSize'])
+        amount = self.toDecimal(amount)
         if direction == 'amount_to_contract':
-            contract_size = float(amount) / float(market_contractSize)
+            contract_size = amount / market_contractSize
         elif direction == 'cost_to_contract':
-            contract_size = float(amount) / float(price) / float(market_contractSize)
+            contract_size = amount / price / market_contractSize
         else:
             raise Exception(f"{symbol}:{direction} 是无效的转换方向，请输入 'amount_to_contract' 或 'cost_to_contract'。")
         
@@ -74,7 +98,7 @@ class ThreeLineStrategyMaker:
     # 获取价格精度
     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
+        return len(f"{tick_size:.15f}".rstrip('0').split('.')[1]) if '.' in f"{tick_size:.15f}" else 0
 
     def get_position_mode(self):
         try:
@@ -129,13 +153,13 @@ class ThreeLineStrategyMaker:
         else:
             raise ValueError("Unexpected response structure or missing 'last' key")
 
-    def round_price_to_tick(self, price, tick_size):
+    def round_price_to_tick(self, symbol, price: Decimal) -> 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 = self.get_precision_length(symbol) 
         # 调整价格为 tick_size 的整数倍
         adjusted_price = round(price / tick_size) * tick_size
-        return f"{adjusted_price:.{tick_decimals}f}"
+        return self.toDecimal(f"{adjusted_price:.{tick_decimals}f}")
 
     def get_historical_klines(self,symbol, bar='1m', limit=241):
         # response = market_api.get_candlesticks(instId, bar=bar, limit=limit)
@@ -214,7 +238,7 @@ class ThreeLineStrategyMaker:
         
         return diff
     
-    def calculate_place_order_price(self, symbol,side,base_price, amplitude_limit, offset=1) -> float:
+    def calculate_place_order_price(self, symbol,side,base_price:Decimal, amplitude_limit: float, offset=1) -> Decimal:
         """
         计算开仓价格
         Args:
@@ -227,15 +251,16 @@ class ThreeLineStrategyMaker:
             place_order_price: 开仓价格
         """
         tick_size = self.get_tick_size(symbol)
+        precision= self.get_precision_length(symbol)
         place_order_price = None
         # 计算止盈价格，用市场价格（取持仓期间历史最高）减去开仓价格的利润，再乘以不同阶段的止盈百分比。
       
         if side == 'buy':
-            place_order_price = base_price * (1- amplitude_limit/100) - offset * tick_size
+            place_order_price = base_price * (1- self.toDecimal(amplitude_limit)/100) - offset * tick_size
         else:
-            place_order_price = base_price * (1 + amplitude_limit/100) + offset * tick_size
-        self.logger.debug(f"++++ {symbol} 下单价格: {place_order_price:.9f} 方向 {side} 基准价格{base_price} 振幅限制 {amplitude_limit} ")
-        return float(self.round_price_to_tick(place_order_price,tick_size))
+            place_order_price = base_price * (1 + self.toDecimal(amplitude_limit)/100) + offset * tick_size
+        self.logger.debug(f"++++ {symbol} 下单价格: {place_order_price:.{precision}f} 方向 {side} 基准价格{base_price:.{precision}} 振幅限制 {amplitude_limit} ")
+        return self.round_price_to_tick(place_order_price,tick_size)
      
     # 定义根据均线斜率判断 K 线方向的函数： 0 空 1 多 -1 平
     def judge_k_line_direction(self, symbol, ema: pd.Series, klines, period=3) -> int:
@@ -427,18 +452,18 @@ class ThreeLineStrategyMaker:
                 self.logger.warning(f"{symbol} 检查持仓失败，正在进行第{retry_count}次重试: {str(e)}")
                 time.sleep(0.1)  # 重试前等待0.1秒
 
-    def place_order(self,symbol, price, amount_usdt, side,order_type='limit'):
-
-        
-        # markets = self.exchange.load_markets()
-        # if symbol not in markets:
-        #     self.logger.error(f"{symbol}: Instrument {symbol} not found in markets")
-        #     return
-        # market = markets[symbol]
-        # # 获取价格精度
-        # price_precision = market['precision']['price']
-        tick_size = self.get_tick_size(symbol)
-        adjusted_price = self.round_price_to_tick(price, tick_size)
+    def place_order(self, symbol, price: Decimal, amount_usdt, side, order_type='limit'): 
+        """
+        下单
+        Args:
+            symbol: 交易对
+            price: 下单价格
+            amount_usdt: 下单金额
+            side: 下单方向
+            order_type: 订单类型
+        """       
+        # 格式化价格
+        adjusted_price = self.format_price(symbol, price)
 
         if amount_usdt > 0:
             if side == 'buy':
@@ -448,7 +473,7 @@ class ThreeLineStrategyMaker:
             # 设置杠杆 
             self.set_leverage(symbol=symbol, leverage=self.leverage_value, mgnMode='isolated',posSide=pos_side)  
             # 20250220 SWAP类型计算合约数量 
-            contract_size = self.convert_contract(symbol=symbol, price = adjusted_price ,amount=amount_usdt)
+            contract_size = self.convert_contract(symbol=symbol, price = self.toDecimal(adjusted_price) ,amount=amount_usdt)
     
             params = {
                 
@@ -456,7 +481,7 @@ class ThreeLineStrategyMaker:
                 "side": side,
                 "ordType": order_type,
                 "sz": contract_size,
-                "px": str(adjusted_price)
+                "px": adjusted_price
             } 
             
             # 模拟盘(demo_trading)需要 posSide
@@ -470,7 +495,7 @@ class ThreeLineStrategyMaker:
                     'side': side,
                     'type': 'limit',
                     'amount': contract_size,
-                    'price': float(adjusted_price),
+                    'price': adjusted_price,
                     'params': params
                 }
                 # 使用ccxt创建订单
@@ -486,7 +511,9 @@ class ThreeLineStrategyMaker:
                 )
                 # self.logger.debug(f"{symbol} ++ Order placed rs :  {order_result}")
             except Exception as e:
-                self.logger.error(f"{symbol} Failed to place order: {e}")
+                error_message = f"{symbol} Failed to place order: {e}"
+                self.logger.error(error_message)
+                self.send_feishu_notification(error_message)
         self.logger.info(f"--------- ++ {symbol} Order placed done! --------")         
   
     def cancel_all_orders(self, symbol):
@@ -514,7 +541,9 @@ class ThreeLineStrategyMaker:
             except Exception as e:
                 retry_count += 1
                 if retry_count == max_retries:
-                    self.logger.warning(f"{symbol} 取消挂单失败(重试{retry_count}次): {str(e)}")
+                    error_message = f"{symbol} 取消挂单失败(重试{retry_count}次): {str(e)}"
+                    self.logger.error(error_message)
+                    self.send_feishu_notification(error_message)
                     return False
                 self.logger.warning(f"{symbol} 取消挂单失败，正在进行第{retry_count}次重试: {str(e)}")
                 time.sleep(0.1)  # 重试前等待0.1秒
@@ -616,8 +645,8 @@ class ThreeLineStrategyMaker:
             df_3 = pd.DataFrame(klines[-4:-1], columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
             low_prices = df_3['low']
             high_prices = df_3['high']
-            max_high = high_prices.max()
-            min_low = low_prices.min()
+            max_high = self.toDecimal(high_prices.max())
+            min_low = self.toDecimal(low_prices.min())
       
             # 计算当前 振幅是否超过amplitude_limit
             long_amount_usdt = pair_config.get('long_amount_usdt', 5)
@@ -669,7 +698,19 @@ class ThreeLineStrategyMaker:
             self.send_feishu_notification(error_message)
             
         self.logger.info("-" * 60)  
-          
+        
+    def get_pair_config(self,symbol):
+        # 获取交易对特定配置,如果没有则使用全局策略配置
+        pair_config = self.trading_pairs_config.get(symbol, {})
+        
+        # 使用字典推导式合并配置,trading_pairs_config优先级高于strategy_config
+        pair_config = {
+            **self.strategy_config,  # 基础配置
+            **pair_config  # 交易对特定配置会覆盖基础配置
+        }
+        return pair_config
+    
+    
     def monitor_klines(self):
         symbols = list(self.trading_pairs_config.keys())  # 获取所有币对的ID
         batch_size = 5  # 每批处理的数量
@@ -678,8 +719,6 @@ class ThreeLineStrategyMaker:
         for i in range(0, len(symbols), batch_size):
             batch = symbols[i:i + batch_size]
             with ThreadPoolExecutor(max_workers=batch_size) as executor:
-                futures = [executor.submit(self.process_pair, symbol,self.trading_pairs_config[symbol]) for symbol in batch]
+                futures = [executor.submit(self.process_pair, symbol,self.get_pair_config(symbol)) for symbol in batch]
                 for future in as_completed(futures):
                     future.result()  # Raise any exceptions caught during execution
-
-            # time.sleep(self.monitor_interval)

maker/main.py

@@ -1,35 +1,15 @@
 import logging
+import logging.config
 import yaml
-from logging.handlers import TimedRotatingFileHandler
 from apscheduler.triggers.interval import IntervalTrigger
 from apscheduler.schedulers.blocking import BlockingScheduler
 from datetime import datetime
 from pyfiglet import Figlet
 
-from maker.WickReversalStrategyMaker import WickReversalStrategyMaker
 from maker.ThreeLineStrategyMaker import ThreeLineStrategyMaker
-# from maker.MACDStrategyMaker import MACDStrategyMaker
 from maker.SMCStrategyMaker import SMCStrategyMaker
 from maker.BestFVGStrategyMaker import BestFVGStrategyMaker
 
-def build_logger(log_config) -> logging.Logger:
-        # 配置日志
-
-        log_file = log_config["file"] 
-        logger = logging.getLogger(__name__)
-        logger.setLevel(log_config["level"])
-
-        file_handler = TimedRotatingFileHandler(log_file, when='midnight', interval=1, backupCount=7, encoding='utf-8')
-        file_handler.suffix = "%Y-%m-%d"
-        formatter = logging.Formatter('%(asctime)s - %(name)s - %(lineno)d - %(levelname)s - %(message)s')
-        file_handler.setFormatter(formatter)
-        logger.addHandler(file_handler)
-
-        console_handler = logging.StreamHandler()
-        console_handler.setFormatter(formatter)
-        logger.addHandler(console_handler)
-        
-        return logger
     
 def read_config_file(file_path):
     try:
@@ -51,36 +31,39 @@ def run_bot(bot, logger):
         logger.error(f"执行任务时发生错误: {str(e)}", exc_info=True)
 
 def main():   
+
     import importlib.metadata
+    package_name = __package__ or "openfund-maker"
     version = importlib.metadata.version("openfund-maker")
     
     maker_config_path = 'maker_config.yaml'
     config_data = read_config_file(maker_config_path)
         
-    platform_config = config_data['okx']
-    feishu_webhook_url = config_data['feishu_webhook']
-    logger = build_logger(config_data["Logger"])
-    package_name = __package__ or "maker"
-
-    
-    maker = config_data.get('actived_maker', 'MACDStrategyMaker')
+    logging.config.dictConfig(config_data["Logger"])
+    logger = logging.getLogger("openfund-maker")
     
+    f = Figlet(font="standard")  # 字体可选（如 "block", "bubble"）
+    logger.info(f"\n{f.renderText("OpenFund Maker")}")
+
+    common_config = config_data['common']
+    feishu_webhook_url = common_config['feishu_webhook']
+    maker = common_config.get('actived_maker', 'MACDStrategyMaker')
+    logger.info(f" ++ {package_name}.{maker}:{version} is doing...")
     
+    platform_config = config_data['platform']['okx']
     # 根据配置动态创建策略实例
     strategy_class = globals()[maker]
-    bot = strategy_class(config_data, platform_config, feishu_webhook=feishu_webhook_url, logger=logger)
+    bot = strategy_class(config_data, platform_config, common_config, feishu_webhook=feishu_webhook_url, logger=logger)
     
-    logger.info(f" ++ {package_name}.{maker}:{version} is doing...")
     
     # 获取计划配置
-    schedule_config = config_data.get('schedule', {})
+    schedule_config = common_config.get('schedule', {})
     if schedule_config.get('enabled', False):
         scheduler = BlockingScheduler()
         
         # 设置每5分钟执行一次的任务，从整点开始
         monitor_interval = int(schedule_config.get('monitor_interval', 4)) 
-        f = Figlet(font="standard")  # 字体可选（如 "block", "bubble"）
-        logger.info(f"\n{f.renderText("OpenFund Maker")}")
+ 
         # 计算下一个整点分钟
         now = datetime.now()
         # 将当前时间的秒和微秒设置为0

{openfund_maker-2.2.6.dist-info → openfund_maker-2.2.8.dist-info}/METADATA

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

openfund_maker-2.2.8.dist-info/RECORD

@@ -0,0 +1,15 @@
+maker/BestFVGStrategyMaker.py,sha256=xIiDIvMw8RwHayUuz5Won3stSG9BxdYIQgeXDok_SqM,12336
+maker/MACDStrategyMaker.py,sha256=WX8wqpF9h5W4WclN1NjZ_Bur7KFi_aMTvacfLyHzEcI,12681
+maker/SMCStrategyMaker.py,sha256=hkDqymWnuyYDo1gTYY_uyO4H4yOwCw8NBTM9RcfLRPc,28780
+maker/ThreeLineStrategyMaker.py,sha256=jCdyTvI9oTMixCM0tQF9D_-6ig0-bYstKuRFECE4deE,32099
+maker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maker/history_code/WickReversalStrategyMaker.py,sha256=7DqPDVJot4EM0_lSAcFAHrR9rNvkIds9KLMoDOiAHEc,17486
+maker/history_code/config.py,sha256=YPxghO5i0vgRg9Cja8kGj9O7pgSbbtzOgf3RexqXXwY,1188
+maker/history_code/okxapi.py,sha256=_9G0U_o0ZC8NxaT6PqpiLgxBm9gPobC9PsFHZE1c5w0,553
+maker/history_code/zhen.py.bak,sha256=HNkrQbJts8G9umE9chEFsc0cLQApcM9KOVNMYPpkBXM,10918
+maker/history_code/zhen_2.py,sha256=4IaHVtTCMSlrLGSTZrWpW2q-f7HZsUNRkW_-5QgWv24,10509
+maker/main.py,sha256=kumgkgyYj1tVKrHTQmSx0prFs9K4i5KpvcOnqimV2eA,3805
+openfund_maker-2.2.8.dist-info/METADATA,sha256=sXu087Rbc_JVoJ3aKcWrt2RCJQ7rhB5u0zgblu2Rcf4,1955
+openfund_maker-2.2.8.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+openfund_maker-2.2.8.dist-info/entry_points.txt,sha256=gKMytICEKcMRFQDFkHZLnIpID7UQFoTIM_xcpiiV6Ns,50
+openfund_maker-2.2.8.dist-info/RECORD,,

maker/main_m.py

@@ -1,378 +0,0 @@
-import time
-import json
-import logging
-import requests
-import pandas as pd
-
-import okx.PublicData as PublicData
-import okx.Trade as Trade
-import okx.MarketData as MarketData
-import okx.Account as Account
-
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from logging.handlers import TimedRotatingFileHandler
-
-# import app.okx_buou.Trade_api as TradeAPI
-# import app.okx_buou.Public_api as PublicAPI
-# import app.okx_buou.Market_api as MarketAPI
-# import app.okx_buou.Account_api as AccountAPI
-
-import os
-openfund_config_path = os.getenv('wick_reversal_config_path','config_okx.json')
-# 读取配置文件
-with open(openfund_config_path, 'r') as f:
-    config = json.load(f)
-
-# 提取配置
-okx_config = config['okx']
-trading_pairs_config = config.get('tradingPairs', {})
-monitor_interval = config.get('monitor_interval', 60)  # 默认60秒
-feishu_webhook = config.get('feishu_webhook', '')
-leverage_value = config.get('leverage', 10)
-api_key = okx_config["apiKey"]
-secret_key = okx_config["secret"]
-passphrase = okx_config["password"]
-flag = "0"  # live trading: 0, demo trading: 1
-
-public_api = PublicData.PublicAPI(api_key, secret_key, passphrase, False, flag)
-trade_api = Trade.TradeAPI(api_key, secret_key, passphrase, False, flag)
-market_api = MarketData.MarketAPI(api_key, secret_key, passphrase, False, flag)
-account_api = Account.AccountAPI(api_key, secret_key, passphrase, False, flag)
-# trade_api = TradeAPI.TradeAPI(okx_config["apiKey"], okx_config["secret"], okx_config["password"], False, flag)
-# market_api = MarketAPI.MarketAPI(okx_config["apiKey"], okx_config["secret"], okx_config["password"], False, flag)
-# public_api = PublicAPI.PublicAPI(okx_config["apiKey"], okx_config["secret"], okx_config["password"], False, flag)
-# account_api = AccountAPI.AccountAPI(okx_config["apiKey"], okx_config["secret"], okx_config["password"], False, flag)
-
-log_file = "log/okx.log"
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
-
-file_handler = TimedRotatingFileHandler(log_file, when='midnight', interval=1, backupCount=7, encoding='utf-8')
-file_handler.suffix = "%Y-%m-%d"
-formatter = logging.Formatter('%(asctime)s - %(name)s -%(lineno)d - %(levelname)s - %(message)s')
-file_handler.setFormatter(formatter)
-logger.addHandler(file_handler)
-
-console_handler = logging.StreamHandler()
-console_handler.setFormatter(formatter)
-logger.addHandler(console_handler)
-
-instrument_info_dict = {}
-
-def fetch_and_store_all_instruments(instType='SWAP'):
-    try:
-        logger.info(f"Fetching all instruments for type: {instType}")
-
-        response = public_api.get_instruments(instType=instType)
-        # response = public_api.get_instruments(instType=instType)
-        # logger.debug(f"data: {response['data']}")
-        if 'data' in response and len(response['data']) > 0:
-            instrument_info_dict.clear()
-            for instrument in response['data']:
-                instId = instrument['instId']
-                instrument_info_dict[instId] = instrument
-                # logger.debug(f"Stored instrument: {instId}")
-        else:
-            raise ValueError("Unexpected response structure or no instrument data available")
-    except Exception as e:
-        logger.error(f"Error fetching instruments: {e}")
-        raise
-
-def send_feishu_notification(message):
-    if feishu_webhook:
-        headers = {'Content-Type': 'application/json'}
-        data = {"msg_type": "text", "content": {"text": message}}
-        response = requests.post(feishu_webhook, headers=headers, json=data)
-        if response.status_code == 200:
-            logger.debug("飞书通知发送成功")
-        else:
-            logger.error(f"飞书通知发送失败: {response.text}")
-            
-def get_close_price(instId):
-    '''
-    bar = 
-    时间粒度，默认值1m
-    如 [1m/3m/5m/15m/30m/1H/2H/4H]
-    香港时间开盘价k线：[6H/12H/1D/2D/3D/1W/1M/3M]
-    UTC时间开盘价k线：[/6Hutc/12Hutc/1Dutc/2Dutc/3Dutc/1Wutc/1Mutc/3Mutc]
-    '''
-    response = market_api.get_candlesticks(instId=instId,bar='1m')
-    if 'data' in response and len(response['data']) > 0:
-        close_price = response['data'][0][4]
-        return float(close_price)
-    else:
-        raise ValueError("Unexpected response structure or missing 'c' value")
-
-
-def get_mark_price(instId):
-    response = market_api.get_ticker(instId)
-    if 'data' in response and len(response['data']) > 0:
-        last_price = response['data'][0]['last']
-        return float(last_price)
-    else:
-        raise ValueError("Unexpected response structure or missing 'last' key")
-
-def round_price_to_tick(price, tick_size):
-    # 计算 tick_size 的小数位数
-    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}"
-
-def get_historical_klines(instId, bar='1m', limit=241):
-    response = market_api.get_candlesticks(instId, bar=bar, limit=limit)
-    if 'data' in response and len(response['data']) > 0:
-        return response['data']
-    else:
-        raise ValueError("Unexpected response structure or missing candlestick data")
-
-def calculate_atr(klines, period=60):
-    trs = []
-    for i in range(1, len(klines)):
-        high = float(klines[i][2])
-        low = float(klines[i][3])
-        prev_close = float(klines[i-1][4])
-        tr = max(high - low, abs(high - prev_close), abs(low - prev_close))
-        trs.append(tr)
-    atr = sum(trs[-period:]) / period
-    return atr
-
-def calculate_ema_pandas(data, period):
-    """
-    使用 pandas 计算 EMA
-    :param 收盘价列表
-    :param period: EMA 周期
-    :return: EMA 值
-    """
-    df = pd.Series(data)
-    ema = df.ewm(span=period, adjust=False).mean()
-    return ema.iloc[-1]  # 返回最后一个 EMA 值
-
-
-def calculate_average_amplitude(klines, period=60):
-    amplitudes = []
-    for i in range(len(klines) - period, len(klines)):
-        high = float(klines[i][2])
-        low = float(klines[i][3])
-        close = float(klines[i][4])
-        amplitude = ((high - low) / close) * 100
-        amplitudes.append(amplitude)
-    average_amplitude = sum(amplitudes) / len(amplitudes)
-    return average_amplitude
-
-def cancel_all_orders(instId):
-    open_orders = trade_api.get_order_list(instId=instId, state='live')
-    order_ids = [order['ordId'] for order in open_orders['data']]
-    for ord_id in order_ids:
-        trade_api.cancel_order(instId=instId, ordId=ord_id)
-    logger.info(f"{instId}挂单取消成功.")
-
-def set_leverage(instId, leverage, mgnMode='isolated',posSide=None):
-    try:
-        body = {
-            "instId": instId,
-            "lever": str(leverage),
-            "mgnMode": mgnMode
-        }
-        # 模拟盘需要控制 posSide
-        if flag =='1' and mgnMode == 'isolated' and posSide:
-            body["posSide"] = posSide
-        logger.debug(f"Leverage set parameter is:{body}")    
-        response = account_api.set_leverage(**body)
-        if response['code'] == '0':
-            logger.debug(f"Leverage set to {leverage}x for {instId} with mgnMode: {mgnMode}")
-        else:
-            logger.error(f"Failed to set leverage: {response['msg']}")
-    except Exception as e:
-        logger.error(f"Error setting leverage: {e}")
-
-def place_order(instId, price, amount_usdt, side):
-    if instId not in instrument_info_dict:
-        logger.error(f"Instrument {instId} not found in instrument info dictionary")
-        return
-    tick_size = float(instrument_info_dict[instId]['tickSz'])
-    adjusted_price = round_price_to_tick(price, tick_size)
-    # response = public_api.convert_contract_coin(type='1', instId=instId, sz=str(amount_usdt), px=str(adjusted_price), unit='usdt', opType='open')
-    
-    # https://www.okx.com/docs-v5/zh/#public-data-rest-api-unit-convert
-    '''
-    type 转换类型
-        1：币转张
-        2：张转币
-        默认为1
-    '''
-
-    response = public_api.get_convert_contract_coin(type='1', instId=instId, sz=str(amount_usdt), px=str(adjusted_price), unit='usdt')
-    if response['code'] == '0':
-        sz = response['data'][0]['sz']
-        if float(sz) > 0:
-
-            if side == 'buy':
-                pos_side = 'long' 
-            else:
-                pos_side = 'short'
-                
-            set_leverage(instId=instId, leverage=leverage_value, mgnMode='isolated',posSide=pos_side)
-            
-            
-            params = {
-                "instId": instId,
-                "tdMode": 'isolated',
-                "side": side,
-                "ordType": 'limit',
-                "sz": sz,
-                "px": str(adjusted_price)
-            } 
-            # 模拟盘需要控制 posSide
-            if flag == 1 :
-                params["posSide"] = pos_side
-            
-            logger.info(f"Order placed params: {params}")
-            order_result = trade_api.place_order(
-                **params
-                # instId=instId,
-                # #tdMode='isolated',
-                # tdMode='cross',# 保证金模式：isolated：逐仓 ；cross：全仓
-                # side=side, # 订单方向 buy：买， sell：卖
-                # posSide=pos_side, #持仓方向 在开平仓模式下必填，且仅可选择 long 或 short。 仅适用交割、永续。
-                # ordType='limit',
-                # sz=sz,
-                # px=str(adjusted_price)
-            )
-            logger.debug(f"Order placed: {order_result}")
-        else:
-            logger.info(f"{instId}计算出的合约张数太小，无法下单。")
-    else:
-        logger.info(f"{instId}转换失败: {response['msg']}")
-        send_feishu_notification(f"{instId}转换失败: {response['msg']}")
-    logger.info(f"------------------ {instId} Order placed done! ------------------")   
-def check_position(instId, instType='SWAP') -> bool:
-    """
-    检查指定交易对是否有持仓
-    
-    Args:
-        instType: 交易对类型 SPOT、SWAP、FUTURES
-        instId: 交易对ID
-        
-    Returns:
-        bool: 是否有持仓
-    """
-    try:
-        
-        positions = account_api.get_positions(instType=instType)
-        if positions and 'data' in positions and len(positions['data']) > 0:
-            logger.debug(f"{instId} 有持仓，{positions['data']}")
-            return True
-        return False
-    except Exception as e:
-        logger.error(f"检查持仓失败 {instId}: {str(e)}")
-        return False
-
-
-# 处理交易对
-def process_pair(instId, pair_config):
-    if check_position(instId,instType='SWAP'):
-        logger.info(f"{instId} 有持仓，不下单!")
-        return 
-    try:
-        use_market_price = pair_config.get('use_market_price', 1)
-        if use_market_price == 1 :
-            mark_price = get_mark_price(instId)
-        else :
-            mark_price = get_close_price(instId) # 替换成上周期的收盘价格
-        klines = get_historical_klines(instId)
-
-        # 提取收盘价数据用于计算 EMA
-        close_prices = [float(kline[4]) for kline in klines[::-1]]  # K线中的收盘价，顺序要新的在最后
-
-        # 计算 EMA
-        ema_value = pair_config.get('ema', 240)
-        # 如果ema值为0 不区分方向，两头都挂单
-        if ema_value == 0:
-            is_bullish_trend = True
-            is_bearish_trend = True
-        else:
-            ema60 = calculate_ema_pandas(close_prices, period=ema_value)
-            logger.info(f"{instId} EMA60: {ema60:.6f}, 当前价格: {mark_price:.6f}")
-            # 判断趋势：多头趋势或空头趋势
-            is_bullish_trend = close_prices[-1] > ema60  # 收盘价在 EMA60 之上
-            is_bearish_trend = close_prices[-1] < ema60  # 收盘价在 EMA60 之下
-
-        # 计算 ATR
-        atr = calculate_atr(klines)
-        # 当前价格/ATR比值
-        price_atr_ratio = (mark_price / atr) / 100
-        logger.info(f"{instId} ATR: {atr:.3f}, 当前价格/ATR比值: {price_atr_ratio:.3f}")
-        # 平均振幅
-        average_amplitude = calculate_average_amplitude(klines)
-        logger.info(f"{instId} 平均振幅: {average_amplitude:.2f}%")
-
-        value_multiplier = pair_config.get('value_multiplier', 2)
-        '''
-            接针的挂单距离，默认计算逻辑是atr/close 跟 振幅ma的区间求最小值 *系数，如果周期小这样其实大部分时候都是采用的振幅，
-            其实可以多试试其他方案，比如改成atr/close 跟 振幅ma的平均值，这样的话atr权重实际会更大，大部分行情还是atr反应更直接。
-        '''
-        # 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))
-        selected_value = max(selected_value, amplitude_limit)
-        logger.info(f"{instId} selected_value: {selected_value} ")
-
-
-        long_price_factor = 1 - selected_value / 100
-        short_price_factor = 1 + selected_value / 100
-
-        long_amount_usdt = pair_config.get('long_amount_usdt', 5)
-        short_amount_usdt = pair_config.get('short_amount_usdt', 5)
-
-        target_price_long = mark_price * long_price_factor
-        target_price_short = mark_price * short_price_factor
-
-        logger.info(f"{instId} mark_price: {mark_price} Long target price: {target_price_long:.6f}, Short target price: {target_price_short:.6f}")
-
-        cancel_all_orders(instId)
-
-        # 判断趋势后决定是否挂单
-        if is_bullish_trend:
-            logger.info(f"{instId} 当前为多头趋势，允许挂多单")
-            # send_feishu_notification(f"{instId} place_order:+buy+,目标价格:{target_price_long},交易USDT:{long_amount_usdt} ")
-            place_order(instId, target_price_long, long_amount_usdt, 'buy')
-        else:
-            logger.info(f"{instId} 当前非多头趋势，跳过多单挂单")
-
-        if is_bearish_trend:
-            logger.info(f"{instId} 当前为空头趋势，允许挂空单")
-            # send_feishu_notification(f"{instId} place_order:-sell-,目标价格:{target_price_short},交易USDT:{short_amount_usdt} ")
-            place_order(instId, target_price_short, short_amount_usdt, 'sell')
-        else:
-            logger.info(f"{instId} 当前非空头趋势，跳过空单挂单")
-
-    except Exception as e:
-        error_message = f'Error processing {instId}: {e}'
-        logger.error(error_message)
-        send_feishu_notification(error_message)
-
-def main():
-    import importlib.metadata
-
-    version = importlib.metadata.version("openfund-wick-reversal")
-    logger.info(f" ++ openfund-wick-reversal:{version} is doing...")
-    logger.info(f" ++ api_key : {api_key}")
-    fetch_and_store_all_instruments()
-    inst_ids = list(trading_pairs_config.keys())  # 获取所有币对的ID
-    batch_size = 5  # 每批处理的数量
-
-    while True:
-        for i in range(0, len(inst_ids), batch_size):
-            batch = inst_ids[i:i + batch_size]
-            with ThreadPoolExecutor(max_workers=batch_size) as executor:
-                futures = [executor.submit(process_pair, instId, trading_pairs_config[instId]) for instId in batch]
-                for future in as_completed(futures):
-                    future.result()  # Raise any exceptions caught during execution
-
-        time.sleep(monitor_interval)
-
-if __name__ == '__main__':
-    main()

openfund_maker-2.2.6.dist-info/RECORD

@@ -1,16 +0,0 @@
-maker/BestFVGStrategyMaker.py,sha256=YZiHrUlQPVnlFwsfuwbgG81mrNLZDrq6nIHAjh2KQRk,12154
-maker/MACDStrategyMaker.py,sha256=iS5HO04piKHFJxUI2e5QmicxzGeK-V1aphJSr2n_4Ac,12651
-maker/SMCStrategyMaker.py,sha256=grmQKqUj03qVhHyo24qUk8eFmPeyTqq1taYebxzSDXw,35351
-maker/ThreeLineStrategyMaker.py,sha256=JhPfebBLEL7LIQj1YcH0j1mco1Nuocs8ceR6bjdI8qc,30517
-maker/WickReversalStrategyMaker.py,sha256=7DqPDVJot4EM0_lSAcFAHrR9rNvkIds9KLMoDOiAHEc,17486
-maker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maker/config.py,sha256=YPxghO5i0vgRg9Cja8kGj9O7pgSbbtzOgf3RexqXXwY,1188
-maker/main.py,sha256=9b7YRh0rOZlCXmTvAXE3oGhmE4b19NCc0557_jY8bV8,4564
-maker/main_m.py,sha256=0PzDTnuBrxfpy5WDfsIHKAzZ_7pkuvuqqeWik0vpWio,15522
-maker/okxapi.py,sha256=_9G0U_o0ZC8NxaT6PqpiLgxBm9gPobC9PsFHZE1c5w0,553
-maker/zhen.py.bak,sha256=HNkrQbJts8G9umE9chEFsc0cLQApcM9KOVNMYPpkBXM,10918
-maker/zhen_2.py,sha256=4IaHVtTCMSlrLGSTZrWpW2q-f7HZsUNRkW_-5QgWv24,10509
-openfund_maker-2.2.6.dist-info/METADATA,sha256=qW2yuUoP7qTjOj3cinBb7SzKzzpbRjLMPD54GgeznOg,1955
-openfund_maker-2.2.6.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-openfund_maker-2.2.6.dist-info/entry_points.txt,sha256=gKMytICEKcMRFQDFkHZLnIpID7UQFoTIM_xcpiiV6Ns,50
-openfund_maker-2.2.6.dist-info/RECORD,,