openfund-core 1.0.5__tar.gz → 1.0.7__tar.gz

{openfund_core-1.0.5 → openfund_core-1.0.7}/PKG-INFO

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

{openfund_core-1.0.5 → openfund_core-1.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "openfund-core"
-version = "1.0.5"
+version = "1.0.7"
 description = "Openfund-core."
 authors = []
 readme = "README.md"

{openfund_core-1.0.5 → openfund_core-1.0.7}/src/core/Exchange.py

@@ -31,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
@@ -61,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:
@@ -105,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
@@ -262,7 +320,7 @@ class Exchange:
         
         max_retries = 3
         retry_count = 0
-        self.logger.debug(f"{symbol} : Pre Algo Order placed:  {order} ")
+        self.logger.info(f"{symbol} : Pre Algo Order placed:  {order} ")
         while retry_count < max_retries:
             try:
                 
@@ -355,10 +413,11 @@ class Exchange:
         max_retries = 3
         retry_count = 0
 
+        self.logger.info(f"{symbol} : Pre Order placed:  {order} ")
+        
         while retry_count < max_retries:
             try:
                 # 使用ccxt创建订单
-                self.logger.debug(f"{symbol} : Pre Order placed:  {order} ")
                 order_result = self.exchange.create_order(
                     **order
                     # symbol=symbol,
@@ -371,24 +430,24 @@ class Exchange:
             except ccxt.NetworkError as e:
                 # 处理网络相关错误
                 retry_count += 1
-                self.logger.warning(f"{symbol} : 设置下单时发生网络错误,正在进行第{retry_count}次重试: {str(e)}")
+                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)}")
+                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)}")
+                self.logger.warning(f"{symbol} : 下单时发生未知错误,正在进行第{retry_count}次重试: {str(e)}")
                 time.sleep(0.1)
                 continue
         if retry_count >= max_retries:
             # 重试次数用完仍未成功设置止损单
-            error_message = f"!! {symbol}: 设置止盈止损单时重试次数用完仍未成功设置成功。 "
+            error_message = f"!! {symbol}: 下单时重试次数用完仍未成功设置成功。 "
             self.logger.error(error_message)
             raise Exception(error_message)        
         self.logger.debug(f"{symbol} : --------- ++ Order placed done. --------")  

openfund_core-1.0.7/src/core/smc/SMCLiquidity.py

@@ -0,0 +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"
+
+
+    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
+
+
+        
+

{openfund_core-1.0.5 → openfund_core-1.0.7}/src/core/smc/SMCStruct.py

@@ -270,10 +270,13 @@ class SMCStruct(SMCBase):
         获取最新的结构
         """
         check_columns = [self.STRUCT_COL]
-        if not self.check_columns(df, check_columns):
-            data = self.build_struct(df=df)
-        else:
-            data = df.copy()
+        # 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范围内的数据
         last_struct = None

openfund_core-1.0.5/src/core/smc/SMCLiquidity.py

@@ -1,7 +0,0 @@
-import logging
-
-class SMCLiquidity:
-    def __init__(self):
-        self.logger = logging.getLogger(__name__)
-   
-