""" 山寨币爆发监控系统 v11 — 第三层：爆发确认 + 入场方案（纯前瞻版） 只用量价齐飞+PA起爆点+放量突破做确认，不用MACD/RSI/均线 """ import sys, os, shutil # ⚠️ 安全机制：启动时强制清__pycache__，防止旧版字节码残留 for cache_dir in [ os.path.join(os.path.dirname(__file__), "__pycache__"), os.path.join(os.path.dirname(__file__), "..", "__pycache__"), ]: if os.path.exists(cache_dir): shutil.rmtree(cache_dir, ignore_errors=True) import ccxt import pandas as pd import numpy as np import json import sys import os import time import requests from datetime import datetime, timedelta sys.path.insert(0, os.path.dirname(__file__)) from sector_map import get_burst_threshold, is_meme_coin, get_sector_for_coin, COIN_TO_SECTORS from altcoin_db import ( init_db, expire_old_states, expire_old_recommendations, get_candidates_for_confirm, update_state, get_conn, create_recommendation, log_screening, log_cron_run, should_push, log_push, update_latest_price_cache, get_recommendation_for_push, ) from feishu_push import push_recommendation_state_alert from config_loader import ( get_strategy_direction, vp_fly_params, confirm_min_score, confirm_volume_breakout_ratio, confirm_atr_multipliers, confirm_stop_loss_params, get_strategy_params, ) from opportunity_lifecycle import apply_entry_quality_gate from config_loader import _get_section as _get_cfg_section from pa_engine import ( classify_candles, calc_atr, find_supply_demand_zones, find_continuous_k, detect_ignition_point, full_pa_analysis, analyze_entry_point, detect_trend_exhaustion, ) exchange = ccxt.binance({"enableRateLimit": True}) def fetch_klines(symbol, timeframe, limit=200): try: ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit) df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"]) df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms") return df except Exception: return None def symbol_recently_closed(symbol: str, hours: int = 8) -> bool: """检查该币种最近N小时内是否有已完成的交易（止盈/止损）。 用于冷却期：刚止盈的币不宜立即追入。""" import sqlite3, os from datetime import datetime, timezone, timedelta db = os.getenv("ALPHAX_DB_PATH", os.path.join(os.path.dirname(__file__), "data", "altcoin_monitor.db")) conn = sqlite3.connect(db) cutoff = (datetime.now(timezone.utc) - timedelta(hours=hours)).isoformat() row = conn.execute(""" SELECT COUNT(*) FROM recommendation WHERE symbol = ? AND status IN ('hit_tp1', 'hit_tp2', 'stopped_out') AND COALESCE(hit_tp1_time, hit_tp2_time, stopped_out_time, '') >= ? """, (symbol, cutoff)).fetchone() conn.close() return (row[0] or 0) > 0 def _event_time_from_age(df, age_bars: int): """把 age_bars 转成K线时间，用于候选信号新鲜度判断。""" try: if df is None or age_bars is None: return None idx = len(df) - 1 - int(age_bars) if idx < 0 or idx >= len(df): return None ts = df["timestamp"].iloc[idx] return ts.to_pydatetime() if hasattr(ts, "to_pydatetime") else ts except Exception: return None def _is_candidate_fresh(cand, event_times, max_hours=6): """候选新鲜度：当前触发或新近进入候选池，避免旧结构反复确认。""" now = datetime.now() fresh_events = [] for t in event_times or []: if not t: continue try: age_h = (now - t.replace(tzinfo=None)).total_seconds() / 3600 if age_h <= max_hours: fresh_events.append({"time": t.isoformat(), "age_hours": round(age_h, 2)}) except Exception: pass if fresh_events: return True, "current_trigger", fresh_events detected_at = cand.get("detected_at") or cand.get("updated_at") or cand.get("created_at") or "" try: if detected_at: age_h = (now - datetime.fromisoformat(str(detected_at).replace("Z", "").split("+")[0])).total_seconds() / 3600 if age_h <= max_hours: return True, "fresh_candidate_state", [{"time": str(detected_at), "age_hours": round(age_h, 2)}] # coin_state.detected_at 会被每轮扫描刷新，不适合作为“当前触发”。 # 超过窗口后只能作为历史结构背景；是否确认必须依赖当前K线/消息等新触发。 return True, "stale_structure_background_only", [{"time": str(detected_at), "age_hours": round(age_h, 2)}] except Exception: pass return True, "structure_candidate_unknown_age", [] def _build_trigger_context(fresh_reason, fresh_events, vp_data=None, stale_vp_count=0, stale_1h_ignitions=None, stale_d1_ignitions=None, bp_daily=None, entry_action=""): """生成用户可审计的触发上下文：区分当前触发、历史背景、消息触发。""" fresh_events = fresh_events or [] stale_1h_ignitions = stale_1h_ignitions or [] stale_d1_ignitions = stale_d1_ignitions or [] current = [] stale = [] if (vp_data or {}).get("vp_fly_count", 0) > 0: current.append({"type": "technical", "label": "当前1H量价齐飞", "source": "binance_ohlcv_1h"}) if stale_vp_count: stale.append({"type": "technical", "label": "历史1H量价齐飞", "source": "binance_ohlcv_1h", "count": stale_vp_count}) if stale_1h_ignitions: stale.append({"type": "technical", "label": "历史1H起爆点", "source": "pa_engine_1h", "count": len(stale_1h_ignitions)}) if stale_d1_ignitions: stale.append({"type": "technical", "label": "历史日线起爆点", "source": "pa_engine_1d", "count": len(stale_d1_ignitions)}) for e in fresh_events: current.append({"type": "technical", "label": "当前结构触发", "source": "pa_engine", **e}) if (bp_daily or {}).get("detected"): stale.append({"type": "technical_background", "label": "日线底部突破回踩背景", "source": "daily_structure"}) if fresh_reason == "stale_structure_background_only": status = "stale_background_only" label = "历史结构背景，缺少当前K线触发" elif current: status = "current_technical" label = "当前K线/形态触发" elif fresh_reason == "fresh_candidate_state": status = "fresh_candidate" label = "新近进入候选池" else: status = "background" label = "结构背景观察" return { "trigger_status": status, "trigger_label": label, "fresh_reason": fresh_reason or "", "current_triggers": current, "stale_background": stale, "entry_action": entry_action or "", "is_current_opportunity": status in ("current_technical", "fresh_candidate"), } # ==================== 上下文数据 enrichment ==================== def _spot_to_futures(symbol): """BTC/USDT → BTCUSDT""" return symbol.replace("/", "") def fetch_derivatives_context(symbol): """从 Binance 期货 API 获取衍生品情绪数据。 返回: {funding_rate, open_interest_change_24h, top_trader_long_pct, top_trader_long_short_ratio} 失败时返回空 dict。 """ futures_sym = _spot_to_futures(symbol) ctx = {} try: # 1. Funding Rate r = requests.get( f"https://fapi.binance.com/fapi/v1/premiumIndex?symbol={futures_sym}", timeout=5, ) if r.status_code == 200: ctx["funding_rate"] = float(r.json().get("lastFundingRate", 0) or 0) except Exception: pass try: # 2. Open Interest r = requests.get( f"https://fapi.binance.com/fapi/v1/openInterest?symbol={futures_sym}", timeout=5, ) if r.status_code == 200: ctx["open_interest"] = float(r.json().get("openInterest", 0) or 0) except Exception: pass try: # 3. 大户多空比 (取最近2条，对比OI变化) r = requests.get( f"https://fapi.binance.com/futures/data/topLongShortAccountRatio" f"?symbol={futures_sym}&period=5m&limit=2", timeout=5, ) if r.status_code == 200: data = r.json() if len(data) >= 1: last = data[-1] long_pct = round(float(last["longAccount"]) * 100, 1) short_pct = round(float(last["shortAccount"]) * 100, 1) ctx["top_trader_long_pct"] = long_pct ctx["top_trader_long_short_ratio"] = ( round(long_pct / short_pct, 2) if short_pct > 0 else 0 ) except Exception: pass # 4. OI 24h变化（通过 openInterestHist 日线数据计算） try: r = requests.get( f"https://fapi.binance.com/futures/data/openInterestHist" f"?symbol={futures_sym}&period=1d&limit=2", timeout=5, ) if r.status_code == 200: hist = r.json() if len(hist) >= 2: oi_yesterday = float(hist[0].get("sumOpenInterestValue", 0) or 0) oi_today = float(hist[1].get("sumOpenInterestValue", 0) or 0) if oi_yesterday > 0: ctx["open_interest_change_24h"] = round( (oi_today - oi_yesterday) / oi_yesterday * 100, 1 ) except Exception: pass # 兜底：没有 OI 24h 变化时标 0 if "open_interest_change_24h" not in ctx: ctx["open_interest_change_24h"] = 0 return ctx def compute_market_context(h1_df, price): """从已有 1H K线计算市场热度上下文。 返回: {volume_24h, turnover_acceleration_1h, turnover_acceleration_4h, change_24h} """ ctx = {} try: if h1_df is None or len(h1_df) < 2: return ctx # 24h成交量（近24根1H K线） recent_24h = h1_df.tail(24) ctx["volume_24h"] = round(float(recent_24h["volume"].sum()), 0) # 1H量能加速：最新1根 vs 近20根均值 avg_vol_1h = float(h1_df["volume"].rolling(20).mean().iloc[-1]) if avg_vol_1h > 0: ctx["turnover_acceleration_1h"] = round( float(h1_df["volume"].iloc[-1]) / avg_vol_1h, 2 ) else: ctx["turnover_acceleration_1h"] = 1.0 # 4H量能加速：近4根 vs 近12根均值 if len(h1_df) >= 16: recent_4h_vol = float(h1_df["volume"].tail(4).sum()) prev_12h_vol = float(h1_df["volume"].iloc[-16:-4].sum()) / 3 # 每4H均值 if prev_12h_vol > 0: ctx["turnover_acceleration_4h"] = round( recent_4h_vol / 4 / (prev_12h_vol / 4), 2 ) else: ctx["turnover_acceleration_4h"] = 1.0 else: ctx["turnover_acceleration_4h"] = float(ctx.get("turnover_acceleration_1h", 1.0)) # 24h涨跌 if len(h1_df) >= 24: price_24h_ago = float(h1_df["close"].iloc[-24]) if price_24h_ago > 0: ctx["change_24h"] = round((price - price_24h_ago) / price_24h_ago * 100, 1) else: ctx["change_24h"] = 0 else: ctx["change_24h"] = 0 except Exception: pass return ctx def compute_sector_context(symbol, cand_detail=None): """用 sector_map.py 推断板块联动上下文。 优先使用粗筛/细筛已计算的 sector_context，兜底自行推断。 返回: {sectors, hot_sectors, leader_symbol, leader_move_pct} """ ctx = {} try: sectors = get_sector_for_coin(symbol) ctx["sectors"] = sectors # 优先使用上游已计算的 sector_context（粗筛/细筛已做板块龙头检测） upstream = (cand_detail or {}).get("sector_context") or {} upstream_hot = upstream.get("hot_sectors") or [] upstream_leader = upstream.get("leader_symbol") or "" if upstream_hot: ctx["hot_sectors"] = upstream_hot elif sectors: ctx["hot_sectors"] = sectors[:1] else: ctx["hot_sectors"] = [] if upstream_leader: ctx["leader_symbol"] = upstream_leader else: ctx["leader_symbol"] = "" # leader_move_pct：优先上游 sector_context.leader_pct，兜底本币24h涨跌 upstream_leader_pct = upstream.get("leader_pct") if upstream_leader_pct is not None and upstream_leader_pct != 0: ctx["leader_move_pct"] = round(float(upstream_leader_pct), 1) else: ctx["leader_move_pct"] = round( float((cand_detail or {}).get("change_24h", 0) or 0), 1 ) except Exception: pass return ctx # ==================== 确认逻辑 ==================== def detect_volume_price_fly_1h(df_1h): """确认层量价齐飞检测。 “1H量价齐飞”必须是当前/近当前信号，默认只承认最近2根1H K线； 更早的放量阳线属于历史爆发背景，不能继续作为当前爆发确认。 """ if df_1h is None or len(df_1h) < 20: return {"vp_fly_count": 0, "max_vol_ratio": 0, "vp_fly_details": [], "stale_vp_fly_details": []} vp_cfg = vp_fly_params() avg_vol = df_1h["volume"].rolling(20).mean().iloc[-1] recent = df_1h.tail(12) vp_fly_count = 0 max_vol_ratio = 0 vp_fly_details = [] stale_vp_fly_details = [] max_signal_age_hours = vp_cfg.get("max_signal_age_hours", 1) for i, (_, row) in enumerate(recent.iterrows()): vol_ratio = row["volume"] / avg_vol if avg_vol > 0 else 0 body_pct = abs(row["close"] - row["open"]) / (row["high"] - row["low"] + 0.00001) * 100 direction = 1 if row["close"] > row["open"] else -1 age_hours = len(recent) - 1 - i max_vol_ratio = max(max_vol_ratio, vol_ratio) if vol_ratio >= vp_cfg.get("vol_ratio_min", 5.0) and body_pct >= vp_cfg.get("body_ratio_min", 0.70) * 100 and direction == 1: detail = {"vol_ratio": round(vol_ratio, 1), "body_pct": round(body_pct, 0), "age_hours": age_hours, "direction": "阳"} if age_hours <= max_signal_age_hours: vp_fly_count += 1 vp_fly_details.append(detail) else: detail["stale"] = True stale_vp_fly_details.append(detail) return { "vp_fly_count": vp_fly_count, "max_vol_ratio": round(max_vol_ratio, 1), "vp_fly_details": vp_fly_details, "stale_vp_fly_details": stale_vp_fly_details, "stale_vp_fly_count": len(stale_vp_fly_details), "latest_vp_age_hours": min((d.get("age_hours", 999) for d in vp_fly_details), default=None), } def _recent_pa_items(items, max_age_bars, direction=None): """过滤 PA 事件：只把当前/近当前事件当成触发信号。""" result = [] stale = [] for item in items or []: if direction is not None and item.get("direction") != direction: continue age = item.get("age_bars") if age is None and item.get("index") is not None: # 兼容旧结构：调用方传入的是 full_pa_analysis 当前窗口结果，index 可推断相对位置。 age = 999 if age is not None and age <= max_age_bars: result.append(item) else: stale.append(item) return result, stale def detect_breakout_pullback(df, timeframe="1d"): """日线/周线底部突破回踩检测（经典安全形态）。 模式：底部形成 → 放量突破关键阻力 → 回踩不破 → 起爆确认。 返回: {detected, score, signals, entry_zone, stop_level, quality} """ result = {"detected": False, "score": 0, "signals": [], "entry_zone": None, "stop_level": None, "quality": ""} if df is None or len(df) < 50: return result closes = df["close"].values highs = df["high"].values lows = df["low"].values volumes = df["volume"].values # 1. 找波段低点（局部最小值，左右各5根K线） swing_lows = [] for i in range(10, len(closes) - 5): if lows[i] == min(lows[i-10:i+5]): swing_lows.append({"idx": i, "low": lows[i], "close": closes[i]}) if len(swing_lows) < 2: return result # 2. 找最近的重要底部（最低的低点） recent_lows = [sl for sl in swing_lows if sl["idx"] >= len(closes) - 60] if not recent_lows: recent_lows = swing_lows[-5:] bottom = min(recent_lows, key=lambda x: x["low"]) # 3. 找底部之后的第一个波段高点（突破目标） swing_highs = [] for i in range(10, len(closes) - 5): if highs[i] == max(highs[i-10:i+5]): swing_highs.append({"idx": i, "high": highs[i]}) # 取底部之后的波段高点 post_bottom_highs = [sh for sh in swing_highs if sh["idx"] > bottom["idx"] and sh["idx"] < len(closes) - 5] if not post_bottom_highs: # 用底部到现在的最高点 max_idx = bottom["idx"] + np.argmax(highs[bottom["idx"]:]) post_bottom_highs = [{"idx": int(max_idx), "high": highs[int(max_idx)]}] breakout_level = post_bottom_highs[0]["high"] # 4. 检查突破：最近20根内是否有收盘价超过突破位 recent_closes = closes[-20:] broke_out = any(c > breakout_level * 1.005 for c in recent_closes) # 0.5% buffer if not broke_out: return result # 5. 检查回踩：突破后是否有回落，但现在是否稳在突破位之上 current_price = closes[-1] recent_lows_arr = lows[-10:] pullback_low = min(recent_lows_arr) # 回踩幅度 = (突破后最高 - 回踩最低) / 突破位 post_breakout_high = max(highs[-20:]) pullback_pct = (post_breakout_high - pullback_low) / breakout_level * 100 if breakout_level > 0 else 0 # 当前价格必须稳在突破位上方（或轻微跌破但快速收回） holding = current_price >= breakout_level * 0.98 if not holding and pullback_low < breakout_level * 0.96: return result # 跌破了，形态失败 # 6. 评分 score = 0 signals = [] # ---- 底部质量（K线形态+量价关系，替代数天数） ---- bottom_idx = bottom["idx"] bottom_price = float(bottom["low"]) # 底部观察窗口：底部K线前后各15根 zone_start = max(0, bottom_idx - 15) zone_end = min(len(closes), bottom_idx + 15) zone_closes = closes[zone_start:zone_end] # ① 底部附近量缩（卖盘枯竭） pre_vol = np.mean(volumes[max(0, bottom_idx - 20):bottom_idx]) if bottom_idx >= 20 else np.mean(volumes[:bottom_idx]) post_vol = np.mean(volumes[bottom_idx:min(len(volumes), bottom_idx + 10)]) vol_shrink_ratio = post_vol / pre_vol if pre_vol > 0 else 1 if vol_shrink_ratio <= 0.7: score += 4 signals.append(f"{timeframe} 底部缩量({vol_shrink_ratio:.1f}x)") elif vol_shrink_ratio <= 0.9: score += 2 signals.append(f"{timeframe} 底部量稳({vol_shrink_ratio:.1f}x)") # ② K线实体收窄（多空平衡） df_opens = df["open"].values[zone_start:zone_end] df_closes = zone_closes bodies_arr = np.abs(df_closes - df_opens) body_mean = np.mean(bodies_arr) body_recent_mean = np.mean(np.abs(closes[max(0, len(closes)-20):] - df["open"].values[max(0, len(closes)-20):])) body_shrink = body_mean / body_recent_mean if body_recent_mean > 0 else 1 if body_shrink <= 0.6: score += 3 signals.append(f"{timeframe} K线缩量收敛") # ③ 反转形态检测（底部附近找锤子线/吞没） reversal_found = False for i in range(max(0, bottom_idx - 3), min(len(closes), bottom_idx + 3)): o = float(df["open"].values[i]) c = float(closes[i]) h = float(highs[i]) l = float(lows[i]) body = abs(c - o) upper_wick = h - max(o, c) lower_wick = min(o, c) - l total_range = h - l if h > l else 0.0001 if body < total_range * 0.3 and lower_wick > body * 2 and c > o: reversal_found = True signals.append(f"{timeframe} 锤子线反转") score += 3 break if i > 0: prev_o = float(df["open"].values[i-1]) prev_c = float(closes[i-1]) if prev_c < prev_o and c > o and c > prev_o and o < prev_c: reversal_found = True signals.append(f"{timeframe} 看涨吞没") score += 4 break if not reversal_found: # Check for morning star (3-candle pattern) for i in range(max(0, bottom_idx - 5), min(len(closes) - 2, bottom_idx + 1)): c1 = float(closes[i]) c2 = float(closes[i+1]) c3 = float(closes[i+2]) o1 = float(df["open"].values[i]) o3 = float(df["open"].values[i+2]) if (c1 < o1) and abs(c2 - o1) < abs(c1 - o1) * 0.5 and c3 > o3 and c3 > c1: reversal_found = True signals.append(f"{timeframe} 晨星反转") score += 4 break # ④ 底部后主力吸筹（阳线放量 > 阴线量） up_vols = [] down_vols = [] for i in range(bottom_idx, min(len(closes), bottom_idx + 15)): if float(closes[i]) >= float(df["open"].values[i]): up_vols.append(float(volumes[i])) else: down_vols.append(float(volumes[i])) if up_vols and down_vols: up_avg = np.mean(up_vols) down_avg = np.mean(down_vols) if up_avg > down_avg * 1.3: score += 3 signals.append(f"{timeframe} 阳线放量吸筹({up_avg/down_avg:.1f}x)") elif up_avg > down_avg: score += 1 # ⑤ 二次回踩量更小（抛压消失） bottom_zone = bottom_price * 1.03 touches = [] for i in range(bottom_idx + 5, len(lows)): if float(lows[i]) <= bottom_zone and i > bottom_idx + 3: touches.append((i, float(volumes[i]))) if len(touches) >= 2: first_touch_vol = touches[0][1] last_touch_vol = touches[-1][1] if last_touch_vol < first_touch_vol * 0.7: score += 4 signals.append(f"{timeframe} 回踩缩量确认({len(touches)}次)") elif len(touches) >= 2: score += 2 signals.append(f"{timeframe} 多次回踩({len(touches)}次)") elif len(touches) == 1: score += 1 # ⑥ 底部形成时间（距离越远=越充分，但权重降低） bars_from_bottom = len(closes) - bottom_idx if bars_from_bottom >= 30: score += 2 signals.append(f"{timeframe} 筑底{bars_from_bottom}根") elif bars_from_bottom >= 15: score += 1 # 突破放量确认（最新1根量 vs 近30日中位数，≥3x才叫放量） breakout_vol = float(volumes[-1]) avg_vol = float(np.median(volumes[-30:])) if len(volumes) >= 30 else float(np.mean(volumes[-20:])) vol_ratio = breakout_vol / avg_vol if avg_vol > 0 else 1 if vol_ratio >= 3.0: score += 6 signals.append(f"{timeframe} 突破放量({vol_ratio:.1f}x)") elif vol_ratio >= 2.0: score += 3 signals.append(f"{timeframe} 突破量能确认({vol_ratio:.1f}x)") # 回踩质量（浅回踩=强支撑） if pullback_pct <= 3: score += 5 signals.append(f"{timeframe} 浅回踩({pullback_pct:.1f}%)") elif pullback_pct <= 6: score += 3 signals.append(f"{timeframe} 正常回踩({pullback_pct:.1f}%)") else: score += 1 # 当前价站稳突破位上方 price_above_breakout = (current_price - breakout_level) / breakout_level * 100 if price_above_breakout >= 1: score += 3 signals.append(f"{timeframe} 站稳突破位+{price_above_breakout:.1f}%") elif price_above_breakout >= 0: score += 2 elif price_above_breakout >= -2: score += 1 signals.append(f"{timeframe} 回踩突破位(-{abs(price_above_breakout):.1f}%)") # 质量评价 if score >= 15: quality = "优质" elif score >= 10: quality = "良好" elif score >= 6: quality = "可观察" else: quality = "弱" result["detected"] = True result["score"] = score result["signals"] = signals result["entry_zone"] = round(float(breakout_level), 6) result["stop_level"] = round(float(bottom["low"] * 0.97), 6) # 止损设在底部下方3% result["quality"] = quality return result def confirm_burst(symbol, cand): """对单个候选做爆发确认（v1.7.0：强共振旁路+量价齐飞双门控） cand: coin_state行数据，含leader_status/detail_json等 确认条件=量价齐飞K≥1 OR (起爆点≥10× + 蓄力≥4根 + 辅助信号≥1) 不用MACD/RSI/均线 """ score = 0 signals = [] confirmed = False entry_plan = {} # 提取cand数据（v1.7.0：用于辅助信号检测） cand_detail = json.loads(cand.get("detail_json", "{}")) leader_status = cand.get("leader_status", "") h1_df = fetch_klines(symbol, "1h", limit=100) m15_df = fetch_klines(symbol, "15m", limit=100) h4_df = fetch_klines(symbol, "4h", limit=100) d1_df = fetch_klines(symbol, "1d", limit=120) # 日线趋势安全检查+突破回踩 current_trigger_times = [] if h1_df is None or len(h1_df) < 50: return {"confirmed": False, "score": 0, "signals": ["数据不足"], "entry_plan": {}, "pa_1h": {}, "pa_15min": {}, "pa_1d": {}, "m30_aligned": False, "market_context": {}, "derivatives_context": {}, "sector_context": {}} price = float(h1_df["close"].iloc[-1]) atr_1h = calc_atr(h1_df, 14) confirm_cfg = _get_cfg_section("confirm") pa_recency_cfg = confirm_cfg.get("pa_recency", {}) # ---- 1H量价行为（核心前瞻信号） ---- vol_avg = float(h1_df["volume"].rolling(20).mean().iloc[-1]) vol_latest = float(h1_df["volume"].iloc[-1]) vol_ratio = vol_latest / vol_avg if vol_avg > 0 else 1 vp_data = detect_volume_price_fly_1h(h1_df) vp_fly_count = vp_data["vp_fly_count"] for d in vp_data.get("vp_fly_details", []): t = _event_time_from_age(h1_df, d.get("age_hours")) if t: current_trigger_times.append(t) stale_vp_count = vp_data.get("stale_vp_fly_count", 0) # 量价齐飞K≥2 → 极强确认 if vp_fly_count >= 2: signals.append(f"1H {vp_fly_count}根量价齐飞K(最强确认)") score += 8 elif vp_fly_count == 1: signals.append(f"1H 量价齐飞K(量{vp_data['max_vol_ratio']}x)") score += 5 elif vp_data.get("stale_vp_fly_count", 0) > 0: stale = vp_data.get("stale_vp_fly_details", [{}])[0] signals.append(f"1H历史放量阳线已过期({stale.get('age_hours')}小时前, 量{stale.get('vol_ratio')}x)") # 1H放量≥3x（但不是量价齐飞=量价背离） if vol_ratio >= 3 and vp_fly_count == 0: signals.append(f"1H放量({vol_ratio:.1f}x)但无量价齐飞(量价背离)") score += 1 # 低权重：量价背离是假信号 # ---- PA引擎：4H级别（阻力/支撑） ---- pa_4h = full_pa_analysis(h4_df, "4h") if h4_df is not None and len(h4_df) >= 30 else {} h4_zones = pa_4h.get("zones", []) high_q_supply = [z for z in h4_zones if z["type"] == "supply" and z["q_score"] >= 7] resistance = None if high_q_supply: resistance = high_q_supply[0]["top"] # ---- v1.7.7: 日线 PA 全分析（供需区 + 起爆点 + 动K，高权重）---- # 日线是最大的时间框架，信号强度远高于小时级 pa_1d = {} d1_zones = [] if d1_df is not None and len(d1_df) >= 50: pa_1d = full_pa_analysis(d1_df, "1d") d1_zones = pa_1d.get("zones", []) # 日线起爆点：只承认最近1根日线内发生；更早的日线起爆属于背景，不当作当前触发。 d1_ignitions = pa_1d.get("ignition_points", []) recent_d1_ignitions, stale_d1_ignitions = _recent_pa_items(d1_ignitions, confirm_cfg.get("pa_recency", {}).get("d1_ignition_max_age_bars", 1)) for ig in recent_d1_ignitions[-3:]: if ig["direction"] == 1: signals.append(f"日线 {ig['signal_type']}(强度{ig['strength_ratio']}×)") score += 6 # 日线×1.5 vs 4H的+4 elif ig["direction"] == -1: signals.append(f"日线 {ig['signal_type']}(强度{ig['strength_ratio']}×)") score += 3 for ig in recent_d1_ignitions: if ig.get("direction") == 1: t = _event_time_from_age(d1_df, ig.get("age_bars")) if t: current_trigger_times.append(t) if stale_d1_ignitions: ig = stale_d1_ignitions[-1] signals.append(f"日线历史起爆点已过期({ig.get('age_bars', '?')}根前, 强度{ig.get('strength_ratio')}×)") # 日线连续动K(阳) — 日线趋势确认 d1_candles = pa_1d.get("candles_class", []) recent_d1 = d1_candles[-5:] if len(d1_candles) >= 5 else d1_candles dy_d1 = sum(1 for c in recent_d1 if c["type"] == "dynamic" and c["direction"] == 1) if dy_d1 >= 3: signals.append(f"日线 {dy_d1}动K(阳)趋势确认") score += 5 elif dy_d1 >= 1: signals.append(f"日线 {dy_d1}动K(阳)") score += 2 # 日线需求区反弹 — 最强结构信号 d1_demand = [z for z in d1_zones if z["type"] == "demand" and z["q_score"] >= 5] if d1_demand and price > 0: nearest = min(d1_demand, key=lambda z: abs(z["top"] - price)) if nearest["top"] < price < nearest["top"] * 1.15: signals.append(f"日线需求区反弹(Q={nearest['q_score']} ${nearest['top']:.4f})") score += 6 # ---- 1H放量突破4H高质量阻力 ---- breakout_confirmed = False if resistance and vol_ratio >= confirm_volume_breakout_ratio(): prev_close_1h = float(h1_df["close"].iloc[-2]) if price > resistance and prev_close_1h < resistance: q_info = f"Q={high_q_supply[0]['q_score']}" if high_q_supply else "" signals.append(f"1H放量突破阻力${resistance:.4f}({q_info} 量{vol_ratio:.1f}x)") breakout_confirmed = True elif vol_ratio >= 5: # 5x以上放量即有效突破（山寨币历史数据不足以形成阻力区） signals.append(f"1H极放量({vol_ratio:.1f}x)") score += 2 # ---- PA引擎：1H级别分析 ---- pa_1h = full_pa_analysis(h1_df, "1h") if atr_1h > 0 else {} # ---- PA起爆点检测(1H)：只承认最近2根1H内发生 ---- pa_1h_ignitions = pa_1h.get("ignition_points", []) recent_1h_ignitions, stale_1h_ignitions = _recent_pa_items( pa_1h_ignitions, pa_recency_cfg.get("h1_ignition_max_age_bars", 1), ) ignition_confirmed = False for ig in recent_1h_ignitions[-3:]: if ig["direction"] == 1: signals.append(f"1H {ig['signal_type']}(强度{ig['strength_ratio']}×)") score += 4 ignition_confirmed = True elif ig["direction"] == -1: signals.append(f"1H {ig['signal_type']}(强度{ig['strength_ratio']}×)") score += 2 for ig in recent_1h_ignitions: if ig.get("direction") == 1: t = _event_time_from_age(h1_df, ig.get("age_bars")) if t: current_trigger_times.append(t) if stale_1h_ignitions: ig = stale_1h_ignitions[-1] signals.append(f"1H历史起爆点已过期({ig.get('age_bars', '?')}根前, 强度{ig.get('strength_ratio')}×)") # ---- 1H动K(阳)+量递增 ---- pa_1h_candles = pa_1h.get("candles_class", []) recent_1h = pa_1h_candles[-6:] if len(pa_1h_candles) >= 6 else pa_1h_candles dy_1h = sum(1 for c in recent_1h if c["type"] == "dynamic" and c["direction"] == 1) if dy_1h >= 3: recent_1h_df = h1_df.tail(dy_1h + 1) vol_increasing = True for i in range(1, len(recent_1h_df)): if float(recent_1h_df["volume"].iloc[i]) < float(recent_1h_df["volume"].iloc[i-1]): vol_increasing = False break if vol_increasing: signals.append(f"1H {dy_1h}动K(阳)+量递增") score += 3 else: signals.append(f"1H {dy_1h}动K(阳)") score += 1 # ---- 1H趋势衰减检测 ---- pa_1h_exhaustion = pa_1h.get("trend_exhaustion", {}) if pa_1h_exhaustion.get("exhausted"): for es in pa_1h_exhaustion.get("signals", []): signals.append(f"⚠️ {es}") if pa_1h_exhaustion["severity"] == "high": score -= 3 elif pa_1h_exhaustion["severity"] == "medium": score -= 1 # ---- v1.7.7: 30min 桥接（填补 1H→15min 缺口）---- # 30min 是中间周期：确认 1H 趋势在中等周期是否有结构支撑 m30_df = fetch_klines(symbol, "30m", limit=60) m30_aligned = False if m30_df is not None and len(m30_df) >= 30 and atr_1h > 0: pa_30min = full_pa_analysis(m30_df, "30m") m30_candles = pa_30min.get("candles_class", []) recent_30 = m30_candles[-8:] if len(m30_candles) >= 8 else m30_candles dy_30 = sum(1 for c in recent_30 if c["type"] == "dynamic" and c["direction"] == 1) st_30 = sum(1 for c in recent_30 if c["type"] == "static") # 30min 与 1H 方向对齐：阳动K≥3 且 阴动K≤1 if dy_30 >= 3 and sum(1 for c in recent_30 if c["type"] == "dynamic" and c["direction"] == -1) <= 1: signals.append(f"30min {dy_30}阳动K(与1H共振)") score += 3 m30_aligned = True elif st_30 >= 4 and dy_30 >= 1: # 30min 蓄力中（静K多+少量动K）— 待突破，不加分但也不扣 signals.append(f"30min 蓄力({st_30}静K+{dy_30}阳动K)") m30_aligned = True # 不扣分，视为中性偏多 elif sum(1 for c in recent_30 if c["type"] == "dynamic" and c["direction"] == -1) >= 3: signals.append("⚠️ 30min 阴动K≥3(与1H背离)") score -= 2 # else: 无明确信号，不干预 # ---- PA引擎：15min入场点分析 ---- pa_15min_result = {} entry_action = "等回踩" # 默认保守，PA引擎会覆盖 # v1.7.8: PA引擎始终调用（有15min数据即可），不再依赖 direction 变量 # direction=0 时仍可基于 h1_df + m15_df 独立判断入场时机 direction = 1 if (vp_fly_count >= 1 or ignition_confirmed or breakout_confirmed) else 0 if m15_df is not None and len(m15_df) >= 20 and atr_1h > 0: # 始终调用 PA 引擎，不限制 direction。PA 内部自己判断即刻买入/等回踩/放弃 pa_15min_result = analyze_entry_point( h1_df=h1_df, m15_df=m15_df, atr_1h=atr_1h, zones_4h=h4_zones if h4_zones else [], direction=max(direction, 1), ) entry_action = pa_15min_result.get("action", "等回踩") if pa_15min_result.get("breakout_k_info"): bk = pa_15min_result["breakout_k_info"] t = _event_time_from_age(m15_df, bk.get("age_bars")) if t: current_trigger_times.append(t) atr_ratio = bk.get("atr_ratio", 0) if atr_ratio > 2.0: signals.append(f"15min 强突破K线(ATR×{atr_ratio:.1f})") score += 3 elif atr_ratio > 1.5: signals.append(f"15min 突破K线(ATR×{atr_ratio:.1f})") score += 2 if pa_15min_result.get("pullback_info"): pb = pa_15min_result["pullback_info"] signals.append(f"15min 回踩确认(${pb.get('low', 0):.4f}→${pb.get('high', 0):.4f})") score += 2 if pa_15min_result.get("false_breakout"): signals.append("⚠️ 15min假突破！排除") score -= 5 if entry_action == "即刻买入": signals.append("🟢 15min即刻入场信号") score += 3 elif entry_action == "等回踩": wait_price = pa_15min_result.get("wait_price", 0) if wait_price > 0: signals.append(f"🟡 15min等回踩到${wait_price:.4f}") elif entry_action == "放弃": signals.append("🔴 15min无入场信号") # ---- 日线底部突破回踩检测（提前到门控前，供高位过滤器复用）---- # 复用已拉取的 d1_df，零额外API调用 bp_daily = {"detected": False} try: if d1_df is not None and len(d1_df) >= 50: bp_daily = detect_breakout_pullback(d1_df, "日线") except Exception: pass # ---- 底部突破回踩加分（必须在最终确认判定前生效）---- if bp_daily.get("detected"): signals.extend(bp_daily.get("signals", [])) score += min(bp_daily["score"], 12) # ---- 最终确认判定（v1.7.0：双门控 — 量价齐飞 OR 强共振旁路）---- # 门控A：量价齐飞K ≥1（保留，历史最可靠） # 门控B：强共振旁路 — 起爆点≥10× + 蓄力≥4根 + 辅助信号≥1 # WIF案例: 起爆点15×+板块联动→等2天才放量，$0.193→$0.211(+9.3%) fresh_ok, fresh_reason, fresh_events = _is_candidate_fresh( cand, current_trigger_times, max_hours=confirm_cfg.get("current_trigger_max_age_hours", 6), ) if not fresh_ok: signals.append("⛔ 候选过期：无近6小时当前触发，避免旧结构反复确认") confirmed = fresh_ok and (vp_fly_count >= 1) if not confirmed and fresh_ok: # 旧放量/旧起爆不能直接确认；但如果当前 15min/日线/结构给出强分， # 允许作为“历史强背景 + 当前结构确认”。避免修复时效后把所有结构型机会一刀切为0。 structure_gate_score = confirm_cfg.get("structure_gate_min_score", 12) current_trigger_ok = bool(current_trigger_times) recent_candidate_ok = (fresh_reason == "fresh_candidate_state") if score >= structure_gate_score and entry_action in ("即刻买入", "可即刻买入") and (current_trigger_ok or recent_candidate_ok): if fresh_reason != "stale_structure_background_only" and (stale_vp_count > 0 or stale_1h_ignitions or stale_d1_ignitions or bp_daily.get("detected")): signals.append(f"🟡 历史强背景+当前结构确认(score≥{structure_gate_score})") confirmed = True # ---- v1.7.0: 强共振旁路（在量价齐飞门控未过时启用）---- if fresh_ok and not confirmed: bypass_cfg = _get_cfg_section("confirm").get("strong_resonance_bypass", {}) if bypass_cfg.get("enabled", True): # 1. 最大起爆点强度（1H + 4H + 日线） max_ig_strength = 0 for ig in recent_1h_ignitions[-5:]: if ig.get("direction") == 1: max_ig_strength = max(max_ig_strength, ig.get("strength_ratio", 0)) if pa_4h: pa_4h_ignitions = pa_4h.get("ignition_points", []) recent_4h_ignitions, _ = _recent_pa_items(pa_4h_ignitions, pa_recency_cfg.get("h4_ignition_max_age_bars", 1)) for ig in recent_4h_ignitions[-5:]: if ig.get("direction") == 1: max_ig_strength = max(max_ig_strength, ig.get("strength_ratio", 0)) if pa_1d: d1_ignitions = pa_1d.get("ignition_points", []) recent_d1_for_bypass, _ = _recent_pa_items(d1_ignitions, pa_recency_cfg.get("d1_ignition_max_age_bars", 1)) for ig in recent_d1_for_bypass[-5:]: if ig.get("direction") == 1: max_ig_strength = max(max_ig_strength, ig.get("strength_ratio", 0) * 1.5) # 日线权重1.5× # 2. 静K蓄力计数（1H最近12根） static_k_count = sum( 1 for c in (pa_1h_candles[-12:] if pa_1h_candles else []) if c.get("type") == "static" ) # 3. 辅助信号计数 aux_count = 0 # 板块联动：leader_status含"龙头" if leader_status and "龙头" in str(leader_status): aux_count += 1 # 大户偏多：>55% deriv = cand_detail.get("derivatives_context", {}) top_long = deriv.get("top_trader_long_pct") if deriv else None if top_long is not None and top_long > 55: aux_count += 1 # 日线筑底 if bp_daily.get("detected"): aux_count += 1 # 舆情共振：screener给了sentiment_bonus sentiment_bonus = cand_detail.get("sentiment_bonus") if sentiment_bonus is not None and sentiment_bonus > 0: aux_count += 1 min_ig = bypass_cfg.get("min_ignition_strength", 10) min_static = bypass_cfg.get("min_static_k_count", 4) min_aux = bypass_cfg.get("min_aux_signals", 1) if max_ig_strength >= min_ig and static_k_count >= min_static and aux_count >= min_aux: bonus = bypass_cfg.get("score_bonus", 3) signals.append( "🔥 强共振旁路(起爆{}×+蓄力{}根+辅助{})".format( max_ig_strength, static_k_count, aux_count ) ) confirmed = True score += bonus # ---- 日线趋势安全检查（v1.6.3）---- # 日线持续走低 → 不确认，即使有1H量价齐飞 if confirmed and d1_df is not None and len(d1_df) >= 20: d1_closes = d1_df["close"].values.astype(float) d1_sma20 = float(d1_closes[-20:].mean()) d1_last = float(d1_closes[-1]) # 近5日趋势：净涨幅 < 0 且至少3天在跌 recent5 = d1_closes[-5:] net_change_pct = (float(recent5[-1]) - float(recent5[0])) / float(recent5[0]) * 100 down_days = sum(1 for i in range(1, len(recent5)) if float(recent5[i]) <= float(recent5[i-1])) if d1_last < d1_sma20 and net_change_pct < -2 and down_days >= 3: signals.append(f"⛔ 日线持续走低(价{d1_last:.5f}gain_7d%）+ 无底部突破信号 → 拒绝 # v1.7.8: range_percentile 从80%降到70%（数据：高位>70%入场TP率仅1%） # confirm_cfg 已在函数开头读取，供高位过滤+等回踩降权共用 if confirmed and d1_df is not None and len(d1_df) >= 60: d1_cl_all = d1_df["close"].values.astype(float) d1_hi_all = d1_df["high"].values.astype(float) max_60d = float(d1_hi_all[-60:].max()) min_60d = float(d1_cl_all[-60:].min()) cur_close = float(d1_cl_all[-1]) range_60d = max_60d - min_60d position_pct = (cur_close - min_60d) / range_60d * 100 if range_60d > 0 else 50 close_7d = float(d1_cl_all[-7]) gain_7d = (cur_close - close_7d) / close_7d * 100 if close_7d > 0 else 0 high_cfg = confirm_cfg.get("high_position", {}) high_percentile = high_cfg.get("range_percentile", 70) high_gain = high_cfg.get("gain_7d_pct", 15) is_high = position_pct > high_percentile and gain_7d > high_gain has_bottom = bp_daily.get("detected", False) if is_high and not has_bottom: signals.append( f"⛔ 高位无底部突破拒绝(区间{position_pct:.0f}%, 7日涨{gain_7d:.0f}%)" ) confirmed = False confirmed = confirmed and score >= confirm_min_score() # === 等回踩降权 (v1.6.9) === # 数据: 等回踩37%失败率 vs 持有0% # confirm_cfg 已在上面高位过滤器中获取 pullback_cfg = confirm_cfg.get("pullback_penalty", {}) if pullback_cfg.get("enabled", True) and entry_action == "等回踩": penalty = pullback_cfg.get("score_deduction", 3) score -= penalty signals.append(f"⚠️ 等回踩降权(-{penalty}分)") confirmed = confirmed and score >= confirm_min_score() # 假突破排除 if pa_15min_result.get("false_breakout"): confirmed = False # 衰减严重时排除 if pa_1h_exhaustion.get("severity") == "high": confirmed = False # ---- 入场方案 ---- stop_cfg = confirm_stop_loss_params() if confirmed and atr_1h > 0: if entry_action == "即刻买入" and pa_15min_result: entry_price = round(float(price), 6) entry_method = "🟢15min即刻入场(突破进行中)" elif entry_action == "等回踩" and pa_15min_result.get("wait_price", 0) > 0: entry_price = round(pa_15min_result["wait_price"], 6) entry_method = f"🟡等回踩到${entry_price:.4f}(15min静K确认)" else: last_k_low = float(h1_df["low"].iloc[-1]) atr_multipliers = confirm_atr_multipliers() entry_price = round(float(last_k_low + atr_multipliers.get("entry_offset", 0.5) * atr_1h), 6) entry_method = "1H突破回踩确认(突破K线低点+0.5ATR)" # 🔴 v1.7.6 修复: 等回踩/突破回踩的入场价不能高于当前市价。 # 出现这种情况意味着价格在目标之下运行，不是真正的"回踩等待"。 # 此时应取当前价作为入场参考，或取当前价×0.995作为保守目标。 if entry_action != "即刻买入" and entry_price > price: entry_price = round(float(price), 6) entry_method = f"{entry_method}（入场价已修正为当前价${price:.4f}）" signals.append("⚠️ 入场方案价高于现价，已修正为当前市价") # === ATR动态止损 (v1.6.8 → v1.7.1) === # 止损% = max(2×ATR_1h/price, 5%地板)，min(止损%, 10%天花板) atr_stop_pct = (atr_1h * stop_cfg.get("atr_mult", 2.0)) / price stop_pct_final = max(atr_stop_pct, stop_cfg.get("floor_pct", 0.05)) stop_pct_final = min(stop_pct_final, stop_cfg.get("ceiling_pct", 0.10)) atr_stop_price = round(float(price * (1 - stop_pct_final)), 6) # 收集所有止损候选 → 取最低价（最宽止损） stop_candidates = [atr_stop_price] # Q≥5需求区兜底：有结构支撑优先用需求区底部 demand_zones = [z for z in h4_zones if z["type"] == "demand" and z["q_score"] >= stop_cfg.get("demand_zone_min_q", 5)] if demand_zones: zone_stop = round(demand_zones[0]["btm"] * stop_cfg.get("zone_discount", 0.98), 6) stop_candidates.append(zone_stop) # v1.7.1: 结构止损 — 最近swing_low下方（AR案例：入场$2.21→最低$2.06→$2.06止损存活） swing_lookback = stop_cfg.get("swing_low_lookback", 12) swing_buffer = stop_cfg.get("swing_low_buffer", 0.98) if len(h1_df) >= swing_lookback: swing_low = float(h1_df["low"].tail(swing_lookback).min()) if swing_low < price: swing_stop = round(swing_low * swing_buffer, 6) # 只取有效的结构止损（在入场价下方，且不过于极端） if swing_stop > price * 0.82: stop_candidates.append(swing_stop) signals.append(f"结构止损(swing_low${swing_low:.4f}×{swing_buffer})") stop_loss = min(stop_candidates) # 最低价=最宽止损 # === ATR动态止盈 (v1.6.8) === # TP1% = max(3×ATR_1h/price, 5%地板), TP2% = max(5×ATR_1h/price, 8%地板) atr_multipliers = confirm_atr_multipliers() tp1_atr_pct = (atr_1h * atr_multipliers.get("tp1", 3.0)) / price tp1_pct = max(tp1_atr_pct, atr_multipliers.get("tp1_floor", 0.05)) tp1_candidates = [round(float(price * (1 + tp1_pct)), 6)] if high_q_supply: tp1_candidates.append(round(high_q_supply[0]["top"], 6)) tp1 = min(tp1_candidates) tp2_atr_pct = (atr_1h * atr_multipliers.get("tp2", 5.0)) / price tp2_pct = max(tp2_atr_pct, atr_multipliers.get("tp2_floor", 0.08)) tp2 = round(float(price * (1 + tp2_pct)), 6) risk = price - stop_loss reward1 = tp1 - price reward2 = tp2 - price rr1 = round(reward1 / risk, 2) if risk > 0 else 0 rr2 = round(reward2 / risk, 2) if risk > 0 else 0 entry_plan = { "entry_price": entry_price, "entry_method": entry_method, "entry_action": entry_action, "stop_loss": stop_loss, "stop_pct": round(stop_pct_final * 100, 1), "tp1": tp1, "tp2": tp2, # v1.7.8: TP2已废除(历史0命中),保留字段向后兼容.主止盈=跟踪止盈 "rr1": rr1, "rr2": rr2, "atr_1h": round(float(atr_1h), 6), "current_price": round(float(price), 6), "risk_reward_ok": rr1 >= 1.5, "pa_15min_summary": pa_15min_result.get("reason", ""), "pa_1h_exhaustion": pa_1h_exhaustion.get("severity", "low"), "trailing_stop_level": 0.0, # v1.7.8: tracker动态填充,初始0 } # v1.7.5 买点质量闸门：确认强势 ≠ 允许现价追买。 gated_action, gated_plan, gate_reasons = apply_entry_quality_gate( action_status="可即刻买入" if entry_action in ("即刻买入", "可即刻买入") else "等回踩", entry_plan=entry_plan, signals=signals, current_price=price, market_context=compute_market_context(h1_df, price), derivatives_context=cand_detail.get("derivatives_context", {}), sector_context=cand_detail.get("sector_context", {}), ) entry_plan = gated_plan entry_plan["entry_action"] = gated_action if gate_reasons: signals.append("⚠️ 买点质量闸门: " + "；".join(gate_reasons[:3])) if gated_action == "观察": score -= 2 # 周线突破回踩（需独立拉取） bp_weekly = {"detected": False} try: w1_df = fetch_klines(symbol, "1w", limit=52) if w1_df is not None and len(w1_df) >= 30: bp_weekly = detect_breakout_pullback(w1_df, "周线") except Exception: pass if bp_weekly.get("detected"): signals.extend(bp_weekly.get("signals", [])) score += min(bp_weekly["score"], 10) # ---- 计算上下文数据 ---- market_context = compute_market_context(h1_df, price) derivatives_context = fetch_derivatives_context(symbol) sector_context = compute_sector_context(symbol, cand_detail) trigger_context = _build_trigger_context( fresh_reason if 'fresh_reason' in locals() else "", fresh_events if 'fresh_events' in locals() else [], vp_data=vp_data if 'vp_data' in locals() else {}, stale_vp_count=stale_vp_count if 'stale_vp_count' in locals() else 0, stale_1h_ignitions=stale_1h_ignitions if 'stale_1h_ignitions' in locals() else [], stale_d1_ignitions=stale_d1_ignitions if 'stale_d1_ignitions' in locals() else [], bp_daily=bp_daily if 'bp_daily' in locals() else {}, entry_action=entry_action, ) market_context["trigger_context"] = trigger_context return { "confirmed": confirmed, "score": score, "signals": signals, "entry_plan": entry_plan if confirmed else {}, "price": round(float(price), 6), "pa_1h": pa_1h, "pa_15min": pa_15min_result, "pa_1d": pa_1d, "m30_aligned": m30_aligned, "entry_action": entry_action, "market_context": market_context, "derivatives_context": derivatives_context, "sector_context": sector_context, "fresh_reason": fresh_reason if 'fresh_reason' in locals() else "", "fresh_events": fresh_events if 'fresh_events' in locals() else [], "trigger_context": trigger_context if 'trigger_context' in locals() else {}, } def main(): started_at = datetime.now() try: init_db() expire_old_states() candidates = get_candidates_for_confirm() if not candidates: output = { "status": "no_candidates", "message": "无需要确认的候选（需加速状态+评分≥6）", "check_time": datetime.now().isoformat(), } print(json.dumps(output, ensure_ascii=False)) return output results = [] for cand in candidates: symbol = cand["symbol"] result = confirm_burst(symbol, cand) if result["confirmed"]: cand_detail = json.loads(cand.get("detail_json", "{}")) state_result = update_state( symbol, new_state="爆发", score=result["score"], anomaly_type=",".join(result["signals"][:3]), sector=cand_detail.get("sector", cand.get("sector", "")), leader_status=cand_detail.get("leader_status", cand.get("leader_status", "")), detail={**cand_detail, **result}, ) result["state_update"] = state_result # 飞书只是通知层：确认阶段不再绕过 recommendation 主链路直接推送。 # 先完成 create_recommendation + DB 主状态派生，再用同一条主链路结果决定是否通知。 log_screening( layer="确认", symbol=symbol, state="爆发", score=result["score"], price=result["price"], signals=result["signals"], sector=cand_detail.get("sector", cand.get("sector", "")), leader_status=cand_detail.get("leader_status", cand.get("leader_status", "")), is_meme=int(is_meme_coin(symbol)), ) # 🟢 只做做多！方向永远多头 rec_direction = get_strategy_direction() # 🔴 v1.7.7 冷却期：刚止盈/止损的币不立即重新推荐 # Sahara案例：17:24止盈(+5%)→17:40重新推荐→现价跌-3% cooldown_hours = 8 if symbol_recently_closed(symbol, hours=8) else 0 if cooldown_hours > 0: print(f"⏭ 跳过推荐({symbol}): 冷却期({cooldown_hours}h)，刚止盈/止损不宜追") results.append({**result, "cooling_off": True}) continue ep = result["entry_plan"] rec_id = create_recommendation( symbol=symbol, rec_state="爆发", rec_score=result["score"], entry_price=result["price"], stop_loss=ep.get("stop_loss", 0), tp1=ep.get("tp1", 0), tp2=ep.get("tp2", 0), sector=cand_detail.get("sector", cand.get("sector", "")), signals=result["signals"], is_meme=int(is_meme_coin(symbol)), entry_plan=ep, direction=rec_direction, market_context=result.get("market_context"), derivatives_context=result.get("derivatives_context"), sector_context=result.get("sector_context"), ) update_latest_price_cache(symbol, result["price"], updated_at=datetime.now().isoformat(), source="confirm") result["rec_id"] = rec_id # 主链路派生状态是网站和飞书的唯一共同口径。只通知实时看板也会消费的有效推荐记录。 mainline_item = get_recommendation_for_push(rec_id) if mainline_item and mainline_item.get("execution_status") in ("buy_now", "wait_pullback"): push_type = "entry" if mainline_item.get("execution_status") == "buy_now" else "watch_pool" action = mainline_item.get("action_status", "") if should_push(symbol, push_type, action): try: push_recommendation_state_alert(mainline_item) log_push(symbol, push_type, action, rec_id=rec_id) except Exception as e: print(f"飞书推送失败({symbol}): {e}") else: print(f"⏭ 跳过推送({symbol}): {push_type}/{action} 12h冷却中") else: status = mainline_item.get("execution_status") if mainline_item else "missing" print(f"[飞书跳过] {symbol}: 主链路状态={status}，不推旁路通知") else: result["state_update"] = {"should_alert": False, "reason": "未确认爆发"} results.append({"symbol": symbol, **result}) confirmed = [r for r in results if r["confirmed"]] unconfirmed = [r for r in results if not r["confirmed"]] output = { "status": "confirmed" if confirmed else "unconfirmed", "confirmed_count": len(confirmed), "unconfirmed_count": len(unconfirmed), "confirmed": confirmed, "unconfirmed": unconfirmed, "check_time": datetime.now().isoformat(), } print(json.dumps(output, ensure_ascii=False, indent=2)) return output except Exception as e: finished_at = datetime.now() log_cron_run( job_name="确认", script_name="altcoin_confirm.py", run_status="error", result_status="exception", started_at=started_at.isoformat(), finished_at=finished_at.isoformat(), duration_ms=int((finished_at - started_at).total_seconds() * 1000), summary={}, error_message=str(e), ) raise finally: if 'output' in locals(): finished_at = datetime.now() summary = { "confirmed_count": output.get("confirmed_count", 0), "unconfirmed_count": output.get("unconfirmed_count", 0), "processed_count": output.get("confirmed_count", 0) + output.get("unconfirmed_count", 0), } log_cron_run( job_name="确认", script_name="altcoin_confirm.py", run_status="success", result_status=output.get("status", "completed"), started_at=started_at.isoformat(), finished_at=finished_at.isoformat(), duration_ms=int((finished_at - started_at).total_seconds() * 1000), summary=summary, error_message="", ) if __name__ == "__main__": main()