openfund-taker 2.2.8__py3-none-any.whl → 2.3.1__py3-none-any.whl

{openfund_taker-2.2.8.dist-info → openfund_taker-2.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openfund-taker
-Version: 2.2.8
+Version: 2.3.1
 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.8.dist-info → openfund_taker-2.3.1.dist-info}/RECORD

@@ -1,4 +1,6 @@
+taker/BestTopDownStrategyTaker.py,sha256=2GCHFr15N-RBVYklraFnAunXi2aKS--asYAIvRgvbwo,4376
 taker/SMCSLAndTPTaker.py,sha256=zJCtwyzIuDtbxMdLOwRbpUE60o9fKe-tNWuiuej4RGs,27621
+taker/StrategyTaker.py,sha256=SHm-YmT4eVATbfiYzS-zYMOn8oj1fi1QqJi6aCY3G44,26281
 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.8.dist-info/METADATA,sha256=jWTmXIsLQO3gc8wvQ4ZcHzTmrTTgykgayHTgFZBLNpo,7529
-openfund_taker-2.2.8.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-openfund_taker-2.2.8.dist-info/entry_points.txt,sha256=a7mG8F7aOA5-Gk2vPWuAR4537faxaHUgM_jwIDBZoEc,50
-openfund_taker-2.2.8.dist-info/RECORD,,
+taker/main.py,sha256=w1FaaDlqbWZkXffCA47mQTJ5n4uaE0kclc_teez6_Ek,2252
+openfund_taker-2.3.1.dist-info/METADATA,sha256=CkKJcYe-zRX-yI_gNesX19Yk5cYasvBDzu9jEoT3c_8,7575
+openfund_taker-2.3.1.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+openfund_taker-2.3.1.dist-info/entry_points.txt,sha256=a7mG8F7aOA5-Gk2vPWuAR4537faxaHUgM_jwIDBZoEc,50
+openfund_taker-2.3.1.dist-info/RECORD,,

taker/BestTopDownStrategyTaker.py

@@ -0,0 +1,104 @@
+from typing import override
+
+from taker.StrategyTaker import StrategyTaker
+
+class BestTopDownStrategyTaker(StrategyTaker):
+    """
+    最佳顶底策略
+    """
+    def __init__(self, g_config,  platform_config, common_config, monitor_interval=4, logger=None, exchangeKey='okx') -> None:
+        super().__init__(g_config=g_config,  platform_config=platform_config, common_config=common_config, monitor_interval=monitor_interval, logger=logger, exchangeKey=exchangeKey)
+        self.has_init_SL_TPs = {}
+        
+    @override
+    def rest_SL_TP(self, symbol):
+        super().rest_SL_TP(symbol)
+        if not symbol :
+            self.has_init_SL_TPs.clear()
+                  
+        elif symbol in self.has_init_SL_TPs:
+            del self.has_init_SL_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]
+        # etf = tfs[self.ETF_KEY]
+        atf = tfs[self.ATF_KEY]
+        
+        # 1.1  ATF Key Support & Resistance Levels 支撑或阻力关键位置(ATF 看上下的供需区位置）
+        atf_df = self.get_historical_klines_df_by_cache(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)
+    
+        atf_support_OB = self.get_lastest_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)
+        else:
+            atf_support_price = atf_struct.at[atf_struct.index[-1], self.STRUCT_LOW_COL]
+    
+        atf_resistance_OB = self.get_lastest_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)
+        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} ")
+        
+        side = self.SELL_SIDE if position[self.SIDE_KEY] == self.SHORT_KEY else self.BUY_SIDE # 和持仓反向相反下单
+        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)
+            tp_price = self.toDecimal(atf_resistance_price) + self.toDecimal(price_offset)
+        else:
+            sl_price = self.toDecimal(atf_resistance_price) + self.toDecimal(price_offset)
+            tp_price = self.toDecimal(atf_support_price) - self.toDecimal(price_offset)
+
+        self.cancel_all_algo_orders(symbol=symbol, attachType='SL')
+        self.set_stop_loss(symbol=symbol, position=position, sl_price=sl_price)
+        self.cancel_all_algo_orders(symbol=symbol, attachType='TP')
+        self.set_take_profit(symbol=symbol, position=position, tp_price=tp_price)
+    
+        
+        return True
+
+    @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
+        
+        
+        pass    

taker/StrategyTaker.py

@@ -0,0 +1,670 @@
+# -*- coding: utf-8 -*-
+import traceback
+import pandas as pd
+import time
+from functools import lru_cache
+from datetime import datetime, timedelta
+from decimal import Decimal
+from abc import abstractmethod
+from concurrent.futures import ThreadPoolExecutor, as_completed
+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'
+    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
+    
+    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, monitor_interval=4, 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 = monitor_interval
+        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 place_order(self, symbol, price:Decimal, side,  pair_config, leverage:int=0, order_type='limit', params={}):
+        """_summary_
+            下单
+        Args:
+            symbol (_type_): _description_
+            price (_type_): _description_
+            amount_usdt (_type_): _description_
+            side (_type_): _description_
+            order_type (_type_): _description_
+        """
+        # 获取做多和做空的下单金额配置
+        long_amount_usdt = pair_config.get('long_amount_usdt', 5)
+        short_amount_usdt = pair_config.get('short_amount_usdt', 5)
+        
+        # 设置杠杆倍数
+        leverage = leverage or self.leverage_value
+        
+        # 根据交易方向设置下单金额
+        order_amount_usdt = short_amount_usdt if side == self.SELL_SIDE else long_amount_usdt
+        
+        # 记录下单日志
+        direction = self.BULLISH_TREND if side == self.BUY_SIDE else self.BEARISH_TREND
+        self.logger.debug(f"{symbol} : 触发{direction}下单条件。")
+        
+        # 执行下单
+        self.exchange.place_order(
+            symbol=symbol,
+            price=price,
+            amount_usdt=order_amount_usdt,
+            side=side,
+            leverage=leverage,
+            order_type=order_type
+        )
+      
+    def cancel_all_orders(self, symbol):
+        """_summary_
+            取消所有挂单
+        Args:
+            symbol (_type_): _description_
+        """
+        self.exchange.cancel_all_orders(symbol=symbol)
+    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, pair_config=None) -> pd.DataFrame:
+        """_summary_
+            寻找PDArray
+        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.smcPDArray.find_PDArrays(struct=struct, side=side, start_index=start_index)  
+    
+    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_lastest_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_lastest_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_last_struct(self, symbol, data) -> dict:
+        """_summary_
+            获取最后一个SMC结构
+        Args:
+            symbol (_type_): _description_
+            data (_type_): _description_
+        Returns:
+            _type_: _description_
+        """
+        return self.smcStruct.get_last_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 rest_SL_TP(self, symbol):
+        """_summary_
+            重置止盈止损
+        """
+        if not symbol:
+            self.stop_loss_prices.clear()
+            self.take_profit_prices.clear()
+        else :
+            if symbol in self.stop_loss_prices:
+                del self.stop_loss_prices[symbol]
+            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.rest_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.rest_SL_TP(symbol)
+        
+    def fetch_positions(self):
+        """_summary_
+            获取所有持仓
+        Returns:
+            _type_: _description_
+        """
+        return self.exchange.fetch_positions()
+    def check_position(self, symbol, position):
+        # TODO 检查持仓是否有异常，比如未设置止损
+        self.logger.debug(f"{symbol} : 检查持仓是否有异常。")
+        pass
+    
+    def cancel_all_algo_orders(self, symbol, attachType: str = None):
+        """取消止盈止损订单
+        Args:
+            symbol: 交易对
+            attachType: 订单类型,'SL'表示止损单,'TP'表示止盈单,None表示不不区分
+        """
+      
+        self.exchange.cancel_all_algo_orders(symbol=symbol, attachType=attachType)
+        if attachType == "SL" and symbol in self.stop_loss_prices:
+           del self.stop_loss_prices[symbol]
+        elif attachType == "TP" and symbol in self.take_profit_prices:
+           del self.take_profit_prices[symbol]
+        else:
+           self.rest_SL_TP(symbol)
+          
+    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 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(" ",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,64 @@
 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, monitor_interval: int, 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'],
+        monitor_interval=monitor_interval,
+        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')
+    monitor_interval = common_config.get("monitor_interval", 60)
 
+    # 初始化日志
+    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, monitor_interval, 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()