386 lines
19 KiB
Python
386 lines
19 KiB
Python
# 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)
|