openfund-core 1.0.1__py3-none-any.whl → 1.0.7__py3-none-any.whl

core/Exchange.py

@@ -10,6 +10,15 @@ from ccxt.base.exchange import ConstructorArgs
 
 
 class Exchange:
+    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'
     def __init__(self, config:ConstructorArgs, exchangeKey:str = "okx",) :
         # 配置交易所
         self.exchange = getattr(ccxt, exchangeKey)(config)
@@ -22,19 +31,8 @@ class Exchange:
         self.exchange.load_markets()
         
         return self.exchange.market(symbol)
-
-    def get_tick_size(self,symbol) -> Decimal:     
-        
-        market = self.getMarket(symbol)
-        if market and 'precision' in market and 'price' in market['precision']:            
-            return OPTools.toDecimal(market['precision']['price'])
-        else:
-            raise ValueError(f"{symbol}: 无法从市场数据中获取价格精度")
-
-    def amount_to_precision(self,symbol, contract_size):
-        return self.exchange.amount_to_precision(symbol, contract_size)
-    
-    def get_position_mode(self):
+  
+    def get_position_mode(self) -> str:
     
         try:
             # 假设获取账户持仓模式的 API
@@ -52,6 +50,19 @@ class Exchange:
             error_message = f"Error fetching position mode: {e}"
             self.logger.error(error_message)        
             raise Exception(error_message)  
+        
+    def get_tick_size(self,symbol) -> Decimal:     
+        
+        market = self.getMarket(symbol)
+        if market and 'precision' in market and 'price' in market['precision']:            
+            return OPTools.toDecimal(market['precision']['price'])
+        else:
+            raise ValueError(f"{symbol}: 无法从市场数据中获取价格精度")
+
+    def amount_to_precision(self,symbol, contract_size):
+        return self.exchange.amount_to_precision(symbol, contract_size)
+    
+
     
     def set_leverage(self,symbol, leverage, mgnMode='isolated',posSide=None):
         try:
@@ -96,10 +107,66 @@ class Exchange:
         elif direction == 'cost_to_contract':
             contract_size = amount / price / market_contractSize
         else:
-            raise Exception(f"{symbol}:{direction} 是无效的转换方向，请输入 'amount_to_contract' 或 'cost_to_contract'。")
+            raise Exception(f"{symbol} : {direction} 是无效的转换方向，请输入 'amount_to_contract' 或 'cost_to_contract'。")
         
         return self.amount_to_precision(symbol, contract_size)
-   
+    
+    def close_position(self, symbol, position, params={}) -> dict:
+
+        amount = abs(float(position['contracts']))
+
+        if amount <= 0:
+            self.logger.warning(f"{symbol}: position contracts must be greater than 0")
+            return
+            
+        max_retries = 3
+        retry_count = 0
+        while retry_count < max_retries:
+            
+            try:
+                side = position[self.SIDE_KEY]
+                self.logger.debug(f"{symbol}: Preparing to close position, side= {side}, amount={amount}")
+                position_mode = self.get_position_mode()  # 获取持仓模式
+                if position_mode == 'long_short_mode':
+                    # 在双向持仓模式下，指定平仓方向
+                    # pos_side = 'long' if side == 'long' else 'short'
+                    pos_side = side
+                else:
+                    # 在单向模式下，不指定方向
+                    pos_side = 'net'
+                orderSide = 'buy' if side == 'long' else 'sell'                
+                
+                td_mode = position['marginMode']
+                params = {                    
+                    'mgnMode': td_mode,
+                    'posSide': pos_side,
+                    # 当市价全平时，平仓单是否需要自动撤销,默认为false. false：不自动撤单 true：自动撤单
+                    'autoCxl': 'true',
+                    **params
+            
+                }
+
+                # 发送平仓请求并获取返回值
+                order = self.exchange.close_position(
+                    symbol=symbol,
+                    side=orderSide,
+                    params=params
+                )
+                
+                self.logger.info(f"{symbol} Close position response : {order}")
+                return order
+            
+            except Exception as e:
+                
+                retry_count += 1
+                if retry_count == max_retries:
+                    error_message = f"{symbol} Error closing position : {str(e)}"
+                    self.logger.error(error_message)
+                    raise Exception(error_message)                
+                else:
+                    self.logger.warning(f"{symbol} 平仓失败，正在进行第{retry_count}次重试: {str(e)}")
+                    time.sleep(0.1)  # 重试前等待0.1秒
+                    
      
     def cancel_all_orders(self, symbol):
         max_retries = 3
@@ -133,8 +200,171 @@ class Exchange:
                     self.logger.warning(f"{symbol} 取消挂单失败，正在进行第{retry_count}次重试: {str(e)}")
                     time.sleep(0.1)  # 重试前等待0.1秒
 
+    def cancel_all_algo_orders(self, symbol, attachType=None) -> bool:
+        """_summary_
+
+        Args:
+            symbol (_type_): _description_
+            attachType (_type_, optional): "TP"|"SL". Defaults to None.
+        """
+        
+        params = {
+            "ordType": "conditional",
+        }
+        try:
+            orders = self.fetch_open_orders(symbol=symbol,params=params)
+        except Exception as e:
+            error_message = f"!!{symbol} : Error fetching open orders: {e}"
+            self.logger.error(error_message)
+            raise Exception(error_message)
+       
+        
+        if len(orders) == 0:           
+            self.logger.debug(f"{symbol} 未设置策略订单列表。")
+            return True
+     
+        algo_ids = []
+        if attachType and attachType == 'SL':
+            algo_ids = [order['id'] for order in orders if order['stopLossPrice'] and order['stopLossPrice'] > 0.0 ]
+        elif attachType and attachType == 'TP':
+            algo_ids = [order['id'] for order in orders if order['takeProfitPrice'] and order['takeProfitPrice'] > 0.0]
+        else :
+            algo_ids = [order['id'] for order in orders ]
+            
+        if len(algo_ids) == 0 :         
+            self.logger.debug(f"{symbol} 未设置策略订单列表。")
+            return True
+        
+        max_retries = 3
+        retry_count = 0
+        
+        while retry_count < max_retries:
+            try:
+                params = {
+                    "algoId": algo_ids,
+                    "trigger": 'trigger'
+                }
+                rs = self.exchange.cancel_orders(ids=algo_ids, symbol=symbol, params=params)
+                
+                return len(rs) > 0
+       
+            except Exception as e:
+                retry_count += 1
+                if retry_count == max_retries:
+                    error_message = f"!!{symbol} : Error cancelling order {algo_ids}: {e}"
+                    self.logger.error(error_message)
+                    raise Exception(error_message) 
+                   
+                self.logger.warning(f"{symbol} : Error cancelling order {algo_ids}: {str(e)}")
+                time.sleep(0.1)  # 重试前等待0.1秒 
+    def place_algo_orders(self, symbol, position, price: Decimal, order_type, sl_or_tp='SL', params={}) -> bool:
+        """
+        下单
+        Args:
+            symbol: 交易对
+            position: 仓位
+            price: 下单价格
+            order_type: 订单类型
+        """
+        # 计算下单数量
+        amount = abs(position[self.CONTRACTS_KEY])
+    
+        if amount <= 0:
+            self.logger.warning(f"{symbol}: amount is 0 for {symbol}")
+            return
+
+        # 止损单逻辑 
+        adjusted_price = self.format_price(symbol, price)
+        
+        # 默认市价止损，委托价格为-1时，执行市价止损。
+        sl_params = {
+            **params,
+            'slTriggerPx':adjusted_price , 
+            'slOrdPx':'-1', # 委托价格为-1时，执行市价止损
+            # 'slOrdPx' : adjusted_price,
+            'slTriggerPxType':'last',
+            'tdMode':position['marginMode'],
+            'sz': str(amount),        
+            'cxlOnClosePos': True,
+            'reduceOnly':True,            
+        }
+        
+        tp_params = {  
+            **params,
+            'tpTriggerPx':adjusted_price,
+            'tpOrdPx' : adjusted_price,
+            'tpOrdKind': 'condition',
+            'tpTriggerPxType':'last',            
+            'tdMode':position['marginMode'],
+            'sz': str(amount),          
+            'cxlOnClosePos': True,
+            'reduceOnly':True
+        }
+        
+        order_params = sl_params if sl_or_tp == 'SL' else tp_params
+        # order_params.update(params)
+        
+        if order_type == 'limit' and sl_or_tp =='SL':
+            order_params['slOrdPx'] = adjusted_price
+        
+        orderSide = self.BUY_SIDE if position[self.SIDE_KEY] == self.SHORT_KEY else self.SELL_SIDE # 和持仓反向相反下单
+        
+        order = {
+            'symbol': symbol,
+            'side': orderSide,
+            'type': order_type,
+            'amount': amount,
+            'price': adjusted_price,
+            'params': order_params
+        }
+        
+        max_retries = 3
+        retry_count = 0
+        self.logger.info(f"{symbol} : Pre Algo Order placed:  {order} ")
+        while retry_count < max_retries:
+            try:
+                
+                self.exchange.create_order(
+                    **order
+                    # symbol=symbol,
+                    # type=order_type,
+                    # price=adjusted_price,
+                    # side=orderSide,
+                    # amount=amount,
+                    # params=order_params
+                )             
+                
+                break               
+               
+            except ccxt.NetworkError as e:
+                # 处理网络相关错误
+                retry_count += 1
+                self.logger.warning(f"{symbol} : 设置止盈止损时发生网络错误,正在进行第{retry_count}次重试: {str(e)}")
+                time.sleep(0.1)  # 重试前等待1秒
+                continue
+            except ccxt.ExchangeError as e:
+                # 处理交易所API相关错误
+                retry_count += 1
+                self.logger.warning(f"{symbol} : 设置止盈止损单时发生交易所错误,正在进行第{retry_count}次重试: {str(e)}")
+                time.sleep(0.1)
+                continue
+            except Exception as e:
+                # 处理其他未预期的错误
+                retry_count += 1
+                self.logger.warning(f"{symbol} : 设置止盈止损单时发生未知错误,正在进行第{retry_count}次重试: {str(e)}")
+                time.sleep(0.1)
+                continue
+            
+        if retry_count >= max_retries:
+            # 重试次数用完仍未成功设置止损单
+            error_message = f"!! {symbol}: 设置止盈止损单时重试次数用完仍未成功设置成功。 "
+            self.logger.error(error_message)
+            raise Exception(error_message)
+        self.logger.debug(f"{symbol} : --------- ++ Order placed done. --------")
+        return True
+        
 
-    def place_order(self, symbol, price: Decimal, amount_usdt,  side, leverage=20, order_type='limit'): 
+    def place_order(self, symbol, price: Decimal, amount_usdt, side, leverage=20, order_type='limit', params={}) -> bool: 
         """
         下单
         Args:
@@ -147,41 +377,47 @@ class Exchange:
         # 格式化价格
         adjusted_price = self.format_price(symbol, price)
 
-        if amount_usdt > 0:
-            if side == 'buy':
-                pos_side = 'long' 
-            else:
-                pos_side = 'short'   
-            # 设置杠杆 
-            self.set_leverage(symbol=symbol, leverage=leverage, mgnMode='isolated',posSide=pos_side)  
-            # 20250220 SWAP类型计算合约数量 
-            contract_size = self.convert_contract(symbol=symbol, price = OPTools.toDecimal(adjusted_price) ,amount=amount_usdt)
+        if amount_usdt <= 0:
+            self.logger.warning(f"{symbol}: amount_usdt must be greater than 0")
+            return
     
-            params = {
-                
-                "tdMode": 'isolated',
-                "side": side,
-                "ordType": order_type,
-                "sz": contract_size,
-                "px": adjusted_price
-            } 
+        pos_side = self.LONG_KEY if side == self.BUY_SIDE else self.SHORT_KEY
+
+        # 设置杠杆 
+        self.set_leverage(symbol=symbol, leverage=leverage, mgnMode='isolated',posSide=pos_side)  
+        # 20250220 SWAP类型计算合约数量 
+        contract_size = self.convert_contract(symbol=symbol, price = OPTools.toDecimal(adjusted_price) ,amount=amount_usdt)
+
+        order_params = {
+            **params,
+            "tdMode": 'isolated',
+            "side": side,
+            "ordType": order_type,
+            "sz": contract_size,
+            "px": adjusted_price
+        } 
+        
+        # # 模拟盘(demo_trading)需要 posSide
+        # if self.is_demo_trading == 1 :
+        #     params["posSide"] = pos_side
             
-            # # 模拟盘(demo_trading)需要 posSide
-            # if self.is_demo_trading == 1 :
-            #     params["posSide"] = pos_side
-                
-            # self.logger.debug(f"---- Order placed params: {params}")
+        order = {
+            'symbol': symbol,
+            'side': side,
+            'type': order_type,
+            'amount': contract_size,
+            'price': adjusted_price,
+            'params': order_params
+        }
+        
+        max_retries = 3
+        retry_count = 0
+
+        self.logger.info(f"{symbol} : Pre Order placed:  {order} ")
+        
+        while retry_count < max_retries:
             try:
-                order = {
-                    'symbol': symbol,
-                    'side': side,
-                    'type': 'limit',
-                    'amount': contract_size,
-                    'price': adjusted_price,
-                    'params': params
-                }
                 # 使用ccxt创建订单
-                self.logger.debug(f"Pre Order placed:  {order} ")
                 order_result = self.exchange.create_order(
                     **order
                     # symbol=symbol,
@@ -191,13 +427,31 @@ class Exchange:
                     # price=float(adjusted_price),
                     # params=params
                 )
-                # self.logger.debug(f"{symbol} ++ Order placed rs :  {order_result}")
+            except ccxt.NetworkError as e:
+                # 处理网络相关错误
+                retry_count += 1
+                self.logger.warning(f"{symbol} : 下单时发生网络错误,正在进行第{retry_count}次重试: {str(e)}")
+                time.sleep(0.1)  # 重试前等待1秒
+                continue
+            except ccxt.ExchangeError as e:
+                # 处理交易所API相关错误
+                retry_count += 1
+                self.logger.warning(f"{symbol} : 下单时发生交易所错误,正在进行第{retry_count}次重试: {str(e)}")
+                time.sleep(0.1)
+                continue
             except Exception as e:
-                error_message = f"{symbol} Failed to place order: {e}"
-                self.logger.error(error_message)
-                raise Exception(error_message)
-                
-        self.logger.debug(f"--------- ++ {symbol} Order placed done! --------")  
+                # 处理其他未预期的错误
+                retry_count += 1
+                self.logger.warning(f"{symbol} : 下单时发生未知错误,正在进行第{retry_count}次重试: {str(e)}")
+                time.sleep(0.1)
+                continue
+        if retry_count >= max_retries:
+            # 重试次数用完仍未成功设置止损单
+            error_message = f"!! {symbol}: 下单时重试次数用完仍未成功设置成功。 "
+            self.logger.error(error_message)
+            raise Exception(error_message)        
+        self.logger.debug(f"{symbol} : --------- ++ Order placed done. --------")  
+        return True
       
     def fetch_position(self, symbol):
         """_summary_
@@ -215,8 +469,8 @@ class Exchange:
         while retry_count < max_retries:
             try:
                 position = self.exchange.fetch_position(symbol=symbol)
-                if position and position['contracts'] > 0:
-                    self.logger.debug(f"{symbol} 有持仓合约数: {position['contracts']}")
+                if position :
+                    # self.logger.debug(f"{symbol} 有持仓合约数: {position['contracts']}")
                     return position
                 return None
             except Exception as e:
@@ -228,7 +482,69 @@ class Exchange:
                    
                 self.logger.warning(f"{symbol} 检查持仓失败，正在进行第{retry_count}次重试: {str(e)}")
                 time.sleep(0.1)  # 重试前等待0.1秒
-      
+    
+    def fetch_positions(self):
+        """_summary_
+        Returns:
+            _type_: _description_
+        """
+        max_retries = 3
+        retry_count = 0
+
+        while retry_count < max_retries:
+            try:
+                positions = self.exchange.fetch_positions()
+                return positions
+            except Exception as e:
+                retry_count += 1
+                if retry_count == max_retries:
+                    error_message = f"!! 获取持仓列表失败(重试{retry_count}次): {str(e)}"
+                    self.logger.error(error_message)
+                    raise Exception(error_message)
+
+                self.logger.warning(f"获取持仓列表失败，正在进行第{retry_count}次重试: {str(e)}")
+                time.sleep(0.1)  # 重试前等待0.1秒
+    
+    def fetch_open_orders(self,symbol,params={}):
+        max_retries = 3
+        retry_count = 0
+        
+        while retry_count < max_retries:
+            try:
+                orders = self.exchange.fetch_open_orders(symbol=symbol,params=params)
+                return orders
+            
+            except Exception as e:
+                retry_count += 1
+                if retry_count == max_retries:
+                    error_message = f"{symbol} : fetching open orders(retry {retry_count} times): {str(e)}"
+                    self.logger.error(error_message)
+                    raise Exception(error_message)
+                   
+                self.logger.warning(f"{symbol} : Error fetching open orders: {str(e)}")
+                time.sleep(0.1)  # 重试前等待0.1秒     
+    def get_market_price(self, symbol) -> Decimal:
+        """
+        获取最新价格
+        Args:
+            symbol: 交易对
+        """
+        max_retries = 3
+        retry_count = 0
+
+        while retry_count < max_retries:
+            try:
+                ticker = self.exchange.fetch_ticker(symbol)
+                if ticker and 'last' in ticker:
+                    return OPTools.toDecimal(ticker['last'])
+                else:
+                    raise Exception(f"{symbol} : Unexpected response structure or missing 'last' price")
+            except Exception as e:
+                retry_count += 1
+                if retry_count == max_retries:
+                    error_message = f"{symbol} 获取最新价格失败(重试{retry_count}次): {str(e)}"
+                    self.logger.error(error_message)
+                    raise Exception(error_message)
             
     def get_historical_klines(self, symbol, bar='15m', limit=300, after:str=None, params={}):
         """

core/smc/SMCLiquidity.py

@@ -1,7 +1,209 @@
 import logging
+from re import S
+import pandas as pd
+from core.smc.SMCStruct import SMCStruct
+from pandas.core.strings.accessor import F
+from pandas.io.parquet import catch_warnings
+
+class SMCLiquidity(SMCStruct):
+    EQUAL_HIGH_COL = "equal_high"
+    EQUAL_LOW_COL = "equal_low"
+    LIQU_HIGH_COL = "liqu_high"
+    LIQU_LOW_COL = "liqu_low"
+    EQUAL_HIGH_INDEX_KEY = "equal_high_index"
+    EQUAL_LOW_INDEX_KEY = "equal_low_index"
+    HAS_EQ_KEY = "has_EQ"
+    LIQU_HIGH_DIFF_COL = "liqu_high_diff"
+    LIQU_LOW_DIFF_COL = "liqu_low_diff"
+
 
-class SMCLiquidity:
     def __init__(self):
+        super().__init__()
         self.logger = logging.getLogger(__name__)
-   
-    
+        
+        
+    def _identify_liquidity_pivots(self, data, pivot_length=1):
+        """
+        识别流动性的高点和低点
+        """
+
+        df = data.copy()
+        
+        # 识别高点
+        df[self.LIQU_HIGH_COL] = 0
+        for i in range(pivot_length, len(df) - pivot_length):
+            if df[self.HIGH_COL].iloc[i] == max(df[self.HIGH_COL].iloc[i-pivot_length:i+pivot_length+1]):
+                df.loc[df.index[i], self.LIQU_HIGH_COL] = df[self.HIGH_COL].iloc[i]
+        
+        # 识别低点
+        df[self.LIQU_LOW_COL] = 0
+        for i in range(pivot_length, len(df) - pivot_length):
+
+            if df[self.LOW_COL].iloc[i] == min(df[self.LOW_COL].iloc[i-pivot_length:i+pivot_length+1]):
+                df.loc[df.index[i], self.LIQU_LOW_COL] = df[self.LOW_COL].iloc[i]
+
+        
+        
+        return df
+        
+    def find_EQH_EQL(self, data, trend, end_idx=-1, atr_offset=0.1) -> dict:
+        """_summary_
+        识别等高等低流动性
+        Args:
+            data (_type_): _description_
+            trend (_type_): _description_
+            end_idx (int, optional): _description_. Defaults to -1.
+            atr_offset (float, optional): _description_. Defaults to 0.1.
+
+        Returns:
+            dict: _description_
+        """
+        
+        df = data.copy() if end_idx == -1 else data.copy().iloc[:end_idx+1]
+
+        check_columns = [self.LIQU_HIGH_COL, self.LIQU_LOW_COL]
+
+        try:
+            self.check_columns(df, check_columns) 
+        except ValueError as e:
+            self.logger.warning(f"DataFrame must contain columns {check_columns} : {str(e)}")
+            df = self._identify_liquidity_pivots(df)
+            
+        df = df[(df[self.LIQU_HIGH_COL] > 0) | (df[self.LIQU_LOW_COL] > 0)]
+        # 初始化结果列
+        df[self.EQUAL_HIGH_COL] = 0
+        df[self.EQUAL_LOW_COL] = 0 
+        df[self.ATR_COL] = self.calculate_atr(df)
+        # 跟踪前一个高点和低点
+        previous_high = None
+        previous_high_index = None
+        previous_high_pos = -1
+        previous_low = None
+        previous_low_index = None  
+        previous_low_pos = -1   
+        for i in range(len(df)-1, -1, -1):
+
+            offset = self.toDecimal(df[self.ATR_COL].iloc[i] * atr_offset)
+
+            if trend == self.BULLISH_TREND:
+                current_high = df[self.LIQU_HIGH_COL].iloc[i]
+                if current_high == 0:
+                    continue
+        
+                if previous_high is None:
+                    previous_high = current_high
+                    previous_high_index = df.index[i]
+                    previous_high_pos = i
+                    continue
+                
+                max_val = max(current_high, previous_high)
+                min_val = min(current_high, previous_high)
+                
+                
+                if abs(max_val - min_val) <= offset: # EQH|EQL
+            
+                    df.loc[df.index[i], self.EQUAL_HIGH_COL] = previous_high_index
+                    df.loc[df.index[previous_high_pos], self.EQUAL_HIGH_COL] = previous_high_index
+                        
+                else:
+                    # 倒序遍历，等高线被高点破坏，则更新等高点位置
+                    if current_high > previous_high:
+                        previous_high = current_high
+                        previous_high_index = df.index[i]
+                        previous_high_pos = i
+
+
+
+            else:
+                current_low = df[self.LIQU_LOW_COL].iloc[i]
+                if current_low == 0:
+                    continue
+        
+                # current_low = df[self.EQUAL_LOW_COL].iloc[i]
+                if previous_low is None:
+                    previous_low = current_low
+                    previous_low_index = df.index[i]
+                    previous_low_pos = i
+                    continue
+                
+                max_val = max(current_low, previous_low)
+                min_val = min(current_low, previous_low)
+                
+                
+
+                
+                if abs(max_val - min_val) <= offset: # EQH|EQL
+            
+                    df.loc[df.index[i], self.EQUAL_LOW_COL] = previous_low_index
+                    df.loc[df.index[previous_low_pos], self.EQUAL_LOW_COL] = previous_low_index
+                        
+                else:
+                    # 倒序遍历，等高线被高点破坏，则更新等高点位置
+                    if current_low < previous_low:
+                        previous_low = current_low
+                        previous_low_index = df.index[i]
+                        previous_low_pos = i
+                
+        # 筛选有效结构且在prd范围内的数据
+        last_EQ = {
+
+        }
+        if trend == self.BULLISH_TREND :
+            mask = df[self.EQUAL_HIGH_COL] > 0
+            valid_EQH_df = df[ mask ]
+            if not valid_EQH_df.empty:
+                last_EQ[self.HAS_EQ_KEY] = True
+                last_EQ[self.EQUAL_HIGH_COL] = valid_EQH_df.iloc[-1][self.LIQU_HIGH_COL]
+                last_EQ[self.EQUAL_HIGH_INDEX_KEY] = valid_EQH_df.iloc[-1][self.EQUAL_HIGH_COL]
+        else:
+            mask = df[self.EQUAL_LOW_COL] > 0
+            valid_EQL_df = df[ mask ]
+            if not valid_EQL_df.empty:
+                last_EQ[self.HAS_EQ_KEY] = True
+                last_EQ[self.EQUAL_LOW_COL] = valid_EQL_df.iloc[-1][self.LIQU_LOW_COL]
+                last_EQ[self.EQUAL_LOW_INDEX_KEY] = valid_EQL_df.iloc[-1][self.EQUAL_LOW_COL]
+
+        return last_EQ
+               
+    def identify_dynamic_trendlines(self, data, trend, start_idx=-1, end_idx=-1, ratio=0.8) -> tuple:
+        """
+        识别动态趋势线或隧道
+        Args:
+            data (pd.DataFrame): _description_
+
+        Returns:
+            pd.DataFrame: _description_
+        """          
+
+        df = data.copy() if start_idx == -1 or end_idx == -1 else data.copy().iloc[start_idx-1:end_idx+2] #考虑poivt值，前后各增加一个
+
+        check_columns = [self.LIQU_HIGH_COL]
+
+        try:
+            self.check_columns(df, check_columns) 
+        except ValueError as e:
+            self.logger.warning(f"DataFrame must contain columns {check_columns} : {str(e)}")
+            df = self._identify_liquidity_pivots(df)
+        diff_ratio = 0.0
+        if trend == self.BEARISH_TREND:
+            # 判断Bearish趋势是高点不断升高,
+            liqu_bear_df = df[df[self.LIQU_HIGH_COL] > 0]
+            liqu_bear_df[self.LIQU_HIGH_DIFF_COL] = liqu_bear_df[self.LIQU_HIGH_COL].diff()
+            # self.logger.info(f"dynamic_trendlines:\n {liqu_bear_df[[self.TIMESTAMP_COL,self.LIQU_HIGH_COL,self.LIQU_HIGH_DIFF_COL]]}")
+            diff_ratio = self.toDecimal(liqu_bear_df[self.LIQU_HIGH_DIFF_COL].dropna().lt(0).mean(),2)
+            if diff_ratio >= ratio:
+               return diff_ratio,True
+        else:
+            # Bullish趋势是低点不断降低
+            liqu_bullish_df = df[df[self.LIQU_LOW_COL] > 0]
+            liqu_bullish_df[self.LIQU_LOW_DIFF_COL] = liqu_bullish_df[self.LIQU_LOW_COL].diff()
+            # self.logger.info(f"dynamic_trendlines:\n {liqu_bullish_df[[self.TIMESTAMP_COL,self.LIQU_LOW_COL,self.LIQU_LOW_DIFF_COL]]}")
+            diff_ratio = self.toDecimal(liqu_bullish_df[self.LIQU_LOW_DIFF_COL].dropna().gt(0).mean(),2)
+            if diff_ratio >= ratio:
+               return diff_ratio,True
+
+        return diff_ratio,False
+
+
+        
+

core/smc/SMCOrderBlock.py

@@ -54,7 +54,7 @@ class SMCOrderBlock(SMCStruct):
             ob_df = ob_df[ob_df[self.OB_DIRECTION_COL] == direction]
 
         # 检查OB是否被平衡过
-
+        ob_df = ob_df.copy() 
         ob_df.loc[:, self.OB_WAS_CROSSED] = ob_df.apply(
             lambda row: any(
                 df.loc[row.name + 1 :, self.LOW_COL] <= row[self.OB_LOW_COL]
@@ -64,25 +64,7 @@ class SMCOrderBlock(SMCStruct):
             axis=1,
         )
 
-        ob_df = ob_df[~ob_df[self.OB_WAS_CROSSED]]
-
-        # # 过滤出有效的OB
-        # if is_valid is not None and not ob_df.empty:
-        #     valid_mask = []
-        #     for _, row in ob_df.iterrows():
-        #         start_idx = row[self.OB_START_INDEX_COL] + 1
-        #         if start_idx >= len(df):
-        #             valid = False
-        #         else:
-        #             future_data = df.loc[start_idx:]
-        #             if row[self.OB_DIRECTION_COL] == "Bullish":
-        #                 valid = row[self.OB_LOW_COL] < future_data[self.LOW_COL].min()
-        #             else:  # Bearish
-        #                 valid = row[self.OB_HIGH_COL] > future_data[self.HIGH_COL].max()
-
-        #         valid_mask.append(valid if is_valid else not valid)
-
-        #     ob_df = ob_df[pd.Series(valid_mask, index=ob_df.index)]
+        ob_df = ob_df[~ob_df[self.OB_WAS_CROSSED]]      
 
         if if_combine:
             # 合并OB
@@ -91,7 +73,7 @@ class SMCOrderBlock(SMCStruct):
         return ob_df
 
     def build_struct_for_ob(
-        self, df, window=20, is_struct_body_break=True, atr_multiplier=0.6
+        self, df, is_struct_body_break=True, atr_multiplier=0.6
     ):
         """
         构建结构并检测Order Block
@@ -107,7 +89,7 @@ class SMCOrderBlock(SMCStruct):
             处理后的数据框,包含结构和Order Block相关列
         """
         # 首先构建基础结构
-        df = self.build_struct(df, window, is_struct_body_break)
+        df = self.build_struct(df, is_struct_body_break)
 
         check_columns = [self.HIGH_COL, self.LOW_COL, self.CLOSE_COL]
         self.check_columns(df, check_columns)
@@ -256,22 +238,30 @@ class SMCOrderBlock(SMCStruct):
         # df.at[i, self.OB_START_TS_COL] = df.loc[index, self.TIMESTAMP_COL]
         df.at[index, self.OB_ATR] = atr
 
-    def get_last_ob(self, df, prd=-1):
+    def get_lastest_OB(self, data, trend, start_index=-1):
         """
         获取最新的Order Block
 
         Args:
-            df: 包含OB信息的数据框
-            prd: 回溯周期，-1表示全部
+            df: 数据框
+            trend: 趋势，"Bullish" 或 "Bearish"
 
         Returns:
             最新的Order Block信息或None
         """
         # 获取prd范围内的数据
-        start_idx = max(0, len(df) - 1 - prd) if prd > 0 else 0
+        df = (
+            data.copy()
+            if start_index == -1
+            else data.copy().iloc[start_index :]
+        )
+
+        # 检查数据中是否包含必要的列
+        check_columns = [self.OB_DIRECTION_COL]
+        self.check_columns(df, check_columns)
 
         # 筛选有效OB且在prd范围内的数据
-        mask = df[self.OB_DIRECTION_COL].notna() & (df.index >= start_idx)
+        mask = df[self.OB_DIRECTION_COL] == trend
         valid_obs = df[mask]
 
         if not valid_obs.empty:
@@ -283,6 +273,8 @@ class SMCOrderBlock(SMCStruct):
                 self.OB_MID_COL: last_ob[self.OB_MID_COL],
                 self.OB_VOLUME_COL: last_ob[self.OB_VOLUME_COL],
                 self.OB_DIRECTION_COL: last_ob[self.OB_DIRECTION_COL],
+                self.OB_ATR: last_ob[self.OB_ATR],
+                self.OB_WAS_CROSSED: last_ob[self.OB_WAS_CROSSED],
             }
 
         return None

core/smc/SMCPDArray.py

@@ -36,8 +36,6 @@ class SMCPDArray(SMCFVG,SMCOrderBlock):
             if start_index == -1
             else struct.copy().iloc[max(0, start_index - 1) :]
         )
-        # check_columns = [self.HIGH_COL, self.LOW_COL, self.CLOSE_COL]
-        # self.check_columns(df, check_columns)
 
         df_FVGs = self.find_FVGs(df, side)
         # self.logger.info(f"fvgs:\n{df_FVGs[['timestamp', self.FVG_SIDE, self.FVG_TOP, self.FVG_BOT, self.FVG_WAS_BALANCED]]}")

core/smc/SMCStruct.py

@@ -4,9 +4,12 @@ from core.utils.OPTools import OPTools
 from core.smc.SMCBase import SMCBase
 
 class SMCStruct(SMCBase):
+    BULLISH_TREND = 'Bullish'
+    BEARISH_TREND = 'Bearish'
     STRUCT_COL = "struct"
     STRUCT_HIGH_COL = "struct_high"
     STRUCT_LOW_COL = "struct_low"
+    STRUCT_MID_COL = "struct_mid"
     STRUCT_HIGH_INDEX_COL = "struct_high_index"
     STRUCT_LOW_INDEX_COL = "struct_low_index"
     STRUCT_DIRECTION_COL = "struct_direction"
@@ -16,10 +19,9 @@ class SMCStruct(SMCBase):
     def __init__(self):  
         super().__init__()
         self.logger = logging.getLogger(__name__)
-
-        
+      
    
-    def build_struct(self, data, window=10, is_struct_body_break=True):
+    def build_struct(self, data, is_struct_body_break=True):
         """处理价格结构,识别高低点突破和结构方向
         
         Args:
@@ -30,7 +32,8 @@ class SMCStruct(SMCBase):
         Returns:
             处理后的数据框,包含结构相关列
         """
-        df = data.copy()
+        # 复制数据并去掉最后一条记录，因为最后一条记录不是完成状态的K线
+        df = data.copy().iloc[:-1]
         check_columns = [self.HIGH_COL, self.LOW_COL, self.CLOSE_COL]
         self.check_columns(df, check_columns)
         
@@ -46,7 +49,7 @@ class SMCStruct(SMCBase):
             self.STRUCT_LOW_COL: self.toDecimal('0.0'),  # 结构低点价格初始化为0
             self.STRUCT_HIGH_INDEX_COL: 0,  # 结构高点索引初始化为0 
             self.STRUCT_LOW_INDEX_COL: 0,  # 结构低点索引初始化为0
-            self.STRUCT_DIRECTION_COL: 0  # 结构方向初始化为0
+            self.STRUCT_DIRECTION_COL: None  # 结构方向初始化为0
         }
         
         # 为每个结构列赋默认值
@@ -103,7 +106,7 @@ class SMCStruct(SMCBase):
             if is_low_broken:
                 # 处理低点突破
                 structure = self._handle_structure_break(
-                    df, i, window, structure,
+                    df, i, structure,
                     break_type=self.LOW_COL,
                     struct_type='BOS' if structure['direction'] == 1 else 'CHOCH'
                 )
@@ -111,7 +114,7 @@ class SMCStruct(SMCBase):
             elif is_high_broken:
                 # 处理高点突破
                 structure = self._handle_structure_break(
-                    df, i, window, structure,
+                    df, i, structure,
                     break_type=self.HIGH_COL, 
                     struct_type='BOS' if structure['direction'] == 2 else 'CHOCH'
                 )
@@ -128,7 +131,7 @@ class SMCStruct(SMCBase):
 
         return df
 
-    def _get_structure_extreme_bar(self, df, bar_index,  struct_index, lookback=10, mode='high'):
+    def _get_structure_extreme_bar(self, df, bar_index,  struct_index, mode='high'):
         """
         获取结构最高点或最低点
         :param df: DataFrame数据
@@ -199,7 +202,7 @@ class SMCStruct(SMCBase):
         
         return basic_break or direction_break
 
-    def _handle_structure_break(self, df, i, window, structure, break_type, struct_type):
+    def _handle_structure_break(self, df, i, structure, break_type, struct_type):
         """处理结构突破"""
         is_high_break = break_type == self.HIGH_COL
         
@@ -207,7 +210,7 @@ class SMCStruct(SMCBase):
         
         # 获取新的极值点
         extreme_idx = self._get_structure_extreme_bar(
-            df, i, struct_start, window, 
+            df, i, struct_start,  
             mode=self.LOW_COL if is_high_break else self.HIGH_COL
         )
         
@@ -231,8 +234,9 @@ class SMCStruct(SMCBase):
             })
             
         # 更新DataFrame结构信息
-        df.at[i, 'struct_direction'] = new_structure['direction']
-        df.at[i, 'struct'] = f"{'Bullish' if is_high_break else 'Bearish'}_{struct_type}"
+        # df.at[i, self.STRUCT_DIRECTION_COL] = new_structure['direction'] 
+        df.at[i, self.STRUCT_DIRECTION_COL] = self.BULLISH_TREND if is_high_break else self.BEARISH_TREND
+        df.at[i, self.STRUCT_COL] = f"{self.BULLISH_TREND if is_high_break else self.BEARISH_TREND}_{struct_type}"
         
         return new_structure
 
@@ -261,18 +265,22 @@ class SMCStruct(SMCBase):
         df.at[i, self.STRUCT_HIGH_INDEX_COL] = structure[self.HIGH_START_COL]
         df.at[i, self.STRUCT_LOW_INDEX_COL] = structure[self.LOW_START_COL]
 
-    def get_last_struct(self, df, prd=-1):
+    def get_last_struct(self, df):
         """
         获取最新的结构
         """
-        data = self.build_struct(df=df, window=10)
-        # 筛选出有效的结构
+        check_columns = [self.STRUCT_COL]
+        # if not self.check_columns(df, check_columns):
+        try :
+            self.check_columns(df, check_columns)
+        except ValueError as e:
+            df = self.build_struct(df)
+ 
+        data = df.copy()
        
-        # 获取prd范围内的数据
-        start_idx = max(0, len(data) - 1 - prd)
         # 筛选有效结构且在prd范围内的数据
         last_struct = None
-        mask = data[self.STRUCT_COL].notna() & (data.index >= start_idx) if prd > 0 else data[self.STRUCT_COL].notna()
+        mask = data[self.STRUCT_COL].notna()
         valid_structs = data[ mask ]
         if not valid_structs.empty:
             # 获取最近的结构
@@ -281,6 +289,7 @@ class SMCStruct(SMCBase):
                 self.STRUCT_COL: last_struct[self.STRUCT_COL],
                 self.STRUCT_HIGH_COL: last_struct[self.STRUCT_HIGH_COL],
                 self.STRUCT_LOW_COL: last_struct[self.STRUCT_LOW_COL], 
+                self.STRUCT_MID_COL: (last_struct[self.STRUCT_HIGH_COL] + last_struct[self.STRUCT_LOW_COL]) / 2,
                 self.STRUCT_HIGH_INDEX_COL: last_struct[self.STRUCT_HIGH_INDEX_COL],
                 self.STRUCT_LOW_INDEX_COL: last_struct[self.STRUCT_LOW_INDEX_COL],
                 self.STRUCT_DIRECTION_COL: last_struct[self.STRUCT_DIRECTION_COL]

{openfund_core-1.0.1.dist-info → openfund_core-1.0.7.dist-info}/METADATA

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

openfund_core-1.0.7.dist-info/RECORD

@@ -0,0 +1,15 @@
+core/Exchange.py,sha256=MDhV71jmWyM1IGaUI-iSfZqrUG9RNOpSWqm0jNV_GXU,23173
+core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/main.py,sha256=E-VZzem7-0_J6EmOo9blLPokc5MRcgjqCbqAvbkPnWI,630
+core/smc/SMCBase.py,sha256=epRC5bWDymx7ZMIhn_bVJRjvBHItt6BCnYASO2fhSDg,4302
+core/smc/SMCFVG.py,sha256=QtqlW1oooYVA7CG5ld5X0Q5twX1XCELO118IlMUhX6M,2974
+core/smc/SMCLiquidity.py,sha256=EkfyBVXmAiRihof6w3YJvRHlbwUtqag8S6aVrV_XWvc,8100
+core/smc/SMCOrderBlock.py,sha256=Il5JKmVER2vT6AKZLo0mD4wRqV_Op9IBK3jB1SfgTqY,9894
+core/smc/SMCPDArray.py,sha256=Vn_nTBLaIhrBhxe_hX3Iycn0gY0tmYd_qaqNalztfmA,2841
+core/smc/SMCStruct.py,sha256=BIp5CIipLtOq-Z7aXhHK8KwjdPZzg2_7TVANirO-HlY,12337
+core/smc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/utils/OPTools.py,sha256=tJ1Jq_Caab6OWaX12xn4_g9ryf98Rm5I1zsJEEU8NIQ,1002
+openfund_core-1.0.7.dist-info/METADATA,sha256=tLNUyBlVeEkAKu1QyHltTgtvMmGUH_OUuOgjTNmGq3I,1953
+openfund_core-1.0.7.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+openfund_core-1.0.7.dist-info/entry_points.txt,sha256=g8GUw3cyKFtcG5VWs8geU5VBLqiWr59GElqERuH8zD0,48
+openfund_core-1.0.7.dist-info/RECORD,,

{openfund_core-1.0.1.dist-info → openfund_core-1.0.7.dist-info}/WHEEL

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

openfund_core-1.0.1.dist-info/RECORD

@@ -1,15 +0,0 @@
-core/Exchange.py,sha256=_nAQy0frzaY4LHWwmDvJPmjX2BNsBz-fAPi1cPTpPRc,10799
-core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-core/main.py,sha256=E-VZzem7-0_J6EmOo9blLPokc5MRcgjqCbqAvbkPnWI,630
-core/smc/SMCBase.py,sha256=epRC5bWDymx7ZMIhn_bVJRjvBHItt6BCnYASO2fhSDg,4302
-core/smc/SMCFVG.py,sha256=QtqlW1oooYVA7CG5ld5X0Q5twX1XCELO118IlMUhX6M,2974
-core/smc/SMCLiquidity.py,sha256=lZt2IQk3TWaT-nA7he57dUxPdLEWW61jRZWLAzOTat0,119
-core/smc/SMCOrderBlock.py,sha256=hdY9X_9xrlbUGQGyXjzf-Un-XWgf3QihSWVgzefyP18,10378
-core/smc/SMCPDArray.py,sha256=yf-ZVabQhe1xcYz2gsETHpTJCSsMiUyPVQ6DdAiUd4U,2961
-core/smc/SMCStruct.py,sha256=m_LsVlwGXZjDLovSO1Swvvx5JLCsJ5VYwvP-CAM3KzY,11926
-core/smc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-core/utils/OPTools.py,sha256=tJ1Jq_Caab6OWaX12xn4_g9ryf98Rm5I1zsJEEU8NIQ,1002
-openfund_core-1.0.1.dist-info/METADATA,sha256=9PvQQtpzuz4LG5hQFaXJ83vpOaz01DTz37NRH9Fkf0E,1953
-openfund_core-1.0.1.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-openfund_core-1.0.1.dist-info/entry_points.txt,sha256=g8GUw3cyKFtcG5VWs8geU5VBLqiWr59GElqERuH8zD0,48
-openfund_core-1.0.1.dist-info/RECORD,,