Persist monitor state across restarts

.env.example

@@ -0,0 +1,8 @@
+# Hugging Face deployment / persistent state
+HF_TOKEN=
+STATE_HUB_REPO_ID=
+STATE_HUB_REPO_TYPE=dataset
+STATE_HUB_FILENAME=monitor_state.json
+
+# 企业微信机器人 Webhook
+WEWORK_BOT_WEBHOOK=

README.md

@@ -66,6 +66,17 @@ uvicorn app.main:app --host 0.0.0.0 --port 7860
 
 如果 Space 没有挂载持久化存储，重启后 `/data` 数据可能丢失。建议在 Space 设置里挂载 Storage 后再长期运行。
 
+如果没有挂载 Storage，也可以配置私有状态数据集，让关键配置跨重启保留：
+
+```text
+HF_TOKEN=<具备写入权限的 Hugging Face token>
+STATE_HUB_REPO_ID=<用户名>/coinpush-state
+STATE_HUB_REPO_TYPE=dataset
+STATE_HUB_FILENAME=monitor_state.json
+```
+
+状态文件会保存币价配置、全市场涨跌配置、暂停的监控项 ID 和告警冷却时间。写入状态失败时不影响监控运行，本地文件仍会保留。
+
 ## 本地运行
 
 ```bash
@@ -126,7 +137,7 @@ DISABLE_WORKER=true .venv/bin/uvicorn app.main:app --host 0.0.0.0 --port 7860
 - `BINANCE_API_KEY` / `BINANCE_API_SECRET`：币安私有接口凭证，可选。
 - `BINANCE_SPOT_BASE` / `BINANCE_FAPI_BASE` / `BINANCE_FSTREAM_BASE`：币安接口基址，可选。
 - `BINANCE_ALPHA_BASE`：Binance Alpha 公共行情基址，默认 `https://www.binance.com`。
-- `ENABLE_FUTURES`：是否启用币安合约指标和强平流，默认 `false`。
+- 合约指标和强平流由币种配置里的 `enable_futures` 控制；币安合约接口受限时字段会降级为空。
 - `BITGET_API_KEY` / `BITGET_API_SECRET` / `BITGET_API_PASSPHRASE`：Bitget 凭证，可选。
 - `OKX_API_KEY` / `OKX_API_SECRET` / `OKX_API_PASSPHRASE`：OKX 凭证，可选。
 - `BITGET_BASE` / `OKX_BASE`：交易所接口基址，可选。

app/core/alerts.py

@@ -4,13 +4,16 @@ import time
 class SQLiteAlertManager:
     """Alert sender with cooldown and persistent alert history."""
 
-    def __init__(self, pusher, store, logger, stats, cooldowns=None):
+    def __init__(self, pusher, store, logger, stats, cooldowns=None, state_store=None):
         self.pusher = pusher
         self.store = store
         self.logger = logger
         self.stats = stats
         self.cooldowns = cooldowns or {}
         self.last_sent = {}
+        self.state_store = state_store
+        if self.state_store is not None:
+            self.last_sent = dict(self.state_store.get("alert_sent_at") or {})
 
     def emit(self, alerts):
         alerts = sorted(alerts, key=lambda a: (a.get("direction") != "跌",))
@@ -37,6 +40,8 @@ class SQLiteAlertManager:
                 delivered=delivered,
                 error=None if delivered else "notifier returned false",
             )
+            if self.state_store is not None:
+                self.state_store.set_kv("alert_sent_at", dict(self.last_sent))
             self.logger(
                 f"{alert.get('sev_emoji', '')} 推送[{alert.get('category')}] "
                 f"{alert.get('title', key)}",

app/core/dashboard.py

@@ -393,6 +393,11 @@ def render_dashboard():
       overflow: auto;
       overflow-wrap: anywhere;
     }
+    .stale-note {
+      color: var(--muted);
+      font-size: 12px;
+      line-height: 1.4;
+    }
     .log-snippet {
       max-height: 120px;
       overflow: auto;
@@ -1167,10 +1172,16 @@ def render_dashboard():
       return chip(label, formatter ? formatter(value) : value);
     }
 
-    function rawDetails(payload, raw) {
+    function rawDetails(payload, raw, summary = "原始数据") {
       if (!payload && !raw) return "";
       const text = payload ? JSON.stringify(payload, null, 2) : String(raw);
-      return `<details><summary>原始数据</summary><pre class="value-json">${escapeHtml(text)}</pre></details>`;
+      return `<details><summary>${escapeHtml(summary)}</summary><pre class="value-json">${escapeHtml(text)}</pre></details>`;
+    }
+
+    function isCalibrationOnlyPayload(payload) {
+      if (!payload || typeof payload !== "object" || Array.isArray(payload)) return false;
+      const keys = Object.keys(payload);
+      return keys.length === 1 && payload.calibrated === true;
     }
 
     function firstScalarChips(payload) {
@@ -1246,18 +1257,26 @@ def render_dashboard():
     function renderMonitorValue(monitor) {
       const payload = parseJsonField(monitor.last_value_json);
       const raw = monitor.last_value_json;
-      const details = rawDetails(payload, raw);
+      const hasMarketPayload = !isCalibrationOnlyPayload(payload);
+      const displayPayload = hasMarketPayload ? payload : null;
+      const displayRaw = hasMarketPayload ? raw : null;
 
       if (monitor.last_error) {
+        const staleNote = displayRaw && monitor.last_success_at
+          ? `<div class="stale-note">下方为上次成功数据：${escapeHtml(formatDateTime(monitor.last_success_at))}</div>`
+          : "";
+        const details = rawDetails(displayPayload, displayRaw, "上次成功数据");
         return (
           `<div class="value-card">` +
           `<div class="error-box">${escapeHtml(monitor.last_error)}</div>` +
+          staleNote +
           details +
           `</div>`
         );
       }
 
-      const chips = monitorSummaryChips(monitor, payload);
+      const details = rawDetails(displayPayload, displayRaw);
+      const chips = monitorSummaryChips(monitor, displayPayload);
       if (!chips.length && !details) return "<span class='muted'>暂无数据</span>";
       return (
         `<div class="value-card">` +

app/core/database.py

@@ -125,6 +125,21 @@ class MonitorStore:
                 ),
             )
 
+    def apply_paused_ids(self, monitor_ids):
+        ids = sorted(set(monitor_ids or []))
+        if not ids:
+            return
+        now = utc_now_iso()
+        with self._lock, self._conn:
+            self._conn.executemany(
+                """
+                UPDATE monitors
+                SET paused=1, status='paused', next_run_at=NULL, updated_at=?
+                WHERE id=?
+                """,
+                [(now, monitor_id) for monitor_id in ids],
+            )
+
     def get_monitor(self, monitor_id):
         with self._lock:
             row = self._conn.execute(

app/core/platform.py

@@ -1,7 +1,9 @@
+import json
 import os
 import threading
 
 from app.core.database import MonitorStore
+from app.core.state import HubStateStore
 from app.monitors.crypto_price import CryptoPriceMonitor
 from app.monitors.market_move import MarketMoveMonitor
 from app.monitors.strategy_treasury import StrategyTreasuryMonitor
@@ -15,18 +17,44 @@ class MonitoringPlatform:
         if not os.path.isdir(data_dir) or not os.access(data_dir, os.W_OK):
             data_dir = os.path.join(os.getcwd(), "data")
         self.data_dir = data_dir
+        self.state_store = HubStateStore(data_dir)
         self.store = MonitorStore(os.getenv("MONITOR_DB_PATH", os.path.join(data_dir, "monitor.db")))
+        crypto_config = self.state_store.get("crypto_config")
+        if crypto_config is not None:
+            self._write_crypto_config(crypto_config)
+            self.store.set_kv("crypto_config", crypto_config)
+        market_move_config = self.state_store.get("market_move:config")
+        if market_move_config is not None:
+            self.store.set_kv("market_move:config", market_move_config)
+        market_move_alert_state = self.state_store.get("market_move:alert_state")
+        if market_move_alert_state is not None:
+            self.store.set_kv("market_move:alert_state", market_move_alert_state)
         self._lock = threading.RLock()
-        self.crypto = CryptoPriceMonitor(self.store)
-        self.strategy_treasury = StrategyTreasuryMonitor(self.store)
-        self.market_move = MarketMoveMonitor(self.store)
+        self.crypto = CryptoPriceMonitor(self.store, self.state_store)
+        self.strategy_treasury = StrategyTreasuryMonitor(self.store, self.state_store)
+        self.market_move = MarketMoveMonitor(self.store, self.state_store)
         self.plugins = {
             "crypto_price": self.crypto,
             "strategy_treasury": self.strategy_treasury,
             "market_move": self.market_move,
         }
+        paused_ids = self.state_store.get("paused_monitor_ids") or []
+        if paused_ids:
+            self.store.apply_paused_ids(paused_ids)
         self.started = False
 
+    def _write_crypto_config(self, cfg):
+        try:
+            from coinpush import CONFIG_FILE
+
+            os.makedirs(os.path.dirname(CONFIG_FILE), exist_ok=True)
+            temp_path = CONFIG_FILE + ".tmp"
+            with open(temp_path, "w", encoding="utf-8") as handle:
+                json.dump(cfg, handle, ensure_ascii=False, indent=2)
+            os.replace(temp_path, CONFIG_FILE)
+        except Exception as exc:
+            self.state_store.last_error = str(exc)
+
     def start(self):
         with self._lock:
             if self.started:
@@ -46,6 +74,11 @@ class MonitoringPlatform:
         return {
             "started": self.started,
             "data_dir": self.data_dir,
+            "state_sync": {
+                "enabled": self.state_store.enabled,
+                "remote_synced": self.state_store.remote_synced,
+                "last_error": self.state_store.last_error,
+            },
             "monitors": self.store.list_monitors(),
             "alerts": self.store.recent_alerts(20),
             "events": self.store.recent_events(40),
@@ -71,14 +104,22 @@ class MonitoringPlatform:
         }
 
     def set_monitor_paused(self, monitor_id, paused):
-        return self.store.set_monitor_paused(monitor_id, paused)
+        result = self.store.set_monitor_paused(monitor_id, paused)
+        paused_ids = set(self.state_store.get("paused_monitor_ids") or [])
+        if paused:
+            paused_ids.add(monitor_id)
+        else:
+            paused_ids.discard(monitor_id)
+        self.state_store.update(paused_monitor_ids=sorted(paused_ids))
+        return result
 
     def get_config(self):
         return self.crypto.get_config()
 
     def update_config(self, cfg):
-        self.crypto.update_config(cfg)
-        return self.crypto.get_config()
+        result = self.crypto.update_config(cfg)
+        self.state_store.set_kv("crypto_config", result)
+        return result
 
     def calibrate_all(self):
         self.crypto.calibrate_all()
@@ -91,4 +132,6 @@ class MonitoringPlatform:
         return self.market_move.get_config()
 
     def update_market_move_config(self, cfg):
-        return self.market_move.update_config(cfg)
+        result = self.market_move.update_config(cfg)
+        self.state_store.set_kv("market_move:config", result)
+        return result

app/core/state.py

@@ -0,0 +1,142 @@
+import copy
+import io
+import json
+import os
+import tempfile
+import threading
+from datetime import datetime, timezone
+
+
+def utc_now_iso():
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+class HubStateStore:
+    """Small JSON state store backed by a private Hugging Face dataset."""
+
+    def __init__(self, data_dir):
+        self.repo_id = os.getenv("STATE_HUB_REPO_ID")
+        self.repo_type = os.getenv("STATE_HUB_REPO_TYPE", "dataset")
+        self.filename = os.getenv("STATE_HUB_FILENAME", "monitor_state.json")
+        token = os.getenv("HF_TOKEN")
+        self.path = os.path.join(data_dir, self.filename)
+        self._lock = threading.RLock()
+        self._api = None
+        self.last_error = None
+        self.remote_synced = False
+
+        if self.repo_id and token:
+            try:
+                from huggingface_hub import HfApi
+
+                self._api = HfApi(token=token)
+            except Exception as exc:
+                self.last_error = str(exc)
+
+        self._state = self._load()
+
+    @property
+    def enabled(self):
+        return self._api is not None and bool(self.repo_id)
+
+    def _empty(self):
+        return {"updated_at": "1970-01-01T00:00:00+00:00", "paused_monitor_ids": [], "values": {}}
+
+    def _decode(self, path):
+        with open(path, "r", encoding="utf-8") as handle:
+            state = json.load(handle)
+        if not isinstance(state, dict):
+            raise ValueError("state root must be an object")
+        state.setdefault("paused_monitor_ids", [])
+        state.setdefault("values", {})
+        if not isinstance(state["paused_monitor_ids"], list):
+            state["paused_monitor_ids"] = []
+        if not isinstance(state["values"], dict):
+            state["values"] = {}
+        return state
+
+    def _write_local(self, state):
+        os.makedirs(os.path.dirname(self.path), exist_ok=True)
+        fd, temp_path = tempfile.mkstemp(prefix=".monitor-state-", dir=os.path.dirname(self.path))
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as handle:
+                json.dump(state, handle, ensure_ascii=False, indent=2, sort_keys=True)
+            os.replace(temp_path, self.path)
+        except Exception:
+            try:
+                os.unlink(temp_path)
+            except OSError:
+                pass
+            raise
+
+    def _load(self):
+        local = self._empty()
+        if os.path.exists(self.path):
+            try:
+                local = self._decode(self.path)
+            except Exception as exc:
+                self.last_error = str(exc)
+
+        if not self.enabled:
+            return local
+
+        try:
+            from huggingface_hub import hf_hub_download
+
+            remote_path = hf_hub_download(
+                repo_id=self.repo_id,
+                repo_type=self.repo_type,
+                filename=self.filename,
+                force_download=True,
+            )
+            remote = self._decode(remote_path)
+            if str(remote.get("updated_at") or "") >= str(local.get("updated_at") or ""):
+                self.remote_synced = True
+                self._write_local(remote)
+                return remote
+            return local
+        except Exception as exc:
+            self.last_error = str(exc)
+            return local
+
+    def _upload(self, state):
+        if not self.enabled:
+            return False
+        try:
+            payload = json.dumps(state, ensure_ascii=False, indent=2, sort_keys=True).encode("utf-8")
+            self._api.upload_file(
+                path_or_fileobj=io.BytesIO(payload),
+                path_in_repo=self.filename,
+                repo_id=self.repo_id,
+                repo_type=self.repo_type,
+                commit_message="Update monitor state",
+            )
+            self.last_error = None
+            self.remote_synced = True
+            return True
+        except Exception as exc:
+            self.last_error = str(exc)
+            self.remote_synced = False
+            return False
+
+    def get(self, key, default=None):
+        with self._lock:
+            if key == "paused_monitor_ids":
+                return copy.deepcopy(self._state.get(key, []))
+            return copy.deepcopy(self._state.get("values", {}).get(key, default))
+
+    def update(self, **updates):
+        with self._lock:
+            self._state.update(updates)
+            self._state["updated_at"] = utc_now_iso()
+            state = copy.deepcopy(self._state)
+            self._write_local(state)
+            self._upload(state)
+
+    def set_kv(self, key, value):
+        with self._lock:
+            self._state.setdefault("values", {})[key] = copy.deepcopy(value)
+            self._state["updated_at"] = utc_now_iso()
+            state = copy.deepcopy(self._state)
+            self._write_local(state)
+            self._upload(state)

app/monitors/base.py

@@ -3,8 +3,9 @@ class BaseMonitor:
 
     monitor_type = "base"
 
-    def __init__(self, store):
+    def __init__(self, store, state_store=None):
         self.store = store
+        self.state_store = state_store
 
     def start(self):
         raise NotImplementedError

app/monitors/crypto_price.py

@@ -29,8 +29,8 @@ class CryptoPriceMonitor(BaseMonitor):
 
     monitor_type = "crypto_price"
 
-    def __init__(self, store):
-        super().__init__(store)
+    def __init__(self, store, state_store=None):
+        super().__init__(store, state_store)
         self.logs = deque(maxlen=200)
         self.status_text = "初始化中..."
         self.next_wakeup = None
@@ -59,6 +59,14 @@ class CryptoPriceMonitor(BaseMonitor):
             self.log,
         )
         self.okx_adapter = legacy.OKXMarketAdapter(self.okx, self.log)
+        self.binance_spot_with_fallback = legacy.FallbackMarketAdapter(
+            self.api,
+            self.okx_adapter,
+            self.log,
+            primary_label="Binance现货主源",
+            fallback_label="OKX",
+            fallback_symbol_resolver=legacy.okx_fallback_symbol,
+        )
         self.binance_futures_adapter = legacy.BinanceFuturesMarketAdapter(self.api)
         self.binance_futures_with_fallback = legacy.FallbackMarketAdapter(
             self.binance_futures_adapter,
@@ -80,6 +88,7 @@ class CryptoPriceMonitor(BaseMonitor):
             self.log,
             self.stats,
             cooldowns=legacy.COOLDOWN_MIN,
+            state_store=state_store,
         )
         self.liq = legacy.LiquidationTracker(self._futures_symbols(), self.log)
         self.cross_ex = legacy.CrossExchangeMonitor(self.api, self.bitget, self.okx, self.log)
@@ -161,7 +170,7 @@ class CryptoPriceMonitor(BaseMonitor):
             return self.alpha_with_futures
         if source == "okx":
             return self.okx_adapter
-        return self.api
+        return self.binance_spot_with_fallback
 
     def _futures_symbols(self):
         symbols = []
@@ -169,9 +178,7 @@ class CryptoPriceMonitor(BaseMonitor):
             if not coin.get("enable_futures") or not coin.get("futures_symbol"):
                 continue
             source = coin.get("data_source", "binance")
-            if source in ("binance_futures", "binance_alpha") or (
-                source == "binance" and legacy.FUTURES_ENABLED
-            ):
+            if source in ("binance", "binance_futures", "binance_alpha"):
                 symbols.append(coin["futures_symbol"])
         return symbols
 
@@ -252,7 +259,7 @@ class CryptoPriceMonitor(BaseMonitor):
                 self.log(f"开始校准 {name}", monitor_id=coin_monitor_id(name))
                 overrides = legacy.calibrate_thresholds(self._api_for(coin), coin, self.log, scale)
                 cfg["coins"][name] = legacy._deep_merge(coin, overrides)
-                self._record_success(coin_monitor_id(name), {"calibrated": True})
+                self.store.add_event(coin_monitor_id(name), "info", "校准完成")
             except Exception as exc:
                 self._record_failure(coin_monitor_id(name), f"{name} 校准失败: {exc}")
         cfg["global"]["last_calibrate_ts"] = time.time()
@@ -480,7 +487,12 @@ class CryptoPriceMonitor(BaseMonitor):
                     )
                 else:
                     self.stats["api_fails"] += 1
-                    self._record_failure(monitor_id, "数据不足或接口无返回")
+                    data_error = getattr(evaluator, "last_data_error", None)
+                    error = (
+                        f"数据不足或接口无返回：{data_error}"
+                        if data_error else "数据不足或接口无返回"
+                    )
+                    self._record_failure(monitor_id, error)
                 total_alerts.extend(alerts)
             except Exception as exc:
                 self._record_failure(monitor_id, f"{name} 评估异常: {exc}")

app/monitors/market_move.py

@@ -1185,8 +1185,8 @@ class MarketMoveMonitor(BaseMonitor):
 
     monitor_type = "market_move"
 
-    def __init__(self, store):
-        super().__init__(store)
+    def __init__(self, store, state_store=None):
+        super().__init__(store, state_store)
         self.config = self._load_config()
         self.enabled = bool(self.config.get("enabled", True))
         self.interval = int(self.config.get("interval_sec", 300))
@@ -1230,6 +1230,8 @@ class MarketMoveMonitor(BaseMonitor):
             self.threshold_pct = float(cfg.get("threshold_pct", 30.0))
             self.client.update_config(cfg)
         self.store.set_kv(CONFIG_KEY, cfg)
+        if self.state_store is not None:
+            self.state_store.set_kv(CONFIG_KEY, cfg)
         self._register_monitors()
         self.log("全市场涨跌监控配置已更新")
         return self.get_config()
@@ -1459,6 +1461,8 @@ class MarketMoveMonitor(BaseMonitor):
             changed = True
         if changed:
             self.store.set_kv(ALERT_STATE_KEY, state)
+            if self.state_store is not None:
+                self.state_store.set_kv(ALERT_STATE_KEY, state)
         return sent
 
     def _send_move_alert(self, snapshot, window, change_info, direction, rule):

app/monitors/strategy_treasury.py

@@ -245,8 +245,8 @@ class StrategyTreasuryClient:
 class StrategyTreasuryMonitor(BaseMonitor):
     monitor_type = "strategy_treasury"
 
-    def __init__(self, store):
-        super().__init__(store)
+    def __init__(self, store, state_store=None):
+        super().__init__(store, state_store)
         self.interval = int(os.getenv("STRATEGY_TREASURY_INTERVAL_SEC", "60"))
         self.enabled = os.getenv("ENABLE_STRATEGY_TREASURY", "true").lower() not in ("0", "false", "no", "off")
         self._stop_event = threading.Event()

coinpush.py

@@ -89,12 +89,6 @@ UPBIT_BASE = os.getenv("UPBIT_BASE", "https://api.upbit.com")
 HYPERLIQUID_BASE = os.getenv("HYPERLIQUID_BASE", "https://api.hyperliquid.xyz")
 ASTER_FAPI_BASE = os.getenv("ASTER_FAPI_BASE", "https://fapi.asterdex.com")
 
-# 合约功能全局开关（默认关闭）。币安合约接口/强平流对 US 区域可能返回 451。
-# 该开关控制现货主行情币种的合约指标与强平 websocket；若标的本身以 Binance
-# 合约作为主行情源（如 STRC），会优先访问 /fapi，受限时自动使用 OKX 备用行情。
-# 若自带可访问合约接口的代理，设置 BINANCE_FAPI_BASE 指向代理即可恢复 Binance 主源。
-FUTURES_ENABLED = os.getenv("ENABLE_FUTURES", "false").strip().lower() in ("1", "true", "yes", "on")
-
 # 配置持久化文件
 CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
 LOCAL_CONFIG_FILE = os.path.join(CURRENT_DIR, "crypto_config.json")
@@ -120,17 +114,15 @@ def _btc_defaults():
     return {
         "symbol": "BTCUSDT",
         "futures_symbol": "BTCUSDT",
-        # 数据来源：binance（默认）或 okx。okx 标的走 OKXMarketAdapter，
-        # 合约信息(资金费率/持仓量)不受 FUTURES_ENABLED(仅针对币安US限制)约束。
+        # 数据来源：binance（默认）、binance_futures、binance_alpha 或 okx。
         "data_source": "binance",
         # 首页核心展示：同一时间只应有一个币种开启；旧配置默认 GRAM。
         "core_display": False,
         # 休市属性：股票类标的(如 STRC)休市时价格长时间不变，期间不推送任何提醒
         "market_close": False,
         "market_close_static_secs": 600,
-        # 默认关闭合约监控：币安合约接口(/fapi)与强平 websocket 对部分地区(如US)
-        # 返回 451，而 HuggingFace Space 运行在 US 区域。现货数据走 data-api.binance.vision
-        # 不受限制。如自带可访问合约接口的代理，可在页面重新开启。
+        # 合约监控按币种开启；币安合约接口(/fapi)与强平 websocket 在部分区域
+        # 可能返回 451。受限时会保留现货监控，合约字段降级为空。
         "enable_futures": False,
         # 个人关键价位（0 表示未设置，不监控）
         "cost_price": 0.0,
@@ -1568,7 +1560,7 @@ class FallbackMarketAdapter:
 
     def __init__(self, primary, fallback, logger, fallback_symbols=None,
                  primary_label="主源", fallback_label="备用源",
-                 allow_symbol_guess=True):
+                 allow_symbol_guess=True, fallback_symbol_resolver=None):
         self.primary = primary
         self.fallback = fallback
         self.logger = logger
@@ -1576,9 +1568,12 @@ class FallbackMarketAdapter:
         self.primary_label = primary_label
         self.fallback_label = fallback_label
         self.allow_symbol_guess = allow_symbol_guess
+        self.fallback_symbol_resolver = fallback_symbol_resolver
         self._fallback_logged = set()
 
-    def _fallback_symbol(self, symbol):
+    def _fallback_symbol(self, method, symbol):
+        if self.fallback_symbol_resolver:
+            return self.fallback_symbol_resolver(method, symbol)
         if symbol in self.fallback_symbols:
             return self.fallback_symbols[symbol]
         if self.allow_symbol_guess and symbol.endswith("USDT") and len(symbol) > 4:
@@ -1593,7 +1588,7 @@ class FallbackMarketAdapter:
         if result:
             return result
 
-        fb_symbol = self._fallback_symbol(symbol)
+        fb_symbol = self._fallback_symbol(method, symbol)
         if not fb_symbol:
             return None
         fallback_fn = getattr(self.fallback, method, None)
@@ -1634,6 +1629,20 @@ class FallbackMarketAdapter:
         return self._call("funding_rate_history", symbol, limit)
 
 
+DERIVATIVE_METHODS = {"premium_index", "open_interest", "funding_rate_history"}
+
+
+def okx_fallback_symbol(method, symbol):
+    text = str(symbol or "").strip().upper()
+    if not text:
+        return None
+    if text.endswith("USDT") and len(text) > 4:
+        asset = text[:-4]
+        suffix = "-USDT-SWAP" if method in DERIVATIVE_METHODS else "-USDT"
+        return f"{asset}{suffix}"
+    return text
+
+
 # --- 7. 实时强平监控（websocket，可选）---
 class LiquidationTracker:
     """
@@ -1876,12 +1885,10 @@ def calibrate_thresholds(api, coin_cfg, logger=print, sensitivity=1.0):
             out["liq_5m_usdt"] = round(max(avg5 * 0.5, 10000))
             out["liq_severe_usdt"] = round(out["liq_5m_usdt"] * 4)
 
-    # 7) 资金费率：历史费率分位（合约启用时；合约主行情源不受 FUTURES_ENABLED 限制）
-    _ds = coin_cfg.get("data_source", "binance")
+    # 7) 资金费率：历史费率分位（合约启用时）
     if (
         coin_cfg.get("enable_futures")
         and coin_cfg.get("futures_symbol")
-        and (_ds in ("okx", "binance_futures", "binance_alpha") or FUTURES_ENABLED)
     ):
         fr = api.funding_rate_history(coin_cfg["futures_symbol"], 500)
         if fr:
@@ -2022,6 +2029,7 @@ class CoinEvaluator:
         self.last_oi_changes = {}
         self.last_liq_5m_usdt = None
         self.last_rsi = None
+        self.last_data_error = None
 
     def evaluate(self, cfg):
         sym = cfg["symbol"]
@@ -2029,18 +2037,40 @@ class CoinEvaluator:
 
         ticker = self.api.ticker_24h(sym)
         k1 = self.api.klines(sym, "1m", 62)
-        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)
+        ticker_ok = isinstance(ticker, dict) and bool(ticker)
+        k1_ok = isinstance(k1, list) and bool(k1)
+        data_warnings = []
+        if not ticker_ok:
+            data_warnings.append("24h ticker 无返回")
+        if not k1_ok:
+            data_warnings.append("1m K线无返回")
+        elif len(k1) < 17:
+            data_warnings.append(f"1m K线较少 {len(k1)}/17")
+
+        closes = _floats(k1, 4) if k1_ok else []
+        highs = _floats(k1, 2) if k1_ok else []
+        lows = _floats(k1, 3) if k1_ok else []
+        qvols = _floats(k1, 7) if k1_ok else []  # quoteAssetVolume
+
+        def num(value, default=None):
+            try:
+                if value is None or value == "":
+                    return default
+                return float(value)
+            except (TypeError, ValueError):
+                return default
+
+        price = num((ticker or {}).get("lastPrice")) if ticker_ok else None
+        if price is None and closes:
+            price = closes[-1]
+        if price is None:
+            self.last_data_error = f"{sym} " + "；".join(data_warnings or ["无可用价格"])
+            return alerts, None
+        self.last_data_error = None
+
+        high24 = num((ticker or {}).get("highPrice"), 0.0) if ticker_ok else 0.0
+        low24 = num((ticker or {}).get("lowPrice"), 0.0) if ticker_ok else 0.0
+        qvol24 = num((ticker or {}).get("quoteVolume"), 0.0) if ticker_ok else 0.0
         volume5m = sum(qvols[-5:]) if len(qvols) >= 5 else 0.0
         avg5m_volume = qvol24 / 288.0 if qvol24 > 0 else 0.0
         volume_ratio_5m = (volume5m / avg5m_volume) if avg5m_volume > 0 else None
@@ -2057,9 +2087,9 @@ class CoinEvaluator:
                 "data_source": cfg.get("data_source", self.data_source),
                 "enable_futures": bool(cfg.get("enable_futures")),
                 "price": price,
-                "high24": high24,
-                "low24": low24,
-                "quoteVolume24h": qvol24,
+                "high24": high24 if high24 > 0 else None,
+                "low24": low24 if low24 > 0 else None,
+                "quoteVolume24h": qvol24 if qvol24 > 0 else None,
                 "volume5m": volume5m,
                 "volumeRatio5m": volume_ratio_5m,
                 "priceChange": price_changes,
@@ -2068,6 +2098,7 @@ class CoinEvaluator:
                 "openInterest": self.last_open_interest,
                 "openInterestChange": copy.deepcopy(self.last_oi_changes),
                 "liquidation5m": self.last_liq_5m_usdt,
+                "dataWarnings": data_warnings,
                 "updatedAt": datetime.now(timezone.utc).isoformat(),
             }
 
@@ -2170,11 +2201,10 @@ class CoinEvaluator:
         # 11) RSI
         self._check_rsi(cfg, sym, head, add)
 
-        # 12) 合约类（合约主行情源不受 FUTURES_ENABLED 限制）
+        # 12) 合约类
         if (
             cfg.get("enable_futures")
             and cfg.get("futures_symbol")
-            and (self.data_source in ("okx", "binance_futures", "binance_alpha") or FUTURES_ENABLED)
         ):
             self._check_futures(cfg, head, add)
 
@@ -2659,6 +2689,14 @@ class CryptoMonitor:
         self.bitget = BitgetAPI(self.log)
         self.okx = OKXAPI(self.log)
         self.okx_adapter = OKXMarketAdapter(self.okx, self.log)
+        self.binance_spot_with_fallback = FallbackMarketAdapter(
+            self.api,
+            self.okx_adapter,
+            self.log,
+            primary_label="Binance现货主源",
+            fallback_label="OKX",
+            fallback_symbol_resolver=okx_fallback_symbol,
+        )
         self.binance_futures_adapter = BinanceFuturesMarketAdapter(self.api)
         self.binance_futures_with_fallback = FallbackMarketAdapter(
             self.binance_futures_adapter,
@@ -2702,7 +2740,7 @@ class CryptoMonitor:
             return self.alpha_with_futures
         if coin_cfg.get("data_source") == "okx":
             return self.okx_adapter
-        return self.api
+        return self.binance_spot_with_fallback
 
     def _futures_symbols(self):
         # OKX 标的不走 Binance 强平 websocket；Alpha 如显式开启合约，则订阅其 Binance 合约 symbol。
@@ -2711,9 +2749,7 @@ class CryptoMonitor:
             if not coin.get("enable_futures") or not coin.get("futures_symbol"):
                 continue
             source = coin.get("data_source", "binance")
-            if source in ("binance_futures", "binance_alpha") or (
-                source == "binance" and FUTURES_ENABLED
-            ):
+            if source in ("binance", "binance_futures", "binance_alpha"):
                 symbols.append(coin["futures_symbol"])
         return symbols
 

requirements.txt

@@ -1,5 +1,6 @@
 fastapi
 uvicorn[standard]
 requests
+huggingface_hub
 python-dotenv
 websocket-client