# src/strategies/smc_pure_h1_long_strategy.py from datetime import datetime, timedelta from typing import Optional, List, Any, Dict import math from .base_strategy import Strategy from ..core_data import Bar, Order, Trade class SMCPureH1LongStrategy(Strategy): """ 基于 15分钟 K线进行交易，但聚合 1小时 K线判断趋势，结合 SMC/PA 入场信号。 下单手数固定，止盈止损由策略内部管理，止损为固定点数。 新增波段出场条件（跌破最近15分钟波段低点）。 """ def __init__( self, context: "BacktestContext", main_symbol: str, fixed_volume: float, fixed_stop_loss_points: float, # 新增：固定止损点数 (例如 10 或 20) tick_size: float, # 新增：最小跳动点 (例如 0.5, 1.0 等) enable_log: bool = True, trend_lookback_bars_1h: int = 30, # 用于判断聚合后1小时趋势的K线数量 ob_fvg_lookback_bars: int = 10, # 用于识别15分钟OB/FVG和流动性扫荡的K线数量 liquidity_sweep_wick_ratio: float = 0.5, # 15分钟扫荡K线下影线占其总范围的最小比例 limit_order_retrace_ratio: float = 0.382, # 15分钟限价单的入场点位于扫荡K线低点到收盘价的斐波那契回撤比例 tp_rr_ratio: float = 2.0, # 止盈风险回报比 **params: Any, ): super().__init__(context, main_symbol, enable_log, **params) self.fixed_volume = fixed_volume self.fixed_stop_loss_points = fixed_stop_loss_points self.tick_size = tick_size self.trend_lookback_bars_1h = trend_lookback_bars_1h self.ob_fvg_lookback_bars = ob_fvg_lookback_bars self.liquidity_sweep_wick_ratio = liquidity_sweep_wick_ratio self.limit_order_retrace_ratio = limit_order_retrace_ratio self.tp_rr_ratio = tp_rr_ratio # 存储当前持仓的止盈止损目标 self.active_trade_params: Dict[str, Dict[str, float]] = {} # 用于1小时K线聚合 self.current_1h_bars_data: List[Bar] = [] # 存储当前正在聚合的15分钟K线 self.aggregated_1h_bars_history: List[Bar] = [] # 存储聚合完成的1小时K线历史 # 用于确保只处理每个1小时周期的第一个15分钟bar的聚合，防止重复 self.last_aggregated_1h_bar_end_time: Optional[datetime] = None self.log(f"SMCPureH1LongStrategy for {self.symbol} initialized.") self.log(f"Params: Fixed SL Points={self.fixed_stop_loss_points}, Tick Size={self.tick_size}") def on_init(self): super().on_init() self.cancel_all_pending_orders(main_symbol=self.symbol) self.trading = True self.active_trade_params.clear() self.current_1h_bars_data.clear() self.aggregated_1h_bars_history.clear() self.last_aggregated_1h_bar_end_time = None def on_open_bar(self, open_price: float, symbol: str): """ 每当新的 15分钟 K线数据到来时调用此方法。 """ if symbol != self.symbol: return current_time_15m = self.context.get_current_time() # 获取 15分钟历史K线（用于入场和波段出场判断） history_15m: List[Bar] = self.get_bar_history() # 确保有足够的 15分钟历史数据来获取 prev_bar_15m (刚刚收盘的K线) if len(history_15m) < 2: # self.log(f"历史15分钟数据不足，当前只有 {len(history_15m)} 根K线。") return prev_bar_15m = history_15m[-1] # 刚刚收盘的 15分钟 K线 # --- 1. 聚合 15分钟 K线到 1小时 K线 --- # 确保我们正在处理的是新的15分钟K线，并且避免在同一1小时周期内重复聚合 # K线的start_time通常是整点或15/30/45分 # 我们聚合的是 prev_bar_15m, 也就是刚刚结束的15分钟K线 self.current_1h_bars_data.append(prev_bar_15m) # 检查是否凑齐了4根15分钟K线，或者当前15分钟K线是新1小时的开始 # 1小时K线的结束时间是下一个小时的整点（例如 09:00, 10:00） # 我们可以根据prev_bar_15m的结束时间来判断是否完成了一个小时周期 # 这里的逻辑是，每当15分钟K线的结束时间刚好是一个小时的整点时，就尝试聚合 # 例如，09:00, 09:15, 09:30, 09:45 对应下一根K线的 open_time。 # 如果当前prev_bar_15m的end_time是例如 09:00:00, 那么它就是08:45:00-09:00:00的K线。 # 下一个小时的整点 (e.g., 09:00:00) # 调整为基于 K线数量的聚合 if len(self.current_1h_bars_data) == 4: # 聚合这4根15分钟K线 first_15m_bar = self.current_1h_bars_data[0] last_15m_bar = self.current_1h_bars_data[-1] aggregated_1h_bar = Bar( symbol=self.symbol, datetime=first_15m_bar.datetime, open=first_15m_bar.open, high=max(b.high for b in self.current_1h_bars_data), low=min(b.low for b in self.current_1h_bars_data), close=last_15m_bar.close, volume=sum(b.volume for b in self.current_1h_bars_data), open_oi=0, close_oi=0 ) self.aggregated_1h_bars_history.append(aggregated_1h_bar) self.current_1h_bars_data.clear() # 清空，准备收集下一小时的K线 # self.log(f"聚合生成新的1小时K线: {aggregated_1h_bar.start_time.strftime('%H:%M')} - {aggregated_1h_bar.close:.2f}") # --- 2. 获取当前仓位信息 --- current_positions = self.get_current_positions() current_pos_volume = current_positions.get(self.symbol, 0) avg_entry_price = self.get_average_position_price(self.symbol) # --- 3. 首先处理现有仓位的止盈止损及波段出场 --- if current_pos_volume > 0 and self.symbol in self.active_trade_params: trade_params = self.active_trade_params[self.symbol] stop_loss_price = trade_params['stop_loss'] take_profit_price = trade_params['take_profit'] # --- 3.1 检查固定点数止损或止盈 --- if open_price <= stop_loss_price: self.log( f"在 {current_time_15m} 触及固定点数止损！当前开盘价 {open_price:.2f} <= 止损价 {stop_loss_price:.2f}。平仓。") self.log(f"持仓均价: {avg_entry_price:.2f}, 止损价: {stop_loss_price:.2f}") self._close_position(current_pos_volume, "止损") return elif open_price >= take_profit_price: self.log( f"在 {current_time_15m} 触及止盈！当前开盘价 {open_price:.2f} >= 止盈价 {take_profit_price:.2f}。平仓。") self.log(f"持仓均价: {avg_entry_price:.2f}, 止盈价: {take_profit_price:.2f}") self._close_position(current_pos_volume, "止盈") return # --- 3.2 检查波段出场条件 (15分钟级别结构破坏) --- if self._check_swing_exit_condition(history_15m, open_price): self.log(f"在 {current_time_15m} 触及波段出场条件（15分钟结构破坏）。平仓。") self.log(f"持仓均价: {avg_entry_price:.2f}") self._close_position(current_pos_volume, "波段出场") return # --- 4. 如果没有持仓，尝试寻找开仓机会 --- # 确保有足够的 15分钟历史数据进行入场分析 required_bars_15m = self.ob_fvg_lookback_bars + 5 if len(history_15m) < required_bars_15m: # self.log(f"15分钟历史数据不足，当前只有 {len(history_15m)} 根K线，需要至少 {required_bars_15m} 根。") return # 检查是否存在挂单，如果是，则不重复开仓 (单次下单限制) pending_orders = self.get_pending_orders() if any(order.symbol == self.symbol for order in pending_orders.values()): # self.log(f"已有 {self.symbol} 挂单，不开新仓。") return # 如果当前有持仓，并且没有触及任何出场条件，那么就不再开新仓，直接返回 if current_pos_volume > 0: return # --- 4.1 1小时趋势判断 (使用聚合后的K线) --- # 确保有足够的1小时K线用于趋势判断 if len(self.aggregated_1h_bars_history) < self.trend_lookback_bars_1h + 5: # self.log(f"聚合1小时K线数据不足，当前只有 {len(self.aggregated_1h_bars_history)} 根，需要至少 {self.trend_lookback_bars_1h + 5} 根。") return is_uptrend_1h, swing_lows_1h = self._is_uptrend_1h( self.aggregated_1h_bars_history, self.trend_lookback_bars_1h ) if not is_uptrend_1h: # self.log(f"在 {current_time_15m}，1小时趋势非明确上升趋势，等待。") return self.log(f"在 {current_time_15m}，1小时趋势判断: 明确上升趋势。") # --- 4.2 15分钟 SMC/PA 入场信号 (波段回踩后的流动性扫荡) --- # 这里使用 prev_bar_15m 作为扫荡K线候选，因为 on_open_bar 意味着 prev_bar_15m 已经完整 is_sweep_candle_15m, sweep_low_point_15m, swept_liquidity_level_15m = self._is_bullish_liquidity_sweep_15m( prev_bar_15m, history_15m, self.ob_fvg_lookback_bars, self.liquidity_sweep_wick_ratio ) if not is_sweep_candle_15m: # self.log(f"前一根15分钟K线 {prev_bar_15m.start_time} 非扫荡K线，等待。") return self.log( f"确认15分钟扫荡K线 {prev_bar_15m.datetime}，低点 {sweep_low_point_15m:.2f} 刺破流动性 {swept_liquidity_level_15m:.2f}。") # --- 4.3 计算入场价格 (限价单) --- # entry_limit_price_candidate = prev_bar_15m.low + ( # prev_bar_15m.close - prev_bar_15m.low) * self.limit_order_retrace_ratio entry_limit_price_candidate = open_price - ( prev_bar_15m.close - prev_bar_15m.low) * self.limit_order_retrace_ratio # 确保限价单价格在当前15分钟K线开盘价之下，才能以限价单形式成交 if entry_limit_price_candidate > open_price: # self.log(f"计算的限价入场价格 {entry_limit_price_candidate:.2f} 高于当前15分钟开盘价 {open_price:.2f}，无法通过限价单成交，放弃。") return entry_price = entry_limit_price_candidate # --- 4.4 计算固定点数止损和止盈目标 --- # 止损点: 入场价 - 固定点数 * 最小跳动点 stop_loss_calculated = entry_price - (self.fixed_stop_loss_points * self.tick_size) # 止盈点: 基于风险回报比计算 risk_per_unit_for_tp = abs(entry_price - stop_loss_calculated) if risk_per_unit_for_tp <= 0: self.log("计算风险为零或负数，无法下单。") return take_profit_calculated = entry_price + (risk_per_unit_for_tp * self.tp_rr_ratio) # 确保止盈价格大于入场价格 if take_profit_calculated <= entry_price: self.log(f"止盈价格 {take_profit_calculated:.2f} 小于或等于入场价格 {entry_price:.2f}，无效交易。") return # --- 4.5 设置固定头寸数量 --- volume = self.fixed_volume if volume <= 0: self.log("设定的交易量为零或负数，无法下单。") return # --- 4.6 发送限价买入订单 --- order = Order( symbol=self.symbol, direction="BUY", volume=int(volume), price_type="LIMIT", limit_price=entry_price, ) self.cancel_all_pending_orders(main_symbol=self.symbol) # 取消所有之前的挂单 sent_order = self.send_order(order) if sent_order: self.log( f"在 {current_time_15m} 发送买入限价订单: {self.symbol}, " f"限价 {sent_order.limit_price:.2f}, 数量 {sent_order.volume}" ) # 存储止盈止损目标，以便后续管理 self.active_trade_params[self.symbol] = { 'stop_loss': stop_loss_calculated, 'take_profit': take_profit_calculated, 'entry_price': entry_price, # 存储理论入场价 'volume': volume } self.log(f"预期止损: {stop_loss_calculated:.2f}, 预期止盈: {take_profit_calculated:.2f}") else: self.log(f"未能发送买入订单：{self.symbol}") def _close_position(self, volume_to_close: float, reason: str): """通用平仓方法""" close_order = Order( symbol=self.symbol, direction="SELL", volume=int(volume_to_close), price_type="MARKET", ) sent_close_order = self.send_order(close_order) if sent_close_order: self.log(f"成功发送平仓订单 ({reason}): {self.symbol}, 数量 {volume_to_close}") if self.symbol in self.active_trade_params: del self.active_trade_params[self.symbol] # 清除止盈止损目标 else: self.log(f"未能发送平仓订单 ({reason}): {self.symbol}") def _is_uptrend_1h(self, history_1h: List[Bar], lookback: int) -> tuple[bool, List[float]]: """ 基于聚合后的 1小时 K线判断上升趋势。 1. 最新收盘价高于最近均线。 2. 最后一个波段低点高于第一个波段低点（宽松版 Higher Low）。 """ if len(history_1h) < lookback + 2: # 确保有足够K线用于计算和判断 return False, [] recent_bars = history_1h[-lookback:] # 1. 简单均线判断：最新收盘价高于 SMA sum_closes = sum(bar.close for bar in recent_bars) avg_close = sum_closes / len(recent_bars) if recent_bars[-1].close < avg_close: return False, [] # 2. 识别 Higher Lows (HL) swing_lows = [] # 查找波段低点（局部最低点，且其左右K线更高） for i in range(1, len(recent_bars) - 1): # 遍历中间K线 if recent_bars[i].low < recent_bars[i - 1].low and \ recent_bars[i].low < recent_bars[i + 1].low: swing_lows.append(recent_bars[i].low) if len(swing_lows) < 2: # 至少需要两个波段低点来判断HL return False, [] # 调整后的 Higher Lows 检查: 只需要最后一个波段低点高于第一个波段低点即可。 is_hl_pattern = swing_lows[-1] > swing_lows[0] return is_hl_pattern, swing_lows def _is_bullish_liquidity_sweep_15m(self, current_bar_15m: Bar, history_15m: List[Bar], lookback_bars: int, wick_ratio: float) -> tuple[bool, float, float]: """ 判断 `current_bar_15m` 是否为看涨流动性扫荡K线 (15分钟图)。 """ sweep_candidate_bar = current_bar_15m # 1. 识别最近的低点作为潜在的流动性池 (在扫荡K线之前，在 15分钟图上) if len(history_15m) < lookback_bars + 1: return False, 0.0, 0.0 # 取扫荡K线之前的 lookback_bars 范围内的K线来识别流动性池 # history_15m 包含从最早到最新的K线，[- (lookback_bars + 1) : -1] 确保不包含 sweep_candidate_bar relevant_history_for_liquidity = history_15m[-(lookback_bars + 1):-1] if not relevant_history_for_liquidity: return False, 0.0, 0.0 # 找到相关历史中的最低点作为被扫荡的流动性水平 swept_liquidity_level = min(bar.low for bar in relevant_history_for_liquidity) # 2. 扫荡K线 (sweep_candidate_bar) 的低点是否刺穿了流动性水平 if sweep_candidate_bar.low >= swept_liquidity_level: return False, 0.0, 0.0 # 3. 扫荡K线是否形成长下影线并收回 total_range = sweep_candidate_bar.high - sweep_candidate_bar.low if total_range <= 0: return False, 0.0, 0.0 lower_wick_length = min(sweep_candidate_bar.open, sweep_candidate_bar.close) - sweep_candidate_bar.low # 下影线必须足够长，且收盘价必须收回至刺破的流动性水平之上 if (lower_wick_length / total_range) >= wick_ratio and \ sweep_candidate_bar.close > swept_liquidity_level: # 扫荡K线本身不能是巨幅下跌的K线（实体不能太大，最好是阳线或小阴线） # 允许小幅下跌，但不能是明显的空头趋势K线 if sweep_candidate_bar.close < sweep_candidate_bar.open * (1 - 0.005): return False, 0.0, 0.0 return True, sweep_candidate_bar.low, swept_liquidity_level return False, 0.0, 0.0 def _check_swing_exit_condition(self, history_15m: List[Bar], open_price) -> bool: """ 检查 15分钟图上的波段出场条件（结构破坏）。 当价格跌破最近的 15分钟波段低点时，视为结构破坏，触发平仓。 """ if len(history_15m) < 5: # 需要至少几根K线来识别波段 return False # 识别最近的15分钟波段低点 (例如，最近5根K线内的最低点，且其左右K线更高) swing_lows_15m = [] # 查找局部最低点 for i in range(len(history_15m) - 4, len(history_15m) - 1): # 在最近的几根K线中查找 if history_15m[i].low < history_15m[i - 1].low and \ history_15m[i].low < history_15m[i + 1].low: swing_lows_15m.append(history_15m[i].low) if not swing_lows_15m: # 如果没有找到波段低点 return False last_swing_low_15m = min(swing_lows_15m) # 找到最近的（最低的）波段低点 # 获取当前 15分钟 K线（即 on_open_bar 传入的 `open_price` 对应的 K线，它还没收盘） # 以及前一根完整的 15分钟 K线 (`prev_bar_15m`) current_bar_15m_open = open_price # 判断：如果当前 K线（或其开盘价）已经跌破了最近的波段低点 # 我们可以用当前K线的open_price来判断，因为在on_open_bar事件发生时，我们只有这个价格 if current_bar_15m_open < last_swing_low_15m: self.log(f"15分钟图结构破坏：当前价格 {current_bar_15m_open:.2f} 跌破最近波段低点 {last_swing_low_15m:.2f}。") return True return False def on_close_bar(self, bar: Bar): # 这个策略主要在on_open_bar中处理逻辑，on_close_bar在这里可以不使用 self.cancel_all_pending_orders(main_symbol=self.symbol)