import streamlit as st import requests import time import json import os import copy import threading import hmac import hashlib import urllib3 from datetime import datetime, timedelta, timezone, time as dt_time from collections import deque, defaultdict from dotenv import load_dotenv # --- 0. 基础配置 --- st.set_page_config(page_title="虚拟货币价格通知", page_icon="🚀", layout="wide") urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) try: from streamlit_autorefresh import st_autorefresh except ImportError: st_autorefresh = None # 可选：实时强平依赖 websocket-client，缺失则自动禁用强平监控 try: import websocket as ws_client # websocket-client except ImportError: ws_client = None # --- 1. 环境变量与常量 --- load_dotenv() # 企业微信机器人 Webhook WEWORK_BOT_WEBHOOK = os.getenv("WEWORK_BOT_WEBHOOK") # 币安 API Key（公共行情接口无需密钥，仅在需要私有接口时使用） BINANCE_API_KEY = os.getenv("BINANCE_API_KEY") BINANCE_API_SECRET = os.getenv("BINANCE_API_SECRET") # 行情接口基址（部分地区需要换成 data-api.binance.vision 等镜像） SPOT_BASE = os.getenv("BINANCE_SPOT_BASE", "https://api.binance.com") FAPI_BASE = os.getenv("BINANCE_FAPI_BASE", "https://fapi.binance.com") FSTREAM_BASE = os.getenv("BINANCE_FSTREAM_BASE", "wss://fstream.binance.com/ws") # 配置持久化文件 CURRENT_DIR = os.path.dirname(os.path.abspath(__file__)) CONFIG_FILE = os.path.join(CURRENT_DIR, "crypto_config.json") REQ_HEADERS = {"User-Agent": "Mozilla/5.0"} # K线周期对应的毫秒数（用于分页拉取长周期历史） INTERVAL_MS = { "1m": 60_000, "5m": 300_000, "15m": 900_000, "1h": 3_600_000, "1d": 86_400_000, } # --- 2. 默认阈值配置 --- # 价格变动：每个时间窗口 [关注, 重要, 紧急]（百分比，绝对值） def _btc_defaults(): return { "symbol": "BTCUSDT", "futures_symbol": "BTCUSDT", "enable_futures": True, # 个人关键价位（0 表示未设置，不监控） "cost_price": 0.0, "target_price": 0.0, "stop_price": 0.0, # 快速涨跌触发阈值（百分比绝对值），方向由涨/跌自动判断 "price_change": { "1m": 0.35, "5m": 0.80, "15m": 1.50, "1h": 2.50, }, # 关键价位 "near_cost_pct": 0.5, "near_key_pct": 0.4, # 突破 "break_24h_pct": 0.2, "break_24h_hold_sec": 120, "break_7d_pct": 0.5, # 成交量 "vol_anomaly_mult": 2.5, "vol_severe_mult": 5.0, # 振幅 "amp_5m": 1.0, "amp_15m": 1.8, "amp_1h": 3.0, # 大额成交 "big_trade_usdt": 1_000_000, "cum_trade_5m_usdt": 10_000_000, # 盘口 "spread_pct": 0.03, "spread_severe_pct": 0.08, "imbalance_depth_pct": 0.5, "imbalance_ratio": 2.5, "wall_depth_pct": 1.0, "wall_mult": 3.0, "wall_vanish_pct": 60.0, # 技术指标 "ma_deviation_pct": 2.5, "consecutive_klines": 5, "rsi_high": 75.0, "rsi_low": 25.0, # 合约（enable_futures 为 False 时整体跳过） "funding_high": 0.03, "funding_hot": 0.07, "funding_neg": -0.03, "oi_15m": 2.0, "oi_1h": 5.0, "oi_4h": 10.0, "liq_5m_usdt": 5_000_000, "liq_severe_usdt": 20_000_000, } def _ton_defaults(): d = _btc_defaults() d.update({ "symbol": "TONUSDT", "futures_symbol": "TONUSDT", "enable_futures": False, # TONUSDT 合约已下线，待 GRAMUSDT 重新上线后启用 "price_change": { "1m": 0.80, "5m": 1.80, "15m": 3.00, "1h": 5.00, }, "near_cost_pct": 1.0, "near_key_pct": 1.0, "break_24h_pct": 0.5, "break_24h_hold_sec": 180, "break_7d_pct": 1.2, "vol_anomaly_mult": 3.5, "vol_severe_mult": 8.0, "amp_5m": 2.5, "amp_15m": 5.0, "amp_1h": 8.0, "big_trade_usdt": 100_000, "cum_trade_5m_usdt": 500_000, "spread_pct": 0.12, "spread_severe_pct": 0.35, "imbalance_depth_pct": 1.0, "imbalance_ratio": 3.0, "wall_depth_pct": 2.0, "wall_mult": 4.0, "wall_vanish_pct": 70.0, "ma_deviation_pct": 5.0, "consecutive_klines": 4, "rsi_high": 80.0, "rsi_low": 20.0, "funding_high": 0.05, "funding_hot": 0.12, "funding_neg": -0.05, "oi_15m": 4.0, "oi_1h": 8.0, "oi_4h": 15.0, "liq_5m_usdt": 300_000, "liq_severe_usdt": 1_000_000, }) return d DEFAULT_CONFIG = { "coins": { "BTC": _btc_defaults(), "TON": _ton_defaults(), }, "global": { "poll_interval_sec": 30, "daily_report_hour": 9, "down_priority": True, "alert_sensitivity": 1.0, }, } # 各类告警冷却时间（分钟），避免重复刷屏 # 微观结构类（盘口/大单/价差/振幅）天然高频，冷却拉长，突出关键事件 COOLDOWN_MIN = { "price_change": 10, "near_cost": 30, "near_key": 30, "break_24h": 30, "break_7d": 120, "volume": 20, "amplitude": 20, "big_trade": 15, "cum_trade": 20, "spread": 30, "imbalance": 30, "wall": 90, "wall_vanish": 30, "ma_deviation": 30, "consecutive": 60, "rsi": 60, "funding": 120, "oi": 30, "liquidation": 10, } # --- 3. 配置持久化 --- def _deep_merge(base, override): """用 override 覆盖 base，缺失项以 base 补全（保证新增阈值字段有默认值）""" result = copy.deepcopy(base) for k, v in (override or {}).items(): if isinstance(v, dict) and isinstance(result.get(k), dict): result[k] = _deep_merge(result[k], v) else: result[k] = v return result def load_config(): """读取配置文件，并以默认值补全缺失字段""" cfg = copy.deepcopy(DEFAULT_CONFIG) if os.path.exists(CONFIG_FILE): try: with open(CONFIG_FILE, "r", encoding="utf-8") as f: saved = json.load(f) # global 直接合并 cfg["global"] = _deep_merge(cfg["global"], saved.get("global", {})) # coins：保留用户自定义币种，并以 BTC 默认结构补全字段 saved_coins = saved.get("coins", {}) merged_coins = {} for name, coin_cfg in saved_coins.items(): template = _btc_defaults() merged_coins[name] = _deep_merge(template, coin_cfg) if merged_coins: cfg["coins"] = merged_coins except Exception as e: print(f"⚠️ 配置读取失败，使用默认值: {e}") return cfg def save_config(cfg): try: with open(CONFIG_FILE, "w", encoding="utf-8") as f: json.dump(cfg, f, ensure_ascii=False, indent=2) return True except Exception as e: print(f"❌ 配置保存失败: {e}") return False # --- 4. 工具函数 --- def get_beijing_now(): utc_now = datetime.now(timezone.utc) return utc_now.astimezone(timezone(timedelta(hours=8))).replace(tzinfo=None) def fmt_price(p): """根据量级自适应小数位""" try: p = float(p) except (TypeError, ValueError): return str(p) if p >= 100: return f"{p:,.2f}" if p >= 1: return f"{p:.4f}" return f"{p:.6f}" def fmt_usdt(v): """金额转人类可读（万/亿）""" try: v = float(v) except (TypeError, ValueError): return str(v) if v >= 1e8: return f"{v / 1e8:.2f}亿USDT" if v >= 1e4: return f"{v / 1e4:.2f}万USDT" return f"{v:.0f}USDT" def compute_rsi(closes, period=14): """标准 RSI""" if len(closes) < period + 1: return None gains, losses = 0.0, 0.0 for i in range(1, period + 1): diff = closes[i] - closes[i - 1] if diff >= 0: gains += diff else: losses -= diff avg_gain = gains / period avg_loss = losses / period for i in range(period + 1, len(closes)): diff = closes[i] - closes[i - 1] gain = diff if diff > 0 else 0.0 loss = -diff if diff < 0 else 0.0 avg_gain = (avg_gain * (period - 1) + gain) / period avg_loss = (avg_loss * (period - 1) + loss) / period if avg_loss == 0: return 100.0 rs = avg_gain / avg_loss return 100.0 - (100.0 / (1.0 + rs)) # --- 5. 企业微信机器人推送 --- class WeWorkBotPusher: def __init__(self, webhook_url): self.webhook_url = webhook_url def send_text(self, content): if not self.webhook_url: print("⚠️ 未配置 WEWORK_BOT_WEBHOOK，消息未发送：\n" + content) return False try: resp = requests.post( self.webhook_url, json={"msgtype": "text", "text": {"content": content}}, headers={"Content-Type": "application/json"}, timeout=10, ) result = resp.json() if result.get("errcode") == 0: return True print(f"❌ 企业微信机器人发送失败: {result}") return False except Exception as e: print(f"❌ 企业微信机器人发送异常: {e}") return False # --- 6. 币安行情接口 --- class BinanceAPI: def __init__(self, logger): self.logger = logger self.session = requests.Session() self.session.headers.update(REQ_HEADERS) if BINANCE_API_KEY: self.session.headers.update({"X-MBX-APIKEY": BINANCE_API_KEY}) def _get(self, base, path, params=None, timeout=10): try: r = self.session.get(base + path, params=params, timeout=timeout) if r.status_code != 200: self.logger(f"⚠️ 接口 {path} 状态码 {r.status_code}") return None return r.json() except Exception as e: self.logger(f"⚠️ 接口 {path} 异常: {e}") return None # 现货行情 def ticker_24h(self, symbol): return self._get(SPOT_BASE, "/api/v3/ticker/24hr", {"symbol": symbol}) def klines(self, symbol, interval, limit): return self._get(SPOT_BASE, "/api/v3/klines", {"symbol": symbol, "interval": interval, "limit": limit}) def klines_history(self, symbol, interval, days, max_calls=40): """分页拉取约 days 天的历史K线（用于稳定的长周期校准）""" ms = INTERVAL_MS.get(interval) if not ms: return self.klines(symbol, interval, 1000) end = int(time.time() * 1000) cursor = end - int(days * 86_400_000) out, calls = [], 0 while cursor < end and calls < max_calls: data = self._get(SPOT_BASE, "/api/v3/klines", {"symbol": symbol, "interval": interval, "startTime": cursor, "limit": 1000}) calls += 1 if not data: break out.extend(data) nxt = data[-1][0] + ms if nxt <= cursor: break cursor = nxt if len(data) < 1000: break return out def depth(self, symbol, limit=500): return self._get(SPOT_BASE, "/api/v3/depth", {"symbol": symbol, "limit": limit}) def agg_trades(self, symbol, limit=1000): return self._get(SPOT_BASE, "/api/v3/aggTrades", {"symbol": symbol, "limit": limit}) # 合约行情 def premium_index(self, symbol): return self._get(FAPI_BASE, "/fapi/v1/premiumIndex", {"symbol": symbol}) def open_interest(self, symbol): return self._get(FAPI_BASE, "/fapi/v1/openInterest", {"symbol": symbol}) # --- 7. 实时强平监控（websocket，可选）--- class LiquidationTracker: """ 订阅币安合约 !forceOrder@arr 全市场强平流，按 symbol 维护近 5 分钟滚动金额。 websocket-client 未安装时整体禁用。 """ def __init__(self, symbols, logger): self.symbols = set(symbols) self.logger = logger self.enabled = ws_client is not None and len(self.symbols) > 0 # symbol -> deque[(ts, notional)] self.events = defaultdict(lambda: deque(maxlen=5000)) self.lock = threading.Lock() if self.enabled: threading.Thread(target=self._run, daemon=True).start() def update_symbols(self, symbols): self.symbols = set(symbols) def _on_message(self, _ws, message): try: data = json.loads(message) o = data.get("o", {}) sym = o.get("s") if sym not in self.symbols: return price = float(o.get("ap") or o.get("p") or 0) qty = float(o.get("q") or 0) notional = price * qty with self.lock: self.events[sym].append((time.time(), notional)) except Exception: pass def _run(self): url = f"{FSTREAM_BASE}/!forceOrder@arr" while True: try: self.logger("🔌 连接强平 websocket...") app = ws_client.WebSocketApp( url, on_message=self._on_message, on_error=lambda _w, e: self.logger(f"⚠️ 强平流错误: {e}"), ) app.run_forever(ping_interval=180, ping_timeout=10) except Exception as e: self.logger(f"⚠️ 强平流断开，5秒后重连: {e}") time.sleep(5) def get_5m_total(self, symbol): if not self.enabled: return None cutoff = time.time() - 300 with self.lock: dq = self.events.get(symbol) if dq is None: return 0.0 return sum(n for ts, n in dq if ts >= cutoff) # --- 8. 告警冷却管理 --- class AlertManager: def __init__(self, pusher, logger, stats): self.pusher = pusher self.logger = logger self.stats = stats self.last_sent = {} # key -> timestamp def emit(self, alerts): """alerts: list[dict(category,key,severity,sev_emoji,text,direction)]""" # 下跌优先：跌 排前面先发 alerts = sorted(alerts, key=lambda a: (a.get("direction") != "跌",)) now = time.time() for a in alerts: key = a["key"] cd = COOLDOWN_MIN.get(a["category"], 5) * 60 if now - self.last_sent.get(key, 0) < cd: continue ok = self.pusher.send_text(a["text"]) self.last_sent[key] = now self.stats["alerts"] += 1 if not ok: self.stats["notify_fails"] += 1 self.logger(f"{a['sev_emoji']} 推送[{a['category']}] {a.get('title', key)}") # 方向信号 -> emoji / 文案：🟢涨 / 🔴跌 / 🟡值得关注 SIGNAL_EMOJI = {"涨": "🟢", "跌": "🔴", "关注": "🟡"} SIGNAL_LABEL = {"涨": "涨", "跌": "跌", "关注": "值得关注"} def _floats(klines, idx): return [float(k[idx]) for k in klines] def _percentile(sorted_vals, p): """线性插值分位数；sorted_vals 必须已升序""" if not sorted_vals: return None if len(sorted_vals) == 1: return sorted_vals[0] k = (len(sorted_vals) - 1) * p / 100.0 f = int(k) c = min(f + 1, len(sorted_vals) - 1) if f == c: return sorted_vals[f] return sorted_vals[f] * (c - k) + sorted_vals[c] * (k - f) # 校准目标：各事件“理想的每日触发次数”（再乘以全局灵敏度） # 数值越小 -> 阈值越高 -> 通知越少（只剩关键转折点） TARGET_PER_DAY = { "1m": 3.0, "5m": 3.0, "15m": 2.0, "1h": 1.5, "amp_5m": 2.0, "amp_15m": 1.5, "amp_1h": 1.0, "vol_anomaly": 3.0, "vol_severe": 0.5, "ma_dev": 2.0, } def _threshold_for_rate(sorted_vals, window_min, target_per_day, floor=0.0): """ 给定该周期下的历史样本（升序），返回一个阈值： 使得历史上“超过该阈值”的次数 ≈ target_per_day 次/天。 样本为相邻周期收盘价变动/振幅，互不重叠，故覆盖天数 = n*window/1440。 """ n = len(sorted_vals) if n == 0: return None days_span = n * window_min / 1440.0 exceed = max(1, int(round(target_per_day * days_span))) idx = min(max(n - exceed, 0), n - 1) return max(sorted_vals[idx], floor) def calibrate_thresholds(api, coin_cfg, logger=print, sensitivity=1.0): """ 基于约30天历史行情，按“理想每日触发次数”反推阈值，突出关键转折点。 sensitivity 越大 -> 目标次数越多 -> 阈值越低 -> 通知越多。 任一环节失败均跳过，保留原默认值。 """ sym = coin_cfg["symbol"] out = {} s = max(0.2, float(sensitivity)) logger(f"🧪 {sym} 拉取约30天历史校准（灵敏度 x{s:g}）...") hist_1m = api.klines_history(sym, "1m", 7) # 1m 噪声平稳，7天已足够稳定 hist_5m = api.klines_history(sym, "5m", 30) hist_15m = api.klines_history(sym, "15m", 30) hist_1h = api.klines_history(sym, "1h", 30) def cc_returns(kl): closes = [float(k[4]) for k in kl] return sorted(abs(closes[i] - closes[i - 1]) / closes[i - 1] * 100 for i in range(1, len(closes)) if closes[i - 1] > 0) def amps(kl): v = [] for k in kl: hi, lo = float(k[2]), float(k[3]) if lo > 0: v.append((hi - lo) / lo * 100) return sorted(v) # 1) 快速涨跌：按每日触发次数目标反推 pc = {} src = {"1m": hist_1m, "5m": hist_5m, "15m": hist_15m, "1h": hist_1h} wmin = {"1m": 1, "5m": 5, "15m": 15, "1h": 60} for w in ("1m", "5m", "15m", "1h"): kl = src[w] if kl and len(kl) > 50: t = _threshold_for_rate(cc_returns(kl), wmin[w], TARGET_PER_DAY[w] * s, floor=0.05) if t: pc[w] = round(t, 2) if pc: base = coin_cfg.get("price_change", {}) for w in ("1m", "5m", "15m", "1h"): if w not in pc: bv = base.get(w, 1.0) pc[w] = float(bv[0]) if isinstance(bv, list) else float(bv) out["price_change"] = pc # 2) 振幅 for kl, win, key, floor in ((hist_5m, 5, "amp_5m", 0.1), (hist_15m, 15, "amp_15m", 0.2), (hist_1h, 60, "amp_1h", 0.3)): if kl and len(kl) > 50: t = _threshold_for_rate(amps(kl), win, TARGET_PER_DAY[key] * s, floor) if t: out[key] = round(t, 2) # 3) 成交量倍数 + 5m 累计大额 + 单笔大额：基于 5m 成交额分布 if hist_5m and len(hist_5m) > 50: qv = [float(k[7]) for k in hist_5m] avg5_qvol = sum(qv) / len(qv) if avg5_qvol > 0: ratios = sorted(x / avg5_qvol for x in qv) an = _threshold_for_rate(ratios, 5, TARGET_PER_DAY["vol_anomaly"] * s, 1.5) sv = _threshold_for_rate(ratios, 5, TARGET_PER_DAY["vol_severe"] * s, (an or 1.5) + 0.5) if an: out["vol_anomaly_mult"] = round(an, 1) if sv: out["vol_severe_mult"] = round(max(sv, (an or 1.5) + 0.5), 1) out["cum_trade_5m_usdt"] = round(avg5_qvol * (an or 2.5)) # 单笔大额：一笔成交达到约 3 分钟的平均成交额才算“巨单” avg1m_qvol = avg5_qvol / 5.0 out["big_trade_usdt"] = round(max(avg1m_qvol * 3.0 / s, 5000)) # 4) 偏离 MA20：1h 历史偏离 if hist_1h and len(hist_1h) > 40: closes = [float(k[4]) for k in hist_1h] devs = [] for i in range(20, len(closes)): ma = sum(closes[i - 20:i]) / 20 if ma > 0: devs.append(abs(closes[i] - ma) / ma * 100) t = _threshold_for_rate(sorted(devs), 60, TARGET_PER_DAY["ma_dev"] * s, 0.5) if t: out["ma_deviation_pct"] = round(t, 2) # 5) 价差：以当前盘口价差为基准放大 ob = api.depth(sym, 100) if ob and ob.get("bids") and ob.get("asks"): bb, ba = float(ob["bids"][0][0]), float(ob["asks"][0][0]) mid = (bb + ba) / 2 if mid > 0: sp = (ba - bb) / mid * 100 out["spread_pct"] = round(max(sp * 3, 0.02), 3) out["spread_severe_pct"] = round(max(sp * 6, out["spread_pct"] * 2), 3) # 6) 强平：按 24h 成交额量级缩放 t24 = api.ticker_24h(sym) if t24: qvol24 = float(t24.get("quoteVolume") or 0) if qvol24 > 0: avg5 = qvol24 / 288.0 out["liq_5m_usdt"] = round(max(avg5 * 0.5, 10000)) out["liq_severe_usdt"] = round(out["liq_5m_usdt"] * 4) # 7) 资金费率：历史费率分位（仅合约启用时） if coin_cfg.get("enable_futures"): fr = api._get(FAPI_BASE, "/fapi/v1/fundingRate", {"symbol": coin_cfg["futures_symbol"], "limit": 500}) if fr: try: rates = [float(x["fundingRate"]) * 100 for x in fr] pos = sorted(r for r in rates if r > 0) neg = sorted(r for r in rates if r < 0) if pos: high = round(max(_percentile(pos, 80), 0.005), 4) hot = round(max(_percentile(pos, 97), high * 1.5), 4) out["funding_high"] = high out["funding_hot"] = hot if neg: out["funding_neg"] = round(min(_percentile(neg, 20), -0.005), 4) except (KeyError, ValueError, TypeError): pass logger(f"✅ {sym} 校准完成，覆盖 {len(out)} 组参数") return out # --- 9. 单币种评估器 --- class CoinEvaluator: WINDOW_BACK = {"1m": 2, "5m": 6, "15m": 16, "1h": 61} WINDOW_CN = {"1m": "1分钟", "5m": "5分钟", "15m": "15分钟", "1h": "1小时"} def __init__(self, name, api, liq_tracker, logger): self.name = name self.api = api self.liq = liq_tracker self.logger = logger # 状态 self.break_24h_since = {} # 'high'/'low' -> ts self.break_7d_alerted = {} self.prev_walls = {} # 'bid'/'ask' -> notional self.oi_history = deque(maxlen=2000) # (ts, oi) self.last_price = None self.last_funding_pct = None self.last_rsi = None def evaluate(self, cfg): sym = cfg["symbol"] alerts = [] ticker = self.api.ticker_24h(sym) k1 = self.api.klines(sym, "1m", 61) if not ticker or not k1 or len(k1) < 17: return alerts, None # 数据不足 closes = _floats(k1, 4) highs = _floats(k1, 2) lows = _floats(k1, 3) qvols = _floats(k1, 7) # quoteAssetVolume price = float(ticker.get("lastPrice") or closes[-1]) high24 = float(ticker.get("highPrice") or 0) low24 = float(ticker.get("lowPrice") or 0) qvol24 = float(ticker.get("quoteVolume") or 0) self.last_price = price def add(category, key, direction, headline, body): emoji = SIGNAL_EMOJI[direction] text = f"{emoji} {self.name} {headline}\n{head}\n{body}" alerts.append({"category": category, "key": f"{self.name}_{key}", "direction": direction, "sev_emoji": emoji, "title": headline, "text": text}) head = f"【{self.name}】现价 {fmt_price(price)} USDT" # 1) 快速涨跌（方向决定颜色） for win, back in self.WINDOW_BACK.items(): if len(closes) <= back: continue then = closes[-back] if then == 0: continue pct = (price - then) / then * 100 thr = cfg["price_change"][win] if isinstance(thr, list): thr = thr[0] if abs(pct) >= thr: direction = "涨" if pct >= 0 else "跌" arrow = "📈" if pct >= 0 else "📉" add("price_change", f"pc_{win}_{direction}", direction, f"{self.WINDOW_CN[win]}快速{direction} {arrow}", f"{self.WINDOW_CN[win]}内{direction}幅 {pct:+.2f}%") # 2) 关键价位 if cfg.get("cost_price", 0) > 0: diff = (price - cfg["cost_price"]) / cfg["cost_price"] * 100 if abs(diff) <= cfg["near_cost_pct"]: add("near_cost", "near_cost", "关注", "接近成本价", f"成本价 {fmt_price(cfg['cost_price'])}，当前偏离 {diff:+.2f}%") for label, pkey in (("目标价", "target_price"), ("止损价", "stop_price")): kp = cfg.get(pkey, 0) if kp > 0: diff = (price - kp) / kp * 100 if abs(diff) <= cfg["near_key_pct"]: add("near_key", f"near_{pkey}", "关注", f"接近{label}", f"{label} {fmt_price(kp)}，当前偏离 {diff:+.2f}%") # 3) 突破 24h 高/低（突破后维持一段时间） self._check_break_24h(cfg, price, high24, low24, head, add) # 4) 突破 7 日高/低 self._check_break_7d(cfg, sym, price, head, add) # 5) 成交量 if qvol24 > 0 and len(qvols) >= 5: cur5 = sum(qvols[-5:]) avg5 = qvol24 / 288.0 if avg5 > 0: ratio = cur5 / avg5 if ratio >= cfg["vol_severe_mult"]: add("volume", "vol_severe", "关注", f"严重放量 x{ratio:.1f}", f"近5分钟成交 {fmt_usdt(cur5)}，为24h均量的 {ratio:.1f} 倍") elif ratio >= cfg["vol_anomaly_mult"]: add("volume", "vol_anomaly", "关注", f"成交量异常 x{ratio:.1f}", f"近5分钟成交 {fmt_usdt(cur5)}，为24h均量的 {ratio:.1f} 倍") # 6) 振幅 for win, n, thr_key in (("5分钟", 5, "amp_5m"), ("15分钟", 15, "amp_15m"), ("1小时", 60, "amp_1h")): if len(highs) >= n: hi = max(highs[-n:]) lo = min(lows[-n:]) if lo > 0: amp = (hi - lo) / lo * 100 if amp >= cfg[thr_key]: add("amplitude", f"amp_{n}", "关注", f"{win}振幅过大 {amp:.2f}%", f"{win}高低差 {amp:.2f}%（{fmt_price(lo)} ~ {fmt_price(hi)}）") # 7) 大额成交 self._check_trades(cfg, sym, head, add) # 8) 盘口（价差 / 失衡 / 买卖墙） self._check_orderbook(cfg, sym, price, head, add) # 9) 价格偏离均线 self._check_ma(cfg, sym, price, head, add) # 10) 连续 K 线 self._check_consecutive(cfg, sym, head, add) # 11) RSI self._check_rsi(cfg, sym, head, add) # 12) 合约类 if cfg.get("enable_futures"): self._check_futures(cfg, head, add) snapshot = { "price": price, "high24": high24, "low24": low24, "rsi": self.last_rsi, "funding": self.last_funding_pct, } return alerts, snapshot # ---- 子检查 ---- def _check_break_24h(self, cfg, price, high24, low24, head, add): now = time.time() hold = cfg["break_24h_hold_sec"] thr = cfg["break_24h_pct"] # 突破高点 if high24 > 0 and price >= high24 * (1 + thr / 100): self.break_24h_since.setdefault("high", now) if now - self.break_24h_since["high"] >= hold: add("break_24h", "break_24h_high", "涨", "突破24h高点 📈", f"已突破24h高 {fmt_price(high24)} 超 {thr}% 并维持 {hold // 60} 分钟以上") else: self.break_24h_since.pop("high", None) # 突破低点 if low24 > 0 and price <= low24 * (1 - thr / 100): self.break_24h_since.setdefault("low", now) if now - self.break_24h_since["low"] >= hold: add("break_24h", "break_24h_low", "跌", "突破24h低点 📉", f"已跌破24h低 {fmt_price(low24)} 超 {thr}% 并维持 {hold // 60} 分钟以上") else: self.break_24h_since.pop("low", None) def _check_break_7d(self, cfg, sym, price, head, add): kd = self.api.klines(sym, "1d", 8) if not kd or len(kd) < 2: return # 取已收盘的前 7 日（排除当前未收盘日） closed = kd[:-1][-7:] hi7 = max(float(k[2]) for k in closed) lo7 = min(float(k[3]) for k in closed) thr = cfg["break_7d_pct"] if hi7 > 0 and price >= hi7 * (1 + thr / 100): add("break_7d", "break_7d_high", "涨", "突破7日高点 📈", f"已突破7日高 {fmt_price(hi7)} 超 {thr}%") if lo7 > 0 and price <= lo7 * (1 - thr / 100): add("break_7d", "break_7d_low", "跌", "跌破7日低点 📉", f"已跌破7日低 {fmt_price(lo7)} 超 {thr}%") def _check_trades(self, cfg, sym, head, add): trades = self.api.agg_trades(sym, 1000) if not trades: return cutoff_ms = (time.time() - 300) * 1000 big_thr = cfg["big_trade_usdt"] cum = 0.0 max_single = 0.0 for t in trades: try: notional = float(t["p"]) * float(t["q"]) ts = t.get("T", 0) except (KeyError, ValueError): continue if ts >= cutoff_ms: cum += notional if notional > max_single: max_single = notional if max_single >= big_thr: add("big_trade", "big_trade", "关注", f"单笔大额成交 {fmt_usdt(max_single)}", f"出现单笔成交 {fmt_usdt(max_single)}（阈值 {fmt_usdt(big_thr)}）") if cum >= cfg["cum_trade_5m_usdt"]: add("cum_trade", "cum_trade", "关注", f"连续大额成交 {fmt_usdt(cum)}", f"近5分钟累计成交 {fmt_usdt(cum)}（阈值 {fmt_usdt(cfg['cum_trade_5m_usdt'])}）") def _check_orderbook(self, cfg, sym, price, head, add): ob = self.api.depth(sym, 1000) if not ob or not ob.get("bids") or not ob.get("asks"): return bids = [(float(p), float(q)) for p, q in ob["bids"]] asks = [(float(p), float(q)) for p, q in ob["asks"]] best_bid = bids[0][0] best_ask = asks[0][0] mid = (best_bid + best_ask) / 2 if mid <= 0: return # 价差 spread = (best_ask - best_bid) / mid * 100 if spread >= cfg["spread_severe_pct"]: add("spread", "spread", "关注", f"买卖价差异常 {spread:.3f}%", f"当前价差 {spread:.3f}%（严重阈值 {cfg['spread_severe_pct']}%）") elif spread >= cfg["spread_pct"]: add("spread", "spread", "关注", f"买卖价差偏大 {spread:.3f}%", f"当前价差 {spread:.3f}%（阈值 {cfg['spread_pct']}%）") # 盘口失衡 dp = cfg["imbalance_depth_pct"] / 100 bid_usdt = sum(p * q for p, q in bids if p >= mid * (1 - dp)) ask_usdt = sum(p * q for p, q in asks if p <= mid * (1 + dp)) if bid_usdt > 0 and ask_usdt > 0: if bid_usdt / ask_usdt >= cfg["imbalance_ratio"]: add("imbalance", "imbalance_buy", "涨", "买盘失衡（买强）", f"±{cfg['imbalance_depth_pct']}%深度内 买/卖 = {bid_usdt / ask_usdt:.1f} 倍") elif ask_usdt / bid_usdt >= cfg["imbalance_ratio"]: add("imbalance", "imbalance_sell", "跌", "卖盘失衡（卖强）", f"±{cfg['imbalance_depth_pct']}%深度内 卖/买 = {ask_usdt / bid_usdt:.1f} 倍") # 买卖墙 + 墙消失 wp = cfg["wall_depth_pct"] / 100 self._wall_side(cfg, "bid", "买墙", bids, [p for p, q in bids if p >= mid * (1 - wp)], bids, mid, wp, head, add, "涨") self._wall_side(cfg, "ask", "卖墙", asks, [p for p, q in asks if p <= mid * (1 + wp)], asks, mid, wp, head, add, "跌") def _wall_side(self, cfg, side, label, _all, _prices, orders, mid, wp, head, add, direction): if side == "bid": near = [(p, q) for p, q in orders if p >= mid * (1 - wp)] else: near = [(p, q) for p, q in orders if p <= mid * (1 + wp)] if len(near) < 3: self.prev_walls[side] = 0.0 return notionals = [p * q for p, q in near] max_n = max(notionals) avg_n = sum(notionals) / len(notionals) wall_price = near[notionals.index(max_n)][0] prev = self.prev_walls.get(side, 0.0) if avg_n > 0 and max_n >= avg_n * cfg["wall_mult"]: add("wall", f"wall_{side}", "关注", f"出现{label} {fmt_usdt(max_n)}", f"{fmt_price(wall_price)} 附近挂单 {fmt_usdt(max_n)}，为附近均值的 {max_n / avg_n:.1f} 倍") self.prev_walls[side] = max_n else: # 墙消失检测 if prev > 0 and max_n <= prev * (1 - cfg["wall_vanish_pct"] / 100): add("wall_vanish", f"wall_vanish_{side}", "跌" if side == "bid" else "涨", f"{label}快速撤离", f"原 {label} {fmt_usdt(prev)} 已减少超 {cfg['wall_vanish_pct']}%") self.prev_walls[side] = max_n def _check_ma(self, cfg, sym, price, head, add): kh = self.api.klines(sym, "1h", 21) if not kh or len(kh) < 20: return closes = _floats(kh[-20:], 4) ma20 = sum(closes) / 20 if ma20 <= 0: return dev = (price - ma20) / ma20 * 100 if abs(dev) >= cfg["ma_deviation_pct"]: direction = "涨" if dev > 0 else "跌" add("ma_deviation", "ma_deviation", direction, f"价格偏离均线 {dev:+.2f}%", f"偏离1小时MA20({fmt_price(ma20)}) {dev:+.2f}%") def _check_consecutive(self, cfg, sym, head, add): n = int(cfg["consecutive_klines"]) kl = self.api.klines(sym, "15m", n + 1) if not kl or len(kl) < n: return recent = kl[-n:] ups = all(float(k[4]) > float(k[1]) for k in recent) downs = all(float(k[4]) < float(k[1]) for k in recent) if ups: add("consecutive", "consecutive_up", "涨", "连续上涨 �", f"连续 {n} 根15分钟阳线") elif downs: add("consecutive", "consecutive_down", "跌", "连续下跌 📉", f"连续 {n} 根15分钟阴线") def _check_rsi(self, cfg, sym, head, add): kl = self.api.klines(sym, "15m", 100) if not kl or len(kl) < 20: return closes = _floats(kl, 4) rsi = compute_rsi(closes, 14) self.last_rsi = rsi if rsi is None: return if rsi >= cfg["rsi_high"]: add("rsi", "rsi_high", "关注", f"RSI 超买 {rsi:.0f}", f"15分钟 RSI = {rsi:.1f}（超买阈值 {cfg['rsi_high']}），警惕回调") elif rsi <= cfg["rsi_low"]: add("rsi", "rsi_low", "关注", f"RSI 超卖 {rsi:.0f}", f"15分钟 RSI = {rsi:.1f}（超卖阈值 {cfg['rsi_low']}），警惕反弹") def _check_futures(self, cfg, head, add): fsym = cfg["futures_symbol"] # 资金费率 pi = self.api.premium_index(fsym) if pi and pi.get("lastFundingRate") is not None: rate = float(pi["lastFundingRate"]) * 100 # 转百分比 self.last_funding_pct = rate if rate >= cfg["funding_hot"]: add("funding", "funding_hot", "关注", f"资金费率过热 {rate:+.4f}%", f"当前资金费率 {rate:+.4f}%/期（过热阈值 {cfg['funding_hot']}%），多头拥挤") elif rate >= cfg["funding_high"]: add("funding", "funding_high", "关注", f"资金费率偏高 {rate:+.4f}%", f"当前资金费率 {rate:+.4f}%/期（偏高阈值 {cfg['funding_high']}%）") elif rate <= cfg["funding_neg"]: add("funding", "funding_neg", "关注", f"资金费率偏负 {rate:+.4f}%", f"当前资金费率 {rate:+.4f}%/期（偏负阈值 {cfg['funding_neg']}%），空头拥挤") # 持仓量变化 oi_data = self.api.open_interest(fsym) if oi_data and oi_data.get("openInterest") is not None: oi = float(oi_data["openInterest"]) now = time.time() self.oi_history.append((now, oi)) for win_min, thr_key, cn in ((15, "oi_15m", "15分钟"), (60, "oi_1h", "1小时"), (240, "oi_4h", "4小时")): past = self._oi_at(now - win_min * 60) if past and past > 0: chg = (oi - past) / past * 100 if abs(chg) >= cfg[thr_key]: direction = "增" if chg > 0 else "减" add("oi", f"oi_{win_min}", "关注", f"持仓量{cn}{direction} {chg:+.1f}%", f"持仓量{cn}内{direction} {chg:+.1f}%（阈值 {cfg[thr_key]}%）") # 强平 liq5 = self.liq.get_5m_total(fsym) if self.liq else None if liq5 is not None: if liq5 >= cfg["liq_severe_usdt"]: add("liquidation", "liq_severe", "关注", f"严重强平 {fmt_usdt(liq5)}", f"近5分钟强平 {fmt_usdt(liq5)}（严重阈值 {fmt_usdt(cfg['liq_severe_usdt'])}）") elif liq5 >= cfg["liq_5m_usdt"]: add("liquidation", "liq_5m", "关注", f"强平金额异常 {fmt_usdt(liq5)}", f"近5分钟强平 {fmt_usdt(liq5)}（阈值 {fmt_usdt(cfg['liq_5m_usdt'])}）") def _oi_at(self, target_ts): """返回最接近 target_ts 的历史持仓量（要求有足够久的样本）""" best = None best_diff = None for ts, oi in self.oi_history: diff = abs(ts - target_ts) if best_diff is None or diff < best_diff: best_diff = diff best = oi # 样本与目标时间差太大（超过窗口一半）则视为无效 if best_diff is not None and best_diff <= 600: return best return None # --- 10. 监控主逻辑 --- class CryptoMonitor: def __init__(self): self.logs = deque(maxlen=80) self.status_text = "初始化中..." self.next_wakeup = None self.lock = threading.Lock() self.config = load_config() self.snapshots = {} # coin -> 最新行情快照 self.stats = {"alerts": 0, "notify_fails": 0, "api_fails": 0, "loops": 0} self.last_daily_report_date = None # 配置文件不存在时，首次启动自动校准默认阈值 self._auto_calibrate_needed = not os.path.exists(CONFIG_FILE) self.api = BinanceAPI(self.log) self.pusher = WeWorkBotPusher(WEWORK_BOT_WEBHOOK) self.alert_mgr = AlertManager(self.pusher, self.log, self.stats) self.liq = LiquidationTracker(self._futures_symbols(), self.log) self.evaluators = {} self._rebuild_evaluators() self.thread = threading.Thread(target=self._run_loop, daemon=True) self.thread.start() def log(self, msg): ts = get_beijing_now().strftime("%H:%M:%S") entry = f"[{ts}] {msg}" print(entry) self.logs.appendleft(entry) def _futures_symbols(self): return [c["futures_symbol"] for c in self.config["coins"].values() if c.get("enable_futures")] def _rebuild_evaluators(self): with self.lock: for name in list(self.evaluators.keys()): if name not in self.config["coins"]: self.evaluators.pop(name, None) for name in self.config["coins"]: if name not in self.evaluators: self.evaluators[name] = CoinEvaluator(name, self.api, self.liq, self.log) def update_config(self, new_cfg): """由前端调用：保存并热更新配置""" with self.lock: self.config = new_cfg save_config(new_cfg) self.liq.update_symbols(self._futures_symbols()) self._rebuild_evaluators() self.log("⚙️ 配置已更新并保存") def calibrate_all(self): """对所有币种执行历史校准并保存（后台首次启动调用）""" with self.lock: cfg = copy.deepcopy(self.config) scale = float(cfg["global"].get("alert_sensitivity", 1.0)) for name, coin in cfg["coins"].items(): try: overrides = calibrate_thresholds(self.api, coin, self.log, scale) cfg["coins"][name] = _deep_merge(coin, overrides) except Exception as e: self.log(f"⚠️ {name} 校准失败: {e}") with self.lock: self.config = cfg save_config(cfg) self._rebuild_evaluators() def _maybe_daily_report(self): now = get_beijing_now() today = now.strftime("%Y-%m-%d") hour = int(self.config["global"].get("daily_report_hour", 9)) if now.time() >= dt_time(hour, 0) and self.last_daily_report_date != today: if self.last_daily_report_date is None: # 首次启动当天不发，避免重启刷屏 self.last_daily_report_date = today return coins = "、".join(self.config["coins"].keys()) msg = ( f"🚀 虚拟货币价格监控日报\n\n" f"{now.strftime('%Y年%m月%d日')} 服务正常运行中。\n" f"监控币种：{coins}\n\n" f"昨日统计：\n" f"推送告警：{self.stats['alerts']} 次\n" f"发送失败：{self.stats['notify_fails']} 次\n" f"接口失败：{self.stats['api_fails']} 次\n" f"轮询次数：{self.stats['loops']} 次" ) self.pusher.send_text(msg) self.log(f"🔔 已发送每日报告: {today}") self.last_daily_report_date = today self.stats.update({"alerts": 0, "notify_fails": 0, "api_fails": 0, "loops": 0}) def _run_loop(self): self.log("🚀 虚拟货币价格监控服务已启动") if not WEWORK_BOT_WEBHOOK: self.log("⚠️ 未配置 WEWORK_BOT_WEBHOOK，仅记录日志不推送") if ws_client is None: self.log("⚠️ 未安装 websocket-client，强平监控已禁用") if self._auto_calibrate_needed: self.log("🧪 首次启动：根据历史行情自动校准各币种阈值...") try: self.calibrate_all() self.log("✅ 首次自动校准完成并已保存") except Exception as e: self.log(f"⚠️ 自动校准异常: {e}") self._auto_calibrate_needed = False while True: try: with self.lock: cfg = copy.deepcopy(self.config) interval = int(cfg["global"].get("poll_interval_sec", 30)) self._maybe_daily_report() self.status_text = "🔥 监控中" total_alerts = [] for name, coin_cfg in cfg["coins"].items(): evaluator = self.evaluators.get(name) if not evaluator: continue try: alerts, snap = evaluator.evaluate(coin_cfg) if snap: self.snapshots[name] = snap else: self.stats["api_fails"] += 1 total_alerts.extend(alerts) except Exception as e: self.log(f"❌ {name} 评估异常: {e}") if total_alerts: self.alert_mgr.emit(total_alerts) self.stats["loops"] += 1 now = get_beijing_now() self.next_wakeup = now + timedelta(seconds=interval) time.sleep(interval) except Exception as e: self.log(f"❌ 主循环异常: {e}") time.sleep(30) # --- 11. Streamlit 前端 --- @st.cache_resource def get_monitor(): return CryptoMonitor() # 阈值字段的中文标签与分组（用于动态生成编辑器） FIELD_GROUPS = [ ("关键价位", [ ("cost_price", "成本价 (0=不监控)"), ("target_price", "目标价 (0=不监控)"), ("stop_price", "止损价 (0=不监控)"), ("near_cost_pct", "接近成本价阈值 %"), ("near_key_pct", "接近目标/止损阈值 %"), ]), ("突破", [ ("break_24h_pct", "突破24h高低 %"), ("break_24h_hold_sec", "突破维持秒数"), ("break_7d_pct", "突破7日高低 %"), ]), ("成交量与振幅", [ ("vol_anomaly_mult", "5m放量倍数"), ("vol_severe_mult", "5m严重放量倍数"), ("amp_5m", "5m振幅 %"), ("amp_15m", "15m振幅 %"), ("amp_1h", "1h振幅 %"), ]), ("大额成交", [ ("big_trade_usdt", "单笔大额 USDT"), ("cum_trade_5m_usdt", "5m累计大额 USDT"), ]), ("盘口", [ ("spread_pct", "价差 %"), ("spread_severe_pct", "严重价差 %"), ("imbalance_depth_pct", "失衡统计深度 %"), ("imbalance_ratio", "买卖失衡倍数"), ("wall_depth_pct", "买卖墙深度 %"), ("wall_mult", "墙厚度倍数"), ("wall_vanish_pct", "墙消失减少 %"), ]), ("技术指标", [ ("ma_deviation_pct", "偏离1h MA20 %"), ("consecutive_klines", "连续15m K线根数"), ("rsi_high", "RSI 超买"), ("rsi_low", "RSI 超卖"), ]), ("合约 (需启用)", [ ("funding_high", "资金费率偏高 %"), ("funding_hot", "资金费率过热 %"), ("funding_neg", "资金费率偏负 %"), ("oi_15m", "持仓15m变化 %"), ("oi_1h", "持仓1h变化 %"), ("oi_4h", "持仓4h变化 %"), ("liq_5m_usdt", "5m强平 USDT"), ("liq_severe_usdt", "严重强平 USDT"), ]), ] INT_FIELDS = {"break_24h_hold_sec", "consecutive_klines"} def render_config_editor(monitor): cfg = copy.deepcopy(monitor.config) st.subheader("⚙️ 监控参数设置") with st.expander("全局设置", expanded=False): g = cfg["global"] g["poll_interval_sec"] = st.number_input( "轮询间隔（秒）", min_value=5, max_value=600, value=int(g.get("poll_interval_sec", 30)), step=5) g["daily_report_hour"] = st.number_input( "每日报告时间（小时）", min_value=0, max_value=23, value=int(g.get("daily_report_hour", 9))) g["alert_sensitivity"] = st.number_input( "通知灵敏度（越大通知越多，建议 0.5~2.0）", min_value=0.2, max_value=5.0, value=float(g.get("alert_sensitivity", 1.0)), step=0.1, format="%.1f", help="校准时按“理想每日触发次数 × 灵敏度”反推阈值；调整后点币种页的“历史自动校准”生效") coin_names = list(cfg["coins"].keys()) tabs = st.tabs(coin_names + ["➕ 新增币种"]) for i, name in enumerate(coin_names): with tabs[i]: coin = cfg["coins"][name] cc1, cc2, cc3 = st.columns(3) with cc1: coin["symbol"] = st.text_input( "现货交易对", value=coin["symbol"], key=f"{name}_symbol") with cc2: coin["futures_symbol"] = st.text_input( "合约交易对", value=coin["futures_symbol"], key=f"{name}_fsym") with cc3: coin["enable_futures"] = st.checkbox( "启用合约监控", value=coin.get("enable_futures", False), key=f"{name}_futenable") cal_col, _ = st.columns([1, 3]) if cal_col.button("📈 历史自动校准", key=f"cal_{name}", help="拉取该币种历史行情，自动推算更贴合的阈值"): with st.spinner(f"正在根据历史行情校准 {name} ..."): scale = float(cfg["global"].get("alert_sensitivity", 1.0)) overrides = calibrate_thresholds(monitor.api, coin, monitor.log, scale) cfg["coins"][name] = _deep_merge(coin, overrides) monitor.update_config(cfg) st.success(f"{name} 已根据历史校准并保存") st.rerun() st.markdown("**快速涨跌触发阈值 %（绝对值，方向🟢涨/🔴跌自动判断）**") pc = coin["price_change"] pcols = st.columns(4) for idx, win in enumerate(["1m", "5m", "15m", "1h"]): val = pc.get(win, 1.0) if isinstance(val, list): val = val[0] if val else 1.0 pc[win] = pcols[idx].number_input( win, value=float(val), step=0.05, key=f"{name}_{win}_pc", format="%.2f") for group_name, fields in FIELD_GROUPS: with st.expander(group_name, expanded=False): cols = st.columns(2) for j, (fkey, flabel) in enumerate(fields): with cols[j % 2]: cur = coin.get(fkey, 0) if fkey in INT_FIELDS: coin[fkey] = st.number_input( flabel, value=int(cur), step=1, key=f"{name}_{fkey}") else: coin[fkey] = st.number_input( flabel, value=float(cur), step=1000.0 if "usdt" in fkey else 0.1, key=f"{name}_{fkey}", format="%.4f") if st.button(f"🗑️ 删除 {name}", key=f"del_{name}"): if len(coin_names) > 1: cfg["coins"].pop(name) monitor.update_config(cfg) st.rerun() else: st.warning("至少保留一个币种") # 新增币种 with tabs[-1]: st.markdown("基于 BTC 默认阈值创建新币种，创建后可在对应标签页微调。") nc1, nc2 = st.columns(2) new_name = nc1.text_input("币种代号（如 ETH）", key="new_coin_name") new_symbol = nc2.text_input("现货交易对（如 ETHUSDT）", key="new_coin_symbol") if st.button("➕ 创建币种"): new_name = (new_name or "").strip().upper() new_symbol = (new_symbol or "").strip().upper() if not new_name or not new_symbol: st.warning("请填写币种代号和交易对") elif new_name in cfg["coins"]: st.warning("该币种已存在") else: template = _btc_defaults() template["symbol"] = new_symbol template["futures_symbol"] = new_symbol template["enable_futures"] = False with st.spinner(f"正在根据历史行情自动校准 {new_name} 的默认值..."): scale = float(cfg["global"].get("alert_sensitivity", 1.0)) overrides = calibrate_thresholds(monitor.api, template, monitor.log, scale) template = _deep_merge(template, overrides) cfg["coins"][new_name] = template monitor.update_config(cfg) st.success(f"已创建并校准 {new_name}") st.rerun() st.divider() if st.button("💾 保存全部设置", type="primary"): monitor.update_config(cfg) st.success("设置已保存并热更新") def main(): monitor = get_monitor() if st_autorefresh: st_autorefresh(interval=30 * 1000, key="crypto_refresh") st.title("🚀 虚拟货币价格通知") c1, c2, c3, c4 = st.columns(4) c1.metric("运行状态", monitor.status_text) c2.metric("下次唤醒", monitor.next_wakeup.strftime("%H:%M:%S") if monitor.next_wakeup else "--") c3.metric("今日累计告警", monitor.stats["alerts"]) c4.metric("监控币种", len(monitor.config["coins"])) st.divider() # 实时行情快照 st.subheader("📊 实时行情") snap_cols = st.columns(max(1, len(monitor.snapshots))) if monitor.snapshots: for idx, (name, snap) in enumerate(monitor.snapshots.items()): with snap_cols[idx]: rsi = snap.get("rsi") funding = snap.get("funding") extra = [] if rsi is not None: extra.append(f"RSI {rsi:.0f}") if funding is not None: extra.append(f"费率 {funding:+.3f}%") st.metric(name, f"{fmt_price(snap['price'])}", " | ".join(extra) if extra else None) else: st.caption("等待首次行情拉取...") st.divider() col_log, col_cfg = st.columns([2, 3]) with col_log: st.subheader("📜 运行日志") st.text_area("Logs", "\n".join(list(monitor.logs)), height=600, disabled=True) with col_cfg: render_config_editor(monitor) if __name__ == "__main__": main()