Update app.py

app.py

@@ -1,13 +1,14 @@
 # ============================================
 # АВТО-УСТАНОВКА ПАКЕТОВ
 # ============================================
-import subprocess
-import sys
-import importlib
+import subprocess, sys, importlib
 
 REQUIRED_PACKAGES = {
     'numpy': 'numpy',
     'pandas': 'pandas',
+    'httpx': 'httpx',
+    'fastapi': 'fastapi',
+    'uvicorn': 'uvicorn',
     'requests': 'requests'
 }
 
@@ -20,409 +21,451 @@ for module_name, pip_name in REQUIRED_PACKAGES.items():
         print(f"✅ {pip_name} установлен!")
 
 # ============================================
-# 👑 TOMIRIS SPACE 28 v1.0 — MARKET REGIME & BUBBLE DETECTOR
+# 👑 TOMIRIS SPACE 28 v2.0 — MARKET REGIME & BUBBLE SENTINEL (Async, No MT5, Real NVT)
 # ============================================
-# Определяет режим рынка (TREND/RANGE/VOLATILE/BUBBLE).
-# Euphoria Index, NVT Ratio, RSI экстремумы, пузыри.
-# Имеет право ВЕТО — при пузыре блокирует BUY.
-# ============================================
-
-from fastapi import FastAPI, Query
+import os, time, json, logging, asyncio
 from typing import Dict, Any, List, Optional
-import time
-import requests
-import threading
+from datetime import datetime, timezone
+from collections import deque
 import numpy as np
 import pandas as pd
-from datetime import datetime
-from collections import deque
-import warnings
-warnings.filterwarnings('ignore')
+import httpx
+from fastapi import FastAPI, Query
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger("Space28_RegimeBubble")
 
 # ================= КОНФИГУРАЦИЯ =================
 SYMBOLS = ["XAU/USD", "ETH/USD", "SOL/USD"]
+HUB_URL = os.getenv("SPACE17_URL", "https://tomiris-ai-name5-5.hf.space")
+ARBITER_URL = os.getenv("SPACE18_URL", "https://tomiris-ai-name6-6.hf.space")
+SPACE9_URL = os.getenv("SPACE9_URL", "https://nuxotetotnicksvoboden-name3.hf.space")   # On-Chain Analytics
+SPACE22_URL = os.getenv("SPACE22_URL", "https://tomirisai80-tomirisanal4.hf.space")    # Sentiment
+SPACE26_URL = os.getenv("SPACE26_URL", "https://tomirisg25-tomirisgold2.hf.space")     # Derivatives
+TWELVE_DATA_KEY = os.getenv("TWELVE_DATA_KEY", "e3740c072fda4fe8b8539d40b07e445e")
+
+BUBBLE_HISTORY_FILE = "bubble_history.json"
+CACHE_TTL = {
+    "candles": 300, "onchain": 600, "sentiment": 300, "derivatives": 120
+}
 
-SPACE_18_ARBITER = "https://tomiris-ai-name6-6.hf.space"
+# ================= HTTP КЛИЕНТ =================
+http_client = httpx.AsyncClient(timeout=20.0)
+
+# ================= ГЛОБАЛЬНЫЙ КЭШ И BREAKER =================
+cache_store = {}
+cache_times = {}
+CIRCUIT_BREAKER = {}
+
+def breaker_open(name: str) -> bool:
+    info = CIRCUIT_BREAKER.get(name)
+    if not info: return False
+    if info["fails"] < 3: return False
+    if time.time() - info["last_fail"] > 600:
+        CIRCUIT_BREAKER[name] = {"fails": 0, "last_fail": 0}
+        return False
+    return True
+
+def breaker_record(name: str, success: bool):
+    info = CIRCUIT_BREAKER.get(name, {"fails": 0, "last_fail": 0})
+    if success:
+        info["fails"] = 0
+    else:
+        info["fails"] += 1
+        info["last_fail"] = time.time()
+    CIRCUIT_BREAKER[name] = info
 
-TWELVE_KEYS = [
-    "e3740c072fda4fe8b8539d40b07e445e",
-    "58e67e0008e24161ac9b1671b7c2d2d0"
-]
+# История пузырей
+if os.path.exists(BUBBLE_HISTORY_FILE):
+    try:
+        with open(BUBBLE_HISTORY_FILE) as f:
+            BUBBLE_HISTORY = deque(json.load(f), maxlen=500)
+    except:
+        BUBBLE_HISTORY = deque(maxlen=500)
+else:
+    BUBBLE_HISTORY = deque(maxlen=500)
 
-CACHE = {}
-CACHE_TIMES = {}
-FEATURES_STORE = {}
-MT5_MAX_AGE_SEC = 300
-BUBBLE_HISTORY = deque(maxlen=200)
+def save_bubble_history():
+    with open(BUBBLE_HISTORY_FILE, 'w') as f:
+        json.dump(list(BUBBLE_HISTORY), f)
 
-twelve_counter = 0
-api_lock = threading.Lock()
+# ================= ЗАГРУЗКА ДАННЫХ =================
+async def fetch_candles(symbol: str, tf: str = "1h", count: int = 200) -> Optional[pd.DataFrame]:
+    """Получает свечи из Hub."""
+    cache_key = f"candles_{symbol}_{tf}_{count}"
+    if cache_key in cache_store and time.time() - cache_times.get(cache_key, 0) < CACHE_TTL["candles"]:
+        return cache_store[cache_key]
 
-def get_next_key():
-    global twelve_counter
-    with api_lock:
-        key = TWELVE_KEYS[twelve_counter % len(TWELVE_KEYS)]
-        twelve_counter += 1
-        return key
+    if breaker_open("hub"): return None
+    try:
+        r = await http_client.get(f"{HUB_URL}/candles", params={"symbol": symbol, "interval": tf, "limit": count})
+        if r.status_code == 200:
+            data = r.json().get("candles", [])
+            if data:
+                df = pd.DataFrame(data)
+                df.rename(columns={"o": "open", "h": "high", "l": "low", "c": "close", "v": "volume", "t": "timestamp"}, inplace=True)
+                df["close"] = pd.to_numeric(df["close"], errors="coerce")
+                df["high"] = pd.to_numeric(df["high"], errors="coerce")
+                df["low"] = pd.to_numeric(df["low"], errors="coerce")
+                if "volume" in df.columns:
+                    df["volume"] = pd.to_numeric(df["volume"], errors="coerce").fillna(0)
+                breaker_record("hub", True)
+                cache_store[cache_key] = df
+                cache_times[cache_key] = time.time()
+                return df
+        breaker_record("hub", False)
+    except:
+        breaker_record("hub", False)
+    return None
 
-def send_to_arbiter(signal_data):
+async def fetch_onchain_volume(symbol: str) -> Optional[float]:
+    """Пытается получить on‑chain объём транзакций из Space 9."""
+    if not SPACE9_URL or breaker_open("space9"):
+        return None
     try:
-        requests.post(
-            f"{SPACE_18_ARBITER}/log_signal",
-            json={'space': 'space_28_regime', 'symbol': 'ALL', 'signal': signal_data.get('signal', {})},
-            timeout=5
-        )
+        # Ожидаем, что Space 9 отдаёт что-то вроде {"network": {"tx_volume_24h": ...}}
+        r = await http_client.get(f"{SPACE9_URL}/consilium?symbol={symbol}")
+        if r.status_code == 200:
+            data = r.json()
+            # Ищем поле с объёмом транзакций (может быть в разных местах)
+            metrics = data.get("onchain_analysis", {}).get("metrics", {})
+            network = metrics.get("network", {})
+            vol = network.get("tx_volume_24h") or network.get("total_volume_24h")
+            if vol:
+                breaker_record("space9", True)
+                return float(vol)
     except:
-        pass
+        breaker_record("space9", False)
+    return None
 
-# ================= ЗАГРУЗКА ДАННЫХ =================
-def fetch_historical(symbol, tf="1h", count=200):
-    cache_key = f"hist_{symbol}_{tf}_{count}"
-    if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 300:
-        return CACHE[cache_key]
+async def fetch_sentiment_signal(symbol: str) -> Optional[Dict]:
+    """Получает социальный сентимент из Space 22."""
+    if not SPACE22_URL or breaker_open("space22"): return None
+    try:
+        r = await http_client.get(f"{SPACE22_URL}/sentiment/{symbol}")
+        if r.status_code == 200:
+            data = r.json()
+            breaker_record("space22", True)
+            return data
+    except:
+        breaker_record("space22", False)
+    return None
 
+async def fetch_derivatives(symbol: str) -> Optional[Dict]:
+    """Получает Funding Rate и OI из Space 26."""
+    if not SPACE26_URL or breaker_open("space26"): return None
     try:
-        key = get_next_key()
-        twelve_symbol = symbol.replace("/", "")
-        url = f"https://api.twelvedata.com/time_series?symbol={twelve_symbol}&interval={tf}&outputsize={count}&apikey={key}"
-        r = requests.get(url, timeout=10)
+        # Предполагаем, что Space 26 отдаёт /consilium с метриками
+        r = await http_client.get(f"{SPACE26_URL}/consilium?symbol={symbol}")
         if r.status_code == 200:
             data = r.json()
-            if 'values' in data:
-                df = pd.DataFrame(data['values']).iloc[::-1]
-                df['close'] = pd.to_numeric(df['close'])
-                df['high'] = pd.to_numeric(df['high'])
-                df['low'] = pd.to_numeric(df['low'])
-                if 'volume' in df.columns:
-                    df['volume'] = pd.to_numeric(df['volume'], errors='coerce').fillna(0)
-                CACHE[cache_key] = df
-                CACHE_TIMES[cache_key] = time.time()
-                return df
-    except Exception as e:
-        print(f"⚠️ {symbol}: {e}")
+            deriv = data.get("derivative_analysis", {}).get("metrics", {})
+            breaker_record("space26", True)
+            return deriv
+    except:
+        breaker_record("space26", False)
     return None
 
 # ================= ИНДИКАТОРЫ =================
-def safe_rsi(close, period=14):
+def safe_rsi(close: pd.Series, period: int = 14) -> float:
     try:
         delta = close.diff()
         gain = delta.clip(lower=0).rolling(period, min_periods=period).mean()
         loss = (-delta.clip(upper=0)).rolling(period, min_periods=period).mean()
-        g_val, l_val = gain.iloc[-1], loss.iloc[-1]
-        if pd.notna(g_val) and pd.notna(l_val) and l_val > 0:
-            rs = g_val / l_val
-            return float(100 - (100 / (1 + rs)))
-        return 50.0
+        rs = gain / (loss + 1e-10)
+        return float(100 - (100 / (1 + rs.iloc[-1])))
     except:
         return 50.0
 
-def calculate_euphoria_index(df):
-    """Euphoria Index: 0-100, где >70 = эйфория."""
-    if df is None or len(df) < 50:
+def calculate_euphoria_index(df: pd.DataFrame, funding_signal: Optional[str] = None,
+                             oi_change: Optional[float] = None, sentiment_fear: Optional[float] = None) -> float:
+    """Euphoria Index 0-100, учитывающий RSI, цену, объём, фондирование, OI, сентимент."""
+    if df is None or len(df) < 20:
         return 50.0
-
     close = df['close']
-    volume = df['volume'] if 'volume' in df.columns else pd.Series([1]*len(df))
+    volume = df['volume'] if 'volume' in df.columns else pd.Series([1.0]*len(df))
 
     score = 0.0
 
+    # RSI
     rsi = safe_rsi(close, 14)
     if rsi > 80:
-        score += 30
+        score += 25
     elif rsi > 70:
-        score += 20
+        score += 18
     elif rsi > 60:
-        score += 10
+        score += 8
+    elif rsi < 30:
+        score -= 15
+    elif rsi < 20:
+        score -= 20
 
+    # Цена относительно SMA50
     if len(close) >= 50:
         sma50 = close.rolling(50).mean().iloc[-1]
-        price_vs_sma = ((close.iloc[-1] - sma50) / sma50) * 100
-        if price_vs_sma > 20:
-            score += 25
-        elif price_vs_sma > 10:
-            score += 15
-        elif price_vs_sma > 5:
+        dev = (close.iloc[-1] - sma50) / sma50 * 100
+        if dev > 20:
+            score += 20
+        elif dev > 10:
+            score += 12
+        elif dev > 5:
             score += 5
+        elif dev < -20:
+            score -= 15
 
+    # Объём
     if len(volume) >= 20:
-        vol_avg = volume.rolling(20).mean().iloc[-1]
-        vol_ratio = volume.iloc[-1] / (vol_avg + 1e-10)
+        avg_vol = volume.rolling(20).mean().iloc[-1]
+        vol_ratio = volume.iloc[-1] / (avg_vol + 1e-10)
         if vol_ratio > 3:
-            score += 20
+            score += 15
         elif vol_ratio > 2:
-            score += 10
-
-    return min(100, score)
+            score += 8
 
-def calculate_nvt_ratio(df):
-    """Network Value to Transactions — аналог NVT для крипты."""
-    if df is None or len(df) < 30:
-        return 50.0
-
-    close = df['close']
-    volume = df['volume'] if 'volume' in df.columns else pd.Series([1]*len(df))
+    # Funding (если есть)
+    if funding_signal:
+        if funding_signal == 'EXTREME_LONG' or funding_signal == 'BEARISH':
+            score += 15
+        elif funding_signal == 'BULLISH':
+            score -= 10
 
-    market_cap = close.iloc[-1] * 120_000_000
-    daily_volume = volume.iloc[-24:].sum() if len(volume) >= 24 else volume.sum()
+    # OI изменение
+    if oi_change:
+        if oi_change > 10:
+            score += 10
+        elif oi_change < -10:
+            score -= 5
 
-    if daily_volume > 0:
-        nvt = market_cap / daily_volume
+    # Сентимент (0 - страх, 100 - жадность)
+    if sentiment_fear is not None:
+        greed = 100 - sentiment_fear
+        if greed > 70:
+            score += 10
+        elif greed < 30:
+            score -= 10
+
+    return max(0.0, min(100.0, score))
+
+def calculate_nvt_ratio(symbol: str, df: pd.DataFrame, onchain_volume: Optional[float] = None) -> float:
+    """
+    Настоящий NVT: Market Cap / On‑Chain Transaction Volume.
+    Если onchain_volume недоступен, используем биржевой объём как fallback (pseudo NVT).
+    Возвращает Z‑score относительно нормы.
+    """
+    if df is None or len(df) < 24:
+        return 0.0
+    close = df['close'].iloc[-1]
+    # Циркулирующее предложение (приблизительно)
+    supply = {"ETH/USD": 120_000_000, "SOL/USD": 440_000_000, "XAU/USD": 1}.get(symbol, 1)
+    market_cap = close * supply
+
+    if onchain_volume and onchain_volume > 0:
+        nvt = market_cap / onchain_volume
     else:
-        nvt = 50
-
-    if nvt > 150:
-        nvt_score = 30
-    elif nvt > 100:
-        nvt_score = 20
-    elif nvt < 30:
-        nvt_score = -15
+        # Pseudo NVT: используем биржевой объём за 24 часа
+        volume = df['volume'] if 'volume' in df.columns else pd.Series([1.0]*len(df))
+        daily_volume = volume.iloc[-24:].sum() if len(volume) >= 24 else volume.sum()
+        if daily_volume <= 0:
+            return 0.0
+        nvt = market_cap / daily_volume
+
+    # Нормальный диапазон NVT: ~30-100 (для ETH), ~50-150 (для SOL)
+    if "ETH" in symbol:
+        normal_low, normal_high = 30, 100
+    elif "SOL" in symbol:
+        normal_low, normal_high = 50, 150
     else:
-        nvt_score = 0
+        return 0.0  # для золота не считаем
 
-    return float(nvt_score)
+    if nvt > normal_high:
+        return min(30, (nvt - normal_high) / 10)  # до +30
+    elif nvt < normal_low:
+        return max(-20, (nvt - normal_low) / 10)   # до -20
+    return 0.0
 
 # ================= РЕЖИМ РЫНКА =================
-def detect_market_regime(df, symbol):
+async def detect_market_regime(symbol: str) -> Dict[str, Any]:
+    df = await fetch_candles(symbol, "1h", 200)
     if df is None or len(df) < 50:
-        return {"regime": "UNKNOWN", "score": 50, "bubble_risk": "UNKNOWN", "veto": False}
-
-    close = df['close'].values
-    high = df['high'].values
-    low = df['low'].values
-
-    returns = np.diff(np.log(close))
+        return {"regime": "UNKNOWN", "bubble_probability": 0, "veto": False, "euphoria_index": 50}
+
+    # Дополнительные данные
+    onchain_vol = None
+    if symbol != "XAU/USD":
+        onchain_vol = await fetch_onchain_volume(symbol)
+    deriv = None
+    if symbol != "XAU/USD":
+        deriv = await fetch_derivatives(symbol)
+    sent = await fetch_sentiment_signal(symbol)
+
+    funding_signal = None
+    oi_change = None
+    if deriv:
+        funding = deriv.get("funding_rate", {})
+        funding_signal = funding.get("signal")
+        oi = deriv.get("open_interest", {})
+        oi_change = oi.get("change_pct")
+
+    fear_ratio = None
+    if sent:
+        # Ищем fear_ratio в ответе (поле может называться по-разному)
+        reddit = sent.get("metrics", {}).get("reddit", {})
+        fear_ratio = reddit.get("fear_ratio") or sent.get("fear_ratio")
+
+    close = df['close'].astype(float)
+    returns = np.diff(np.log(close.values))
     volatility = float(np.std(returns[-24:])) if len(returns) >= 24 else 0.01
 
-    recent_high = np.max(high[-20:])
-    recent_low = np.min(low[-20:])
-    range_pct = (recent_high - recent_low) / recent_low * 100
-
-    euphoria = calculate_euphoria_index(df)
-
+    euphoria = calculate_euphoria_index(df, funding_signal, oi_change, fear_ratio)
     nvt_score = 0.0
-    if "XAU" not in symbol:
-        nvt_score = calculate_nvt_ratio(df)
-
-    rsi = safe_rsi(pd.Series(close), 14)
+    if symbol != "XAU/USD":
+        nvt_score = calculate_nvt_ratio(symbol, df, onchain_vol)
 
-    if euphoria > 70:
+    # Определяем режим
+    if euphoria > 70 or nvt_score > 20:
         regime = "BUBBLE"
+        bubble_probability = min(100, euphoria + nvt_score * 2)
         veto = True
         signal = "FORCE_WAIT"
     elif euphoria > 55:
         regime = "EUPHORIA"
+        bubble_probability = euphoria
         veto = False
         signal = "CAUTION"
     elif volatility > 0.03:
         regime = "VOLATILE"
+        bubble_probability = 40
         veto = False
         signal = "NEUTRAL"
-    elif range_pct < 3:
+    elif close.iloc[-1] < close.iloc[-50] * 0.8 and euphoria < 30:
+        regime = "CAPITULATION"
+        bubble_probability = 10
+        veto = False
+        signal = "NORMAL"
+    elif abs(close.iloc[-1] - close.iloc[-20]) / close.iloc[-20] < 0.02:
         regime = "RANGE"
+        bubble_probability = 20
         veto = False
         signal = "NEUTRAL"
     else:
         regime = "TREND"
+        bubble_probability = max(0, min(100, 50 + (close.iloc[-1] > close.iloc[-50] and 15 or -15)))
         veto = False
         signal = "NORMAL"
 
-    regime_score = 50.0
-    if regime == "BUBBLE":
-        regime_score = 90
-    elif regime == "EUPHORIA":
-        regime_score = 70
-    elif regime == "VOLATILE":
-        regime_score = 55
-    elif regime == "RANGE":
-        regime_score = 30
-    else:
-        regime_score = 50
+    # Сохраняем в историю пузырей
+    BUBBLE_HISTORY.append({
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "symbol": symbol,
+        "regime": regime,
+        "bubble_probability": bubble_probability,
+        "euphoria": euphoria
+    })
+    save_bubble_history()
 
     return {
         "regime": regime,
-        "regime_score": regime_score,
+        "bubble_probability": round(bubble_probability, 1),
         "euphoria_index": round(euphoria, 1),
         "nvt_score": round(nvt_score, 1),
-        "rsi_14": round(rsi, 1),
+        "rsi_14": round(safe_rsi(close, 14), 1),
         "volatility_24h_pct": round(volatility * 100, 3),
-        "range_20_pct": round(range_pct, 1),
-        "bubble_risk": "HIGH" if regime == "BUBBLE" else "ELEVATED" if regime == "EUPHORIA" else "LOW",
         "veto": veto,
         "signal": signal
     }
 
-# ================= АНАЛИЗ ИЗ MT5 =================
-def analyze_from_mt5(mt5_features):
-    try:
-        score = 50.0
-        veto = False
-        regime = "NORMAL"
-
-        rsi = mt5_features.get('H1_rsi', 50)
-        if isinstance(rsi, (int, float)):
-            if rsi > 85:
-                veto = True
-                regime = "BUBBLE"
-                score = 90
-            elif rsi > 75:
-                regime = "EUPHORIA"
-                score = 70
-            elif rsi < 20:
-                regime = "CAPITULATION"
-                score = 10
-
-        atr_pct = mt5_features.get('H1_atr_pct', 1)
-        if isinstance(atr_pct, (int, float)) and atr_pct > 4:
-            regime = "VOLATILE"
-            score = max(score, 60)
-
-        return {
-            "regime": regime,
-            "regime_score": score,
-            "veto": veto,
-            "euphoria_index": score,
-            "source": "MT5"
-        }
-    except:
-        return None
-
 # ================= ГЛАВНЫЙ СИГНАЛ =================
-def get_regime_signal(symbol="XAU/USD"):
+async def get_regime_signal(symbol: str = "XAU/USD") -> Dict[str, Any]:
     start = time.time()
-
-    if symbol in FEATURES_STORE:
-        fs = FEATURES_STORE[symbol]
-        age = time.time() - fs.get("timestamp", 0)
-        if age < MT5_MAX_AGE_SEC:
-            mt5_features = fs.get("features", {})
-            if mt5_features:
-                mt5_result = analyze_from_mt5(mt5_features)
-                if mt5_result:
-                    direction = "WAIT" if mt5_result["veto"] else "NEUTRAL"
-                    result = {
-                        "space": "space_28_regime",
-                        "timestamp": int(time.time()),
-                        "symbol": symbol,
-                        "signal": {
-                            "direction": direction,
-                            "confidence": mt5_result["regime_score"] / 100,
-                            "veto": mt5_result["veto"]
-                        },
-                        "regime_analysis": {
-                            "regime": mt5_result["regime"],
-                            "regime_score": mt5_result["regime_score"],
-                            "euphoria_index": mt5_result["euphoria_index"],
-                            "veto": mt5_result["veto"]
-                        },
-                        "data_source": "MT5",
-                        "meta": {"latency_ms": int((time.time() - start) * 1000)}
-                    }
-                    send_to_arbiter(result)
-                    print(f"🫧 REGIME {symbol}: {mt5_result['regime']} | Veto={mt5_result['veto']} (MT5)")
-                    return result
-
-    df = fetch_historical(symbol, "1h", 200)
-    regime_data = detect_market_regime(df, symbol)
-
-    direction = "WAIT" if regime_data["veto"] else "NEUTRAL"
-    confidence = regime_data["regime_score"] / 100
-
+    regime_data = await detect_market_regime(symbol)
     latency = int((time.time() - start) * 1000)
 
+    direction = "WAIT" if regime_data["veto"] else "NEUTRAL"
     result = {
         "space": "space_28_regime",
         "timestamp": int(time.time()),
         "symbol": symbol,
         "signal": {
             "direction": direction,
-            "confidence": round(confidence, 4),
+            "confidence": regime_data["bubble_probability"] / 100 if regime_data["veto"] else 0.0,
             "veto": regime_data["veto"],
             "veto_reason": "BUBBLE_DETECTED" if regime_data["veto"] else None
         },
         "regime_analysis": regime_data,
-        "data_source": "API",
-        "meta": {"latency_ms": latency}
+        "latency_ms": latency
     }
 
-    send_to_arbiter(result)
-    print(f"🫧 REGIME v1 {symbol}: {regime_data['regime']} | Euphoria={regime_data['euphoria_index']:.0f} | Veto={regime_data['veto']}")
+    # Отправка в Arbiter
+    try:
+        await http_client.post(f"{ARBITER_URL}/log_signal", json={
+            "space": "space_28_regime",
+            "symbol": symbol,
+            "signal": result["signal"],
+            "regime_details": regime_data
+        })
+    except:
+        pass
+
+    logger.info(f"🫧 Regime {symbol}: {regime_data['regime']} bubble_prob={regime_data['bubble_probability']:.1f} veto={regime_data['veto']}")
     return result
 
-# ================= KEEP-ALIVE =================
-def keep_alive():
-    while True:
-        time.sleep(840)
-        try:
-            requests.get("http://localhost:7860/health", timeout=5)
-        except:
-            pass
+# ================= FASTAPI =================
+app = FastAPI(title="Tomiris Space 28 v2.0 — Market Regime & Bubble Sentinel")
 
-threading.Thread(target=keep_alive, daemon=True).start()
+@app.on_event("startup")
+async def startup(): pass
 
-# ================= FASTAPI =================
-app = FastAPI(title="TOMIRIS SPACE 28 v1.0 — MARKET REGIME & BUBBLE DETECTOR")
+@app.on_event("shutdown")
+async def shutdown(): await http_client.aclose()
 
 @app.get("/health")
-@app.head("/health")
 async def health():
-    return {
-        "space": "Space 28 - Market Regime & Bubble Detector v1.0",
-        "status": "operational",
-        "symbols": SYMBOLS,
-        "features": ["Euphoria Index", "NVT Ratio", "RSI Extremes", "Bubble VETO"],
-        "bubble_history": len(BUBBLE_HISTORY)
-    }
+    return {"status": "operational", "version": "2.0", "async": True, "no_mt5": True,
+            "features": ["Real NVT", "Composite Bubble Index", "Funding/Sentiment Integration", "Persistent Bubble History"]}
 
 @app.get("/consilium")
 async def consilium(symbol: str = Query("XAU/USD")):
     if symbol not in SYMBOLS:
-        return {"error": f"Unsupported: {symbol}"}
-    return get_regime_signal(symbol)
+        return {"error": "Invalid symbol"}
+    return await get_regime_signal(symbol)
 
 @app.get("/regime/{symbol}")
 async def regime(symbol: str):
     if symbol not in SYMBOLS:
-        return {"error": f"Unsupported: {symbol}"}
-    df = fetch_historical(symbol)
-    if df is None:
-        return {"error": "no_data"}
-    return detect_market_regime(df, symbol)
+        return {"error": "Invalid symbol"}
+    return await detect_market_regime(symbol)
 
 @app.get("/euphoria/{symbol}")
 async def euphoria(symbol: str):
     if symbol not in SYMBOLS:
-        return {"error": f"Unsupported: {symbol}"}
-    df = fetch_historical(symbol)
+        return {"error": "Invalid symbol"}
+    df = await fetch_candles(symbol)
     if df is None:
-        return {"error": "no_data"}
-    return {
-        "symbol": symbol,
-        "euphoria_index": calculate_euphoria_index(df)
-    }
+        return {"error": "no data"}
+    deriv = await fetch_derivatives(symbol) if symbol != "XAU/USD" else None
+    sent = await fetch_sentiment_signal(symbol)
+    fear = None
+    if sent:
+        reddit = sent.get("metrics", {}).get("reddit", {})
+        fear = reddit.get("fear_ratio")
+    funding_signal = deriv.get("funding_rate", {}).get("signal") if deriv else None
+    oi_change = deriv.get("open_interest", {}).get("change_pct") if deriv else None
+    ei = calculate_euphoria_index(df, funding_signal, oi_change, fear)
+    return {"symbol": symbol, "euphoria_index": round(ei, 1)}
 
 @app.get("/nvt/{symbol}")
 async def nvt(symbol: str):
     if symbol not in ["ETH/USD", "SOL/USD"]:
         return {"error": "NVT доступен только для крипты"}
-    df = fetch_historical(symbol)
+    df = await fetch_candles(symbol)
     if df is None:
-        return {"error": "no_data"}
-    return {
-        "symbol": symbol,
-        "nvt_score": calculate_nvt_ratio(df)
-    }
+        return {"error": "no data"}
+    onchain_vol = await fetch_onchain_volume(symbol)
+    nvt_score = calculate_nvt_ratio(symbol, df, onchain_vol)
+    return {"symbol": symbol, "nvt_score": round(nvt_score, 1), "onchain_volume_used": onchain_vol is not None}
 
-@app.post("/features")
-async def receive_features(data: Dict[str, Any]):
-    symbol = data.get("symbol", "XAU/USD")
-    FEATURES_STORE[symbol] = {
-        "features": data.get("features", {}),
-        "price": data.get("price", 0.0),
-        "timestamp": time.time()
-    }
-    print(f"📥 MT5 {symbol}: {len(data.get('features', {}))} признаков")
-    return {"status": "ok"}
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)
 
-print(f"🚀 SPACE 28 v1.0 — MARKET REGIME & BUBBLE DETECTOR ЗАПУЩЕН!")
-print(f"🫧 Детектор: Euphoria Index | NVT Ratio | RSI | Режим рынка | ВЕТО при пузыре")
-print(f"✅ Готов к бою!")
+print("🚀 SPACE 28 v2.0 — MARKET REGIME & BUBBLE SENTINEL ЗАПУЩЕН!")