diff --git a/bitmart/四分之一，五分钟，反手条件充足修改版.py b/bitmart/四分之一，五分钟，反手条件充足修改版.py index 0b4d114..1714843 100644 --- a/bitmart/四分之一，五分钟，反手条件充足修改版.py +++ b/bitmart/四分之一，五分钟，反手条件充足修改版.py @@ -1,121 +1,13 @@ -import sys import time -from datetime import datetime -from collections import deque from tqdm import tqdm from loguru import logger from bit_tools import openBrowser from DrissionPage import ChromiumPage from DrissionPage import ChromiumOptions + from bitmart.api_contract import APIContract -from rich.console import Console -from rich.panel import Panel -from rich.table import Table -from rich.layout import Layout -from rich.align import Align -from rich.text import Text -from rich.live import Live - -# 是否使用 Rich 仪表盘（否则用 loguru 普通输出） -USE_RICH_DASHBOARD = True -console = Console() - -# 颜色标签（loguru 用，无 Rich 时） -_R = "\033[0m" -_B = "\033[1m" -_C = "\033[36m" -_Y = "\033[33m" -_G = "\033[32m" -_M = "\033[90m" -_W = "\033[97m" - -def _tag(t: str, color: str) -> str: - return color + "[" + t + "]" + _R + " " - -LOG_PRICE = _tag("价格", _C) -LOG_SIGNAL = _tag("信号", _Y) -LOG_POSITION = _tag("仓位", _G) -LOG_SYSTEM = _tag("系统", _M) - -if not USE_RICH_DASHBOARD: - logger.remove() - logger.add(sys.stderr, format="\033[2m│\033[0m {message}", colorize=False, level="INFO") - -def log_kline_header(kline_id): - """新 K 线分块头（仅非 Rich 模式使用）""" - s = f" K 线 {kline_id} " - width = max(52, len(s) + 4) - line = "─" * (width - 2) - pad_left = (width - 2 - len(s)) // 2 - pad_right = width - 2 - len(s) - pad_left - logger.info(_M + "╭" + line + "╮" + _R) - logger.info(_M + "│" + _R + " " * pad_left + _B + _W + s + _R + " " * pad_right + _M + "│" + _R) - logger.info(_M + "╰" + line + "╯" + _R) - - -# ---------- Rich 仪表盘 ---------- -def make_header() -> Panel: - title = Text("四分之一策略 · ETHUSDT 5m", style="bold cyan") - subtitle = Text(datetime.now().strftime("%Y-%m-%d %H:%M:%S"), style="dim") - return Panel(Align.center(title + Text("\n") + subtitle), border_style="cyan") - -def make_metrics_panel(state: dict) -> Panel: - t = Table(show_header=True, header_style="bold magenta", expand=True) - t.add_column("指标", style="cyan") - t.add_column("数值", justify="right", style="green") - t.add_row("当前价", f"{state.get('price', 0):.2f}") - pos_map = {0: "无", 1: "多", -1: "空"} - t.add_row("持仓", pos_map.get(state.get("position", 0), "?")) - t.add_row("K线 ID", str(state.get("kline_id", "-"))) - t.add_row("做多触发", f"{state.get('long_trigger', 0):.2f}") - t.add_row("做空触发", f"{state.get('short_trigger', 0):.2f}") - t.add_row("突破做多", f"{state.get('long_breakout', 0):.2f}") - t.add_row("突破做空", f"{state.get('short_breakout', 0):.2f}") - ema10 = state.get("ema10") - ema20 = state.get("ema20") - atr14 = state.get("atr14") - t.add_row("EMA10", f"{ema10:.2f}" if ema10 is not None else "-") - t.add_row("EMA20", f"{ema20:.2f}" if ema20 is not None else "-") - t.add_row("ATR14", f"{atr14:.2f}" if atr14 is not None else "-") - pnl = state.get("unrealized_pnl") - t.add_row("未实现盈亏", f"{pnl:.2f}$" if pnl is not None else "-") - return Panel(t, title="[bold]价格 / 指标[/bold]", border_style="magenta") - -def make_logs_panel(logs: list) -> Panel: - recent = list(logs)[-16:] if logs else [] - body = "\n".join(recent) if recent else "等待日志..." - text = Text.from_ansi(body) if body else Text("等待日志...", style="dim") - return Panel(text, title="[bold]状态 / 日志[/bold]", border_style="green") - -def make_footer(msg: str = "Ctrl+C 退出") -> Panel: - return Panel(Align.center(Text(msg, style="bold yellow")), border_style="yellow") - -def build_dashboard_layout(state: dict, logs: list) -> Layout: - layout = Layout() - layout.split_column( - Layout(make_header(), name="header", size=5), - Layout(name="body", ratio=1), - Layout(make_footer(), name="footer", size=3), - ) - layout["body"].split_row( - Layout(make_metrics_panel(state), name="left", ratio=1), - Layout(make_logs_panel(logs), name="right", ratio=2), - ) - return layout - - -# ---------- 穿越触发（避免“已在阈值下方/上方”的追单） ---------- -def cross_up(prev_price: float, curr_price: float, level: float) -> bool: - """上一轮 < 阈值 且 这一轮 >= 阈值""" - return prev_price < level <= curr_price - - -def cross_down(prev_price: float, curr_price: float, level: float) -> bool: - """上一轮 > 阈值 且 这一轮 <= 阈值""" - return prev_price > level >= curr_price - class BitmartFuturesTransaction: def __init__(self, bit_id): @@ -136,27 +28,12 @@ class BitmartFuturesTransaction: self.last_kline_time = None # 上一次处理的K线时间戳，用于判断是否是新K线 - # 反手过滤（仅价差，无冷却） - self.reverse_min_move_pct = 0.05 # 反手最小价差过滤（百分比） - - self.last_open_time = None # 上次开仓时间（用于最短持仓时间判断） - self.last_open_kline_id = None # 上次开仓所在 K 线 id（仅记录，不限制单 K 线开仓次数） - self.leverage = "100" # 高杠杆（全仓模式下可开更大仓位） self.open_type = "cross" # 全仓模式 self.risk_percent = 0 # 未使用；若启用则可为每次开仓占可用余额的百分比 - # 退出：EMA10 快退出 + EMA20 强制平（可独立开关）+ 自开仓以来 ATR 追踪 - self.use_ema_atr_exit = True # 是否启用 EMA/ATR 平仓规则（多单+空单） - self.atr_multiplier = 1.1 # 追踪止盈：自开仓以来最高/最低回撤/反弹 ≥ 此倍数×ATR(14) 则平仓 - self.use_ema20_entry_filter = True # 开仓/反手方向过滤：价在 EMA20 同侧才允许 - self.use_ema20_force_exit = True # 持仓强制平仓：价穿越 EMA20 则平（与入场过滤解耦） - self.min_hold_seconds = 90 # 开仓/反手后至少持仓此时长才允许技术性止盈（EMA10/EMA20/ATR） - self.exit_use_last_close = True # True=用已收盘K线 last_close 判断 EMA 破位（防针洗），False=用当前价 - # 自开仓以来的最高/最低（真正的 ATR 追踪，不随换线重置） - self._highest_since_entry = None - self._lowest_since_entry = None - self._last_exit_kline_id = None # 当前K线出场后，本K线内不再开仓，等下一根K线再判断 - self._prev_price = None # 上一轮轮询价，用于穿越触发 + self.trailing_activation_usd = 2 # 盈利达到此金额后启动移动止损 + self.trailing_distance_usd = 1.5 # 从最高盈利回撤此金额则平仓 + self.max_unrealized_pnl_seen = None # 持仓期间见过的最大盈利（用于移动止损） self.open_avg_price = None # 开仓价格 self.current_amount = None # 持仓量 @@ -164,27 +41,11 @@ class BitmartFuturesTransaction: self.bit_id = bit_id self.default_order_size = 25 # 开仓/反手张数，统一在此修改 - # 实体过滤：ETH 上 0.1 几乎无效，改为百分比或 ATR。二选一：entity_pct 或 entity_atr_ratio - self.entity_filter_mode = "atr" # "pct" | "atr" - self.min_entity_pct = 0.02 # entity/close < 0.02% 视为实体过小（当 mode=pct 时） - self.entity_atr_ratio = 0.2 # entity < 0.2*ATR(14) 视为实体过小（当 mode=atr 时） - # 上/下影线反手阈值（原 0.01% 太小，几乎根根满足） - self.min_upper_shadow_pct = 0.05 # 上影线比例 > 此值才允许“上影线反手” - self.min_lower_shadow_pct = 0.05 # 下影线比例 > 此值才允许“下影线反手” - # 跳空/开盘后延迟：当前 K 线开始后经过此秒数才允许触发（0=不延迟，可设 30 等防开盘即触发） - self.open_trigger_delay_seconds = 0 - # 策略相关变量 - self.prev_kline = None - self.current_kline = None - self.prev_entity = None - self.current_open = None - # Rich 仪表盘：状态与日志（供 build_dashboard_layout 使用） - self._display_state = {} - self._display_logs = deque(maxlen=120) - self._display_triggers = {} - self._last_signal_log_kline_id = None - self._log_throttle_at = {} + self.prev_kline = None # 上一根K线 + self.current_kline = None # 当前K线 + self.prev_entity = None # 上一根K线实体大小 + self.current_open = None # 当前K线开盘价 def get_klines(self): """获取最近2根K线（当前K线和上一根K线）""" @@ -219,79 +80,6 @@ class BitmartFuturesTransaction: self.ding(text="获取K线异常", error=True) return None, None - def get_klines_series(self, count=35): - """获取最近 count 根 5 分钟 K 线（用于 EMA/ATR），按时间正序。最后一根为当前未收盘 K 线。""" - try: - end_time = int(time.time()) - response = self.contractAPI.get_kline( - contract_symbol=self.contract_symbol, - step=5, - start_time=end_time - 3600 * 4, - end_time=end_time - )[0]["data"] - formatted = [] - for k in response: - formatted.append({ - 'id': int(k["timestamp"]), - 'open': float(k["open_price"]), - 'high': float(k["high_price"]), - 'low': float(k["low_price"]), - 'close': float(k["close_price"]) - }) - formatted.sort(key=lambda x: x['id']) - return formatted[-count:] if len(formatted) >= count else formatted - except Exception as e: - logger.error(f"获取K线序列异常: {e}") - return [] - - @staticmethod - def _ema(series, period): - """对序列 series（从旧到新）计算 EMA(period)，返回最后一个 EMA 值。""" - if not series or len(series) < period: - return None - alpha = 2.0 / (period + 1) - ema = sum(series[:period]) / period # 用前 period 根收盘的 SMA 做种子 - for i in range(period, len(series)): - ema = alpha * series[i] + (1 - alpha) * ema - return ema - - @staticmethod - def _atr(klines, period=14): - """对 klines（从旧到新，每项含 high/low/close）计算 ATR(period)，返回最后一个 ATR 值。""" - if not klines or len(klines) < period + 1: - return None - tr_list = [] - for i in range(1, len(klines)): - high, low = klines[i]['high'], klines[i]['low'] - prev_close = klines[i - 1]['close'] - tr = max(high - low, abs(high - prev_close), abs(low - prev_close)) - tr_list.append(tr) - if len(tr_list) < period: - return None - # ATR = EMA(TR, period) - alpha = 2.0 / (period + 1) - atr = sum(tr_list[:period]) / period - for i in range(period, len(tr_list)): - atr = alpha * tr_list[i] + (1 - alpha) * atr - return atr - - def get_ema_atr_for_exit(self, kline_series): - """ - 基于已收盘 K 线计算 EMA10、EMA20、ATR(14)、last_close。 - kline_series 最后一根可为当前未收盘 K 线，计算时用倒数第 2~N 根作为已收盘。 - 返回 dict: ema10, ema20, atr14, last_close（已收盘的最后一根 close，用于防针洗）。 - """ - if not kline_series or len(kline_series) < 21: - return {"ema10": None, "ema20": None, "atr14": None, "last_close": None} - # 用除最后一根外的已收盘 K 线（若只有 21 根则用前 20 根） - closed = kline_series[:-1] if len(kline_series) >= 21 else kline_series[:20] - closes = [k['close'] for k in closed] - ema10 = self._ema(closes, 10) - ema20 = self._ema(closes, 20) - atr14 = self._atr(closed, 14) - last_close = closed[-1]['close'] if closed else None - return {"ema10": ema10, "ema20": ema20, "atr14": atr14, "last_close": last_close} - def get_current_price(self): """获取当前最新价格""" try: @@ -442,15 +230,6 @@ class BitmartFuturesTransaction: else: logger.info(text) - def _log_throttled(self, key, text, interval=1.0, level="info"): - """同类日志限频，避免 0.1 秒循环刷屏。""" - now = time.time() - last = self._log_throttle_at.get(key, 0) - if now - last < interval: - return - self._log_throttle_at[key] = now - getattr(logger, level)(text) - def calculate_entity(self, kline): """计算K线实体大小（绝对值）""" return abs(kline['close'] - kline['open']) @@ -480,189 +259,109 @@ class BitmartFuturesTransaction: 'lower': min(kline['open'], kline['close']) # 实体下边 } - @staticmethod - def quarter_levels(prev_o, prev_h, prev_l, prev_c, curr_open): - """计算四分之一价位（含跳空修正）。返回 dict: entity, upper, lower, long_trigger, short_trigger, breakout_long, breakout_short""" - entity = abs(prev_c - prev_o) - upper = max(prev_o, prev_c) - lower = min(prev_o, prev_c) - gap_up = (prev_c > prev_o) and (curr_open > prev_c) - gap_down = (prev_c < prev_o) and (curr_open < prev_c) - if gap_up or gap_down: - base = curr_open - long_trigger = base + entity / 4 - short_trigger = base - entity / 4 - breakout_long = long_trigger - breakout_short = short_trigger - else: - long_trigger = lower + entity / 4 - short_trigger = upper - entity / 4 - breakout_long = upper + entity / 4 - breakout_short = lower - entity / 4 - return { - "entity": entity, - "upper": upper, - "lower": lower, - "long_trigger": long_trigger, - "short_trigger": short_trigger, - "breakout_long": breakout_long, - "breakout_short": breakout_short, - } - - def _entity_filter_passed(self, entity: float, prev_close: float, atr14: float | None) -> bool: - """实体过滤：False 表示实体过小，不交易。""" - if self.entity_filter_mode == "pct": - if prev_close <= 0: - return False - return (entity / prev_close * 100) >= self.min_entity_pct - # atr - if atr14 is None or atr14 <= 0: - return entity >= 0.1 # 回退：无 ATR 时用固定 0.1 - return entity >= self.entity_atr_ratio * atr14 - - def _allow_entry_by_ema20(self, side: int, curr_price: float, ema20: float | None) -> bool: - """开仓/反手方向过滤：多单要求价>EMA20，空单要求价 ema20) if side == 1 else (curr_price < ema20) - - def check_signal(self, current_price, prev_kline, current_kline, levels: dict, ind: dict): + def check_signal(self, current_price, prev_kline, current_kline): """ - 检查交易信号（穿越触发 + 形态过滤 + 影线反手阈值提高）。 - 返回: ('long'|'short'|'reverse_long'|'reverse_short', trigger_price) 或 None。 + 检查交易信号 + 返回: ('long', trigger_price) / ('short', trigger_price) / None """ - current_kline_id = current_kline.get('id') - should_log_snapshot = self._last_signal_log_kline_id != current_kline_id - prev_price = self._prev_price - if prev_price is None: - # 第一轮无上一轮价，无法判断穿越，不产生开仓/反手 + # 计算上一根K线实体 + prev_entity = self.calculate_entity(prev_kline) + + # 实体过小不交易（实体 < 0.1） + if prev_entity < 0.1: + logger.info(f"上一根K线实体过小: {prev_entity:.4f}，跳过信号检测") return None - prev_entity = levels["entity"] - prev_entity_upper = levels["upper"] - prev_entity_lower = levels["lower"] - long_trigger = levels["long_trigger"] - short_trigger = levels["short_trigger"] - breakout_long = levels["breakout_long"] + # 获取上一根K线的实体上下边 + prev_entity_edge = self.get_entity_edge(prev_kline) + prev_entity_upper = prev_entity_edge['upper'] # 实体上边 + prev_entity_lower = prev_entity_edge['lower'] # 实体下边 - # 形态过滤 + # 优化：以下两种情况以当前这根的开盘价作为计算基准 + # 1) 上一根阳线 且 当前开盘价 > 上一根收盘价（跳空高开） + # 2) 上一根阴线 且 当前开盘价 < 上一根收盘价（跳空低开） + prev_is_bullish_for_calc = prev_kline['close'] > prev_kline['open'] + prev_is_bearish_for_calc = prev_kline['close'] < prev_kline['open'] + current_open_above_prev_close = current_kline['open'] > prev_kline['close'] + current_open_below_prev_close = current_kline['open'] < prev_kline['close'] + use_current_open_as_base = (prev_is_bullish_for_calc and current_open_above_prev_close) or (prev_is_bearish_for_calc and current_open_below_prev_close) + + if use_current_open_as_base: + # 以当前K线开盘价为基准计算（跳空时用当前开盘价参与计算） + calc_lower = current_kline['open'] + calc_upper = current_kline['open'] # 同一基准，上下四分之一对称 + long_trigger = calc_lower + prev_entity / 4 + short_trigger = calc_upper - prev_entity / 4 + long_breakout = calc_upper + prev_entity / 4 + short_breakout = calc_lower - prev_entity / 4 + else: + # 原有计算方式 + long_trigger = prev_entity_lower + prev_entity / 4 # 做多触发价 = 实体下边 + 实体/4（下四分之一处） + short_trigger = prev_entity_upper - prev_entity / 4 # 做空触发价 = 实体上边 - 实体/4（上四分之一处） + long_breakout = prev_entity_upper + prev_entity / 4 # 做多突破价 = 实体上边 + 实体/4 + short_breakout = prev_entity_lower - prev_entity / 4 # 做空突破价 = 实体下边 - 实体/4 + + # 上一根阴线 + 当前阳线：做多形态，不按上一根K线上三分之一做空 prev_is_bearish = prev_kline['close'] < prev_kline['open'] current_is_bullish = current_kline['close'] > current_kline['open'] skip_short_by_upper_third = prev_is_bearish and current_is_bullish + # 上一根阳线 + 当前阴线：做空形态，不按上一根K线下三分之一做多 prev_is_bullish = prev_kline['close'] > prev_kline['open'] current_is_bearish = current_kline['close'] < current_kline['open'] skip_long_by_lower_third = prev_is_bullish and current_is_bearish - if should_log_snapshot: - logger.info(LOG_PRICE + f"当前价: {current_price:.2f} 上一轮价: {prev_price:.2f} | 实体: {prev_entity:.4f} | 上边: {prev_entity_upper:.2f} 下边: {prev_entity_lower:.2f}") - logger.info(LOG_PRICE + f"做多触发: {long_trigger:.2f} | 做空触发: {short_trigger:.2f} | 突破做多: {breakout_long:.2f}") - if skip_short_by_upper_third: - logger.info(LOG_PRICE + "上一根阴+当前阳(做多形态)，不按上1/4做空") - if skip_long_by_lower_third: - logger.info(LOG_PRICE + "上一根阳+当前阴(做空形态)，不按下1/4做多") - self._last_signal_log_kline_id = current_kline_id + if use_current_open_as_base: + if prev_is_bullish_for_calc and current_open_above_prev_close: + logger.info(f"上一根阳线且当前开盘价({current_kline['open']:.2f})>上一根收盘价({prev_kline['close']:.2f})，以当前开盘价为基准计算") + else: + logger.info(f"上一根阴线且当前开盘价({current_kline['open']:.2f})<上一根收盘价({prev_kline['close']:.2f})，以当前开盘价为基准计算") + logger.info(f"当前价格: {current_price:.2f}, 上一根实体: {prev_entity:.4f}") + logger.info(f"上一根实体上边: {prev_entity_upper:.2f}, 下边: {prev_entity_lower:.2f}") + logger.info(f"做多触发价(下1/4): {long_trigger:.2f}, 做空触发价(上1/4): {short_trigger:.2f}") + logger.info(f"突破做多价(上1/4外): {long_breakout:.2f}, 突破做空价(下1/4外): {short_breakout:.2f}") + if skip_short_by_upper_third: + logger.info("上一根阴线+当前阳线(做多形态)，不按上四分之一做空") + if skip_long_by_lower_third: + logger.info("上一根阳线+当前阴线(做空形态)，不按下四分之一做多") - self._display_triggers = { - "long_trigger": long_trigger, "short_trigger": short_trigger, - "long_breakout": breakout_long, "short_breakout": levels["breakout_short"] - } - - ema20 = ind.get("ema20") - - # 无持仓：穿越触发 + # 无持仓时检查开仓信号 if self.start == 0: - if cross_up(prev_price, current_price, breakout_long) and not skip_long_by_lower_third: - if self._allow_entry_by_ema20(1, current_price, ema20): - logger.info(LOG_SIGNAL + f"穿越做多 | 上一轮 {prev_price:.2f} < 突破价 {breakout_long:.2f} <= 当前 {current_price:.2f}") - return ('long', breakout_long) - if cross_down(prev_price, current_price, short_trigger) and not skip_short_by_upper_third: - if self._allow_entry_by_ema20(-1, current_price, ema20): - logger.info(LOG_SIGNAL + f"穿越做空 | 上一轮 {prev_price:.2f} > 做空触发 {short_trigger:.2f} >= 当前 {current_price:.2f}") - return ('short', short_trigger) - return None + if current_price >= long_breakout and not skip_long_by_lower_third: + logger.info(f"触发做多信号！价格 {current_price:.2f} >= 突破价(上1/4外) {long_breakout:.2f}") + return ('long', long_breakout) + elif current_price <= short_breakout and not skip_short_by_upper_third: + logger.info(f"触发做空信号！价格 {current_price:.2f} <= 突破价(下1/4外) {short_breakout:.2f}") + return ('short', short_breakout) - # 持多 → 反手空 - if self.start == 1: - if cross_down(prev_price, current_price, short_trigger) and not skip_short_by_upper_third: - if self._pct_move(current_price, short_trigger) >= self.reverse_min_move_pct and self._allow_entry_by_ema20(-1, current_price, ema20): - logger.info(LOG_SIGNAL + f"持多→穿越反手做空 | 触发价 {short_trigger:.2f}") - return ('reverse_short', short_trigger) + # 持仓时检查反手信号 + elif self.start == 1: # 持多仓 + # 反手条件1: 价格跌到上一根K线的上三分之一处（做空触发价）；上一根阴线+当前阳线做多时跳过 + if current_price <= short_trigger and not skip_short_by_upper_third: + logger.info(f"持多反手做空！价格 {current_price:.2f} <= 触发价(上1/4) {short_trigger:.2f}") + return ('reverse_short', short_trigger) + + # 反手条件2: 上一根K线上阴线涨幅>0.01%，当前跌到上一根实体下边 upper_shadow_pct = self.calculate_upper_shadow(prev_kline) - if upper_shadow_pct > self.min_upper_shadow_pct and cross_down(prev_price, current_price, prev_entity_lower): - if self._allow_entry_by_ema20(-1, current_price, ema20): - logger.info(LOG_SIGNAL + f"持多→反手做空 | 上影线 {upper_shadow_pct:.2f}% 穿越实体下边 {prev_entity_lower:.2f}") - return ('reverse_short', prev_entity_lower) - return None + if upper_shadow_pct > 0.01 and current_price <= prev_entity_lower: + logger.info(f"持多反手做空！上阴线涨幅 {upper_shadow_pct:.4f}% > 0.01%，" + f"价格 {current_price:.2f} <= 实体下边 {prev_entity_lower:.2f}") + return ('reverse_short', prev_entity_lower) - # 持空 → 反手多 - if self.start == -1: - if cross_up(prev_price, current_price, long_trigger) and not skip_long_by_lower_third: - if self._pct_move(current_price, long_trigger) >= self.reverse_min_move_pct and self._allow_entry_by_ema20(1, current_price, ema20): - logger.info(LOG_SIGNAL + f"持空→穿越反手做多 | 触发价 {long_trigger:.2f}") - return ('reverse_long', long_trigger) + elif self.start == -1: # 持空仓 + # 反手条件1: 价格涨到上一根K线的下三分之一处（做多触发价）；上一根阳线+当前阴线做空时跳过 + if current_price >= long_trigger and not skip_long_by_lower_third: + logger.info(f"持空反手做多！价格 {current_price:.2f} >= 触发价(下1/4) {long_trigger:.2f}") + return ('reverse_long', long_trigger) + + # 反手条件2: 上一根K线下阴线跌幅>0.01%，当前涨到上一根实体上边 lower_shadow_pct = self.calculate_lower_shadow(prev_kline) - if lower_shadow_pct > self.min_lower_shadow_pct and cross_up(prev_price, current_price, prev_entity_upper): - if self._allow_entry_by_ema20(1, current_price, ema20): - logger.info(LOG_SIGNAL + f"持空→反手做多 | 下影线 {lower_shadow_pct:.2f}% 穿越实体上边 {prev_entity_upper:.2f}") - return ('reverse_long', prev_entity_upper) - return None + if lower_shadow_pct > 0.01 and current_price >= prev_entity_upper: + logger.info(f"持空反手做多！下阴线跌幅 {lower_shadow_pct:.4f}% > 0.01%，" + f"价格 {current_price:.2f} >= 实体上边 {prev_entity_upper:.2f}") + return ('reverse_long', prev_entity_upper) return None - def _pct_move(self, curr_price: float, trigger_price: float) -> float: - """当前价相对触发价的变动百分比""" - if not trigger_price or trigger_price <= 0: - return 0.0 - return abs(curr_price - trigger_price) / trigger_price * 100.0 - - def can_open(self, current_kline_id): - """开仓前过滤（已删除开仓冷却，保留接口便于后续扩展）。""" - return True - - def can_reverse(self, current_price, trigger_price): - """反手前过滤：仅最小价差（与 check_signal 内已做重复校验，保留双保险）""" - if trigger_price and trigger_price > 0: - move_pct = self._pct_move(current_price, trigger_price) - if move_pct < self.reverse_min_move_pct: - self._log_throttled("reverse_move_small", LOG_SYSTEM + f"反手价差不足: {move_pct:.4f}% < {self.reverse_min_move_pct}%", interval=1.0) - return False - return True - - def should_exit(self, current_price: float, kline_id: int, ind: dict, now_ts: float): - """ - 是否应技术性平仓。使用 last_close 防针洗（可选）。 - 返回 (True, reason_str) 或 (False, None)。 - """ - if self.start == 0 or not self.use_ema_atr_exit: - return False, None - if not self.last_open_time or (now_ts - self.last_open_time) < self.min_hold_seconds: - return False, None - ema10 = ind.get("ema10") - ema20 = ind.get("ema20") - atr14 = ind.get("atr14") - last_close = ind.get("last_close") - ref_price = last_close if (self.exit_use_last_close and last_close is not None) else current_price - - if self.start == 1: - if ema10 is not None and ref_price < ema10: - return True, "EXIT_LONG_EMA10" - if self.use_ema20_force_exit and ema20 is not None and ref_price < ema20: - return True, "EXIT_LONG_EMA20" - if atr14 is not None and self._highest_since_entry is not None: - dd = self._highest_since_entry - current_price - if dd >= self.atr_multiplier * atr14: - return True, "EXIT_LONG_ATR" - elif self.start == -1: - if ema10 is not None and ref_price > ema10: - return True, "EXIT_SHORT_EMA10" - if self.use_ema20_force_exit and ema20 is not None and ref_price > ema20: - return True, "EXIT_SHORT_EMA20" - if atr14 is not None and self._lowest_since_entry is not None: - ru = current_price - self._lowest_since_entry - if ru >= self.atr_multiplier * atr14: - return True, "EXIT_SHORT_ATR" - return False, None - def verify_no_position(self, max_retries=5, retry_interval=3): """ 验证当前无持仓 @@ -671,7 +370,7 @@ class BitmartFuturesTransaction: for i in range(max_retries): if self.get_position_status(): if self.start == 0: - logger.info(LOG_POSITION + "确认无持仓，可以开仓") + logger.info(f"确认无持仓，可以开仓") return True else: logger.warning( @@ -692,7 +391,7 @@ class BitmartFuturesTransaction: """ if self.get_position_status(): if self.start == expected_direction: - logger.info(LOG_POSITION + f"持仓方向验证成功: {self.start}") + logger.info(f"持仓方向验证成功: {self.start}") return True else: logger.warning(f"持仓方向不符: 期望 {expected_direction}, 实际 {self.start}") @@ -708,7 +407,7 @@ class BitmartFuturesTransaction: if signal_type == 'long': # 开多前先确认无持仓 - logger.info(LOG_POSITION + f"准备开多，触发价: {trigger_price:.2f}") + logger.info(f"准备开多，触发价: {trigger_price:.2f}") if not self.get_position_status(): logger.error("开仓前查询持仓状态失败，放弃开仓") return False @@ -716,15 +415,14 @@ class BitmartFuturesTransaction: logger.warning(f"开多前发现已有持仓 (方向: {self.start})，放弃开仓避免双向持仓") return False - logger.info(LOG_POSITION + "确认无持仓，执行开多") + logger.info(f"确认无持仓，执行开多") self.开单(marketPriceLongOrder=1, size=size) time.sleep(3) # 等待订单执行 # 验证开仓是否成功 if self.verify_position_direction(1): - self.last_open_time = time.time() - self.last_open_kline_id = getattr(self, "_current_kline_id_for_open", None) - logger.success(LOG_POSITION + "开多成功") + self.max_unrealized_pnl_seen = None # 新仓位重置移动止损记录 + logger.success("开多成功") return True else: logger.error("开多后持仓验证失败") @@ -732,7 +430,7 @@ class BitmartFuturesTransaction: elif signal_type == 'short': # 开空前先确认无持仓 - logger.info(LOG_POSITION + f"准备开空，触发价: {trigger_price:.2f}") + logger.info(f"准备开空，触发价: {trigger_price:.2f}") if not self.get_position_status(): logger.error("开仓前查询持仓状态失败，放弃开仓") return False @@ -740,15 +438,14 @@ class BitmartFuturesTransaction: logger.warning(f"开空前发现已有持仓 (方向: {self.start})，放弃开仓避免双向持仓") return False - logger.info(LOG_POSITION + "确认无持仓，执行开空") + logger.info(f"确认无持仓，执行开空") self.开单(marketPriceLongOrder=-1, size=size) time.sleep(3) # 等待订单执行 # 验证开仓是否成功 if self.verify_position_direction(-1): - self.last_open_time = time.time() - self.last_open_kline_id = getattr(self, "_current_kline_id_for_open", None) - logger.success(LOG_POSITION + "开空成功") + self.max_unrealized_pnl_seen = None # 新仓位重置移动止损记录 + logger.success("开空成功") return True else: logger.error("开空后持仓验证失败") @@ -756,7 +453,7 @@ class BitmartFuturesTransaction: elif signal_type == 'reverse_long': # 平空 + 开多（反手做多）：先平仓，确认无仓后再开多，避免双向持仓 - logger.info(LOG_POSITION + f"执行反手做多，触发价: {trigger_price:.2f}") + logger.info(f"执行反手做多，触发价: {trigger_price:.2f}") self.平仓() time.sleep(1) # 给交易所处理平仓的时间 # 轮询确认已无持仓再开多（最多等约 10 秒） @@ -767,13 +464,13 @@ class BitmartFuturesTransaction: if self.start != 0: logger.warning("反手做多：平仓后仍有持仓，放弃本次开多") return False - logger.info(LOG_POSITION + "已确认无持仓，执行开多") + logger.info("已确认无持仓，执行开多") self.开单(marketPriceLongOrder=1, size=size) time.sleep(3) if self.verify_position_direction(1): - self.last_open_time = time.time() # 反手后的新仓位也受最短持仓时间保护 - logger.success(LOG_POSITION + "反手做多成功") + self.max_unrealized_pnl_seen = None + logger.success("反手做多成功") time.sleep(20) return True else: @@ -782,7 +479,7 @@ class BitmartFuturesTransaction: elif signal_type == 'reverse_short': # 平多 + 开空（反手做空）：先平仓，确认无仓后再开空 - logger.info(LOG_POSITION + f"执行反手做空，触发价: {trigger_price:.2f}") + logger.info(f"执行反手做空，触发价: {trigger_price:.2f}") self.平仓() time.sleep(1) for _ in range(10): @@ -792,13 +489,13 @@ class BitmartFuturesTransaction: if self.start != 0: logger.warning("反手做空：平仓后仍有持仓，放弃本次开空") return False - logger.info(LOG_POSITION + "已确认无持仓，执行开空") + logger.info("已确认无持仓，执行开空") self.开单(marketPriceLongOrder=-1, size=size) time.sleep(3) if self.verify_position_direction(-1): - self.last_open_time = time.time() # 反手后的新仓位也受最短持仓时间保护 - logger.success(LOG_POSITION + "反手做空成功") + self.max_unrealized_pnl_seen = None + logger.success("反手做空成功") time.sleep(20) return True else: @@ -810,7 +507,7 @@ class BitmartFuturesTransaction: def action(self): """主循环""" - logger.info(LOG_SYSTEM + "开始运行四分之一策略交易...") + logger.info("开始运行四分之一策略交易...") # 启动时设置全仓高杠杆 if not self.set_leverage(): @@ -818,203 +515,100 @@ class BitmartFuturesTransaction: return page_start = True - if USE_RICH_DASHBOARD: - self._display_logs.clear() - logger.remove() - level_color = { - "DEBUG": "\033[2m", - "INFO": "\033[36m", - "SUCCESS": "\033[32m", - "WARNING": "\033[33m", - "ERROR": "\033[31m", - "CRITICAL": "\033[35m", - } - def _sink(msg): - record = msg.record - ts = record["time"].strftime("%H:%M:%S") - level = record["level"].name - color = level_color.get(level, "\033[37m") - line = f"\033[2m{ts}\033[0m {color}{level:<7}\033[0m {record['message']}" - self._display_logs.append(line) - logger.add(_sink, format="{message}", level="INFO") + while True: - live = None - if USE_RICH_DASHBOARD: - live = Live(console=console, refresh_per_second=8, screen=True) - live.start() - try: - while True: - if live is not None: - try: - live.update(build_dashboard_layout(self._display_state, self._display_logs)) - except Exception: - pass + if page_start: + # 打开浏览器 + for i in range(5): + if self.openBrowser(): + logger.info("浏览器打开成功") + break + else: + self.ding("打开浏览器失败！", error=True) + return + + # 进入交易页面 + self.page.get("https://derivatives.bitmart.com/zh-CN/futures/ETHUSDT") + self.click_safe('x://button[normalize-space(text()) ="市价"]') + + self.page.ele('x://*[@id="size_0"]').input(vals=25, clear=True) + + page_start = False + + try: + # 1. 获取K线数据（当前K线和上一根K线） + prev_kline, current_kline = self.get_klines() + if not prev_kline or not current_kline: + logger.warning("获取K线失败，等待重试...") + time.sleep(5) + continue + + # 记录进入新的K线 + current_kline_time = current_kline['id'] + if self.last_kline_time != current_kline_time: + self.last_kline_time = current_kline_time + logger.info(f"进入新K线: {current_kline_time}") + + # 2. 获取当前价格 + current_price = self.get_current_price() + if not current_price: + logger.warning("获取价格失败，等待重试...") + time.sleep(2) + continue + + # 3. 每次循环都通过SDK获取真实持仓状态（避免状态不同步导致双向持仓） + if not self.get_position_status(): + logger.warning("获取持仓状态失败，等待重试...") + time.sleep(2) + continue + + logger.debug(f"当前持仓状态: {self.start} (0=无, 1=多, -1=空)") + + # 3.5 止损/止盈/移动止损 + if self.start != 0: + pnl_usd = self.get_unrealized_pnl_usd() + if pnl_usd is not None: + # 更新持仓期间最大盈利（用于移动止损） + if self.max_unrealized_pnl_seen is None: + self.max_unrealized_pnl_seen = pnl_usd + else: + self.max_unrealized_pnl_seen = max(self.max_unrealized_pnl_seen, pnl_usd) + # 移动止损：盈利曾达到 activation 后，从最高盈利回撤 trailing_distance 则平仓 + if self.max_unrealized_pnl_seen >= self.trailing_activation_usd: + if pnl_usd < self.max_unrealized_pnl_seen - self.trailing_distance_usd: + logger.info(f"移动止损：当前盈利 {pnl_usd:.2f} 从最高 {self.max_unrealized_pnl_seen:.2f} 回撤 >= {self.trailing_distance_usd} 美元，平仓") + self.平仓() + self.max_unrealized_pnl_seen = None + time.sleep(3) + continue + + # 4. 检查信号 + signal = self.check_signal(current_price, prev_kline, current_kline) + + # 5. 有信号则执行交易 + if signal: + trade_success = self.execute_trade(signal) + if trade_success: + logger.success(f"交易执行完成: {signal[0]}, 当前持仓状态: {self.start}") + page_start = True + else: + logger.warning(f"交易执行失败或被阻止: {signal[0]}") + + # 短暂等待后继续循环（同一根K线遇到信号就操作） + time.sleep(0.1) if page_start: - # 打开浏览器 - for i in range(5): - if self.openBrowser(): - logger.info(LOG_SYSTEM + "浏览器打开成功") - break - else: - self.ding("打开浏览器失败！", error=True) - return - - # 进入交易页面 - self.page.get("https://derivatives.bitmart.com/zh-CN/futures/ETHUSDT") - self.click_safe('x://button[normalize-space(text()) ="市价"]') - - self.page.ele('x://*[@id="size_0"]').input(vals=25, clear=True) - - page_start = False - - try: - # 1. 获取K线数据（当前K线和上一根K线） - prev_kline, current_kline = self.get_klines() - if not prev_kline or not current_kline: - logger.warning(LOG_SYSTEM + "获取K线失败，等待重试...") - time.sleep(5) - continue - - # 记录进入新的K线（分块分隔，便于阅读） - current_kline_time = current_kline['id'] - if self.last_kline_time != current_kline_time: - self.last_kline_time = current_kline_time - if USE_RICH_DASHBOARD: - logger.info(LOG_SYSTEM + f"进入新K线: {current_kline_time}") - else: - logger.info("") - log_kline_header(current_kline_time) - - # 2. 获取当前价格 - current_price = self.get_current_price() - if not current_price: - logger.warning(LOG_SYSTEM + "获取价格失败，等待重试...") - time.sleep(2) - continue - - # 3. 每次循环都通过SDK获取真实持仓状态（避免状态不同步导致双向持仓） - if not self.get_position_status(): - logger.warning(LOG_SYSTEM + "获取持仓状态失败，等待重试...") - time.sleep(2) - continue - - self._log_throttled( - "position_state", - f"当前持仓状态: {self.start} (0=无, 1=多, -1=空)", - interval=2.0, - level="debug", - ) - - kline_series = self.get_klines_series(35) - ind = self.get_ema_atr_for_exit(kline_series) - # 更新仪表盘左侧数据（供 Rich 展示） - try: - self._display_state["price"] = current_price - self._display_state["position"] = self.start - self._display_state["kline_id"] = current_kline_time - self._display_state["unrealized_pnl"] = self.get_unrealized_pnl_usd() - self._display_state["ema10"] = ind["ema10"] - self._display_state["ema20"] = ind["ema20"] - self._display_state["atr14"] = ind["atr14"] - if getattr(self, "_display_triggers", None): - self._display_state.update(self._display_triggers) - except Exception: - pass - - # 3.5 更新自开仓以来最高/最低（真正 ATR 追踪，不随换线重置） - if self.start == 1: - self._highest_since_entry = max(self._highest_since_entry or 0, current_price) - elif self.start == -1: - self._lowest_since_entry = min(self._lowest_since_entry if self._lowest_since_entry is not None else float('inf'), current_price) - - # 3.6 平仓：EMA10 / EMA20 强制 / ATR 追踪（ref 用 last_close 防针洗） - now_ts = time.time() - exit_ok, exit_reason = self.should_exit(current_price, current_kline_time, ind, now_ts) - if exit_ok: - logger.info(LOG_POSITION + f"技术性平仓 | 原因: {exit_reason}") - self.平仓() - self._last_exit_kline_id = current_kline_time - self._highest_since_entry = None - self._lowest_since_entry = None - time.sleep(3) - self._prev_price = current_price - continue - - # 4. 四分之一价位与实体过滤 - levels = self.quarter_levels( - prev_kline['open'], prev_kline['high'], prev_kline['low'], prev_kline['close'], - current_kline['open'] - ) - if not self._entity_filter_passed(levels["entity"], prev_kline['close'], ind.get("atr14")): - self._log_throttled("entity_small", LOG_PRICE + f"实体过小(实体={levels['entity']:.4f})，跳过信号", interval=2.0) - self._prev_price = current_price - time.sleep(0.1) - continue - - # 开盘后延迟：避免开盘价即触发 - if self.open_trigger_delay_seconds > 0: - kline_elapsed = time.time() - current_kline_time - if kline_elapsed < self.open_trigger_delay_seconds: - self._prev_price = current_price - time.sleep(0.1) - continue - - # 5. 检查信号（穿越触发 + EMA20 入场过滤已在 check_signal 内） - signal = self.check_signal(current_price, prev_kline, current_kline, levels, ind) - - # 5.5 反手过滤：最小价差（双保险） - if signal and signal[0].startswith('reverse_'): - if not self.can_reverse(current_price, signal[1]): - signal = None - - # 5.6 开仓过滤：当前K线已出场则等下一根K线再开仓 - if signal and signal[0] in ('long', 'short'): - if self._last_exit_kline_id == current_kline_time: - self._log_throttled("same_kline_no_open", LOG_SYSTEM + "当前K线已出场，等下一根K线再开仓", interval=2.0) - signal = None - elif not self.can_open(current_kline_time): - signal = None - else: - self._current_kline_id_for_open = current_kline_time - - # 6. 有信号则执行交易 - if signal: - trade_success = self.execute_trade(signal) - if trade_success: - self._highest_since_entry = current_price - self._lowest_since_entry = current_price - logger.success(LOG_POSITION + f"交易执行完成: {signal[0]} | 当前持仓: {self.start}") - page_start = True - else: - logger.warning(f"交易执行失败或被阻止: {signal[0]}") - - self._prev_price = current_price - time.sleep(0.1) - - if page_start: - self.page.close() - time.sleep(5) - - except KeyboardInterrupt: - logger.info(LOG_SYSTEM + "用户中断，程序退出") - break - except Exception as e: - logger.error(f"主循环异常: {e}") + self.page.close() time.sleep(5) - finally: - if live is not None: - try: - live.stop() - except Exception: - pass - if USE_RICH_DASHBOARD: - logger.remove() - logger.add(sys.stderr, format="{message}", level="INFO") + except KeyboardInterrupt: + logger.info("用户中断，程序退出") + break + except Exception as e: + logger.error(f"主循环异常: {e}") + time.sleep(5) if __name__ == '__main__': BitmartFuturesTransaction(bit_id="f2320f57e24c45529a009e1541e25961").action() -