Update app.py

app.py

@@ -1,3 +1,48 @@
+Hugging Face's logo
+Hugging Face
+Models
+Datasets
+Spaces
+Buckets
+new
+Docs
+Pricing
+
+Website
+Community
+Solutions
+
+Spaces:
+tomirisg25
+/
+TomirisGold5
+
+
+like
+0
+
+App
+Files
+Community
+Settings
+TomirisGold5
+/
+app.py
+
+tomirisg25's picture
+tomirisg25
+Create app.py
+b7c9e15
+verified
+about 18 hours ago
+raw
+
+Copy download link
+history
+blame
+edit
+delete
+14.7 kB
 # ============================================
 # АВТО-УСТАНОВКА ПАКЕТОВ
 # ============================================
@@ -7,6 +52,7 @@ import importlib
 
 REQUIRED_PACKAGES = {
     'numpy': 'numpy',
+    'pandas': 'pandas',
     'requests': 'requests'
 }
 
@@ -19,22 +65,21 @@ for module_name, pip_name in REQUIRED_PACKAGES.items():
         print(f"✅ {pip_name} установлен!")
 
 # ============================================
-# 👑 TOMIRIS SPACE 27 v1.0 — SEASONALITY & CALENDAR EFFECTS
+# 👑 TOMIRIS SPACE 28 v1.0 — MARKET REGIME & BUBBLE DETECTOR
 # ============================================
-# Анализирует календарные закономерности:
-# Месячная сезонность (золото в сентябре, крипта в декабре).
-# Дни недели (понедельник — красный для крипты).
-# Экспирации опционов (Max Pain притяжение).
-# Халвинги, налоговые периоды, праздники.
+# Определяет режим рынка (TREND/RANGE/VOLATILE/BUBBLE).
+# Euphoria Index, NVT Ratio, RSI экстремумы, пузыри.
+# Имеет право ВЕТО — при пузыре блокирует BUY.
 # ============================================
 
 from fastapi import FastAPI, Query
-from typing import Dict, Any, List, Optional
+from typing import Dict, Any, List, Optional, Tuple
 import time
 import requests
 import threading
 import numpy as np
-from datetime import datetime, timedelta
+import pandas as pd
+from datetime import datetime
 from collections import deque
 import warnings
 warnings.filterwarnings('ignore')
@@ -44,297 +89,269 @@ SYMBOLS: List[str] = ["XAU/USD", "ETH/USD", "SOL/USD"]
 
 SPACE_18_ARBITER: str = "https://tomiris-ai-name6-6.hf.space"
 
-CACHE: Dict[str, Dict[str, Any]] = {}
+TWELVE_KEYS: List[str] = [
+    "e3740c072fda4fe8b8539d40b07e445e",
+    "58e67e0008e24161ac9b1671b7c2d2d0"
+]
+
+CACHE: Dict[str, Any] = {}
 CACHE_TIMES: Dict[str, float] = {}
 FEATURES_STORE: Dict[str, Dict[str, Any]] = {}
 MT5_MAX_AGE_SEC: int = 300
+BUBBLE_HISTORY: deque = deque(maxlen=200)
 
-# ================= ИСТОРИЧЕСКАЯ СЕЗОННОСТЬ =================
-# Средняя месячная доходность в % (аппроксимация на основе истории)
-MONTHLY_SEASONALITY: Dict[str, Dict[int, float]] = {
-    "XAU/USD": {
-        1: 0.8, 2: 0.3, 3: -0.2, 4: 0.5, 5: 0.2,
-        6: -0.5, 7: 0.4, 8: 1.2, 9: 2.5, 10: 0.6,
-        11: 0.9, 12: 1.5
-    },
-    "ETH/USD": {
-        1: 2.0, 2: 1.5, 3: 3.0, 4: -1.0, 5: 5.0,
-        6: -2.0, 7: 3.0, 8: -1.5, 9: -3.0, 10: 2.0,
-        11: 1.0, 12: 4.0
-    },
-    "SOL/USD": {
-        1: 3.0, 2: 2.0, 3: 5.0, 4: -2.0, 5: 6.0,
-        6: -3.0, 7: 4.0, 8: -2.0, 9: -4.0, 10: 3.0,
-        11: 2.0, 12: 5.0
-    }
-}
-
-# Доходность по дням недели (средняя)
-DAILY_SEASONALITY: Dict[str, Dict[int, float]] = {
-    "XAU/USD": {0: 0.05, 1: 0.02, 2: -0.03, 3: 0.04, 4: -0.08, 5: 0.0, 6: 0.0},
-    "ETH/USD": {0: -0.15, 1: 0.10, 2: 0.05, 3: 0.08, 4: 0.12, 5: -0.05, 6: -0.10},
-    "SOL/USD": {0: -0.20, 1: 0.15, 2: 0.08, 3: 0.10, 4: 0.15, 5: -0.08, 6: -0.12}
-}
+twelve_counter: int = 0
+api_lock = threading.Lock()
 
-# Ключевые даты экспираций (2026)
-OPTION_EXPIRY_DATES: List[str] = [
-    "2026-06-26", "2026-07-31", "2026-08-28", "2026-09-25",
-    "2026-10-30", "2026-11-27", "2026-12-25"
-]
+def get_next_key() -> str:
+    global twelve_counter
+    with api_lock:
+        key = TWELVE_KEYS[twelve_counter % len(TWELVE_KEYS)]
+        twelve_counter += 1
+        return key
 
 def send_to_arbiter(signal_data: Dict[str, Any]) -> None:
     try:
         requests.post(
             f"{SPACE_18_ARBITER}/log_signal",
-            json={'space': 'space_27_seasonality', 'symbol': 'ALL', 'signal': signal_data.get('signal', {})},
+            json={'space': 'space_28_regime', 'symbol': 'ALL', 'signal': signal_data.get('signal', {})},
             timeout=5
         )
     except:
         pass
 
-# ================= МЕСЯЧНАЯ СЕЗОННОСТЬ =================
-def analyze_monthly_seasonality(symbol: str) -> Dict[str, Any]:
-    now = datetime.utcnow()
-    current_month = now.month
-
-    seasonality = MONTHLY_SEASONALITY.get(symbol, {})
-    current_return = seasonality.get(current_month, 0)
-
-    # Сигнал на основе ожидаемой доходности
-    if current_return > 1.5:
-        seasonal_signal = "STRONG_BULLISH"
-        bias = 0.15
-    elif current_return > 0.5:
-        seasonal_signal = "BULLISH"
-        bias = 0.10
-    elif current_return < -1.5:
-        seasonal_signal = "STRONG_BEARISH"
-        bias = -0.15
-    elif current_return < -0.5:
-        seasonal_signal = "BEARISH"
-        bias = -0.10
-    else:
-        seasonal_signal = "NEUTRAL"
-        bias = 0.0
+# ================= ЗАГРУЗКА ДАННЫХ =================
+def fetch_historical(symbol: str, tf: str = "1h", count: int = 200) -> Optional[pd.DataFrame]:
+    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]
 
-    # Лучшие и худшие месяцы
-    sorted_months = sorted(seasonality.items(), key=lambda x: x[1], reverse=True)
-    best_months = [m for m, _ in sorted_months[:3]]
-    worst_months = [m for m, _ in sorted_months[-3:]]
+    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)
+        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}")
+    return None
+
+# ================= ИНДИКАТОРЫ =================
+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
+    except:
+        return 50.0
+
+def calculate_euphoria_index(df: pd.DataFrame) -> float:
+    """Euphoria Index: 0-100, где >70 = эйфория."""
+    if df is None or len(df) < 50:
+        return 50.0
+
+    close = df['close']
+    volume = df['volume'] if 'volume' in df.columns else pd.Series([1]*len(df))
+
+    score = 0.0
+
+    # RSI на D1 (перекупленность)
+    rsi = safe_rsi(close, 14)
+    if rsi > 80:
+        score += 30
+    elif rsi > 70:
+        score += 20
+    elif rsi > 60:
+        score += 10
+
+    # Положение относительно SMA 50
+    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:
+            score += 5
 
-    return {
-        "current_month": current_month,
-        "month_name": now.strftime("%B"),
-        "expected_return_pct": round(current_return, 2),
-        "seasonal_signal": seasonal_signal,
-        "bias": bias,
-        "best_months": best_months,
-        "worst_months": worst_months
-    }
+    # Объём (аномально высокий = эйфория)
+    if len(volume) >= 20:
+        vol_avg = volume.rolling(20).mean().iloc[-1]
+        vol_ratio = volume.iloc[-1] / (vol_avg + 1e-10)
+        if vol_ratio > 3:
+            score += 20
+        elif vol_ratio > 2:
+            score += 10
 
-# ================= ДНИ НЕДЕЛИ =================
-def analyze_daily_seasonality(symbol: str) -> Dict[str, Any]:
-    now = datetime.utcnow()
-    weekday = now.weekday()
+    return min(100, score)
 
-    daily = DAILY_SEASONALITY.get(symbol, {})
-    today_return = daily.get(weekday, 0)
+def calculate_nvt_ratio(df: pd.DataFrame) -> float:
+    """Network Value to Transactions — аналог NVT для крипты."""
+    if df is None or len(df) < 30:
+        return 50.0
 
-    if today_return > 0.10:
-        daily_signal = "BULLISH"
-        bias = 0.05
-    elif today_return < -0.10:
-        daily_signal = "BEARISH"
-        bias = -0.05
-    else:
-        daily_signal = "NEUTRAL"
-        bias = 0.0
+    close = df['close']
+    volume = df['volume'] if 'volume' in df.columns else pd.Series([1]*len(df))
 
-    day_names = ["Понедельник", "Вторник", "Среда", "Четверг", "Пятница", "Суббота", "Воскресенье"]
+    # Упрощённый NVT = MarketCap / Daily Volume
+    market_cap = close.iloc[-1] * 120_000_000  # Грубая оценка supply
+    daily_volume = volume.iloc[-24:].sum() if len(volume) >= 24 else volume.sum()
 
-    return {
-        "weekday": weekday,
-        "day_name": day_names[weekday],
-        "expected_return_pct": round(today_return, 3),
-        "daily_signal": daily_signal,
-        "bias": bias,
-        "is_weekend": weekday >= 5,
-        "weekend_note": "Рынок XAU закрыт" if weekday >= 5 else None
-    }
-
-# ================= ЭКСПИРАЦИИ ОПЦИОНОВ =================
-def analyze_option_expiry() -> Dict[str, Any]:
-    now = datetime.utcnow()
-    today = now.strftime("%Y-%m-%d")
-    hour = now.hour
-    days_until_expiry = None
-    nearest_expiry = None
-
-    for expiry in OPTION_EXPIRY_DATES:
-        expiry_date = datetime.strptime(expiry, "%Y-%m-%d")
-        diff = (expiry_date - now).days
-
-        if diff >= 0 and (days_until_expiry is None or diff < days_until_expiry):
-            days_until_expiry = diff
-            nearest_expiry = expiry
-
-    if days_until_expiry is not None:
-        if days_until_expiry == 0:
-            expiry_signal = "EXPIRY_TODAY"
-            note = "Максимальная волатильность, притяжение к Max Pain"
-            bias = 0.0
-        elif days_until_expiry <= 2:
-            expiry_signal = "EXPIRY_SOON"
-            note = f"Экспирация через {days_until_expiry} дн. — притяжение к страйкам"
-            bias = -0.05
-        elif days_until_expiry <= 5:
-            expiry_signal = "EXPIRY_WEEK"
-            note = f"Неделя экспирации — повышенная волатильность"
-            bias = 0.0
-        else:
-            expiry_signal = "NORMAL"
-            note = None
-            bias = 0.0
+    if daily_volume > 0:
+        nvt = market_cap / daily_volume
     else:
-        expiry_signal = "NORMAL"
-        note = None
-        bias = 0.0
-
-    return {
-        "nearest_expiry": nearest_expiry,
-        "days_until_expiry": days_until_expiry,
-        "expiry_signal": expiry_signal,
-        "note": note,
-        "bias": bias
-    }
-
-# ================= ПРАЗДНИКИ / ОСОБЫЕ ДНИ =================
-def analyze_special_days() -> Dict[str, Any]:
-    now = datetime.utcnow()
-    month = now.month
-    day = now.day
-
-    specials = []
-
-    # Налоговый сезон США (апрель)
-    if month == 4 and day <= 15:
-        specials.append({"event": "TAX_SEASON_US", "impact": "BEARISH", "note": "Продажи для уплаты налогов"})
-
-    # Рождественское ралли (декабрь)
-    if month == 12 and day >= 20:
-        specials.append({"event": "SANTA_CLAUS_RALLY", "impact": "BULLISH", "note": "Исторически позитивный период"})
-
-    # Сезон свадеб в Индии (октябрь-декабрь) — спрос на золото
-    if month in [10, 11, 12]:
-        specials.append({"event": "INDIAN_WEDDING_SEASON", "impact": "BULLISH", "note": "Повышенный спрос на золото"})
-
-    # Китайский Новый год (конец января — февраль)
-    if (month == 1 and day >= 20) or (month == 2 and day <= 10):
-        specials.append({"event": "CHINESE_NEW_YEAR", "impact": "BULLISH", "note": "Праздничный спрос на золото"})
-
-    # Летнее затишье (июль-август)
-    if month in [7, 8]:
-        specials.append({"event": "SUMMER_LULL", "impact": "NEUTRAL", "note": "Снижение объёмов"})
-
-    if specials:
-        total_bias = sum(0.05 if s['impact'] == 'BULLISH' else -0.05 if s['impact'] == 'BEARISH' else 0 for s in specials)
+        nvt = 50
+
+    # Нормализация (для ETH норма NVT ~ 30-80)
+    if nvt > 150:
+        nvt_signal = "EXTREME_OVERBOUGHT"
+        nvt_score = 30
+    elif nvt > 100:
+        nvt_signal = "OVERBOUGHT"
+        nvt_score = 20
+    elif nvt < 30:
+        nvt_signal = "OVERSOLD"
+        nvt_score = -15
     else:
-        total_bias = 0.0
+        nvt_signal = "NORMAL"
+        nvt_score = 0
+
+    return float(nvt_score)
+
+# ================= РЕЖИМ РЫНКА =================
+def detect_market_regime(df: pd.DataFrame, symbol: str) -> Dict[str, Any]:
+    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))
+    volatility = float(np.std(returns[-24:])) if len(returns) >= 24 else 0.01
+
+    # ADX (упрощённо через размах)
+    recent_high = np.max(high[-20:])
+    recent_low = np.min(low[-20:])
+    range_pct = (recent_high - recent_low) / recent_low * 100
+
+    # Euphoria Index
+    euphoria = calculate_euphoria_index(df)
+
+    # NVT (только для крипты)
+    nvt_score = 0.0
+    if "XAU" not in symbol:
+        nvt_score = calculate_nvt_ratio(df)
+
+    # RSI
+    rsi = safe_rsi(pd.Series(close), 14)
+
+    # Опред��ление режима
+    if euphoria > 70:
+        regime = "BUBBLE"
+        veto = True
+        signal = "FORCE_WAIT"
+    elif euphoria > 55:
+        regime = "EUPHORIA"
+        veto = False
+        signal = "CAUTION"
+    elif volatility > 0.03:
+        regime = "VOLATILE"
+        veto = False
+        signal = "NEUTRAL"
+    elif range_pct < 3:
+        regime = "RANGE"
+        veto = False
+        signal = "NEUTRAL"
+    else:
+        regime = "TREND"
+        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
 
     return {
-        "specials": specials,
-        "has_specials": len(specials) > 0,
-        "bias": total_bias
+        "regime": regime,
+        "regime_score": regime_score,
+        "euphoria_index": round(euphoria, 1),
+        "nvt_score": round(nvt_score, 1),
+        "rsi_14": round(rsi, 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: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     try:
-        now = datetime.utcnow()
-        hour = now.hour
-        weekday = now.weekday()
-
         score = 50.0
-
-        if 13 <= hour < 22:
-            score += 5
-        elif hour < 8:
-            score -= 5
-        if weekday == 4:
-            score -= 5
-        if weekday >= 5:
-            score -= 10
-
-        score = max(0, min(100, score))
-
-        if score > 55:
-            direction, confidence = "LONG", score / 100
-        elif score < 45:
-            direction, confidence = "SHORT", (100 - score) / 100
-        else:
-            direction, confidence = "WAIT", 0.0
+        veto = False
+
+        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
+            else:
+                regime = "NORMAL"
+
+        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 {
-            "direction": direction,
-            "confidence": round(confidence, 4),
-            "calendar_score": score,
+            "regime": regime,
+            "regime_score": score,
+            "veto": veto,
+            "euphoria_index": score,
             "source": "MT5"
         }
     except:
         return None
 
-# ================= ГЛАВНЫЙ АНАЛИЗ =================
-def analyze_seasonality(symbol: str) -> Dict[str, Any]:
-    monthly = analyze_monthly_seasonality(symbol)
-    daily = analyze_daily_seasonality(symbol)
-    expiry = analyze_option_expiry()
-    specials = analyze_special_days()
-
-    # Суммируем bias'ы
-    total_bias = monthly['bias'] + daily['bias'] + expiry['bias'] + specials['bias']
-
-    # Базовый скор
-    score = 50.0 + total_bias * 100
-    score = max(0, min(100, score))
-
-    if score > 55:
-        direction = "LONG"
-        confidence = score / 100
-    elif score < 45:
-        direction = "SHORT"
-        confidence = (100 - score) / 100
-    else:
-        direction = "WAIT"
-        confidence = 0.0
-
-    signals = []
-    if monthly['seasonal_signal'] != 'NEUTRAL':
-        signals.append({"factor": "MONTHLY", "signal": monthly['seasonal_signal'], "reason": f"{monthly['month_name']}: {monthly['expected_return_pct']:+.1f}%"})
-    if daily['daily_signal'] != 'NEUTRAL':
-        signals.append({"factor": "DAILY", "signal": daily['daily_signal'], "reason": f"{daily['day_name']}: {daily['expected_return_pct']:+.2f}%"})
-    if expiry['expiry_signal'] != 'NORMAL':
-        signals.append({"factor": "EXPIRY", "signal": expiry['expiry_signal'], "reason": expiry.get('note', '')})
-    for s in specials.get('specials', []):
-        signals.append({"factor": s['event'], "signal": s['impact'], "reason": s['note']})
-
-    return {
-        "seasonality_score": round(score, 2),
-        "direction": direction,
-        "confidence": round(confidence, 4),
-        "total_bias": round(total_bias, 4),
-        "signals": signals,
-        "components": {
-            "monthly": monthly,
-            "daily": daily,
-            "expiry": expiry,
-            "specials": specials
-        }
-    }
-
 # ================= ГЛАВНЫЙ СИГНАЛ =================
-def get_seasonality_signal(symbol: str = "XAU/USD") -> Dict[str, Any]:
+def get_regime_signal(symbol: str = "XAU/USD") -> Dict[str, Any]:
     start = time.time()
 
+    # Проверка MT5
     if symbol in FEATURES_STORE:
         fs = FEATURES_STORE[symbol]
         age = time.time() - fs.get("timestamp", 0)
@@ -343,48 +360,55 @@ def get_seasonality_signal(symbol: str = "XAU/USD") -> Dict[str, Any]:
             if mt5_features:
                 mt5_result = analyze_from_mt5(mt5_features)
                 if mt5_result:
+                    direction = "WAIT" if mt5_result["veto"] else "NEUTRAL"
                     result = {
-                        "space": "space_27_seasonality",
+                        "space": "space_28_regime",
                         "timestamp": int(time.time()),
                         "symbol": symbol,
                         "signal": {
-                            "direction": mt5_result["direction"],
-                            "confidence": mt5_result["confidence"]
+                            "direction": direction,
+                            "confidence": mt5_result["regime_score"] / 100,
+                            "veto": mt5_result["veto"]
                         },
-                        "seasonality_analysis": {
-                            "score": mt5_result["calendar_score"],
-                            "signals": [{"factor": "MT5", "signal": mt5_result["direction"], "reason": "Технический"}]
+                        "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"📅 SEASON {symbol}: {mt5_result['direction']} | Score={mt5_result['calendar_score']} (MT5)")
+                    print(f"🫧 REGIME {symbol}: {mt5_result['regime']} | Veto={mt5_result['veto']} (MT5)")
                     return result
 
-    analysis = analyze_seasonality(symbol)
+    # Fallback
+    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
+
     latency = int((time.time() - start) * 1000)
 
     result = {
-        "space": "space_27_seasonality",
+        "space": "space_28_regime",
         "timestamp": int(time.time()),
         "symbol": symbol,
         "signal": {
-            "direction": analysis['direction'],
-            "confidence": analysis['confidence']
-        },
-        "seasonality_analysis": {
-            "score": analysis['seasonality_score'],
-            "total_bias": analysis['total_bias'],
-            "signals": analysis['signals'],
-            "components": analysis['components']
+            "direction": direction,
+            "confidence": round(confidence, 4),
+            "veto": regime_data["veto"],
+            "veto_reason": "BUBBLE_DETECTED" if regime_data["veto"] else None
         },
-        "data_source": "CALENDAR",
+        "regime_analysis": regime_data,
+        "data_source": "API",
         "meta": {"latency_ms": latency}
     }
 
     send_to_arbiter(result)
-    print(f"📅 SEASON v1 {symbol}: {analysis['direction']} | Bias={analysis['total_bias']:.3f}")
+    print(f"🫧 REGIME v1 {symbol}: {regime_data['regime']} | Euphoria={regime_data['euphoria_index']:.0f} | Veto={regime_data['veto']}")
     return result
 
 # ================= KEEP-ALIVE =================
@@ -399,49 +423,57 @@ def keep_alive():
 threading.Thread(target=keep_alive, daemon=True).start()
 
 # ================= FASTAPI =================
-app = FastAPI(title="TOMIRIS SPACE 27 v1.0 — SEASONALITY & CALENDAR EFFECTS")
+app = FastAPI(title="TOMIRIS SPACE 28 v1.0 — MARKET REGIME & BUBBLE DETECTOR")
 
 @app.get("/health")
 @app.head("/health")
 async def health():
     return {
-        "space": "Space 27 - Seasonality & Calendar Effects v1.0",
+        "space": "Space 28 - Market Regime & Bubble Detector v1.0",
         "status": "operational",
         "symbols": SYMBOLS,
-        "features": ["Monthly Seasonality", "Daily Patterns", "Option Expiry", "Special Days"]
+        "features": ["Euphoria Index", "NVT Ratio", "RSI Extremes", "Bubble VETO"],
+        "bubble_history": len(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_seasonality_signal(symbol)
+    return get_regime_signal(symbol)
 
-@app.get("/monthly/{symbol}")
-async def monthly(symbol: str):
+@app.get("/regime/{symbol}")
+async def regime(symbol: str):
     if symbol not in SYMBOLS:
         return {"error": f"Unsupported: {symbol}"}
-    return analyze_monthly_seasonality(symbol)
+    df = fetch_historical(symbol)
+    if df is None:
+        return {"error": "no_data"}
+    return detect_market_regime(df, symbol)
 
-@app.get("/daily/{symbol}")
-async def daily(symbol: str):
+@app.get("/euphoria/{symbol}")
+async def euphoria(symbol: str):
     if symbol not in SYMBOLS:
         return {"error": f"Unsupported: {symbol}"}
-    return analyze_daily_seasonality(symbol)
-
-@app.get("/expiry")
-async def expiry():
-    return analyze_option_expiry()
-
-@app.get("/specials")
-async def specials():
-    return analyze_special_days()
+    df = fetch_historical(symbol)
+    if df is None:
+        return {"error": "no_data"}
+    return {
+        "symbol": symbol,
+        "euphoria_index": calculate_euphoria_index(df)
+    }
 
-@app.get("/full/{symbol}")
-async def full(symbol: str):
-    if symbol not in SYMBOLS:
-        return {"error": f"Unsupported: {symbol}"}
-    return analyze_seasonality(symbol)
+@app.get("/nvt/{symbol}")
+async def nvt(symbol: str):
+    if symbol not in ["ETH/USD", "SOL/USD"]:
+        return {"error": "NVT доступен только для крипты"}
+    df = fetch_historical(symbol)
+    if df is None:
+        return {"error": "no_data"}
+    return {
+        "symbol": symbol,
+        "nvt_score": calculate_nvt_ratio(df)
+    }
 
 @app.post("/features")
 async def receive_features(data: Dict[str, Any]):
@@ -454,6 +486,6 @@ async def receive_features(data: Dict[str, Any]):
     print(f"📥 MT5 {symbol}: {len(data.get('features', {}))} признаков")
     return {"status": "ok"}
 
-print(f"🚀 SPACE 27 v1.0 — SEASONALITY & CALENDAR EFFECTS ЗАПУЩЕН!")
-print(f"📅 Анализ: Месяцы | Дни недели | Экспирации | Праздники | Налоговый сезон")
+print(f"🚀 SPACE 28 v1.0 — MARKET REGIME & BUBBLE DETECTOR ЗАПУЩЕН!")
+print(f"🫧 Детектор: Euphoria Index | NVT Ratio | RSI | Режим рынка | ВЕТО при пузыре")
 print(f"✅ Готов к бою!")