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

core/smc/SMCOrderBlock.py

@@ -0,0 +1,288 @@
+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.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]]
+
+        # # 过滤出有效的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)]
+
+        if if_combine:
+            # 合并OB
+            ob_df = self._combineOB(ob_df)
+
+        return ob_df
+
+    def build_struct_for_ob(
+        self, df, window=20, 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, window, 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_last_ob(self, df, prd=-1):
+        """
+        获取最新的Order Block
+
+        Args:
+            df: 包含OB信息的数据框
+            prd: 回溯周期，-1表示全部
+
+        Returns:
+            最新的Order Block信息或None
+        """
+        # 获取prd范围内的数据
+        start_idx = max(0, len(df) - 1 - prd) if prd > 0 else 0
+
+        # 筛选有效OB且在prd范围内的数据
+        mask = df[self.OB_DIRECTION_COL].notna() & (df.index >= start_idx)
+        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],
+            }
+
+        return None

core/smc/SMCPDArray.py

@@ -0,0 +1,77 @@
+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) :]
+        )
+        # 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]]}")
+
+
+        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
+

core/smc/SMCStruct.py

@@ -0,0 +1,290 @@
+import logging
+import operator
+from core.utils.OPTools import OPTools
+from core.smc.SMCBase import SMCBase
+
+class SMCStruct(SMCBase):
+    STRUCT_COL = "struct"
+    STRUCT_HIGH_COL = "struct_high"
+    STRUCT_LOW_COL = "struct_low"
+    STRUCT_HIGH_INDEX_COL = "struct_high_index"
+    STRUCT_LOW_INDEX_COL = "struct_low_index"
+    STRUCT_DIRECTION_COL = "struct_direction"
+    HIGH_START_COL = "high_start"
+    LOW_START_COL = "low_start"
+
+    def __init__(self):  
+        super().__init__()
+        self.logger = logging.getLogger(__name__)
+
+        
+   
+    def build_struct(self, data, window=10, is_struct_body_break=True):
+        """处理价格结构,识别高低点突破和结构方向
+        
+        Args:
+            df: 数据框
+            window: 寻找结构极值的窗口大小
+            is_struct_body_break: 是否使用收盘价判断突破
+            
+        Returns:
+            处理后的数据框,包含结构相关列
+        """
+        df = data.copy()
+        check_columns = [self.HIGH_COL, self.LOW_COL, self.CLOSE_COL]
+        self.check_columns(df, check_columns)
+        
+        # 初始化结构相关列
+        # 定义结构相关的列名
+        struct_columns = [self.STRUCT_COL, self.STRUCT_HIGH_COL, self.STRUCT_LOW_COL, 
+                         self.STRUCT_HIGH_INDEX_COL, self.STRUCT_LOW_INDEX_COL, self.STRUCT_DIRECTION_COL]
+        
+        # 初始化结构相关列的默认值
+        default_values = {
+            self.STRUCT_COL: None,  # 结构类型列初始化为None
+            self.STRUCT_HIGH_COL: self.toDecimal('0.0'),  # 结构高点价格初始化为0
+            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
+        }
+        
+        # 为每个结构列赋默认值
+        for col in struct_columns:
+            df[col] = default_values[col]
+            
+        # 初始化结构变量
+        structure = {
+            self.HIGH_COL: df[self.HIGH_COL].iloc[0],
+            self.LOW_COL: df[self.LOW_COL].iloc[0],
+            self.HIGH_START_COL: -1,
+            self.LOW_START_COL: -1,
+            'direction': 0
+        }
+
+        # 确定突破判断列
+        break_price_col = self.CLOSE_COL if is_struct_body_break else self.HIGH_COL
+        break_price_col_low = self.CLOSE_COL if is_struct_body_break else self.LOW_COL
+
+        for i in range(1, len(df)):
+            curr_prices = {
+                self.HIGH_COL: df[break_price_col].iloc[i],
+                self.LOW_COL: df[break_price_col_low].iloc[i]
+            }
+            
+            # 获取前3根K线价格
+            prev_prices = {
+                self.HIGH_COL: df[break_price_col].iloc[i-3:i].values,
+                self.LOW_COL: df[break_price_col_low].iloc[i-3:i].values
+            }
+
+            # 判断结构突破
+            is_high_broken = self._check_structure_break(
+                curr_price=curr_prices[self.HIGH_COL],
+                struct_price=structure[self.HIGH_COL],
+                prev_prices=prev_prices[self.HIGH_COL],
+                struct_start=structure[self.HIGH_START_COL],
+                i=i,
+                direction=structure['direction'],
+                target_direction=1
+            )
+            
+            is_low_broken = self._check_structure_break(
+                curr_price=curr_prices[self.LOW_COL],
+                struct_price=structure[self.LOW_COL],
+                prev_prices=prev_prices[self.LOW_COL],
+                struct_start=structure[self.LOW_START_COL],
+                i=i,
+                direction=structure['direction'],
+                target_direction=2,
+                mode=self.LOW_COL
+            )
+
+            if is_low_broken:
+                # 处理低点突破
+                structure = self._handle_structure_break(
+                    df, i, window, structure,
+                    break_type=self.LOW_COL,
+                    struct_type='BOS' if structure['direction'] == 1 else 'CHOCH'
+                )
+                
+            elif is_high_broken:
+                # 处理高点突破
+                structure = self._handle_structure_break(
+                    df, i, window, structure,
+                    break_type=self.HIGH_COL, 
+                    struct_type='BOS' if structure['direction'] == 2 else 'CHOCH'
+                )
+                
+            else:
+                # 更新当前结构
+                structure = self._update_current_structure(
+                    df, i, structure,
+                    is_struct_body_break=is_struct_body_break
+                )
+            
+            # 更新数据框结构列
+            self._update_structure_columns(df, i, structure)
+
+        return df
+
+    def _get_structure_extreme_bar(self, df, bar_index,  struct_index, lookback=10, mode='high'):
+        """
+        获取结构最高点或最低点
+        :param df: DataFrame数据
+        :param bar_index: 当前K线索引
+        :param lookback: 回溯周期
+        :param mode: self.HIGH_COL寻找最高点,self.LOW_COL寻找最低点
+        :return: 结构极值点的索引
+        """
+        df = df.copy()
+        # window_start = max(0, bar_index - lookback + 1)
+        window_start = max(0, struct_index)
+        
+        window = df.iloc[window_start : bar_index + 1]
+        
+        # 获取窗口内的极值点索引
+        if mode == self.HIGH_COL:
+            extremeBar = window[self.HIGH_COL].argmax() 
+            price_col = self.HIGH_COL
+            comp_func = lambda x, y: x > y
+        else:
+            extremeBar = window[self.LOW_COL].argmin() 
+            price_col = self.LOW_COL
+            comp_func = lambda x, y: x < y
+
+        # 初始化记录点
+        pivot = 0
+        # 从后向前遍历寻找结构极值点
+        # for i in range(lookback - 1, -1, -1):
+        for idx in range(bar_index - 1, struct_index - 1, -1):
+            # 计算当前位置的索引
+            # idx = bar_index - i
+            if idx - 2 < 0 or idx + 1 >= len(df):
+                continue
+                
+            price_prev = df[price_col].iloc[idx - 1]
+            price_prev2 = df[price_col].iloc[idx - 2]
+            price_curr = df[price_col].iloc[idx]
+            
+            # 记录满足条件的点位
+            if (comp_func(price_prev, price_prev2) and
+                not comp_func(price_curr, price_prev) \
+                # and idx - 1 >= extremeBar
+                ):
+                if pivot == 0:
+                    pivot = idx - 1
+                    continue
+                else:                   
+                    # 比较当前点位与之前记录的极值点的价格,因为在区间内有多个极致点，需要比较
+                    if comp_func(df[price_col].iloc[idx-1], df[price_col].iloc[pivot]):
+                        pivot = idx - 1
+        if pivot != 0:
+            extremeBar = pivot 
+                
+        return extremeBar
+
+    def _check_structure_break(self, curr_price, struct_price, prev_prices, struct_start, i, direction, target_direction, mode='high'):
+        """检查结构是否突破"""
+        comp = operator.gt if mode == self.HIGH_COL else operator.lt
+        reverse_comp = operator.le if mode == self.HIGH_COL else operator.ge
+        
+        basic_break = (
+            comp(curr_price, struct_price) and
+            all(reverse_comp(p, struct_price) for p in prev_prices) and
+            all(i-j > struct_start for j in range(1,4))
+        )
+        
+        direction_break = direction == target_direction and comp(curr_price, struct_price)
+        
+        return basic_break or direction_break
+
+    def _handle_structure_break(self, df, i, window, structure, break_type, struct_type):
+        """处理结构突破"""
+        is_high_break = break_type == self.HIGH_COL
+        
+        struct_start = structure[self.HIGH_START_COL] if is_high_break else structure[self.LOW_START_COL]
+        
+        # 获取新的极值点
+        extreme_idx = self._get_structure_extreme_bar(
+            df, i, struct_start, window, 
+            mode=self.LOW_COL if is_high_break else self.HIGH_COL
+        )
+        
+        # 更新结构信息
+        new_structure = structure.copy()
+        new_structure['direction'] = 2 if is_high_break else 1
+        
+        if is_high_break:
+            new_structure.update({
+                self.LOW_COL: self.toDecimal(df[self.LOW_COL].iloc[extreme_idx]),
+                self.HIGH_COL: self.toDecimal(df[self.HIGH_COL].iloc[i]),
+                self.LOW_START_COL: extreme_idx,
+                self.HIGH_START_COL: i
+            })
+        else:
+            new_structure.update({
+                self.HIGH_COL: self.toDecimal(df[self.HIGH_COL].iloc[extreme_idx]),
+                self.LOW_COL: self.toDecimal(df[self.LOW_COL].iloc[i]),
+                self.HIGH_START_COL: extreme_idx,
+                self.LOW_START_COL: i
+            })
+            
+        # 更新DataFrame结构信息
+        df.at[i, 'struct_direction'] = new_structure['direction']
+        df.at[i, 'struct'] = f"{'Bullish' if is_high_break else 'Bearish'}_{struct_type}"
+        
+        return new_structure
+
+    def _update_current_structure(self, df, i, structure, is_struct_body_break):
+        """更新当前结构"""
+        new_structure = structure.copy()
+        
+        # 检查是否需要更新高点
+        if (structure['direction'] in (2,0)) and df.at[i,self.HIGH_COL] > structure[self.HIGH_COL]:
+            if not (is_struct_body_break and all(i-j > structure[self.HIGH_START_COL] for j in range(1,4))):
+                new_structure[self.HIGH_COL] = df.at[i,self.HIGH_COL]
+                new_structure[self.HIGH_START_COL] = i
+                
+        # 检查是否需要更新低点
+        elif (structure['direction'] in (1,0)) and df.at[i,self.LOW_COL] < structure[self.LOW_COL]:
+            if not (is_struct_body_break and all(i-j > structure[self.LOW_START_COL] for j in range(1,4))):
+                new_structure[self.LOW_COL] = df.at[i,self.LOW_COL]
+                new_structure[self.LOW_START_COL] = i
+                
+        return new_structure
+
+    def _update_structure_columns(self, df, i, structure):
+        """更新数据框中的结构列"""
+        df.at[i, self.STRUCT_HIGH_COL] = self.toDecimal(structure[self.HIGH_COL])
+        df.at[i, self.STRUCT_LOW_COL] = self.toDecimal(structure[self.LOW_COL] )
+        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):
+        """
+        获取最新的结构
+        """
+        data = self.build_struct(df=df, window=10)
+        # 筛选出有效的结构
+       
+        # 获取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()
+        valid_structs = data[ mask ]
+        if not valid_structs.empty:
+            # 获取最近的结构
+            last_struct = valid_structs.iloc[-1]
+            return {
+                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_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]
+            }
+
+        return last_struct
+

core/utils/OPTools.py

@@ -0,0 +1,30 @@
+import requests
+from decimal import Decimal
+
+class OPTools:
+    
+    @staticmethod
+    def toDecimal(value, precision:int=None):
+        """将数值转换为Decimal类型
+        
+        Args:
+            value: 需要转换的数值
+            precision: 精度,如果不指定则保持原始精度
+        
+        Returns:
+            Decimal: 转换后的Decimal对象 
+        """
+        if precision is None:
+            return Decimal(str(value))
+        return Decimal(f"{value:.{precision}f}")
+    
+    @staticmethod
+    def send_feishu_notification(webhook, message):
+        if webhook:
+            headers = {'Content-Type': 'application/json'}
+            data = {"msg_type": "text", "content": {"text": message}}
+            response = requests.post(webhook, headers=headers, json=data)
+            if response.status_code != 200:
+                # self.logger.debug("飞书通知发送成功")
+                raise Exception(f"飞书通知发送失败: {response.text} {webhook}")
+