openfund-maker 2.2.5__py3-none-any.whl → 2.2.7__py3-none-any.whl

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.5.dist-info → openfund_maker-2.2.7.dist-info}/METADATA

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

openfund_maker-2.2.7.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.7.dist-info/METADATA,sha256=Flc_fXTunuA_45YJsL-nT4u0-0z7nWm1TYch6PdFKOI,1955
+openfund_maker-2.2.7.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+openfund_maker-2.2.7.dist-info/entry_points.txt,sha256=gKMytICEKcMRFQDFkHZLnIpID7UQFoTIM_xcpiiV6Ns,50
+openfund_maker-2.2.7.dist-info/RECORD,,

{openfund_maker-2.2.5.dist-info → openfund_maker-2.2.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.2
+Generator: poetry-core 2.0.1
 Root-Is-Purelib: true
 Tag: py3-none-any