openfund-core 0.0.4__py3-none-any.whl → 1.0.5__py3-none-any.whl

core/smc/SMCFVG.py

@@ -0,0 +1,86 @@
+import logging
+import pandas as pd
+
+from core.smc.SMCStruct import SMCStruct
+
+
+class SMCFVG(SMCStruct):
+    FVG_TOP = "fvg_top"
+    FVG_BOT = "fvg_bot"
+    FVG_MID = "fvg_mid"
+    FVG_SIDE = "fvg_side"
+    FVG_WAS_BALANCED = "fvg_was_balanced"
+
+    def __init__(self):
+        super().__init__()
+        self.logger = logging.getLogger(__name__)
+
+    def find_FVGs(
+        self, struct: pd.DataFrame, side, check_balanced=True, start_index=-1
+    ) -> pd.DataFrame:
+        """_summary_
+            寻找公允价值缺口
+        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_
+
+        """
+        # bug2.2.5_1，未到折价区，计算FVG需要前一根K线
+        # df = data.copy().iloc[pivot_index:]
+        df = (
+            struct.copy()
+            if start_index == -1
+            else struct.copy().iloc[max(0, start_index - 1) :]
+        )
+
+        # 检查数据中是否包含必要的列
+        check_columns = [self.HIGH_COL, self.LOW_COL]
+        self.check_columns(df, check_columns)
+
+        # 处理公允价值缺口
+        # 使用向量化操作替代apply，提高性能
+        if side == self.BUY_SIDE:
+            condition = df[self.HIGH_COL].shift(1) < df[self.LOW_COL].shift(-1)
+            side_value = "Bullish"
+            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" 
+            price_top = df[self.LOW_COL].shift(1)
+            price_bot = df[self.HIGH_COL].shift(-1)
+
+        df.loc[:, self.FVG_SIDE] = pd.Series(
+            [side_value if x else None for x in condition], index=df.index
+        )
+        df.loc[:, self.FVG_TOP] = price_top.where(condition, 0)
+        df.loc[:, self.FVG_BOT] = price_bot.where(condition, 0)
+        df.loc[:, self.FVG_MID] = (df[self.FVG_TOP] + df[self.FVG_BOT]) / 2
+
+        fvg_df = df[
+            df[self.FVG_SIDE] == "Bullish"
+            if side == self.BUY_SIDE
+            else df[self.FVG_SIDE] == "Bearish"
+        ]
+        fvg_df = fvg_df.copy()
+        if check_balanced:
+            # 检查FVG是否被平衡过
+            fvg_df.loc[:, self.FVG_WAS_BALANCED] = fvg_df.apply(
+                lambda row: any(df.loc[row.name + 2 :, self.LOW_COL] <= row[self.FVG_BOT])
+                if side == self.BUY_SIDE
+                else any(
+                    df.loc[row.name + 2 :, self.HIGH_COL] >= row[self.FVG_TOP]
+                ),  
+                axis=1,
+            )
+
+            fvg_df = fvg_df[~fvg_df[self.FVG_WAS_BALANCED]]
+
+        return fvg_df
+

core/smc/SMCLiquidity.py

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

core/smc/SMCOrderBlock.py

@@ -0,0 +1,280 @@
+import logging
+import pandas as pd
+
+from core.smc.SMCStruct import SMCStruct
+
+
+class SMCOrderBlock(SMCStruct):
+    OB_HIGH_COL = "ob_high"
+    OB_LOW_COL = "ob_low"
+    OB_MID_COL = "ob_mid"
+    OB_VOLUME_COL = "ob_volume"
+    OB_DIRECTION_COL = "ob_direction"  # 1: 向上突破, 2: 向下突破
+    # OB_START_INDEX_COL = "ob_start_index"
+    # OB_START_TS_COL = "ob_start_ts"
+    OB_ATR = "ob_atr"
+    OB_IS_COMBINED = "ob_is_combined"
+    OB_WAS_CROSSED = "ob_was_crossed"
+
+    def __init__(self):
+        super().__init__()
+        self.logger = logging.getLogger(__name__)
+
+    def find_OBs(
+        self,
+        struct: pd.DataFrame,
+        side=None,
+        start_index: int = -1,
+        is_valid: bool = True,
+        if_combine: bool = True,
+    ) -> pd.DataFrame:
+        """_summary_
+
+        Args:
+            symbol (_type_): _description_
+            data (pd.DataFrame): _description_
+            side (_type_): _description_ 如果是None, 则返回所有OB boxes（包括bullish和bearish）
+            pivot_index (int): _description_ 开始的位置
+            is_valid (bool): _description_ 找到有效的OB，没有被crossed
+            if_combine (bool): _description_ 是否合并OB
+        Returns:
+            list: _description_
+        """
+
+        df = struct.copy() if start_index == -1 else struct.copy().iloc[start_index:]
+        if self.OB_DIRECTION_COL not in df.columns:
+            df = self.build_struct_for_ob(df)
+
+        # 获取有效的OB数据
+        ob_df = df[df[self.OB_DIRECTION_COL].notna()]
+
+        # 根据side过滤并生成OB
+        if side is not None:
+            direction = "Bullish" if side == self.BUY_SIDE else "Bearish"
+            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]
+            )
+            if row[self.OB_DIRECTION_COL] == "Bullish"
+            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 if_combine:
+            # 合并OB
+            ob_df = self._combineOB(ob_df)
+
+        return ob_df
+
+    def build_struct_for_ob(
+        self, df, is_struct_body_break=True, atr_multiplier=0.6
+    ):
+        """
+        构建结构并检测Order Block
+
+        Args:
+            df: 数据框
+            window: 寻找结构极值的窗口大小
+            is_struct_body_break: 是否使用收盘价判断突破
+            ob_length: 搜索Order Block的回溯长度
+            atr_multiplier: ATR倍数阈值
+
+        Returns:
+            处理后的数据框,包含结构和Order Block相关列
+        """
+        # 首先构建基础结构
+        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)
+
+        # 初始化OB相关列
+        ob_columns = [
+            self.OB_HIGH_COL,
+            self.OB_LOW_COL,
+            self.OB_MID_COL,
+            self.OB_VOLUME_COL,
+            self.OB_DIRECTION_COL,
+            # self.OB_START_INDEX_COL,
+            # self.OB_START_TS_COL,
+            self.OB_ATR,
+        ]
+        for col in ob_columns:
+            df[col] = None
+
+        # 计算ATR用于阈值判断
+        df[self.ATR_COL] = self._calculate_atr(df)
+
+        # 检测Order Block
+        for i in range(1, len(df)):
+            # 检查是否为结构高点突破
+            if df.at[i, self.STRUCT_COL] and "Bullish" in df.at[i, self.STRUCT_COL]:
+                self._find_ob(df, i, atr_multiplier)
+
+            # 检查是否为结构低点突破
+            elif df.at[i, self.STRUCT_COL] and "Bearish" in df.at[i, self.STRUCT_COL]:
+                self._find_ob(df, i, atr_multiplier, is_bullish=False)
+
+        return df
+
+    def _combineOB(self, df_OBs, combine_atr_muiltiplier=0.2):
+        """
+        合并OB
+        """
+
+        df_ob = df_OBs.copy()
+        # 初始化 OB_IS_COMBINED 列为 0
+        df_ob[self.OB_IS_COMBINED] = 0
+
+        combine_atr_muiltiplier = self.toDecimal(combine_atr_muiltiplier)
+        # 遍历所有OB，检查是否需要合并
+        for i in range(len(df_ob)):
+            # 如果当前OB已被合并，跳过
+            if df_ob.iloc[i][self.OB_IS_COMBINED] == 1:
+                continue
+
+            current_direction = df_ob.iloc[i][self.OB_DIRECTION_COL]
+            current_mid = df_ob.iloc[i][self.OB_MID_COL]
+            current_atr = df_ob.iloc[i][self.OB_ATR]
+
+            # 检查后续的OB
+            for j in range(i + 1, len(df_ob)):
+                # 如果后续OB已被合并，跳过
+                if df_ob.iloc[j][self.OB_IS_COMBINED] == 1:
+                    continue
+
+                # 如果方向相同且中间价差值小于阈值，标记为已合并
+                if (
+                    df_ob.iloc[j][self.OB_DIRECTION_COL] == current_direction
+                    and abs(df_ob.iloc[j][self.OB_MID_COL] - current_mid)
+                    < current_atr * combine_atr_muiltiplier
+                ):
+                    df_ob.iloc[i, df_ob.columns.get_loc(self.OB_IS_COMBINED)] = 1
+                    break
+        # 遍历所有的OB
+
+        return df_ob
+
+    def _calculate_atr(self, df, period=200, multiplier=1):
+        return super().calculate_atr(df, period, multiplier)
+
+    def _find_ob(self, df, i, atr_multiplier, is_bullish=True):
+        """寻找Order Block
+        Args:
+            df: 数据框
+            i: 当前索引
+            ob_length: OB长度
+            atr_multiplier: ATR乘数
+            is_bullish: 是否为看涨OB,True为看涨,False为看跌
+        """
+        # 根据方向获取相应的结构索引和价格，OB是取结构开始的最高价或最低价的K线
+        if is_bullish:
+            index = df.loc[i, self.STRUCT_LOW_INDEX_COL]
+            extreme_price = df.loc[i, self.STRUCT_LOW_COL]
+
+            # Oper_func = min
+            src = self.toDecimal(df.loc[index, self.HIGH_COL])
+            direction = "Bullish"
+
+        else:
+            index = df.loc[i, self.STRUCT_HIGH_INDEX_COL]
+            extreme_price = df.loc[i, self.STRUCT_HIGH_COL]
+            # Oper_func = max
+            src = self.toDecimal(df.loc[index, self.LOW_COL])
+            direction = "Bearish"
+
+        # 计算累积成交量
+        vol = df.loc[index:i, self.VOLUME_COL].sum()
+
+        # 应用ATR阈值，如果OB的范围小于ATR(=20)的60%（20*0.6=12），则把OB可扩展到ATR(=20)范围。
+        precision = self.get_precision_length(extreme_price)
+        atr = self.toDecimal(df.loc[i, self.ATR_COL])
+        atr_multiplier = self.toDecimal(atr_multiplier)
+        if is_bullish:
+            # 计算当前区间大小
+            current_range = src - extreme_price
+            target_range = atr
+            if current_range < atr * atr_multiplier:
+                # 如果区间过小，将区间扩展到目标大小，并在中心点两侧平均分配
+                extend_amount = (target_range - current_range) / 2
+                src += extend_amount
+                extreme_price -= extend_amount
+
+            high, low = (
+                self.toDecimal(src, precision),
+                self.toDecimal(extreme_price, precision),
+            )
+        else:
+            # 计算当前区间大小
+            current_range = extreme_price - src
+            target_range = atr
+            if current_range < atr * atr_multiplier:
+                # 如果区间过小，将区间扩展到目标大小，并在中心点两侧平均分配
+                extend_amount = (target_range - current_range) / 2
+                src -= extend_amount
+                extreme_price += extend_amount
+
+            high, low = (
+                self.toDecimal(extreme_price, precision),
+                self.toDecimal(src, precision),
+            )
+
+        # 计算中间值
+        mid = (high + low) / 2
+
+        # 更新OB信息到DataFrame
+        df.at[index, self.OB_HIGH_COL] = high
+        df.at[index, self.OB_LOW_COL] = low
+        df.at[index, self.OB_MID_COL] = mid
+        df.at[index, self.OB_VOLUME_COL] = vol
+        df.at[index, self.OB_DIRECTION_COL] = direction
+        # df.at[i, self.OB_START_INDEX_COL] = index
+        # 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):
+        """
+        获取最新的Order Block
+
+        Args:
+            df: 数据框
+            trend: 趋势，"Bullish" 或 "Bearish"
+
+        Returns:
+            最新的Order Block信息或None
+        """
+        # 获取prd范围内的数据
+        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] == trend
+        valid_obs = df[mask]
+
+        if not valid_obs.empty:
+            # 获取最近的OB
+            last_ob = valid_obs.iloc[-1]
+            return {
+                self.OB_HIGH_COL: last_ob[self.OB_HIGH_COL],
+                self.OB_LOW_COL: last_ob[self.OB_LOW_COL],
+                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

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