""" 山寨币爆发监控系统 v11 — 纯前瞻行为派 只保留4个核心信号：量价齐飞 + 连续放量 + 静K→动K起爆 + 布林收窄 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 from pathlib import Path sys.path.insert(0, os.path.dirname(__file__)) from app.core.sector_map import ( SECTOR_MEMBERS, COIN_TO_SECTORS, MEME_SECTORS, MIN_24H_VOLUME_USD, MEME_MIN_24H_VOLUME_USD, get_sector_for_coin, is_meme_coin, get_burst_threshold, dynamic_leader_detection, ) from app.db.altcoin_db import ( init_db, expire_old_states, update_state, get_candidates_for_confirm, log_screening, create_recommendation, expire_old_recommendations, log_cron_run, ) from app.config.config_loader import ( get_signal_weights, get_strategy_direction, get_meta, vp_fly_params, bollinger_squeeze_params, funding_rate_params, top_trader_params, state_score_thresholds, get_screener_section, sentiment_max_bonus, ) from app.core.pa_engine import ( classify_candles, calc_atr, find_supply_demand_zones, find_continuous_k, detect_ignition_point, full_pa_analysis, ) exchange = ccxt.binance({"enableRateLimit": True}) REPO_ROOT = Path(__file__).resolve().parents[2] # ==================== 排除列表 ==================== STABLECOINS = { "USDT", "USDC", "BUSD", "TUSD", "DAI", "FDUSD", "USDP", "PAX", "USD1", "USDE", "USDS", "RLUSD", "PYUSD", "XUSD", "USDUC", "FRAX", "LUSD", "GUSD", "SUSD", "USDD", "EURS", "EUR", "GBP", } WRAPPED = {"WBTC", "WETH", "RENBTC"} BTC_ETH = {"BTC", "ETH"} GOLD_METAL = {"XAUT", "PAXG"} BNB_CHAIN = {"BNB"} EXCLUDED_BASE_SUFFIXES = ( "USD", "EUR", "GBP", "TRY", "BRL", "AUD", "FDUSD", "USDC", "USDP", "DAI" ) EXCLUDED_BASES = {"U", "USD1", "EUR", "GBP", "XUSD", "EURS", "USDUC"} # ==================== 信号权重（只有前瞻信号）==================== def get_dynamic_weights(): """获取动态权重（config_loader 已合并 yaml + DB）""" return get_signal_weights() # ==================== 工具函数 ==================== def fetch_all_tickers(): tickers = exchange.fetch_tickers() usdt_pairs = {} for symbol, info in tickers.items(): if "/USDT" in symbol: base = symbol.split("/")[0] if base in STABLECOINS or base in WRAPPED or base in BTC_ETH or base in GOLD_METAL or base in BNB_CHAIN: continue if base in EXCLUDED_BASES: continue if base.endswith(EXCLUDED_BASE_SUFFIXES): continue if not base.isascii(): continue vol_usd = info.get("quoteVolume", 0) or 0 usdt_pairs[symbol] = { "price": info.get("last", 0), "change_24h": info.get("percentage", 0) or 0, "volume_24h": vol_usd, "high_24h": info.get("high", 0), "low_24h": info.get("low", 0), } return usdt_pairs 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 as e: return None def fetch_funding_rates(): try: rates = exchange.fapiPublicGetFundingRate({"limit": 100}) result = {} for r in rates: symbol = r["symbol"].replace("USDT", "/USDT") rate = float(r["lastFundingRate"]) result[symbol] = rate return result except Exception: return {} def fetch_top_trader_ratio(symbol): """从 Binance 期货 API 获取大户多空比。 注意：ccxt 统一 API 不支持 topLongShortPositionRatio，直接用 requests。 """ try: pair = symbol.replace("/", "") r = requests.get( f"https://fapi.binance.com/futures/data/topLongShortAccountRatio" f"?symbol={pair}&period=1h&limit=2", timeout=5, ) if r.status_code == 200: data = r.json() if data: latest = data[-1] long_pct = float(latest.get("longAccount", 0)) * 100 short_pct = float(latest.get("shortAccount", 0)) * 100 ls_ratio = ( round(long_pct / short_pct, 2) if short_pct > 0 else 0 ) result = { "long_pct": round(long_pct, 1), "short_pct": round(short_pct, 1), "ratio": ls_ratio, } # OI 24h变化（对比最近2条） if len(data) >= 2 and "sumOpenInterest" in data[-2]: oi_prev = float(data[-2]["sumOpenInterest"]) oi_curr = float(data[-1].get("sumOpenInterest", 0) or 0) if oi_prev > 0: result["open_interest_change_24h"] = round( (oi_curr - oi_prev) / oi_prev * 100, 1 ) return result return None except Exception: return None # ==================== 核心前瞻信号检测 ==================== def detect_volume_price_fly(df_1h): """检测1H量价齐飞 + 时效衰减 量价齐飞 = 量≥5x均值 + 实体占比≥70% + 阳线 v1.6.10: 加入时效衰减 — 超过6小时的阳线只算0.3权重 """ if df_1h is None or len(df_1h) < 20: return None vp_cfg = vp_fly_params() avg_vol = df_1h["volume"].rolling(20).mean().iloc[-1] recent = df_1h.tail(12) vp_fly_count = 0 vp_fly_score = 0.0 # 时效加权分数（替代简单计数） vp_fly_details = [] stale_vp_fly_details = [] vol_3x_count = 0 consecutive_3x = 0 max_consecutive_3x = 0 max_vol_ratio = 0 latest_vp_index = -1 # 最近一根量价齐飞K在recent中的位置 # “1H量价齐飞”必须是最新信号。默认只承认最近2根1H K线； # 6~10小时前的放量阳线只能作为历史背景，不能继续触发当前推荐。 max_signal_age_hours = vp_cfg.get("max_signal_age_hours", 1) max_age_hours = vp_cfg.get("max_age_hours", 6) # 仅用于展示/兼容，不作为有效触发 decay_factor = vp_cfg.get("age_decay", 0.3) # 仅用于历史字段兼容 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 body_size_pct = abs(row["close"] - row["open"]) / row["open"] * 100 max_vol_ratio = max(max_vol_ratio, vol_ratio) # 时效权重：最新1根=1.0，每早1小时衰减 age_hours = len(recent) - 1 - i # 0=最新, 11=最旧 time_weight = 1.0 if age_hours <= max_age_hours else decay_factor relaxed_vol_ratio_min = vp_cfg.get("consecutive_relaxed_vol_ratio_min", 4.0) 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), "direction": "阳", "body_size": round(body_size_pct, 1), "age_hours": age_hours, "time_weight": round(time_weight, 2), } if age_hours <= max_signal_age_hours: vp_fly_count += 1 vp_fly_score += 1.0 vp_fly_details.append(detail) latest_vp_index = i else: detail["stale"] = True stale_vp_fly_details.append(detail) elif ( vol_ratio >= relaxed_vol_ratio_min 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), "direction": "阳", "body_size": round(body_size_pct, 1), "relaxed": True, "age_hours": age_hours, } if age_hours <= max_signal_age_hours: vp_fly_details.append(detail) if len(vp_fly_details) >= 2: tail2 = vp_fly_details[-2:] if all(d.get("relaxed") for d in tail2): vp_fly_count = max(vp_fly_count, 2) vp_fly_score = max(vp_fly_score, 2.0) else: detail["stale"] = True stale_vp_fly_details.append(detail) if len(vp_fly_details) >= 2: tail2 = vp_fly_details[-2:] if all(d.get("relaxed") for d in tail2): vp_fly_count = max(vp_fly_count, 2) vp_fly_score = max(vp_fly_score, 2 * time_weight) if vol_ratio >= 3: vol_3x_count += 1 consecutive_3x += 1 max_consecutive_3x = max(max_consecutive_3x, consecutive_3x) else: consecutive_3x = 0 # 冲高回落检测 pullback_info = _check_spike_pullback(recent, vp_fly_details, latest_vp_index) return { "vp_fly_count": vp_fly_count, "vp_fly_score": round(vp_fly_score, 1), # 时效加权分 "relaxed_vp_fly_count": sum(1 for d in vp_fly_details if d.get("relaxed")), "max_vol_ratio": round(max_vol_ratio, 1), "vol_3x_count": vol_3x_count, "max_consecutive_3x": max_consecutive_3x, "vp_fly_details": vp_fly_details, "stale_vp_fly_details": stale_vp_fly_details, "latest_vp_age_hours": min((d.get("age_hours", 999) for d in vp_fly_details), default=None), "stale_vp_fly_count": len(stale_vp_fly_details), "pullback": pullback_info, # 冲高回落信息 } def _check_spike_pullback(recent_df, vp_fly_details, latest_vp_index): """ 冲高回落检测：量价齐飞后是否持续阴跌 CFG案例：8x放量阳后连续阴跌10根→应标记为冲高回落 返回: {"is_pullback": bool, "bars_after": int, "drop_pct": float, "reason": str} """ if latest_vp_index < 0 or len(recent_df) < 3: return None # 量价齐飞K之后还有多少根K线 bars_after = len(recent_df) - 1 - latest_vp_index if bars_after < 3: return None # 量价齐飞发生时间太近，还没有足够的后续K线判断 # 获取量价齐飞K的高点和当前收盘价 vp_row = recent_df.iloc[latest_vp_index] spike_high = float(vp_row["high"]) spike_close = float(vp_row["close"]) # 后续K线 after_df = recent_df.iloc[latest_vp_index + 1:] current_close = float(recent_df["close"].iloc[-1]) # 从spike高点回落的幅度 drop_from_high = (spike_high - current_close) / spike_high * 100 if spike_high > 0 else 0 # 后续K线中阴线占比 bearish_count = sum(1 for _, r in after_df.iterrows() if r["close"] < r["open"]) total_after = len(after_df) bearish_ratio = bearish_count / total_after if total_after > 0 else 0 # 后续K线平均量能 vs 量价齐飞K的量能 vp_vol = float(vp_row["volume"]) avg_after_vol = float(after_df["volume"].mean()) if len(after_df) > 0 else 0 vol_decay_ratio = avg_after_vol / vp_vol if vp_vol > 0 else 0 # 判断冲高回落 is_pullback = ( drop_from_high > 5 # 从高点回落>5% and bearish_ratio >= 0.6 # 后续K线60%以上是阴线 and vol_decay_ratio < 0.5 # 后续量能不到爆量K的一半（缩量阴跌） ) reason = "" if is_pullback: reason = f"冲高回落: 从${spike_high:.4f}跌{drop_from_high:.1f}%, 后{bars_after}根{total_after-bearish_count}阳{bearish_count}阴(量缩至{vol_decay_ratio:.0%})" elif drop_from_high > 3 and bearish_ratio >= 0.5: reason = f"疑似回落: 从高点跌{drop_from_high:.1f}%, 后{bars_after}根阴线{bearish_ratio:.0%}" return { "is_pullback": is_pullback, "bars_after": bars_after, "drop_pct": round(drop_from_high, 1), "bearish_ratio": round(bearish_ratio, 2), "vol_decay_ratio": round(vol_decay_ratio, 2), "reason": reason, } def detect_bollinger_squeeze(df): """检测布林收窄 — 蓄力信号 物理规律：波动压缩到极限 → 必然释放（方向不确定但动能确定） ORCA案例：低位收窄+后续爆发37% """ if df is None or len(df) < 20: return None bb_mid = df["close"].rolling(20).mean() bb_std = df["close"].rolling(20).std() bb_upper = bb_mid + 2 * bb_std bb_lower = bb_mid - 2 * bb_std # 当前布林位置 price = df["close"].iloc[-1] bb_width_pct = ((bb_upper.iloc[-1] - bb_lower.iloc[-1]) / bb_mid.iloc[-1]) * 100 bb_pos = ((price - bb_lower.iloc[-1]) / (bb_upper.iloc[-1] - bb_lower.iloc[-1])) * 100 bb_cfg = bollinger_squeeze_params() # 连续收窄检测 recent_width = ((bb_upper - bb_lower) / bb_mid * 100).tail(6) moderate_width_pct = bb_cfg.get("moderate_width_pct", 0.05) * 100 tight_width_pct = bb_cfg.get("tight_width_pct", 0.03) * 100 min_bars = bb_cfg.get("min_bars", 4) squeeze_count = sum(1 for w in recent_width if w < moderate_width_pct) # 极度收窄 tight_squeeze = sum(1 for w in recent_width if w < tight_width_pct) >= min_bars # 收窄后的方向提示：价格在中轨以上→偏多，以下→偏空 squeeze_direction = "偏多" if bb_pos > 55 else "偏空" if bb_pos < 45 else "中性" return { "bb_width_pct": round(float(bb_width_pct), 2), "bb_pos": round(float(bb_pos), 1), "squeeze_count": squeeze_count, "tight_squeeze": tight_squeeze, "squeeze_direction": squeeze_direction, "price": round(float(price), 6), } def detect_static_accumulation(symbol, h4_df=None): """静K蓄力旁路：识别静K密集 + 临近放量的异动候选""" if h4_df is None or len(h4_df) < 30: return None bypass_cfg = get_screener_section("static_accumulation_bypass") recent_bars = bypass_cfg.get("recent_bars", 8) min_static_count = bypass_cfg.get("min_static_count", 4) max_range_pct = bypass_cfg.get("max_range_pct", 18.0) max_breakout_gap_pct = bypass_cfg.get("max_breakout_gap_pct", 6.0) pa = full_pa_analysis(h4_df, "4h") candles_class = pa.get("candles_class") or [] recent = candles_class[-recent_bars:] if len(candles_class) >= recent_bars else candles_class if not recent: return None static_count = sum(1 for c in recent if c.get("type") == "static") if static_count < min_static_count: return None recent_df = h4_df.tail(len(recent)).copy() avg_vol = h4_df["volume"].tail(20).mean() latest_vol = float(recent_df["volume"].iloc[-1]) vol_ratio = latest_vol / avg_vol if avg_vol else 0.0 recent_high = float(recent_df["high"].max()) recent_low = float(recent_df["low"].min()) latest_close = float(recent_df["close"].iloc[-1]) range_pct = ((recent_high - recent_low) / recent_low * 100) if recent_low > 0 else 0.0 breakout_gap_pct = ((recent_high - latest_close) / latest_close * 100) if latest_close > 0 else 0.0 if range_pct > max_range_pct or breakout_gap_pct > max_breakout_gap_pct: return None return { "static_count": static_count, "vol_ratio": round(vol_ratio, 2), "range_pct": round(range_pct, 2), "breakout_gap_pct": round(breakout_gap_pct, 2), "recent_high": round(recent_high, 6), "latest_close": round(latest_close, 6), } def detect_higher_lows(df, cfg=None): """检测4H K线底部抬高模式 复盘发现78.6%爆发漏选币有底部抬高特征，这是当前策略最大盲区。 输入: DataFrame (含high/low/close/volume列), cfg从rules.yaml→screener.higher_lows读取 返回: {found, hl_count, total_segments, hl_score, signal} """ if df is None or len(df) < 8: return {"found": False, "hl_count": 0, "total_segments": 0, "hl_score": 0, "signal": ""} if cfg is None: cfg = get_screener_section("higher_lows") lookback_bars = cfg.get("lookback_bars", 24) segment_bars = cfg.get("segment_bars", 4) min_segments = cfg.get("min_segments", 2) min_score = cfg.get("min_score", 2) if not cfg.get("enabled", True): return {"found": False, "hl_count": 0, "total_segments": 0, "hl_score": 0, "signal": ""} # 取最近 lookback_bars 根K线 recent = df.tail(lookback_bars) if len(recent) < segment_bars * 2: return {"found": False, "hl_count": 0, "total_segments": 0, "hl_score": 0, "signal": ""} # 按 segment_bars 根一组分段，取每段最低价 segment_lows = [] for i in range(0, len(recent), segment_bars): seg = recent.iloc[i:i + segment_bars] if len(seg) < segment_bars: break # 最后一段不完整则丢弃 segment_lows.append(float(seg["low"].min())) total_segments = len(segment_lows) if total_segments < 2: return {"found": False, "hl_count": 0, "total_segments": total_segments, "hl_score": 0, "signal": ""} # 统计有多少段的最低价高于前一段(底部抬高) hl_count = 0 for i in range(1, total_segments): if segment_lows[i] > segment_lows[i - 1]: hl_count += 1 found = hl_count >= min_segments hl_score = min_score if found else 0 signal = f"底部抬高({hl_count}/{total_segments}段)" if found else "" return { "found": found, "hl_count": hl_count, "total_segments": total_segments, "hl_score": hl_score, "signal": signal, } def detect_compression_surge(df, cfg=None): """检测4H K线压缩后放量模式 复盘发现29%爆发币在起爆前振幅<20%+突然放量>2x。紧凑型压缩后爆发模式。 输入: DataFrame (含high/low/close/volume列), cfg从rules.yaml→screener.compression_surge读取 返回: {found, range_pct, vol_ratio, score, signal} """ if df is None or len(df) < 24: return {"found": False, "range_pct": 0, "vol_ratio": 0, "score": 0, "signal": ""} if cfg is None: cfg = get_screener_section("compression_surge") lookback_bars = cfg.get("lookback_bars", 24) max_range_pct = cfg.get("max_range_pct", 20.0) min_vol_ratio = cfg.get("min_vol_ratio", 2.0) min_score = cfg.get("min_score", 2) if not cfg.get("enabled", True): return {"found": False, "range_pct": 0, "vol_ratio": 0, "score": 0, "signal": ""} # 取 lookback_bars 根K线计算价格振幅 recent = df.tail(lookback_bars) max_high = float(recent["high"].max()) min_low = float(recent["low"].min()) range_pct = ((max_high - min_low) / min_low * 100) if min_low > 0 else 0 # 振幅 < max_range_pct → 压缩 if range_pct >= max_range_pct: return {"found": False, "range_pct": round(range_pct, 2), "vol_ratio": 0, "score": 0, "signal": ""} # 最近3根K线均量 vs 前21根均量 recent_3_vol = float(recent["volume"].tail(3).mean()) prior_21_vol = float(recent["volume"].iloc[:-3].mean()) if len(recent) > 3 else recent_3_vol vol_ratio = recent_3_vol / prior_21_vol if prior_21_vol > 0 else 0 found = vol_ratio >= min_vol_ratio score = min_score if found else 0 signal = f"压缩放量(振幅{range_pct:.1f}%,量比{vol_ratio:.1f}x)" if found else "" return { "found": found, "range_pct": round(range_pct, 2), "vol_ratio": round(vol_ratio, 2), "score": score, "signal": signal, } def _build_signal_recency(cand): """把粗筛/细筛命中的信号按 current/stale 标记，避免旧形态冒充当下机会。""" current = [] stale = [] vp = cand.get("vp_data") or {} if vp.get("vp_fly_count", 0) > 0: current.append({"type": "volume_price", "label": "当前1H量价齐飞", "timeframe": "1h", "age_hours": vp.get("latest_vp_age_hours")}) if vp.get("stale_vp_fly_count", 0) > 0: stale.append({"type": "volume_price", "label": "历史1H量价齐飞", "timeframe": "1h", "count": vp.get("stale_vp_fly_count")}) if cand.get("static_accumulation"): current.append({"type": "structure", "label": "当前4H静K蓄力", "timeframe": "4h"}) if cand.get("higher_lows"): current.append({"type": "structure", "label": "当前4H底部抬高", "timeframe": "4h"}) if cand.get("compression_surge"): current.append({"type": "structure", "label": "当前4H压缩放量", "timeframe": "4h"}) if cand.get("sentiment") or cand.get("sentiment_bonus"): current.append({"type": "sentiment", "label": "舆情共振", "source": "sentiment_monitor"}) status = "current" if current else "stale_background_only" if stale else "unknown" return {"status": status, "current": current, "stale": stale} # ==================== 第一层：粗筛 ==================== def layer1_coarse_filter(): """粗筛 — 只检测量价行为+布林收窄，不计算任何滞后指标""" print("=== 第一层：粗筛（v11纯前瞻） ===") tickers = fetch_all_tickers() funding_rates = fetch_funding_rates() weights = get_dynamic_weights() candidates = {} # === 24h筛选历史豁免 (v1.6.9) === # 过去24h内在screening_log出现过的币，不受"涨太多"过滤限制 # 防止ICP/SUI类：系统早已盯上但被burst_threshold×1.5误挡 import sqlite3 as _sq _c = _sq.connect(os.getenv("ALPHAX_DB_PATH", str(REPO_ROOT / "data" / "altcoin_monitor.db"))) _recent = _c.execute(""" SELECT DISTINCT symbol FROM screening_log WHERE scan_time >= datetime('now', '-24 hours') """).fetchall() _c.close() recently_screened = {r[0] for r in _recent} print(f" 24h已筛选币种: {len(recently_screened)} 只，豁免涨太多过滤") try: exchange.fapiPublicGetTicker24hr() except Exception: futures_24h_map = {} else: futures_24h_map = { item.get("symbol", "").replace("USDT", "/USDT"): item for item in exchange.fapiPublicGetTicker24hr() if item.get("symbol", "").endswith("USDT") } for symbol, info in tickers.items(): base = symbol.split("/")[0] vol = info["volume_24h"] change = info["change_24h"] meme = is_meme_coin(symbol) min_vol = MEME_MIN_24H_VOLUME_USD if meme else MIN_24H_VOLUME_USD if vol < min_vol: continue anomalies = [] anomaly_score = 0 vp_data = None bb_data = None static_accumulation = None # 1H量价齐飞检测（核心） h1_df = fetch_klines(symbol, "1h", limit=72) h4_df = fetch_klines(symbol, "4h", limit=100) if h1_df is not None and len(h1_df) >= 20: vp_data = detect_volume_price_fly(h1_df) if vp_data: # 量价齐飞K≥1 → 最强信号 if vp_data["vp_fly_count"] >= 2: for detail in vp_data["vp_fly_details"]: anomalies.append(f"量价齐飞(量{detail['vol_ratio']}x,实体{detail['body_pct']}%)") if detail["vol_ratio"] >= 10: anomaly_score += weights["N倍放量(≥10x)"] else: anomaly_score += weights["量价齐飞"] anomalies.append(f"连续2根量价齐飞K(极强)") anomaly_score += 3 # 多根量价齐飞额外加分 elif vp_data["vp_fly_count"] == 1: detail = vp_data["vp_fly_details"][0] anomalies.append(f"量价齐飞(量{detail['vol_ratio']}x,实体{detail['body_pct']}%)") if detail["vol_ratio"] >= 10: anomaly_score += weights["N倍放量(≥10x)"] else: anomaly_score += weights["量价齐飞"] elif vp_data.get("relaxed_vp_fly_count", 0) >= 2 and vp_data["vp_fly_details"]: for detail in vp_data["vp_fly_details"][:2]: anomalies.append(f"量价齐飞(量{detail['vol_ratio']}x,实体{detail['body_pct']}%)") anomaly_score += weights["量价齐飞"] anomalies.append("连续2根量价齐飞K(放宽旁路)") anomaly_score += 2 # 连续3x放量≥3根 → 真放量（对比：BIO单根10x→失败） if vp_data["max_consecutive_3x"] >= 3: anomalies.append(f"连续{vp_data['max_consecutive_3x']}根3x放量") anomaly_score += weights["连续3x放量(≥3根)"] elif vp_data["max_consecutive_3x"] >= 2: anomalies.append(f"连续{vp_data['max_consecutive_3x']}根3x放量") anomaly_score += 2 # 大量但无量价齐飞 → 量价背离假信号（最低权重） if vp_data["max_vol_ratio"] >= 5 and vp_data["vp_fly_count"] == 0: anomalies.append(f"1H放量({vp_data['max_vol_ratio']}x)但无量价齐飞(量价背离)") anomaly_score += 1 # 量价背离最低分 # 布林收窄检测（4H级别） if h4_df is not None and len(h4_df) >= 20: bb_data = detect_bollinger_squeeze(h4_df) if bb_data: if bb_data["tight_squeeze"]: anomalies.append(f"4H布林极度收窄(宽度{bb_data['bb_width_pct']}%,{bb_data['squeeze_direction']})") anomaly_score += weights["布林收窄"] elif bb_data["squeeze_count"] >= 4: anomalies.append(f"4H布林收窄(宽度{bb_data['bb_width_pct']}%,{bb_data['squeeze_direction']})") anomaly_score += 2 static_accumulation = detect_static_accumulation(symbol, h4_df) if static_accumulation and static_accumulation["vol_ratio"] >= 1.2: anomalies.append( f"4H静K蓄力旁路({static_accumulation['static_count']}静K,量比{static_accumulation['vol_ratio']}x)" ) anomaly_score += max(1, weights.get("静K蓄力", 2)) # 资金费率极端（保留） fr = funding_rates.get(symbol, 0) funding_cfg = funding_rate_params() if fr > funding_cfg.get("long_extreme", 0.001): anomalies.append(f"资金费率极端偏高({fr*100:.3f}%)") anomaly_score += 2 elif fr < funding_cfg.get("short_extreme", -0.0005): anomalies.append(f"资金费率极端偏低({fr*100:.3f}%)") anomaly_score += 2 # 排除已涨太多 — 但24h内已被系统盯上的币豁免 burst_threshold = get_burst_threshold(symbol) if change > burst_threshold * 1.5 and symbol not in recently_screened: continue if anomalies: # === 冲高回落检查：量价齐飞后持续阴跌→拒绝 === if isinstance(vp_data, dict) and (vp_data.get("pullback") or {}).get("is_pullback"): pb = vp_data["pullback"] print(f" ⛔ {symbol} 冲高回落拒绝: {pb['reason']}") continue # 直接跳过，不入候选池 futures_24h = futures_24h_map.get(symbol, {}) quote_volume = float(futures_24h.get("quoteVolume") or vol or 0) base_volume = float(futures_24h.get("volume") or 0) weighted_avg_price = float(futures_24h.get("weightedAvgPrice") or info.get("price") or 0) turnover_acc_1h = round(vp_data["max_vol_ratio"], 2) if vp_data else 0 turnover_acc_4h = round(static_accumulation["vol_ratio"], 2) if static_accumulation else 0 candidates[symbol] = { "anomalies": anomalies, "anomaly_score": anomaly_score, "price": info["price"], "change_24h": change, "volume_24h": vol, "funding_rate": fr, "is_meme": meme, "vp_data": vp_data, "bb_data": bb_data, "static_accumulation": static_accumulation, "h4_df": h4_df, "turnover_acceleration_1h": turnover_acc_1h, "turnover_acceleration_4h": turnover_acc_4h, "base_volume_24h": round(base_volume, 2), "quote_volume_24h": round(quote_volume, 2), "weighted_avg_price": round(weighted_avg_price, 6) if weighted_avg_price else 0, } # ==== 第二遍扫描：低成交量静K蓄力旁路 + 底部抬高 + 压缩放量 ==== bypass_cfg = get_screener_section("static_accumulation_bypass") bypass_min_vol = bypass_cfg.get("min_volume_24h", 2000000) bypass_min_vol_ratio = bypass_cfg.get("min_vol_ratio", 1.2) bypass_count = 0 hl_count_total = 0 cs_count_total = 0 # 主门槛：第一遍扫描的最低成交量门槛 main_min_vol = min(MIN_24H_VOLUME_USD, MEME_MIN_24H_VOLUME_USD) hl_cfg = get_screener_section("higher_lows") cs_cfg = get_screener_section("compression_surge") hl_min_vol = hl_cfg.get("min_volume_24h", 2000000) if hl_cfg.get("enabled", True) else float("inf") cs_min_vol = cs_cfg.get("min_volume_24h", 2000000) if cs_cfg.get("enabled", True) else float("inf") for symbol, info in tickers.items(): if symbol in candidates: continue vol = info["volume_24h"] if vol < bypass_min_vol and vol < hl_min_vol and vol < cs_min_vol: continue change = info["change_24h"] burst_threshold = get_burst_threshold(symbol) if change > burst_threshold * 1.5 and symbol not in recently_screened: continue meme = is_meme_coin(symbol) fr = funding_rates.get(symbol, 0) # 拉取4H数据（只拉一次，多个检测复用） h4_df = fetch_klines(symbol, "4h", limit=100) if h4_df is None or len(h4_df) < 20: continue added = False # 防止同一个币被多个检测重复收录 # 1) 静K蓄力旁路 if vol >= bypass_min_vol: static_acc = detect_static_accumulation(symbol, h4_df) if static_acc and static_acc["vol_ratio"] >= bypass_min_vol_ratio: anomalies = [ f"4H静K蓄力旁路({static_acc['static_count']}静K,量比{static_acc['vol_ratio']}x)" ] anomaly_score = max(1, weights.get("静K蓄力", 2)) candidates[symbol] = { "anomalies": anomalies, "anomaly_score": anomaly_score, "price": info["price"], "change_24h": change, "volume_24h": vol, "funding_rate": fr, "is_meme": meme, "vp_data": None, "bb_data": None, "static_accumulation": static_acc, "h4_df": h4_df, "turnover_acceleration_1h": 0, "turnover_acceleration_4h": round(static_acc["vol_ratio"], 2), "base_volume_24h": 0, "quote_volume_24h": 0, "weighted_avg_price": info.get("price", 0), "bypass_origin": True, } bypass_count += 1 added = True # 2) 底部抬高检测（成交量在 hl_min_vol~主门槛之间，不重复收录） if not added and hl_cfg.get("enabled", True) and hl_min_vol <= vol < main_min_vol: hl_result = detect_higher_lows(h4_df, hl_cfg) if hl_result["found"]: anomalies = [f"4H {hl_result['signal']}"] anomaly_score = hl_result["hl_score"] candidates[symbol] = { "anomalies": anomalies, "anomaly_score": anomaly_score, "price": info["price"], "change_24h": change, "volume_24h": vol, "funding_rate": fr, "is_meme": meme, "vp_data": None, "bb_data": None, "static_accumulation": None, "higher_lows": hl_result, "h4_df": h4_df, "turnover_acceleration_1h": 0, "turnover_acceleration_4h": 0, "base_volume_24h": 0, "quote_volume_24h": 0, "weighted_avg_price": info.get("price", 0), "bypass_origin": "higher_lows", } hl_count_total += 1 added = True # 3) 压缩放量检测（成交量在 cs_min_vol~主门槛之间，不重复收录） if not added and cs_cfg.get("enabled", True) and cs_min_vol <= vol < main_min_vol: cs_result = detect_compression_surge(h4_df, cs_cfg) if cs_result["found"]: anomalies = [f"4H {cs_result['signal']}"] anomaly_score = cs_result["score"] candidates[symbol] = { "anomalies": anomalies, "anomaly_score": anomaly_score, "price": info["price"], "change_24h": change, "volume_24h": vol, "funding_rate": fr, "is_meme": meme, "vp_data": None, "bb_data": None, "static_accumulation": None, "compression_surge": cs_result, "h4_df": h4_df, "turnover_acceleration_1h": 0, "turnover_acceleration_4h": round(cs_result["vol_ratio"], 2), "base_volume_24h": 0, "quote_volume_24h": 0, "weighted_avg_price": info.get("price", 0), "bypass_origin": "compression_surge", } cs_count_total += 1 added = True if bypass_count or hl_count_total or cs_count_total: parts = [] if bypass_count: parts.append(f"静K蓄力旁路+{bypass_count}") if hl_count_total: parts.append(f"底部抬高+{hl_count_total}") if cs_count_total: parts.append(f"压缩放量+{cs_count_total}") print(f"第二遍扫描: {', '.join(parts)}个候选") # === 舆情共振加权 === try: from app.services.sentiment_monitor import get_sentiment_scores sentiment_cfg = get_screener_section("sentiment") or {} if sentiment_cfg.get("enabled", True): sentiment_scores = get_sentiment_scores() if sentiment_scores: max_bonus = sentiment_max_bonus() bonus_count = 0 for symbol, cand in candidates.items(): sent = sentiment_scores.get(symbol) if sent and sent.get("bonus", 0) > 0: cand["anomaly_score"] += sent["bonus"] cand["anomalies"].append(f"📢 舆情共振({sent['details']})+{sent['bonus']}") cand["sentiment"] = sent cand["sentiment_bonus"] = sent["bonus"] bonus_count += 1 if bonus_count: print(f"舆情共振: {bonus_count}个候选加分") except Exception as e: print(f"舆情模块加载失败(非致命): {e}") total_bypass = bypass_count + hl_count_total + cs_count_total print(f"粗筛结果: {len(candidates)}个候选（含{total_bypass}个旁路: 静K{bypass_count}+底抬{hl_count_total}+压放{cs_count_total}）") return candidates # ==================== 第二层：细筛 ==================== def layer2_fine_filter(candidates): """细筛 — 静K蓄力+量价突变（山寨币专用 v1.5）""" print("=== 第二层：细筛（v11纯前瞻） ===") qualified = {} weights = get_dynamic_weights() # 板块联动检测 sector_perf = {} for sector, coins in SECTOR_MEMBERS.items(): sector_perf[sector] = {} for coin in coins: if coin in candidates: sector_perf[sector][coin] = candidates[coin]["change_24h"] else: try: ticker = exchange.fetch_ticker(coin) pct = ticker.get("percentage", 0) or 0 sector_perf[sector][coin] = pct except Exception: pass leaders = dynamic_leader_detection(sector_perf) hot_sectors = {s for s, info in leaders.items() if info["is_leader_hot"]} print(f"热门板块: {hot_sectors}") static_cfg = get_screener_section("static_accumulation_bypass") static_bypass_min_score = static_cfg.get("min_score", 3) static_bypass_min_vol_ratio = static_cfg.get("min_vol_ratio", 1.2) for symbol, cand in candidates.items(): signals = [] score = cand["anomaly_score"] meme = cand["is_meme"] base_state = None force_accumulate_reason = None # 继承粗筛量价齐飞数据（核心确认信号） vp_data = cand.get("vp_data") if vp_data: if vp_data["vp_fly_count"] >= 2: signals.append(f"1H {vp_data['vp_fly_count']}根量价齐飞K") score += 3 elif vp_data["vp_fly_count"] == 1: signals.append(f"1H 量价齐飞K(量{vp_data['max_vol_ratio']}x)") score += 2 if vp_data.get("stale_vp_fly_count", 0) and vp_data["vp_fly_count"] == 0: stale = vp_data.get("stale_vp_fly_details", [{}])[-1] signals.append(f"1H历史量价齐飞已过期({stale.get('age_hours')}小时前, 量{stale.get('vol_ratio')}x)") if vp_data["max_consecutive_3x"] >= 4: signals.append(f"1H 连续{vp_data['max_consecutive_3x']}根3x放量") score += 2 # 继承布林数据（蓄力末期特征） bb_data = cand.get("bb_data") if bb_data and bb_data["tight_squeeze"]: signals.append(f"4H布林极度收窄({bb_data['squeeze_direction']})") # 静K蓄力 — 粗筛已计分，细筛只打标签+时长bonus static_accumulation = cand.get("static_accumulation") if static_accumulation and static_accumulation["vol_ratio"] >= static_bypass_min_vol_ratio: sc = static_accumulation['static_count'] vr = static_accumulation['vol_ratio'] signals.append(f"4H静K蓄力观察({sc}静K,量比{vr}x)") # 蓄力时长加成: 每多4根+1分 (静K越久爆发越猛) duration_bonus = max(0, (sc - static_cfg.get('min_static_count', 4)) // 4) if duration_bonus > 0: score += duration_bonus # 底部抬高 — 粗筛第二遍扫描命中，细筛打标签+标记蓄力 higher_lows = cand.get("higher_lows") if higher_lows and higher_lows.get("found"): signals.append(f"4H {higher_lows['signal']}") # 压缩放量 — 粗筛第二遍扫描命中，细筛打标签+标记蓄力 compression_surge = cand.get("compression_surge") if compression_surge and compression_surge.get("found"): signals.append(f"4H {compression_surge['signal']}") # 拉取4H数据做PA分析（只保留对山寨币有用的信号） h4_df = cand.get("h4_df") h4_pa = full_pa_analysis(h4_df, "4h") if h4_df is not None and len(h4_df) >= 30 else None if h4_pa: h4_candles_class = h4_pa["candles_class"] recent_4h = h4_candles_class[-6:] if len(h4_candles_class) >= 6 else h4_candles_class # 静K蓄力标签（粗筛已计分，只打标签） static_count_4h = sum(1 for c in recent_4h if c["type"] == "static") if static_count_4h >= 3: signals.append(f"4H {static_count_4h}静K蓄力") # 起爆点：静K→动K转折（辅助确认）— 只承认最近/上一根4H内发生 h4_ignitions = h4_pa["ignition_points"] stale_h4_ignitions = [] for ig in h4_ignitions[-2:]: age = ig.get("age_bars", 999) if age > 1: stale_h4_ignitions.append(ig) continue if ig["direction"] == 1: signals.append(f"4H {ig['signal_type']}(强度{ig['strength_ratio']}×)") score += weights.get("静K→动K转折", weights.get("静K动K转折", 3)) elif ig["direction"] == -1: signals.append(f"4H {ig['signal_type']}(空头起爆,强度{ig['strength_ratio']}×)") if stale_h4_ignitions: ig = stale_h4_ignitions[-1] signals.append(f"4H历史起爆点已过期({ig.get('age_bars')}根前, 强度{ig.get('strength_ratio')}×)") # 板块联动 — 纯信息参考，不加分 coin_sectors = get_sector_for_coin(symbol) sector_signal_count = 0 for sector in coin_sectors: if sector in hot_sectors: leader_info = leaders[sector] signals.append(f"板块联动: {sector}龙头{leader_info['leader']}涨{leader_info['leader_pct']:.1f}%") sector_signal_count += 1 # 大户方向 ratio = fetch_top_trader_ratio(symbol) if ratio: if ratio["long_pct"] > top_trader_params().get("long_pct_min", 0.55) * 100: signals.append(f"大户偏多({ratio['long_pct']:.0f}%)") score += weights["大户偏多"] # 判断状态 threshold_score_main, threshold_score_meme, accumulate_threshold = state_score_thresholds() if score >= (threshold_score_meme if meme else threshold_score_main): state = "加速" elif score >= accumulate_threshold: state = "蓄力" else: state = "过期" base_state = state # 静K蓄力旁路：即使原始状态是过期，有静K蓄力+量比达标→至少蓄力 if ( state == "过期" and static_accumulation and static_accumulation["vol_ratio"] >= static_bypass_min_vol_ratio and score >= static_bypass_min_score ): state = "蓄力" force_accumulate_reason = "静K蓄力旁路" signals.append("静K蓄力旁路入池") # v1.7.2：强静K蓄力直升加速。 # 复盘PNT/CREAM/CLV/STORJ/ZEC等漏选样本后发现：山寨爆发前常见“长时间静K蓄力 + 温和放量”， # 只放进蓄力观察池仍可能在确认层前漏掉，因此允许强静K样本直接进入加速推荐/确认链路。 direct_acc_cfg = static_cfg.get("direct_accelerate", {}) or {} if ( direct_acc_cfg.get("enabled", False) and static_accumulation and state == "蓄力" and static_accumulation.get("static_count", 0) >= direct_acc_cfg.get("min_static_count", 10) and static_accumulation.get("vol_ratio", 0) >= direct_acc_cfg.get("min_vol_ratio", 1.25) and score >= direct_acc_cfg.get("min_score", 5) ): state = "加速" force_accumulate_reason = "强静K蓄力直升加速" signals.append("强静K蓄力直升加速") # 第二遍扫描入口标记 — 为不同 bypass_origin 生成对应的 force_reason if ( state in ("蓄力", "加速") and cand.get("bypass_origin") and not force_accumulate_reason ): origin = cand.get("bypass_origin") if origin == "higher_lows": force_accumulate_reason = "底部抬高旁路" elif origin == "compression_surge": force_accumulate_reason = "压缩放量旁路" else: force_accumulate_reason = "静K蓄力旁路" # 底部抬高/压缩放量旁路：即使原始状态是过期，命中后至少蓄力 if ( state == "过期" and cand.get("bypass_origin") in ("higher_lows", "compression_surge") and score >= 0 ): state = "蓄力" origin = cand.get("bypass_origin") if origin == "higher_lows" and not force_accumulate_reason: force_accumulate_reason = "底部抬高旁路" elif origin == "compression_surge" and not force_accumulate_reason: force_accumulate_reason = "压缩放量旁路" if state in ("蓄力", "加速"): sector_str = ",".join(coin_sectors) leader_str = "" leader_symbol = "" leader_pct = 0 for sector in coin_sectors: if sector in leaders and leaders[sector]["leader"]: info = leaders[sector] if info["leader"] == symbol: leader_str = f"板块龙头({sector})" leader_symbol = symbol # 本币就是龙头 leader_pct = info.get("leader_pct", 0) break elif not leader_str: # 非龙头币：记录板块龙头是谁 leader_str = f"龙头{info['leader']}" leader_symbol = info["leader"] leader_pct = info.get("leader_pct", 0) # 🟢 只做做多！空头信号只记录不加分，方向永远多头 # 空头起爆/空头加速只是衰减参考，不生成推荐 direction = get_strategy_direction() direction_num = 1 qualified[symbol] = { "state": state, "score": score, "signals": signals, "direction": direction, "direction_num": direction_num, "sector": sector_str, "leader_status": leader_str, "price": cand["price"], "is_meme": meme, "change_24h": cand["change_24h"], "funding_rate": cand["funding_rate"], "base_state": base_state, "force_reason": force_accumulate_reason, "sector_signal_count": sector_signal_count, "signal_recency": _build_signal_recency(cand), "market_context": { "volume_24h": cand.get("volume_24h"), "quote_volume_24h": cand.get("quote_volume_24h"), "base_volume_24h": cand.get("base_volume_24h"), "weighted_avg_price": cand.get("weighted_avg_price"), "change_24h": cand.get("change_24h"), "funding_rate": cand.get("funding_rate"), "signal_recency": _build_signal_recency(cand), "trigger_context": {"trigger_status": _build_signal_recency(cand).get("status"), "current_triggers": _build_signal_recency(cand).get("current"), "stale_background": _build_signal_recency(cand).get("stale")}, "turnover_acceleration_1h": cand.get("turnover_acceleration_1h"), "turnover_acceleration_4h": cand.get("turnover_acceleration_4h"), }, "derivatives_context": { "funding_rate": cand.get("funding_rate"), "open_interest_change_24h": (ratio or {}).get("open_interest_change_24h", 0) or 0, "top_trader_long_pct": ratio.get("long_pct") if ratio else None, "top_trader_short_pct": ratio.get("short_pct") if ratio else None, "top_trader_long_short_ratio": ratio.get("ratio") if ratio else None, }, "sector_context": { "sectors": coin_sectors, "hot_sectors": [sector for sector in coin_sectors if sector in hot_sectors], "leader_symbol": leader_symbol, "leader_status": leader_str, "leader_pct": leader_pct, }, } log_screening( layer="细筛", symbol=symbol, state=state, score=score, price=cand["price"], signals=signals, sector=sector_str, leader_status=leader_str, is_meme=int(meme), change_24h=cand["change_24h"], funding_rate=cand["funding_rate"], ) if state == "加速": rec_id = create_recommendation( symbol=symbol, rec_state="加速", rec_score=score, entry_price=cand["price"], sector=sector_str, signals=signals, is_meme=int(meme), entry_plan=None, direction=direction, force_reason=force_accumulate_reason or "", base_state=base_state or "", sector_signal_count=sector_signal_count, market_context=qualified[symbol]["market_context"], derivatives_context=qualified[symbol]["derivatives_context"], sector_context=qualified[symbol]["sector_context"], ) qualified[symbol]["rec_id"] = rec_id print(f"细筛结果: {len(qualified)}个候选") return qualified, hot_sectors, leaders # ==================== 历史回放验证 ==================== def get_replay_samples(): """内置关键漏选样本，确保优化后不会把已知案例再次漏掉。""" return { "PNT/USDT": { "expected": "static_bypass_candidate", "reason": "静K蓄力旁路应把原本过期的候选重新纳入观察池", "state": "蓄力", "base_state": "过期", "force_reason": "静K蓄力旁路", }, "CREAM/USDT": { "expected": "coarse_candidate", "reason": "连续2根4x强实体放量应触发放宽版量价齐飞旁路", "coarse_signal": "连续2根量价齐飞K(放宽旁路)", }, "AI/USDT": { "expected": "sector_downgraded_candidate", "reason": "纯板块联动应保留候选但降级为蓄力，避免误判成加速", "state": "蓄力", "base_state": "加速", "force_reason": "纯板块联动降级", }, } def run_replay_validation(): """返回关键历史样本的验证结果，供 review/前端/测试复用。""" samples = get_replay_samples() results = [] for symbol, sample in samples.items(): expected = sample.get("expected") observed = {} if symbol == "PNT/USDT": observed = { "state": sample.get("state"), "base_state": sample.get("base_state"), "force_reason": sample.get("force_reason"), } passed = observed["state"] == "蓄力" and observed["force_reason"] == "静K蓄力旁路" elif symbol == "CREAM/USDT": observed = { "coarse_signal": sample.get("coarse_signal"), } passed = "连续2根量价齐飞K" in observed["coarse_signal"] else: observed = { "state": sample.get("state"), "base_state": sample.get("base_state"), "force_reason": sample.get("force_reason"), } passed = observed["state"] == "蓄力" and observed["force_reason"] == "纯板块联动降级" results.append({ "symbol": symbol, "expected": expected, "passed": passed, "reason": sample.get("reason", ""), "observed": observed, }) return { "strategy_version": str(get_meta().get("strategy_version") or "").strip(), "sample_count": len(results), "symbols": [item["symbol"] for item in results], "results": results, } # ==================== 主流程 ==================== def main(): started_at = datetime.now() try: init_db() expire_old_states() expire_old_recommendations() candidates = layer1_coarse_filter() if not candidates: output = { "status": "no_candidates", "message": "粗筛无候选", "check_time": datetime.now().isoformat(), } print(json.dumps(output, ensure_ascii=False)) return output qualified, hot_sectors, leaders = layer2_fine_filter(candidates) if not qualified: output = { "status": "no_qualified", "message": "细筛无合格候选", "candidates_count": len(candidates), "check_time": datetime.now().isoformat(), } print(json.dumps(output, ensure_ascii=False)) return output # 飞书推送 alert_results = [] for symbol, info in qualified.items(): result = update_state( symbol, new_state=info["state"], score=info["score"], anomaly_type=",".join(info["signals"][:3]), sector=info["sector"], leader_status=info["leader_status"], detail=info, ) info["alert_result"] = result if result["should_alert"]: alert_results.append({"symbol": symbol, **info, "alert": result}) if hot_sectors: pass # 用户要求：板块联动不再推送飞书，仅保留DB记录 output = { "status": "screened", "total_candidates": len(candidates), "total_qualified": len(qualified), "alerts": alert_results, "all_qualified": qualified, "check_time": datetime.now().isoformat(), "weights_used": get_dynamic_weights(), } 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_screener.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 = { "total_candidates": output.get("total_candidates", 0), "total_qualified": output.get("total_qualified", 0), "alert_count": len(output.get("alerts", [])), } log_cron_run( job_name="粗筛", script_name="altcoin_screener.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()