openfund-taker 2.2.9__py3-none-any.whl → 2.3.2__py3-none-any.whl

{openfund_taker-2.2.9.dist-info → openfund_taker-2.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openfund-taker
-Version: 2.2.9
+Version: 2.3.2
 Summary: Openfund-taker
 Requires-Python: >=3.9,<4.0
 Classifier: Programming Language :: Python :: 3
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: ccxt (>=4.4.26,<5.0.0)
+Requires-Dist: openfund-core (>=1.0.0,<2.0.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: pyfiglet (>=1.0.2,<2.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)

{openfund_taker-2.2.9.dist-info → openfund_taker-2.3.2.dist-info}/RECORD

@@ -1,4 +1,6 @@
+taker/BestTopDownStrategyTaker.py,sha256=nWFgmLvQGCOzNVU7vlHnSM67BMTotUf-BMZZeZxYv34,11607
 taker/SMCSLAndTPTaker.py,sha256=zJCtwyzIuDtbxMdLOwRbpUE60o9fKe-tNWuiuej4RGs,27621
+taker/StrategyTaker.py,sha256=VCRc-QmhYAODfnc7yG6EpfilO2A-11L7dKQSkHykTuU,27686
 taker/ThreeLineTradingTaker.py,sha256=NGEXd4baCfzF4ToGb9tQWXRMweFBpImyh2v4WcKLK3A,20580
 taker/TrailingSLAndTPTaker.py,sha256=W-kj0BhPXqusO8z4zlDU_nb1L6L7TT8jEhCSgMkEF9U,2831
 taker/TrailingSLTaker.py,sha256=diRfcIS71prbm1I4wYgwVUq3c2_ftntiC0tQ5byWeHQ,53465
@@ -9,8 +11,8 @@ taker/history_code/chua_ok.py,sha256=5pPAoEYbFuKxfZwqNvOO890s-2cy6n69QiI0ZA0GTCQ
 taker/history_code/chua_ok_all.py,sha256=2XnZM6QdB3juSE1pqQIJyh2x1XuhlTlnBKNA3owlJ9E,15267
 taker/history_code/chua_ok_bot.py,sha256=9SW0ujhi6PfN4yR1JZ9NaA37HtnXJ2QAWUfW52NG68w,13109
 taker/history_code/config.py,sha256=YPxghO5i0vgRg9Cja8kGj9O7pgSbbtzOgf3RexqXXwY,1188
-taker/main.py,sha256=gud7NagfxDrB4FrggmO4nKNEHbcn0_4jThCOaeGEJuw,2101
-openfund_taker-2.2.9.dist-info/METADATA,sha256=3cl9lHLkRQYP891OT_dMpgodv52gx59nwJ-xvcdBNyI,7529
-openfund_taker-2.2.9.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-openfund_taker-2.2.9.dist-info/entry_points.txt,sha256=a7mG8F7aOA5-Gk2vPWuAR4537faxaHUgM_jwIDBZoEc,50
-openfund_taker-2.2.9.dist-info/RECORD,,
+taker/main.py,sha256=3ebFQDeKR4qF2pmOszK1UXx2XZFUHaaq86MUfJwVfvw,2103
+openfund_taker-2.3.2.dist-info/METADATA,sha256=jsfFkEvSovu_NnLqUVTw54AbBkqIAbVHuFzehp8_Ymk,7575
+openfund_taker-2.3.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+openfund_taker-2.3.2.dist-info/entry_points.txt,sha256=a7mG8F7aOA5-Gk2vPWuAR4537faxaHUgM_jwIDBZoEc,50
+openfund_taker-2.3.2.dist-info/RECORD,,

taker/BestTopDownStrategyTaker.py

@@ -0,0 +1,248 @@
+from re import A
+from typing import override
+
+from taker.StrategyTaker import StrategyTaker
+
+class BestTopDownStrategyTaker(StrategyTaker):
+    """
+    最佳顶底策略
+    """
+    def __init__(self, g_config,  platform_config, common_config, logger=None, exchangeKey='okx') -> None:
+        super().__init__(g_config=g_config,  platform_config=platform_config, common_config=common_config, logger=logger, exchangeKey=exchangeKey)
+        self.has_init_SL_TPs = {}
+        self.entering_channel_tps = {} # 进入止盈监控
+        
+    @override
+    def reset_SL_TP(self, symbol=None, attachType='BOTH'):
+        super().reset_SL_TP(symbol, attachType)
+        if not symbol :
+            self.has_init_SL_TPs.clear()
+            self.entering_channel_tps.clear()
+                  
+        elif attachType==self.BOTH_KEY and symbol in self.has_init_SL_TPs:
+            del self.has_init_SL_TPs[symbol]
+            del self.entering_channel_tps[symbol]
+
+    def init_SL_TP(self, symbol: str, position, tfs: dict, strategy: dict) -> bool:
+        """
+        设置首次止盈止损
+        """
+        
+        precision = self.get_precision_length(symbol)
+        # htf = tfs[self.HTF_KEY]
+        
+        atf = tfs[self.ATF_KEY]
+        
+        # 1.1  ATF Key Support & Resistance Levels 支撑或阻力关键位置(ATF 看上下的供需区位置）
+        atf_df = self.get_historical_klines_df(symbol=symbol, tf=atf)
+        atf_struct =self.build_struct(symbol=symbol, data=atf_df)
+        atf_OBs_df = self.find_OBs(symbol=symbol,struct=atf_struct)
+        pos_side = position[self.SIDE_KEY]
+        side = self.SELL_SIDE if pos_side == self.SHORT_KEY else self.BUY_SIDE 
+        
+        entering_trigger_price = 0.0 # 进入止盈监控的触发价格
+    
+        atf_support_OB = self.get_latest_OB(symbol=symbol,data=atf_OBs_df,trend=self.BULLISH_TREND)
+        if atf_support_OB :
+            atf_support_price = atf_support_OB.get(self.OB_MID_COL)
+            if pos_side == self.SHORT_KEY:
+                entering_trigger_price = atf_support_OB.get(self.OB_LOW_COL)
+        else:
+            atf_support_price = atf_struct.at[atf_struct.index[-1], self.STRUCT_LOW_COL]
+    
+        atf_resistance_OB = self.get_latest_OB(symbol=symbol,data=atf_OBs_df,trend=self.BEARISH_TREND)
+        
+        if atf_resistance_OB :
+            atf_resistance_price = atf_resistance_OB.get(self.OB_MID_COL)
+            if pos_side == self.LONG_KEY:
+                entering_trigger_price = atf_resistance_OB.get(self.OB_HIGH_COL)
+        else:
+            atf_resistance_price = atf_struct.at[atf_struct.index[-1], self.STRUCT_HIGH_COL]
+            
+        self.logger.info(f"{symbol} : ATF {atf}, Key Support={atf_support_price:.{precision}f} "
+                         f"& Key Resistance={atf_resistance_price:.{precision}f} ")
+        
+        etf = tfs[self.ETF_KEY]
+        etf_df = self.get_historical_klines_df_by_cache(symbol=symbol, tf=etf)
+        # etf_struct =self.build_struct(symbol=symbol, data=etf_df)
+        etf_latest_struct = self.get_latest_struct(symbol=symbol, data=etf_df)
+        
+
+        tick_size = self.get_tick_size(symbol)
+        offset = strategy.get('offset',1) # 价格偏移量， 1 代表 1 tick ， 0.000001 代表 1 p
+        price_offset = offset * tick_size
+        
+        if side == self.BUY_SIDE:
+            # sl_price = self.toDecimal(atf_support_price) - self.toDecimal(price_offset)
+            # 20250610 止损价格设置ETF的结构的最低价格
+            sl_price = self.toDecimal(etf_latest_struct[self.STRUCT_LOW_COL]) - self.toDecimal(price_offset)
+            tp_price = self.toDecimal(atf_resistance_price) + self.toDecimal(price_offset)
+        else:
+            # sl_price = self.toDecimal(atf_resistance_price) + self.toDecimal(price_offset)
+            # 20250610 止损价格设置ETF的结构的最高价格
+            sl_price = self.toDecimal(etf_latest_struct[self.STRUCT_HIGH_COL]) + self.toDecimal(price_offset)
+            tp_price = self.toDecimal(atf_support_price) - self.toDecimal(price_offset)
+
+        self.cancel_all_algo_orders(symbol=symbol, attachType=self.SL_KEY)
+        self.set_stop_loss(symbol=symbol, position=position, sl_price=sl_price)
+        self.cancel_all_algo_orders(symbol=symbol, attachType=self.TP_KEY)
+        self.set_take_profit(symbol=symbol, position=position, tp_price=tp_price)
+        
+        if entering_trigger_price > 0:
+            self.entering_channel_tps[symbol] = entering_trigger_price
+        return True
+
+    def check_TP(self, symbol: str, position, tfs, strategy: dict) -> bool:
+        """
+        监控TP，在ETF下Bullish进入BOT或Bearish进入TOP开始监测反转结构止盈
+        """
+        if_pass = False
+        
+        if symbol not in self.entering_channel_tps:
+            return if_pass
+
+        entering_trigger_price = self.entering_channel_tps[symbol]
+        marker_price = position[self.MARK_PRICE_KEY]
+        mask = marker_price >= entering_trigger_price if position[self.SIDE_KEY] == self.LONG_KEY else marker_price <= entering_trigger_price
+        
+        if not mask:
+            return if_pass
+        
+        precision = self.get_precision_length(symbol)
+        self.logger.info(f"{symbol} : 进入止盈监控，当前价格{marker_price:.{precision}f}，触发价格{entering_trigger_price:.{precision}f}")
+        
+        # 1.2  检查反转结构
+        etf = tfs[self.ETF_KEY]
+        etf_side, etf_struct, etf_trend = None, None, None
+        etf_df = self.get_historical_klines_df(symbol=symbol, tf=etf)                   
+        etf_struct =self.build_struct(symbol=symbol, data=etf_df)            
+        etf_latest_struct = self.get_latest_struct(symbol=symbol, data=etf_struct)
+
+        etf_trend = etf_latest_struct[self.STRUCT_DIRECTION_COL]  
+            
+        setp = "1.2.1"
+        self.logger.info(f"{symbol} : {setp}. ETF {etf} Price's Current Trend is {etf_trend}。")
+        # 3.2. Who's In Control 供需控制，Bullish 或者 Bearish ｜ Choch 或者 BOS
+        setp = "1.2.2"
+        self.logger.info(f"{symbol} : {setp}. ETF {etf} struct is {etf_latest_struct[self.STRUCT_COL]}。")
+        setp = "1.2.3"
+        pos_trend = self.BULLISH_TREND if position[self.SIDE_KEY] == self.LONG_KEY else self.BEARISH_TREND
+        
+        if pos_trend != etf_trend:
+        
+            self.logger.info(f"{symbol} : {setp}. ETF {etf} 市场结构{etf_latest_struct[self.STRUCT_COL]}未反转,等待...")
+            return if_pass
+        else:
+            self.logger.info(f"{symbol} : {setp}. ETF {etf} 市场结构{etf_latest_struct[self.STRUCT_COL]}已反转。")
+            if_pass = True
+
+         
+        return if_pass
+    
+    def trailing_SL(self, symbol: str, position, tfs, strategy: dict) :
+        """
+        移动止损
+        :param symbol: 交易对
+        :param position: 仓位
+        :param tfs: 时间周期
+        :param strategy: 策略配置
+        :return:    
+        """
+
+        precision = self.get_precision_length(symbol)
+        atf = tfs[self.ATF_KEY]
+        atf_side = position[self.SIDE_KEY]
+        market_price = position[self.MARK_PRICE_KEY]
+        
+        # 获取ATF K线数据
+        atf_df = self.get_historical_klines_df_by_cache(symbol=symbol, tf=atf)
+        
+        # 获取最新的PDArray
+        atf_struct = self.build_struct(symbol=symbol, data=atf_df)
+        pdArray_side = self.BUY_SIDE if atf_side == self.SELL_SIDE else self.SELL_SIDE
+        atf_PDArrays_df = self.find_PDArrays(symbol=symbol, struct=atf_struct, balanced=True)
+        mask = atf_PDArrays_df[self.PD_HIGH_COL] < market_price if atf_side == self.BUY_SIDE else atf_PDArrays_df[self.PD_LOW_COL] > market_price
+        atf_PDArrays_df = atf_PDArrays_df[mask]
+        atf_latest_crossed_PD = self.get_latest_PDArray(symbol=symbol, data=atf_PDArrays_df, side=pdArray_side)
+        if atf_latest_crossed_PD is None:
+            self.logger.info(f"{symbol} : ATF {atf}  未找到最新被平衡过的PDArray。")
+            return
+
+
+        # 根据方向找到对应的ce价格    
+        pos_side = position[self.SIDE_KEY]
+        tick_size = self.get_tick_size(symbol)
+        offset = strategy.get('offset', 1)
+        price_offset = offset * tick_size        
+       
+        latest_sl_price = self.get_stop_loss_price(symbol)
+        if pos_side == self.LONG_KEY:
+            # 多头找下方PDArray的ce
+            sl_price = atf_latest_crossed_PD[self.PD_MID_COL] - self.toDecimal(price_offset)
+            mask = sl_price > 0 and sl_price < position[self.MARK_PRICE_KEY] and (latest_sl_price is None or sl_price > latest_sl_price)
+        else:
+            # 空头找上方PDArray的ce  
+            sl_price = atf_latest_crossed_PD[self.PD_MID_COL] + self.toDecimal(price_offset)
+            mask = sl_price > 0 and sl_price > position[self.MARK_PRICE_KEY] and (latest_sl_price is None or sl_price < latest_sl_price)
+
+
+        if mask:
+            
+            self.logger.info(f"{symbol} : ATF {atf} {pos_side} 重置SL价格 = {sl_price:.{precision}f}")
+            self.cancel_all_algo_orders(symbol=symbol, attachType=self.SL_KEY)
+            self.set_stop_loss(symbol=symbol, position=position, sl_price=sl_price)
+        else:
+            self.logger.debug(f"{symbol} : ATF {atf} {pos_side} 未重置SL。SL价格 = {sl_price:.{precision}f} "
+                f"最新价格 = {position[self.MARK_PRICE_KEY]:.{precision}f} last_sl={latest_sl_price:.{precision}f}")
+    @override
+    def process_pair(self, symbol: str, position, pair_config: dict) -> None:
+        """
+        处理单个交易对
+        """
+        
+        precision = self.get_precision_length(symbol)
+        
+        top_down_strategy = pair_config.get('top_down_strategy',{})
+
+        """
+        获取策略配置
+        """
+              
+        tfs = {
+            self.HTF_KEY: str(top_down_strategy.get(self.HTF_KEY,'4h')) ,
+            self.ATF_KEY: str(top_down_strategy.get(self.ATF_KEY,'15m')),
+            self.ETF_KEY: str(top_down_strategy.get(self.ETF_KEY, '1m')),
+        }
+        
+        htf = tfs[self.HTF_KEY]
+        atf = tfs[self.ATF_KEY]
+        etf = tfs[self.ETF_KEY]
+        
+        self.logger.info(f"{symbol} : TopDownSMC策略 {htf}|{atf}|{etf} \n")
+        
+        # 1.1 初始化止盈止损
+        if symbol not in self.has_init_SL_TPs:      
+            has_pass = self.init_SL_TP(symbol, position, tfs, top_down_strategy)
+            
+            if has_pass:
+                self.has_init_SL_TPs[symbol] = True
+                self.logger.debug(f"{symbol} : 初始化止盈止损成功。 {has_pass}。")
+            else:
+                self.logger.info(f"{symbol} : 初始化止盈止损失败。 {has_pass}。")
+        
+        # 1.2 移动止损     
+        open_trailing_SL = top_down_strategy.get('open_trailing_SL', False)
+        if open_trailing_SL:
+            self.logger.debug(f"{symbol} : 开启移动止损。")
+            self.trailing_SL(symbol, position, tfs, top_down_strategy)  
+     
+        # 1.3 监测止盈
+        open_check_TP = top_down_strategy.get('open_check_TP', True)
+        if open_check_TP:
+            if not self.check_TP(symbol, position, tfs, top_down_strategy):  
+                self.logger.debug(f"{symbol} : 未触发止盈监控，等待...")       
+            else:
+                order = self.close_position(symbol, position)
+                if order:
+                    self.logger.info(f"{symbol} : 已触发止盈监控，市价{position[self.MARK_PRICE_KEY]:.{precision}f}平仓。")
+

taker/StrategyTaker.py

@@ -0,0 +1,705 @@
+# -*- coding: utf-8 -*-
+import pandas as pd
+import time
+from functools import lru_cache
+from datetime import datetime
+from decimal import Decimal
+from abc import abstractmethod
+
+from core.utils.OPTools import OPTools
+from core.Exchange import Exchange
+# 导入SMC相关模块
+from core.smc import (
+    SMCBase,
+    SMCPDArray,
+    SMCStruct, 
+    SMCOrderBlock,
+    SMCFVG
+)
+
+class StrategyTaker():
+    BUY_SIDE = 'buy'
+    SELL_SIDE = 'sell'
+    LONG_KEY = 'long'
+    SHORT_KEY = 'short'
+    SIDE_KEY = 'side'
+    SYMBOL_KEY = 'symbol'
+    SL_KEY = "SL"
+    TP_KEY = "TP"
+    BOTH_KEY = "BOTH"
+    
+    ENTRY_PRICE_KEY = 'entryPrice'
+    MARK_PRICE_KEY = 'markPrice'
+    CONTRACTS_KEY = 'contracts'
+    BULLISH_TREND = 'Bullish'
+    BEARISH_TREND = 'Bearish'
+    HTF_KEY = 'htf'
+    ATF_KEY = 'atf'
+    ETF_KEY = 'etf'
+
+    HIGH_COL = SMCBase.SMCBase.HIGH_COL
+    LOW_COL = SMCBase.SMCBase.LOW_COL
+    CLOSE_COL = SMCBase.SMCBase.CLOSE_COL
+    OPEN_COL = SMCBase.SMCBase.OPEN_COL
+    TIMESTAMP_COL = SMCBase.SMCBase.TIMESTAMP_COL
+    VOLUME_COL = SMCBase.SMCBase.VOLUME_COL
+    
+    STRUCT_COL = SMCStruct.SMCStruct.STRUCT_COL
+    STRUCT_HIGH_COL = SMCStruct.SMCStruct.STRUCT_HIGH_COL
+    STRUCT_LOW_COL = SMCStruct.SMCStruct.STRUCT_LOW_COL 
+    STRUCT_MID_COL = SMCStruct.SMCStruct.STRUCT_MID_COL
+    STRUCT_HIGH_INDEX_COL = SMCStruct.SMCStruct.STRUCT_HIGH_INDEX_COL
+    STRUCT_LOW_INDEX_COL = SMCStruct.SMCStruct.STRUCT_LOW_INDEX_COL
+    STRUCT_DIRECTION_COL = SMCStruct.SMCStruct.STRUCT_DIRECTION_COL
+    HIGH_START_COL = SMCStruct.SMCStruct.HIGH_START_COL
+    LOW_START_COL = SMCStruct.SMCStruct.LOW_START_COL
+    
+    FVG_TOP_COL = SMCFVG.SMCFVG.FVG_TOP
+    FVG_BOT_COL = SMCFVG.SMCFVG.FVG_BOT
+    FVG_MID_COL = SMCFVG.SMCFVG.FVG_MID
+    FVG_SIDE_COL = SMCFVG.SMCFVG.FVG_SIDE
+    FVG_WAS_BALANCED = SMCFVG.SMCFVG.FVG_WAS_BALANCED
+    
+    OB_HIGH_COL = SMCOrderBlock.SMCOrderBlock.OB_HIGH_COL
+    OB_LOW_COL = SMCOrderBlock.SMCOrderBlock.OB_LOW_COL
+    OB_MID_COL = SMCOrderBlock.SMCOrderBlock.OB_MID_COL
+    OB_VOLUME_COL = SMCOrderBlock.SMCOrderBlock.OB_VOLUME_COL
+    OB_DIRECTION_COL = SMCOrderBlock.SMCOrderBlock.OB_DIRECTION_COL
+    OB_ATR = SMCOrderBlock.SMCOrderBlock.OB_ATR
+    OB_IS_COMBINED = SMCOrderBlock.SMCOrderBlock.OB_IS_COMBINED
+    OB_WAS_CROSSED = SMCOrderBlock.SMCOrderBlock.OB_WAS_CROSSED
+    
+    PD_HIGH_COL = SMCPDArray.SMCPDArray.PD_HIGH_COL
+    PD_LOW_COL = SMCPDArray.SMCPDArray.PD_LOW_COL
+    PD_MID_COL = SMCPDArray.SMCPDArray.PD_MID_COL 
+    PD_TYPE_COL = SMCPDArray.SMCPDArray.PD_TYPE_COL
+    
+    def __init__(self, g_config,  platform_config, common_config, logger=None ,exchangeKey='okx'):
+        """_summary_
+            初始化
+        Args:
+            config (_type_): _description_
+            platform_config (_type_): _description_
+            common_config (_type_): _description_
+            feishu_webhook (_type_, optional): _description_. Defaults to None.
+            logger (_type_, optional): _description_. Defaults to None.
+        """
+        self.logger = logger
+        self.g_config = g_config
+        
+        self.common_config = common_config
+        self.monitor_interval = common_config.get('monitor_interval', 10)
+        self.feishu_webhook = self.common_config.get('feishu_webhook',"")
+      
+        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
+        proxies = {
+            "http": self.common_config.get('proxy', "http://localhost:7890"),
+            "https": self.common_config.get('proxy', "http://localhost:7890")
+        }
+        try:
+            self.exchange = Exchange({
+                'apiKey': platform_config["apiKey"],
+                'secret': platform_config["secret"],
+                'password': platform_config["password"],
+                'timeout': 3000,
+                'rateLimit': 50,
+                'options': {'defaultType': 'future'},
+                'proxies': proxies
+            }, exchangeKey)
+        except Exception as e:
+            self.logger.error(f"连接交易所失败: {e}")
+            raise Exception(f"连接交易所失败: {e}")
+        
+        self.smcPDArray = SMCPDArray.SMCPDArray()
+        self.smcStruct = SMCStruct.SMCStruct()
+        self.smcOB = SMCOrderBlock.SMCOrderBlock()
+        self.smcFVG = SMCFVG.SMCFVG()
+        
+        self.interval_map = {
+            '1d': 24 * 60 * 60 ,  # 1天
+            '4h': 4 * 60 * 60 ,   # 4小时
+            '1h': 60 * 60 ,        # 1小时
+            '30m': 30 * 60 ,       # 30分钟
+            '15m': 15 * 60 ,       # 15分钟
+            '5m': 5 * 60 ,         # 5分钟
+        }
+     
+        self.positions_entry_price = {} # 记录每个symbol的开仓价格   
+        self.cache_time = {}  # 记录缓存时间的字典
+        self.highest_total_profit = {}  # 记录最高总盈利 
+        self.stop_loss_prices = {}  # 记录止损价格 
+        self.take_profit_prices = {}  # 记录止盈价格
+
+    def get_precision_length(self, symbol):
+        """_summary_
+            获取价格的精度长度
+        Args:
+            price (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        tick_size = self.exchange.get_tick_size(symbol)
+        return self.smcStruct.get_precision_length(tick_size)    
+    
+    def toDecimal(self, price):
+        """_summary_
+            将价格转换为Decimal类型
+        Args:
+            price (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        return OPTools.toDecimal(price)
+    
+    def format_price(self, symbol, price:Decimal) -> str:
+        precision = self.get_precision_length(symbol)
+        return f"{price:.{precision}f}" 
+       
+    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 send_feishu_notification(self, symbol, message):
+        if self.feishu_webhook:
+            try:
+                OPTools.send_feishu_notification(self.feishu_webhook,message)
+            except Exception as e:
+                self.logger.warning(f"{symbol} 发送飞书消息失败: {e}")
+
+    def get_tick_size(self, symbol):
+        """_summary_
+            获取最小变动价格
+        Args:
+            symbol (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        return self.exchange.get_tick_size(symbol)
+
+    def get_market_price(self, symbol):
+        """_summary_
+            获取最新成交价
+        Args:
+            symbol (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        return self.exchange.get_market_price(symbol)
+    
+    def close_position(self, symbol, position, params={}) -> dict:
+        """_summary_
+            平仓
+        Args:
+            symbol (_type_): _description_
+            position (_type_): _description_
+            params (_type_, optional): _description_. Defaults to {}.
+
+        Returns:
+            _type_: _description_
+        """
+        try:
+            order = self.exchange.close_position(symbol=symbol, position=position, params=params)
+            return order
+        except Exception as e:
+            error_message = f"{symbol} 平仓失败: {e}"
+            self.logger.error(error_message)
+            self.send_feishu_notification(symbol, error_message)
+            return None
+ 
+    def cancel_all_orders(self, symbol):
+        """_summary_
+            取消所有挂单
+        Args:
+            symbol (_type_): _description_
+        """
+        
+        try:
+            self.exchange.cancel_all_orders(symbol=symbol)
+        except Exception as e:
+            error_message = f"{symbol} 取消所有挂单失败: {e}"
+            self.logger.warning(error_message)
+            self.send_feishu_notification(symbol, error_message)
+     
+    def cancel_all_algo_orders(self, symbol, attachType: str = None):
+        """取消止盈止损单
+        Args:
+            symbol: 交易对
+            attachType: 订单类型,'SL'表示止损单,'TP'表示止盈单,None表示不不区分
+        """
+        try:
+            self.exchange.cancel_all_algo_orders(symbol=symbol, attachType=attachType)
+        except Exception as e:
+            error_message = f"{symbol} 取消止盈止损单失败: {e}"
+            self.logger.warning(error_message)
+            self.send_feishu_notification(symbol, error_message)
+            return 
+            
+        if attachType == self.SL_KEY and symbol in self.stop_loss_prices:
+           del self.stop_loss_prices[symbol]
+        elif attachType == self.TP_KEY and symbol in self.take_profit_prices:
+           del self.take_profit_prices[symbol]
+        else:
+           self.reset_SL_TP(symbol, attachType)
+                 
+    def get_historical_klines(self, symbol, tf='15m'):
+        """_summary_
+            获取历史K线数据
+        Args:
+            symbol (_type_): _description_
+            bar (_type_, optional): _description_. Defaults to '15m'.
+        Returns:
+            _type_: _description_
+        """
+        return self.exchange.get_historical_klines(symbol=symbol, bar=tf)
+    
+    @lru_cache(maxsize=32)  # 缓存最近32个不同的请求
+    def _get_cache_historical_klines_df(self, symbol, tf):
+        """被缓存的获取K线数据的方法"""
+        return self.get_historical_klines_df(symbol, tf)
+    
+    def clear_cache_historical_klines_df(self, symbol=None):
+        """
+        清除指定交易对和时间周期的缓存
+        
+        参数:
+            symbol (str, optional): 交易对符号，如为None则清除所有缓存
+            tf (str, optional): 时间周期，如为None则清除所有缓存
+        """
+        if symbol is None:
+            # 清除所有缓存
+            self._get_cache_historical_klines_df.cache_clear()
+            self.cache_time.clear()
+            # print("已清除所有K线数据缓存")
+        else:
+            # 删除所有包含cache_key的缓存
+            keys_to_delete = [k for k in self.cache_time.keys() if symbol in k]
+            if keys_to_delete:
+                for k in keys_to_delete:
+                    del self.cache_time[k]
+                # 由于lru_cache无法单独清除特定键，这里只能清除所有缓存
+                self._get_cache_historical_klines_df.cache_clear()
+     
+    def get_historical_klines_df_by_cache(self, symbol, tf='15m'):
+        """_summary_
+            获取历史K线数据
+        Args:
+            symbol (_type_): _description_
+            bar (_type_, optional): _description_. Defaults to '15m'.
+        Returns:
+            _type_: _description_
+        """
+        # cache_key = (symbol, tf)
+        cache_valid_second = self.interval_map.get(tf, 4 * 60 * 60)  # 默认缓存时间为60分钟
+        cache_key = (symbol, tf)
+        
+        # 检查缓存是否存在且未过期
+        current_time = datetime.now()
+        if cache_key in self.cache_time:
+            # 计算缓存时间与当前时间的差值(秒)
+            cache_age = (current_time - self.cache_time[cache_key]).total_seconds()
+            if cache_age <= cache_valid_second:
+                # 缓存有效，直接返回
+                # print(f"使用缓存数据: {symbol} {tf} (缓存时间: {cache_age:.2f} 分钟前)")
+                return self._get_cache_historical_klines_df(symbol, tf)
+            else:
+                # 缓存过期，清除缓存
+                self.logger.debug(f"{symbol} : 缓存已过期: {symbol} {tf} (缓存时间: {cache_age:.2f} 秒前)")
+                self._get_cache_historical_klines_df.cache_clear()
+        
+        # 获取新数据并更新缓存时间
+        self.logger.debug(f"{symbol} : 重新获取新数据: {symbol} {tf}")
+        self.cache_time[cache_key] = current_time
+        return self._get_cache_historical_klines_df(symbol, tf)
+   
+    def get_historical_klines_df(self, symbol, tf='15m'):
+        """_summary_
+            获取历史K线数据
+        Args:
+            symbol (_type_): _description_
+            bar (_type_, optional): _description_. Defaults to '15m'.
+        Returns:
+            _type_: _description_
+        """
+        return self.exchange.get_historical_klines_df(symbol=symbol, bar=tf)
+    
+    def format_klines(self, klines) -> pd.DataFrame:
+       
+        """_summary_
+            格式化K线数据
+        Args:
+            klines (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        
+        return self.exchange.format_klines(klines)
+    
+    def find_PDArrays(self, symbol, struct, side=None, start_index=-1,balanced=False, pair_config=None) -> pd.DataFrame:
+        """_summary_
+            寻找PDArray
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+            side (_type_): _description_
+            start_index (_type_): _description_ 
+            balanced (bool, optional): _description_. Defaults to False.
+            pair_config (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        return self.smcPDArray.find_PDArrays(struct=struct, side=side, start_index=start_index, balanced=balanced)  
+    
+    def get_latest_PDArray(self, symbol, data, side, start_index=-1, check_balanced=True, mask=None) -> dict:
+        """_summary_
+            获取最新的PDArray
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+            side (_type_): _description_
+            start_index (_type_): _description_
+            check_balanced (bool, optional): _description_. Defaults to True.
+            mask (_type_, optional): _description_. Defaults to None.
+        Returns:
+            _type_: _description_
+        """
+        return self.smcPDArray.get_latest_PDArray(data, side, start_index, check_balanced, mask)
+    
+    def find_OBs(self, symbol, struct, side=None, start_index=-1, is_valid=True, pair_config=None) -> pd.DataFrame:
+        """_summary_
+            识别OB
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+            side (_type_): _description_
+            start_index (_type_): _description_
+            is_valid (bool, optional): _description_. Defaults to True.
+            pair_config (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        
+
+        return self.smcOB.find_OBs(struct=struct, side=side, start_index=start_index, is_valid=is_valid)
+    
+    def get_latest_OB(self, symbol, data, trend, start_index=-1) -> dict:
+        """_summary_
+            获取最新的Order Block
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+            trend (_type_): _description_
+            start_index (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+
+        return self.smcOB.get_latest_OB(data=data, trend=trend, start_index=start_index)
+             
+    def find_FVGs(self, symbol, data, side, check_balanced=True, start_index=-1, pair_config=None) -> pd.DataFrame:
+        """_summary_
+            寻找公允价值缺口
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+            side (_type_): _description_
+            check_balanced (bool, optional): _description_. Defaults to True.
+            start_index (_type_): _description_
+            pair_config (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+            
+
+        return self.smcFVG.find_FVGs(data, side, check_balanced, start_index)
+
+    def build_struct(self, symbol, data) -> pd.DataFrame:
+        
+        """_summary_
+            构建SMC结构，参考 Tradingview OP@SMC Structures and FVG
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+        Returns:
+            _type_: _description_    
+        """
+        
+                
+        return self.smcStruct.build_struct(data)
+        
+    def get_latest_struct(self, symbol, data) -> dict:
+        """_summary_
+            获取最后一个SMC结构
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        return self.smcStruct.get_latest_struct(data)
+    
+    def reset_highest_profit_and_tier(self,symbol=None):
+        """重置最高总盈利和当前档位状态"""
+        if not symbol:
+            self.highest_total_profit.clear()
+        else :
+            if symbol in self.highest_total_profit:                
+                self.highest_total_profit[symbol] = 0.0
+
+    def reset_SL_TP(self, symbol=None, attachType='BOTH'):
+        """_summary_
+            重置止盈止损
+        """
+        if not symbol:
+            self.stop_loss_prices.clear()
+            self.take_profit_prices.clear()
+        else :
+            if attachType == self.BOTH_KEY or attachType == self.SL_KEY:
+                if symbol in self.stop_loss_prices:
+                    del self.stop_loss_prices[symbol]
+            if attachType == self.BOTH_KEY or attachType == self.TP_KEY:
+                if symbol in self.take_profit_prices:
+                    del self.take_profit_prices[symbol]
+                
+    def close_all_cache(self):
+        self.clear_cache_historical_klines_df()
+        self.positions_entry_price ={}
+   
+        self.reset_highest_profit_and_tier()
+        self.reset_SL_TP()
+                    
+    def reset_all_cache(self, symbol):
+        """_summary_
+            重置所有缓存数据
+        """
+        if symbol in self.positions_entry_price:
+            del self.positions_entry_price[symbol]
+
+        self.reset_highest_profit_and_tier(symbol)    
+        self.clear_cache_historical_klines_df(symbol)
+        self.reset_SL_TP(symbol)
+        
+    def fetch_positions(self):
+        """_summary_
+            获取所有持仓
+        Returns:
+            _type_: _description_
+        """
+        
+        try:
+            positions = self.exchange.fetch_positions()
+            return positions
+        except Exception as e:
+            error_message = f"获取持仓列表失败: {e}"
+            self.logger.error(error_message)            
+            self.send_feishu_notification("",error_message)
+            return []
+    
+    def check_position(self, symbol, position):
+        # TODO 检查持仓是否有异常，比如未设置止损
+        self.logger.debug(f"{symbol} : 检查持仓是否有异常。")
+        pass
+    
+    def set_take_profit(self, symbol, position, tp_price:Decimal=None, order_type='optimal_limit_ioc') -> bool:
+
+        """
+        设置止盈单
+        Args:
+            symbol: 交易对
+            position: 持仓信息
+            tp_price: 止盈价格
+            order_type: 订单类型 ord_type: 'optimal_limit_ioc'|'market'|'limit'
+        Returns:
+            是否成功设置止盈单
+        """
+        if tp_price is None:
+            self.logger.waring(f"{symbol}: TP must greater than 0.0.")
+            return False
+        precision =self.get_precision_length(symbol)      
+        if symbol in self.take_profit_prices:
+            last_tp_price = self.take_profit_prices[symbol]
+            if tp_price and tp_price == last_tp_price:
+                self.logger.debug(f"{symbol}: TP at {tp_price:.{precision}f} Already set.")
+                return True
+            
+        self.logger.debug(f"{symbol}: TP at {tp_price:.{precision}f} Starting....  ")
+        try:
+            has_pass = self.exchange.place_algo_orders(symbol=symbol, position=position, price=tp_price, order_type=order_type, sl_or_tp='TP')
+        except Exception as e:
+            has_pass = False
+            error_message = f"{symbol}: TP at {tp_price:.{precision}f} Failed. {e}"
+            self.logger.error(error_message)
+            self.send_feishu_notification(symbol, error_message)
+       
+        if has_pass:
+            self.take_profit_prices[symbol] = tp_price
+            self.logger.info(f"{symbol}: TP at {tp_price:.{precision}f} Done.")        
+            
+        return has_pass
+          
+    def set_stop_loss(self, symbol, position, sl_price:Decimal=None , order_type='conditional') -> bool:
+        """
+        设置止盈单
+        Args:
+            symbol: 交易对
+            position: 持仓信息
+            sl_price: 止盈价格
+            order_type: 订单类型 ord_type: 'conditional'|'market'|'limit'
+        Returns:
+            是否成功设置止盈单
+        """
+        
+        if sl_price is None:
+            self.logger.waring(f"{symbol}: SL must greater than 0.0.")
+            return False
+        precision =self.get_precision_length(symbol)      
+        if symbol in self.stop_loss_prices:
+            last_sl_price = self.stop_loss_prices[symbol]
+            if sl_price and sl_price == last_sl_price:
+                self.logger.debug(f"{symbol}: SL at {sl_price:.{precision}f} Already set.")
+                return True
+        self.logger.debug(f"{symbol}: SL at {sl_price:.{precision}f} Starting....  ")
+        try:
+            has_pass = self.exchange.place_algo_orders(symbol=symbol, position=position, price=sl_price, order_type=order_type, sl_or_tp='SL')
+        except Exception as e:
+            has_pass = False
+            error_message = f"{symbol}: SL at {sl_price:.{precision}f} Failed. {e}"
+            self.logger.error(error_message)
+            self.send_feishu_notification(symbol, error_message)
+       
+        if has_pass:
+            self.stop_loss_prices[symbol] = sl_price
+            self.logger.info(f"{symbol}: SL at {sl_price:.{precision}f} Done.")        
+            
+        return has_pass
+
+    def get_stop_loss_price(self, symbol):
+        return self.stop_loss_prices.get(symbol, None)
+
+    def calculate_average_profit(self,symbol,position):
+  
+        total_profit_pct = self.toDecimal(0.0)
+        num_positions = 0
+
+        entry_price = self.toDecimal(position[self.ENTRY_PRICE_KEY])
+        current_price = self.toDecimal(position[self.MARK_PRICE_KEY])
+        side = position[self.SIDE_KEY]
+
+        # 计算单个仓位的浮动盈利百分比
+        if side not in [self.LONG_KEY,self.SHORT_KEY]:
+            return
+            
+        # 使用三元运算符简化计算逻辑
+        profit_pct = ((current_price - entry_price) if side == self.LONG_KEY else (entry_price - current_price)) / entry_price * 100
+
+        # 累加总盈利百分比
+        total_profit_pct += profit_pct
+        num_positions += 1
+        # 记录单个仓位的盈利情况
+        precision = self.get_precision_length(symbol)
+        self.logger.info(f"仓位 {symbol}，方向: {side}，开仓价格: {entry_price:.{precision}}，当前价格: {current_price:.{precision}}，"
+                            f"浮动盈亏: {profit_pct:.2f}%")
+
+        # 计算平均浮动盈利百分比
+        average_profit_pct = total_profit_pct / num_positions if num_positions > 0 else 0
+        return average_profit_pct
+    
+    def check_total_profit(self, symbol, position):
+        """
+        检查当前总盈利
+        """
+        
+        total_profit = self.calculate_average_profit(symbol, position)     
+        cur_highest_total_profit = self.highest_total_profit.get(symbol, 0.0)    
+        if total_profit > cur_highest_total_profit:            
+            self.highest_total_profit[symbol] = total_profit
+        
+        precision = self.get_precision_length(symbol)
+        entryPrice = self.toDecimal(position[self.ENTRY_PRICE_KEY])
+        marketPrice = self.toDecimal(position[self.MARK_PRICE_KEY])
+        msg = f"{symbol} : 盈利={total_profit:.2f}% 方向={position[self.SIDE_KEY]} 开仓={entryPrice:.{precision}f} 市价={marketPrice:.{precision}f}"
+        self.logger.info(msg)
+        self.send_feishu_notification(symbol, msg)  
+        
+    @abstractmethod
+    def process_pair(self, symbol, position, pair_config):
+        """
+        处理单个交易对的策略逻辑
+        
+        Args:
+            symbol: 交易对名称
+            pair_config: 交易对配置信息
+            
+        Raises:
+            NotImplementedError: 子类必须实现此方法
+        """
+        raise NotImplementedError("必须在子类中实现process_pair方法")   
+          
+    def monitor_total_profit(self):
+        self.logger.info("启动主循环，开始监控总盈利...")
+
+        while True:
+            
+            try:
+                positions = self.fetch_positions()
+                # 检查是否有仓位
+                if len(positions) == 0:
+                    # self.logger.debug("没有持仓，等待下一次检查...")
+                    self.close_all_cache()
+                    time.sleep(1)
+                    continue
+        
+            except Exception as e:
+                error_message = f"!!获取持仓失败: {str(e)}"
+                self.logger.error(error_message)
+                self.send_feishu_notification("ALL",error_message)               
+                continue
+            
+            try:
+                self.logger.info("-" * 60)
+             
+                for position in positions:
+                    symbol = position[self.SYMBOL_KEY]
+                    cur_entry_price = self.toDecimal(position[self.ENTRY_PRICE_KEY])
+                   
+                    if symbol in self.positions_entry_price and cur_entry_price != self.positions_entry_price[symbol]:
+                        # 新开仓
+                        self.reset_all_cache(symbol)
+                    
+                    if symbol not in self.positions_entry_price:
+                        self.positions_entry_price[symbol] = cur_entry_price
+                        precision = self.get_precision_length(symbol)
+                        msg = f"{symbol} : ## 重新开仓。 入场方向={position[self.SIDE_KEY]} 入场价格={cur_entry_price:.{precision}} ##"
+                        self.logger.info(msg)
+                        self.send_feishu_notification(symbol, msg)
+                        
+                    self.check_total_profit(symbol, position)
+                    self.process_pair(symbol, position, self.get_pair_config(symbol))
+                    time.sleep(0.1) 
+                    # 检查仓位和挂单是否有问题
+                    self.check_position(symbol, position)
+
+                # self.logger.info("=" * 60 + "\n")
+                time.sleep(self.monitor_interval)
+
+            except Exception as e:
+                error_message = f"程序异常退出: {str(e)}"
+                self.logger.error(error_message, exc_info=True)
+                self.send_feishu_notification(symbol, error_message)
+             
+                continue
+            except KeyboardInterrupt:
+                self.logger.info("程序收到中断信号，开始退出...")
+                break
+            finally:
+                self.logger.info("=" * 60 + "\n")

taker/main.py

@@ -1,57 +1,62 @@
 import logging
 import logging.config
 import yaml
-
-from taker.TrailingSLTaker import TrailingSLTaker
-from taker.TrailingSLAndTPTaker import TrailingSLAndTPTaker
-from taker.ThreeLineTradingTaker import ThreeLineTradingTaker
-from taker.SMCSLAndTPTaker import SMCSLAndTPTaker
+import importlib
+import importlib.metadata
+from pathlib import Path
+from typing import Dict, Any
 from pyfiglet import Figlet
-    
-def read_config_file(file_path):
+
+def read_config_file(file_path: str) -> Dict[str, Any]:
+    """读取并解析YAML配置文件"""
     try:
-        # 打开 YAML 文件
         with open(file_path, 'r', encoding='utf-8') as file:
-            # 使用 yaml.safe_load 方法解析 YAML 文件内容
-            data = yaml.safe_load(file)
-            return data
+            return yaml.safe_load(file)
     except FileNotFoundError:
-        raise Exception(f"文件 {file_path} 未找到。")
+        raise FileNotFoundError(f"文件 {file_path} 未找到。")
     except yaml.YAMLError as e:
-        raise Exception(f"解析 {file_path} 文件时出错: {e}")
-
+        raise yaml.YAMLError(f"解析 {file_path} 文件时出错: {e}")
+
+def initialize_logger(config: Dict[str, Any]) -> logging.Logger:
+    """初始化日志配置并返回logger实例"""
+    logging.config.dictConfig(config["Logger"])
+    return logging.getLogger("openfund-taker")
+
+def create_strategy_instance(taker_name: str, configs: Dict[str, Any], logger: logging.Logger, exchangeKey:str):
+    """创建策略实例"""
+    module = importlib.import_module(f"taker.{taker_name}")
+    strategy_class = getattr(module, taker_name)
+    return strategy_class(
+        configs, 
+        configs['platform'][exchangeKey],
+        configs['common'],
+        logger=logger
+    )
 
 def main():
-    import importlib.metadata
+    # 获取版本信息和包名
     version = importlib.metadata.version("openfund-taker")
+    package_name = __package__ or "taker"
 
-    package_name = __package__ or "taker" 
-    
-    openfund_config_path = 'taker_config.yaml'
-    config_data = read_config_file(openfund_config_path)
+    # 读取配置文件
+    config_path = Path('taker_config.yaml')
+    config_data = read_config_file(config_path)
     
-
-    platform_config = config_data['platform']["okx"]
+    # 获取配置参数
     common_config = config_data['common']
-    taker = common_config.get('actived_taker', 'SMCSLAndTPTaker')
-    feishu_webhook_url = common_config['feishu_webhook']
-    monitor_interval = common_config.get("monitor_interval", 60)  # 默认值为60秒
-    
-    logging.config.dictConfig(config_data["Logger"])
-    logger = logging.getLogger("openfund-taker")
-    
-    f = Figlet(font="standard")  # 字体可选（如 "block", "bubble"）
-    logger.info(f"\n{f.renderText("OpenFund Taker")}")
-            
-    logger.info(f" ++ {package_name}.{taker}:{version} is doing...")
-    # 根据配置动态创建策略实例
-    strategy_class = globals()[taker]
-    bot = strategy_class(config_data, platform_config, common_config, feishu_webhook=feishu_webhook_url, monitor_interval=monitor_interval,logger=logger)
-
+    taker_name = common_config.get('actived_taker', 'StrategyTaker')
 
+    # 初始化日志
+    logger = initialize_logger(config_data)
+    
+    # 显示启动信息
+    f = Figlet(font="standard")
+    logger.info(f"\n{f.renderText('OpenFund Taker')}")
+    logger.info(f" ++ {package_name}.{taker_name}:{version} is doing...")
+    exchangeKey = common_config.get("exchange_key", "okx")
+    # 创建并运行策略实例
+    bot = create_strategy_instance(taker_name, config_data, logger, exchangeKey)
     bot.monitor_total_profit()
-    # bot = ThreeLineTradingBot(platform_config, feishu_webhook=feishu_webhook_url, monitor_interval=monitor_interval)
-    # bot.monitor_klines()
 
 if __name__ == "__main__":
     main()