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

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

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

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

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

{openfund_core-1.0.7 → openfund_core-1.0.9}/src/core/smc/SMCFVG.py

@@ -47,12 +47,12 @@ class SMCFVG(SMCStruct):
         # 使用向量化操作替代apply，提高性能
         if side == self.BUY_SIDE:
             condition = df[self.HIGH_COL].shift(1) < df[self.LOW_COL].shift(-1)
-            side_value = "Bullish"
+            side_value = self.BULLISH_TREND
             price_top = df[self.LOW_COL].shift(-1)
             price_bot = df[self.HIGH_COL].shift(1)
         else:
             condition = df[self.LOW_COL].shift(1) > df[self.HIGH_COL].shift(-1)
-            side_value = "Bearish" 
+            side_value = self.BEARISH_TREND
             price_top = df[self.LOW_COL].shift(1)
             price_bot = df[self.HIGH_COL].shift(-1)
 
@@ -64,9 +64,9 @@ class SMCFVG(SMCStruct):
         df.loc[:, self.FVG_MID] = (df[self.FVG_TOP] + df[self.FVG_BOT]) / 2
 
         fvg_df = df[
-            df[self.FVG_SIDE] == "Bullish"
+            df[self.FVG_SIDE] == self.BULLISH_TREND
             if side == self.BUY_SIDE
-            else df[self.FVG_SIDE] == "Bearish"
+            else df[self.FVG_SIDE] == self.BEARISH_TREND
         ]
         fvg_df = fvg_df.copy()
         if check_balanced:

{openfund_core-1.0.7 → openfund_core-1.0.9}/src/core/smc/SMCLiquidity.py

@@ -1,9 +1,7 @@
 import logging
-from re import S
-import pandas as pd
+from decimal import Decimal
 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"
@@ -30,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:
@@ -66,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.7 → openfund_core-1.0.9}/src/core/smc/SMCOrderBlock.py

@@ -34,7 +34,7 @@ class SMCOrderBlock(SMCStruct):
             symbol (_type_): _description_
             data (pd.DataFrame): _description_
             side (_type_): _description_ 如果是None, 则返回所有OB boxes（包括bullish和bearish）
-            pivot_index (int): _description_ 开始的位置
+            start_index (int): _description_ 开始的位置
             is_valid (bool): _description_ 找到有效的OB，没有被crossed
             if_combine (bool): _description_ 是否合并OB
         Returns:
@@ -63,8 +63,8 @@ class SMCOrderBlock(SMCStruct):
             else any(df.loc[row.name + 1 :, self.HIGH_COL] >= row[self.OB_HIGH_COL]),
             axis=1,
         )
-
-        ob_df = ob_df[~ob_df[self.OB_WAS_CROSSED]]      
+        if is_valid :
+            ob_df = ob_df[~ob_df[self.OB_WAS_CROSSED]]      
 
         if if_combine:
             # 合并OB
@@ -238,7 +238,7 @@ 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_lastest_OB(self, data, trend, start_index=-1):
+    def get_latest_OB(self, data, trend, start_index=-1):
         """
         获取最新的Order Block
 

openfund_core-1.0.9/src/core/smc/SMCPDArray.py

@@ -0,0 +1,126 @@
+import logging
+import pandas as pd
+
+from core.smc.SMCFVG import SMCFVG
+from core.smc.SMCOrderBlock import SMCOrderBlock
+
+class SMCPDArray(SMCFVG,SMCOrderBlock):
+    PD_HIGH_COL = "pd_high"
+    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, balanced=False,
+    ) -> pd.DataFrame:
+        """_summary_
+            寻找PDArrays,包括Fair Value Gap (FVG)|Order Block (OB)|Breaker Block(BB)|Mitigation Block(BB) 
+        Args:
+            data (pd.DataFrame): K线数据
+            side (_type_): 交易方向 'buy'|'sell'
+            start_index (int): 开始查找索引的起点,默认为-1
+            balanced (bool): PD是否有效,默认为False。PD被crossed过,则是无效PD
+
+        Returns:
+            pd.DataFrame: _description_
+
+        """
+       
+        df = (
+            struct.copy()
+            if start_index == -1
+            else struct.copy().iloc[max(0, start_index - 1) :]
+        )
+
+        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]]}")
+
+        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)
+        
+        # 使用更简洁的方式重命名和合并时间戳列
+        timestamp_mapping = {self.TIMESTAMP_COL: ['ts_OBs', 'ts_FVGs']}
+        df_OBs = df_OBs.rename(columns={self.TIMESTAMP_COL: timestamp_mapping[self.TIMESTAMP_COL][0]})
+        df_FVGs = df_FVGs.rename(columns={self.TIMESTAMP_COL: timestamp_mapping[self.TIMESTAMP_COL][1]})
+
+        # 使用更高效的方式合并数据框
+        df_PDArrays = pd.concat(
+            [df_OBs, df_FVGs], 
+            axis=1,
+            join='outer'
+        ).sort_index()
+
+        # 使用更清晰的方式合并时间戳列
+        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
+        )
+     
+        df_PDArrays.loc[:, self.PD_HIGH_COL] = df_PDArrays[[self.FVG_TOP, self.OB_HIGH_COL]].max(axis=1)
+        df_PDArrays.loc[:, self.PD_LOW_COL] = df_PDArrays[[self.FVG_BOT, self.OB_LOW_COL]].min(axis=1)
+        df_PDArrays.loc[:, self.PD_MID_COL] = (df_PDArrays[self.PD_HIGH_COL] + df_PDArrays[self.PD_LOW_COL]) / 2
+               
+
+        # 根据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, balanced=False, mask=None) -> dict:
+        """_summary_
+            过滤PDArrays,只保留指定方向的PDArrays
+        Args:
+            df_PDArrays (pd.DataFrame): _description_
+            mask (str): _description_
+
+        Returns:
+            pd.DataFrame: _description_
+        """   
+
+        # 检查数据中是否包含必要的列
+        df = df_PDArrays.copy()
+        check_columns = [self.STRUCT_COL]
+        try:
+            self.check_columns(df, check_columns)
+        except ValueError as e:
+            df = self.build_struct(df)
+
+
+        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],
+                self.PD_TYPE_COL: last_pd[self.PD_TYPE_COL],
+                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],
+            }

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

@@ -265,7 +265,7 @@ 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):
+    def get_latest_struct(self, df):
         """
         获取最新的结构
         """

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

@@ -1,75 +0,0 @@
-import logging
-import pandas as pd
-
-from core.smc.SMCFVG import SMCFVG
-from core.smc.SMCOrderBlock import SMCOrderBlock
-
-class SMCPDArray(SMCFVG,SMCOrderBlock):
-    PD_HIGH_COL = "pd_high"
-    PD_LOW_COL = "pd_low"
-    PD_MID_COL = "pd_mid"
-    PD_TYPE_COL = "pd_type"
-
-    def __init__(self):
-        super().__init__()
-        self.logger = logging.getLogger(__name__)
-
-    def find_PDArrays(
-        self, struct: pd.DataFrame, side, start_index=-1
-    ) -> pd.DataFrame:
-        """_summary_
-            寻找PDArrays,包括Fair Value Gap (FVG)|Order Block (OB)|Breaker Block(BB)|Mitigation Block(BB) 
-        Args:
-            data (pd.DataFrame): K线数据
-            side (_type_): 交易方向 'buy'|'sell'
-            threshold (_type_): 阈值价格，通常为溢价和折价区的CE
-            check_balanced (bool): 是否检查FVG是否被平衡过,默认为True
-            start_index (int): 开始查找索引的起点,默认为-1
-
-        Returns:
-            pd.DataFrame: _description_
-
-        """
-       
-        df = (
-            struct.copy()
-            if start_index == -1
-            else struct.copy().iloc[max(0, start_index - 1) :]
-        )
-
-        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]]}")
-
-
-        df_OBs = self.find_OBs(df, side)
-        # self.logger.info("find_OBs:\n %s", df_OBs)
-        
-        # 使用更简洁的方式重命名和合并时间戳列
-        timestamp_mapping = {self.TIMESTAMP_COL: ['ts_OBs', 'ts_FVGs']}
-        df_OBs = df_OBs.rename(columns={self.TIMESTAMP_COL: timestamp_mapping[self.TIMESTAMP_COL][0]})
-        df_FVGs = df_FVGs.rename(columns={self.TIMESTAMP_COL: timestamp_mapping[self.TIMESTAMP_COL][1]})
-
-        # 使用更高效的方式合并数据框
-        df_PDArrays = pd.concat(
-            [df_OBs, df_FVGs], 
-            axis=1,
-            join='outer'
-        ).sort_index()
-
-        # 使用更清晰的方式合并时间戳列
-        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_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
-        )
-     
-        df_PDArrays.loc[:, self.PD_HIGH_COL] = df_PDArrays[[self.FVG_TOP, self.OB_HIGH_COL]].max(axis=1)
-        df_PDArrays.loc[:, self.PD_LOW_COL] = df_PDArrays[[self.FVG_BOT, self.OB_LOW_COL]].min(axis=1)
-        df_PDArrays.loc[:, self.PD_MID_COL] = (df_PDArrays[self.PD_HIGH_COL] + df_PDArrays[self.PD_LOW_COL]) / 2
-        
-        
-        
-
-        return df_PDArrays
-