openfund-core 1.0.8__tar.gz → 1.0.10__tar.gz

{openfund_core-1.0.8 → openfund_core-1.0.10}/PKG-INFO

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

{openfund_core-1.0.8 → openfund_core-1.0.10}/pyproject.toml

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

{openfund_core-1.0.8 → openfund_core-1.0.10}/src/core/Exchange.py

@@ -24,8 +24,6 @@ class Exchange:
         self.exchange = getattr(ccxt, exchangeKey)(config)
         self.logger = logging.getLogger(__name__)
 
-
-
     def getMarket(self, symbol:str):
         # 配置交易对
         self.exchange.load_markets()
@@ -61,9 +59,7 @@ class Exchange:
 
     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:
             # 设置杠杆
@@ -166,8 +162,7 @@ class Exchange:
                 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
         retry_count = 0
@@ -257,6 +252,7 @@ class Exchange:
                    
                 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:
         """
         下单
@@ -323,47 +319,23 @@ class Exchange:
         self.logger.info(f"{symbol} : Pre Algo Order placed:  {order} ")
         while retry_count < max_retries:
             try:
+                # 创建订单
+                order_result = self.exchange.create_order(**order)
+                self.logger.info(f"{symbol} : --------- ++ Algo Order placed done. --------")
+                return True
                 
-                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相关错误
+            except (ccxt.NetworkError, ccxt.ExchangeError, Exception) as e:
                 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)}")
+                error_type = "网络" if isinstance(e, ccxt.NetworkError) else "交易所" if isinstance(e, ccxt.ExchangeError) else "未知"
+                self.logger.warning(f"{symbol} : 设置止盈止损单时发生{error_type}错误,正在进行第{retry_count}次重试: {str(e)}")
+                
+                if retry_count == max_retries:
+                    error_message = f"!! {symbol}: 设置止盈止损单失败(重试{max_retries}次): {str(e)}"
+                    self.logger.error(error_message)
+                    raise Exception(error_message)
+                    
                 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', params={}) -> bool: 
         """
         下单
@@ -418,40 +390,18 @@ class Exchange:
         while retry_count < max_retries:
             try:
                 # 使用ccxt创建订单
-                order_result = self.exchange.create_order(
-                    **order
-                    # symbol=symbol,
-                    # type='limit',
-                    # side=side,
-                    # amount=amount_usdt,
-                    # price=float(adjusted_price),
-                    # params=params
-                )
-            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:
-                # 处理其他未预期的错误
+                order_result = self.exchange.create_order(**order)
+                self.logger.info(f"{symbol} : --------- ++ Order placed done. --------")  
+                return True
+            except (ccxt.NetworkError, ccxt.ExchangeError, 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
+                error_type = "网络" if isinstance(e, ccxt.NetworkError) else "交易所" if isinstance(e, ccxt.ExchangeError) else "未知"
+                self.logger.warning(f"{symbol} : 下单时发生{error_type}错误,正在进行第{retry_count}次重试: {str(e)}")
+                if retry_count == max_retries:
+                    error_message = f"!! {symbol}: 下单时重试{max_retries}次后仍未成功：{str(e)}"
+                    self.logger.error(error_message)
+                    raise Exception(error_message)
+                time.sleep(1)
       
     def fetch_position(self, symbol):
         """_summary_
@@ -523,6 +473,7 @@ class Exchange:
                    
                 self.logger.warning(f"{symbol} : Error fetching open orders: {str(e)}")
                 time.sleep(0.1)  # 重试前等待0.1秒     
+    
     def get_market_price(self, symbol) -> Decimal:
         """
         获取最新价格

{openfund_core-1.0.8 → openfund_core-1.0.10}/src/core/smc/SMCLiquidity.py

@@ -1,4 +1,5 @@
 import logging
+from decimal import Decimal
 from core.smc.SMCStruct import SMCStruct
 
 
@@ -27,20 +28,17 @@ class SMCLiquidity(SMCStruct):
         df = data.copy()
         
         # 识别高点
-        df[self.LIQU_HIGH_COL] = 0
+        df[self.LIQU_HIGH_COL] = Decimal(0.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.loc[df.index[i], self.LIQU_HIGH_COL] = df[self.HIGH_COL].iloc[i]        
         # 识别低点
-        df[self.LIQU_LOW_COL] = 0
+        df[self.LIQU_LOW_COL] = Decimal(0.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:
@@ -63,7 +61,7 @@ class SMCLiquidity(SMCStruct):
         try:
             self.check_columns(df, check_columns) 
         except ValueError as e:
-            self.logger.warning(f"DataFrame must contain columns {check_columns} : {str(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)]

{openfund_core-1.0.8 → openfund_core-1.0.10}/src/core/smc/SMCPDArray.py

@@ -9,13 +9,14 @@ class SMCPDArray(SMCFVG,SMCOrderBlock):
     PD_LOW_COL = "pd_low"
     PD_MID_COL = "pd_mid"
     PD_TYPE_COL = "pd_type"
+    PD_WAS_BALANCED_COL = "pd_was_balanced"
 
     def __init__(self):
         super().__init__()
         self.logger = logging.getLogger(__name__)
 
     def find_PDArrays(
-        self, struct: pd.DataFrame, side, start_index=-1, check_balanced=True,
+        self, struct: pd.DataFrame, side, start_index=-1, balanced=False,
     ) -> pd.DataFrame:
         """_summary_
             寻找PDArrays,包括Fair Value Gap (FVG)|Order Block (OB)|Breaker Block(BB)|Mitigation Block(BB) 
@@ -23,7 +24,7 @@ class SMCPDArray(SMCFVG,SMCOrderBlock):
             data (pd.DataFrame): K线数据
             side (_type_): 交易方向 'buy'|'sell'
             start_index (int): 开始查找索引的起点,默认为-1
-            check_balanced (bool): PD是否有效,默认为True。PD被crossed过,则是无效PD
+            balanced (bool): PD是否有效,默认为False。PD被crossed过,则是无效PD
 
         Returns:
             pd.DataFrame: _description_
@@ -36,11 +37,14 @@ class SMCPDArray(SMCFVG,SMCOrderBlock):
             else struct.copy().iloc[max(0, start_index - 1) :]
         )
 
-        df_FVGs = self.find_FVGs(df, side, check_balanced, start_index)
-        # self.logger.info(f"fvgs:\n{df_FVGs[['timestamp', self.FVG_SIDE, self.FVG_TOP, self.FVG_BOT, self.FVG_WAS_BALANCED]]}")
+        df_FVGs = self.find_FVGs(df, side, start_index)
 
+        if not balanced:
+            df_FVGs = df_FVGs[~df_FVGs[self.FVG_WAS_BALANCED]]
+        # self.logger.info(f"fvgs:\n{df_FVGs[['timestamp', self.FVG_SIDE, self.FVG_TOP, self.FVG_BOT, self.FVG_WAS_BALANCED]]}")
 
-        df_OBs = self.find_OBs(df, side, start_index, is_valid=check_balanced)
+        is_valid = not balanced
+        df_OBs = self.find_OBs(struct=df, side=side, start_index=start_index, is_valid=is_valid)
         # self.logger.info("find_OBs:\n %s", df_OBs)
         
         # 使用更简洁的方式重命名和合并时间戳列
@@ -59,6 +63,10 @@ class SMCPDArray(SMCFVG,SMCOrderBlock):
         df_PDArrays[self.TIMESTAMP_COL] = df_PDArrays[timestamp_mapping[self.TIMESTAMP_COL][0]].fillna(
             df_PDArrays[timestamp_mapping[self.TIMESTAMP_COL][1]]
         )
+
+        df_PDArrays[self.PD_WAS_BALANCED_COL] = df_PDArrays[[self.OB_WAS_CROSSED, self.FVG_WAS_BALANCED]].apply(
+            lambda x: x.iloc[0] if pd.notna(x.iloc[0]) else x.iloc[1], axis=1)
+
         df_PDArrays[self.PD_TYPE_COL] = df_PDArrays[[self.FVG_SIDE, self.OB_DIRECTION_COL]].apply(
             lambda x: 'FVG-OB' if pd.notna(x.iloc[0]) and pd.notna(x.iloc[1]) else 'FVG' if pd.notna(x.iloc[0]) else 'OB', axis=1
         )
@@ -68,10 +76,12 @@ class SMCPDArray(SMCFVG,SMCOrderBlock):
         df_PDArrays.loc[:, self.PD_MID_COL] = (df_PDArrays[self.PD_HIGH_COL] + df_PDArrays[self.PD_LOW_COL]) / 2
                
 
-        return df_PDArrays
+        # 根据balanced参数过滤PDArrays,返回符合条件的数据
+      
+        return df_PDArrays[df_PDArrays[self.PD_WAS_BALANCED_COL] == balanced]
 
 
-    def get_latest_PDArray(self, df_PDArrays: pd.DataFrame, side, start_index=-1, check_balanced=True, mask:str=None) -> dict:
+    def get_latest_PDArray(self, df_PDArrays: pd.DataFrame, side, start_index=-1, balanced=False, mask=None) -> dict:
         """_summary_
             过滤PDArrays,只保留指定方向的PDArrays
         Args:
@@ -89,16 +99,22 @@ class SMCPDArray(SMCFVG,SMCOrderBlock):
             self.check_columns(df, check_columns)
         except ValueError as e:
             df = self.build_struct(df)
-       
-        df = self.find_PDArrays(df, side, start_index, check_balanced)
 
-        if mask:
-            df = df[df[mask]]
+
+        check_columns = [self.PD_TYPE_COL]
+        try:
+            self.check_columns(df, check_columns)
+        except ValueError as e:
+            df = self.find_PDArrays(df, side, start_index, balanced)
+        
+        if mask is not None:
+            df = df[mask]
             
         if len(df) == 0:
             self.logger.info("未找到PDArray.")
             return None
         else:
+            self.logger.debug(f"PDArray:\n{df[[self.TIMESTAMP_COL, self.PD_TYPE_COL, self.PD_HIGH_COL, self.PD_LOW_COL, self.PD_MID_COL,self.PD_WAS_BALANCED_COL,self.OB_WAS_CROSSED,self.FVG_WAS_BALANCED]]}")
             last_pd = df.iloc[-1]
             return {
                 self.TIMESTAMP_COL: last_pd[self.TIMESTAMP_COL],
@@ -106,4 +122,5 @@ class SMCPDArray(SMCFVG,SMCOrderBlock):
                 self.PD_HIGH_COL: last_pd[self.PD_HIGH_COL],
                 self.PD_LOW_COL: last_pd[self.PD_LOW_COL],
                 self.PD_MID_COL: last_pd[self.PD_MID_COL],
+                self.PD_WAS_BALANCED_COL: last_pd[self.PD_WAS_BALANCED_COL],
             }