Update app.py

app.py

@@ -1,12 +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'
 }
 
@@ -19,448 +21,286 @@ for module_name, pip_name in REQUIRED_PACKAGES.items():
         print(f"✅ {pip_name} установлен!")
 
 # ============================================
-# 👑 TOMIRIS SPACE 29 v1.0 — MACRO SURPRISE INDEX
+# 👑 TOMIRIS SPACE 29 v2.0 — MACRO SURPRISE ENGINE (Async, Real FRED, Fixed CPI)
 # ============================================
-# Оценивает, насколько макроданные отклоняются от консенсуса.
-# NFP, CPI, FOMC, PMI, GDP — сюрпризы двигают рынки.
-# Положительный сюрприз = риск-он, отрицательный = риск-офф.
-# ============================================
-
-from fastapi import FastAPI, Query
+import os, time, json, logging, asyncio
 from typing import Dict, Any, List, Optional
-import time
-import requests
-import threading
-import numpy as np
-from datetime import datetime, timedelta
+from datetime import datetime, timezone, timedelta
 from collections import deque
-import warnings
-warnings.filterwarnings('ignore')
+import numpy as np
+import pandas as pd
+import httpx
+from fastapi import FastAPI, Query
 
-# ================= КОНФИГУРАЦИЯ =================
-SYMBOLS: List[str] = ["XAU/USD", "ETH/USD", "SOL/USD"]
-
-SPACE_18_ARBITER: str = "https://tomiris-ai-name6-6.hf.space"
-
-# FRED API ключи
-FRED_KEYS: List[str] = [
-    "faa11c8e2e4beee08c5b966e8b63a513",
-    "3305a8458cb112b417183b1d6b87f2e1"
-]
-
-# NewsAPI ключи
-NEWSAPI_KEYS: List[str] = [
-    "948c7816beea47baa23b054592472d0e",
-    "96199e06c4ac45e19236e2dfd879fd37"
-]
-
-CACHE: Dict[str, Dict[str, Any]] = {}
-CACHE_TIMES: Dict[str, float] = {}
-FEATURES_STORE: Dict[str, Dict[str, Any]] = {}
-MT5_MAX_AGE_SEC: int = 300
-SURPRISE_HISTORY: deque = deque(maxlen=100)
-
-fred_counter: int = 0
-newsapi_counter: int = 0
-api_lock = threading.Lock()
-
-def get_next_fred_key() -> str:
-    global fred_counter
-    with api_lock:
-        key = FRED_KEYS[fred_counter % len(FRED_KEYS)]
-        fred_counter += 1
-        return key
-
-def get_next_newsapi_key() -> str:
-    global newsapi_counter
-    with api_lock:
-        key = NEWSAPI_KEYS[newsapi_counter % len(NEWSAPI_KEYS)]
-        newsapi_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_29_macro_surprise', 'symbol': 'ALL', 'signal': signal_data.get('signal', {})},
-            timeout=5
-        )
-    except:
-        pass
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger("Space29_MacroSurprise")
 
-# ================= КОНСЕНСУС-ПРОГНОЗЫ (ОЖИДАНИЯ) =================
-# Аппроксимация рыночного консенсуса (обновляется ежемесячно)
-CONSENSUS: Dict[str, float] = {
-    "CPI_YOY": 3.2,       # Инфляция годовая
-    "CORE_CPI_YOY": 3.5,  # Базовая инфляция
-    "UNEMPLOYMENT": 4.0,  # Безработица
-    "NFP": 180_000,       # Non-Farm Payrolls
-    "GDP_QOQ": 2.0,       # ВВП квартальный
-    "FED_RATE": 4.25,     # Ставка ФРС
-    "ISM_MANUF": 49.0,    # ISM Manufacturing
-    "ISM_SERVICES": 52.0, # ISM Services
-    "RETAIL_SALES": 0.3,  # Розничные продажи
-    "DURABLE_GOODS": 0.5, # Заказы длительного пользования
+# ================= КОНФИГУРАЦИЯ =================
+SYMBOLS = ["XAU/USD", "ETH/USD", "SOL/USD"]
+ARBITER_URL = os.getenv("SPACE18_URL", "https://tomiris-ai-name6-6.hf.space")
+FRED_KEY = os.getenv("FRED_KEY", "faa11c8e2e4beee08c5b966e8b63a513")
+NEWSAPI_KEY = os.getenv("NEWSAPI_KEY", "948c7816beea47baa23b054592472d0e")
+
+# Консенсус-прогнозы (обновлять ежемесячно)
+CONSENSUS = {
+    "CPI_YOY": 3.2, "CORE_CPI_YOY": 3.5, "UNEMPLOYMENT": 4.0, "NFP": 180000,
+    "GDP_QOQ": 2.0, "FED_RATE": 4.25, "ISM_MANUF": 49.0, "ISM_SERVICES": 52.0,
+    "RETAIL_SALES": 0.3, "DURABLE_GOODS": 0.5
 }
 
-# ================= ЗАГРУЗКА FRED =================
-def fetch_fred_series(series_id: str, days: int = 12) -> List[Dict[str, Any]]:
-    cache_key = f"fred_{series_id}_{days}"
-    if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 3600:
-        return CACHE[cache_key]
+CACHE_TTL = {"fred": 3600, "news": 1800}
+HISTORY_FILE = "surprise_history.json"
+
+# ================= HTTP КЛИЕНТ =================
+http_client = httpx.AsyncClient(timeout=20.0)
 
+# ================= ГЛОБАЛЬНЫЙ КЭШ =================
+cache_store = {}
+cache_times = {}
+
+# История сюрпризов
+if os.path.exists(HISTORY_FILE):
+    try:
+        with open(HISTORY_FILE) as f:
+            SURPRISE_HISTORY = deque(json.load(f), maxlen=200)
+    except:
+        SURPRISE_HISTORY = deque(maxlen=200)
+else:
+    SURPRISE_HISTORY = deque(maxlen=200)
+
+def save_history():
+    with open(HISTORY_FILE, 'w') as f:
+        json.dump(list(SURPRISE_HISTORY), f)
+
+# ================= ЗАГРУЗКА ДАННЫХ FRED =================
+async def fetch_fred_series(series_id: str, months: int = 13) -> List[Dict]:
+    cache_key = f"fred_{series_id}_{months}"
+    if cache_key in cache_store and time.time() - cache_times.get(cache_key, 0) < CACHE_TTL["fred"]:
+        return cache_store[cache_key]
     try:
-        key = get_next_fred_key()
-        url = f"https://api.stlouisfed.org/fred/series/observations?series_id={series_id}&api_key={key}&file_type=json&sort_order=desc&limit={days}"
-        r = requests.get(url, timeout=10)
+        r = await http_client.get(
+            f"https://api.stlouisfed.org/fred/series/observations?series_id={series_id}&api_key={FRED_KEY}&file_type=json&sort_order=desc&limit={months}")
         if r.status_code == 200:
             data = r.json()
-            values = [
-                {'date': obs['date'], 'value': float(obs['value'])}
-                for obs in data.get('observations', []) if obs['value'] != '.'
-            ]
-            CACHE[cache_key] = values
-            CACHE_TIMES[cache_key] = time.time()
+            values = [{'date': obs['date'], 'value': float(obs['value'])} for obs in data.get('observations', []) if obs['value'] != '.']
+            cache_store[cache_key] = values
+            cache_times[cache_key] = time.time()
             return values
-    except:
-        pass
+    except Exception as e:
+        logger.warning(f"FRED {series_id}: {e}")
     return []
 
-# ================= РАСЧЁТ СЮРПРИЗА =================
-def calculate_surprise(actual: float, consensus: float) -> Dict[str, Any]:
-    """Вычисляет, насколько факт отклонился от консенсуса."""
+def get_yoy_change(data: List[Dict], current_month: str) -> Optional[float]:
+    """Считает YoY изменение: текущее значение vs значение 12 месяцев назад (тот же месяц)."""
+    # Ищем записи с нужным месяцем
+    current_val = None
+    prev_val = None
+    for item in data:
+        date = item['date']
+        if date == current_month:
+            current_val = item['value']
+        # Тот же месяц, год назад (YYYY-1)
+        year_ago = str(int(date[:4]) - 1) + date[4:]
+        if date == year_ago and date[:7] == current_month[:7]:
+            prev_val = item['value']
+    if current_val and prev_val:
+        return ((current_val - prev_val) / prev_val) * 100
+    return None
+
+# ================= АНАЛИЗ СЮРПРИЗА =================
+def calc_surprise(actual: float, consensus: float) -> Dict:
     if consensus == 0:
-        return {"surprise_pct": 0, "level": "NEUTRAL", "impact": 0}
-
+        return {"surprise_pct": 0, "level": "IN_LINE", "impact": 0, "direction": "NEUTRAL"}
     surprise_pct = ((actual - consensus) / abs(consensus)) * 100
-
     if abs(surprise_pct) > 100:
-        level = "EXTREME_SURPRISE"
-        impact = 30
+        level, impact = "EXTREME_SURPRISE", 30
     elif abs(surprise_pct) > 50:
-        level = "MAJOR_SURPRISE"
-        impact = 20
+        level, impact = "MAJOR_SURPRISE", 20
     elif abs(surprise_pct) > 20:
-        level = "MODERATE_SURPRISE"
-        impact = 10
+        level, impact = "MODERATE_SURPRISE", 10
     elif abs(surprise_pct) > 5:
-        level = "MINOR_SURPRISE"
-        impact = 5
+        level, impact = "MINOR_SURPRISE", 5
     else:
-        level = "IN_LINE"
-        impact = 0
+        level, impact = "IN_LINE", 0
+    direction = "POSITIVE" if surprise_pct > 0 else "NEGATIVE" if surprise_pct < 0 else "NEUTRAL"
+    return {"surprise_pct": round(surprise_pct, 2), "level": level, "impact": impact, "direction": direction}
+
+# ================= FOMC SURPRISE (через новости) =================
+async def fetch_fomc_surprise() -> Dict:
+    if not NEWSAPI_KEY:
+        return {"indicator": "FOMC", "impact": 0, "direction": "NEUTRAL"}
+    try:
+        r = await http_client.get(
+            f"https://newsapi.org/v2/everything?q=fomc+fed+rate+decision&pageSize=10&apiKey={NEWSAPI_KEY}")
+        if r.status_code == 200:
+            articles = r.json().get('articles', [])
+            hawk = sum(1 for a in articles if any(w in (a.get('title','')+a.get('description','')).lower() for w in ['hawkish','raise','tighten','surprise hike']))
+            dove = sum(1 for a in articles if any(w in (a.get('title','')+a.get('description','')).lower() for w in ['dovish','cut','ease','surprise cut']))
+            if hawk > dove*2:
+                return {"indicator": "FOMC", "impact": -15, "direction": "HAWKISH", "hawkish": hawk, "dovish": dove}
+            elif dove > hawk*2:
+                return {"indicator": "FOMC", "impact": 15, "direction": "DOVISH", "hawkish": hawk, "dovish": dove}
+    except:
+        pass
+    return {"indicator": "FOMC", "impact": 0, "direction": "NEUTRAL"}
 
-    return {
-        "surprise_pct": round(surprise_pct, 2),
-        "level": level,
-        "impact": impact,
-        "direction": "POSITIVE" if surprise_pct > 0 else "NEGATIVE" if surprise_pct < 0 else "NEUTRAL"
-    }
+# ================= ГЛАВНЫЙ АНАЛИЗ =================
+async def analyze_macro_surprises() -> Dict:
+    today = datetime.now(timezone.utc)
+    current_month_str = today.strftime("%Y-%m")
+
+    # Загружаем FRED параллельно
+    cpi_data = await fetch_fred_series("CPIAUCSL", 13)
+    core_cpi_data = await fetch_fred_series("CPILFESL", 13)
+    unemp_data = await fetch_fred_series("UNRATE", 6)
+    nfp_data = await fetch_fred_series("PAYEMS", 3)       # Non-Farm Payrolls
+    gdp_data = await fetch_fred_series("GDP", 3)           # GDP (квартальный, но берём последний)
+    ism_data = await fetch_fred_series("NAPM", 3)          # ISM Manufacturing
+    retail_data = await fetch_fred_series("RSAFS", 3)      # Retail Sales
+    durable_data = await fetch_fred_series("DGORDER", 3)   # Durable Goods
+    fomc_surprise = await fetch_fomc_surprise()
 
-# ================= ОЦЕНКА МАКРО-СЮРПРИЗОВ =================
-def analyze_macro_surprises() -> Dict[str, Any]:
     surprises = []
-    total_surprise_score = 0.0
-    positive_impact = 0.0
-    negative_impact = 0.0
-
-    # CPI (CPIAUCSL)
-    cpi_data = fetch_fred_series("CPIAUCSL", 12)
-    if len(cpi_data) >= 2:
-        cpi_current = cpi_data[0]['value']
-        cpi_prev = cpi_data[-1]['value']
-        cpi_yoy = ((cpi_current - cpi_prev) / cpi_prev) * 100
-        surprise = calculate_surprise(cpi_yoy, CONSENSUS.get("CPI_YOY", 3.2))
-
-        if surprise['direction'] == 'POSITIVE':
-            # Инфляция выше ожиданий = негатив для риска
-            negative_impact += surprise['impact']
-            total_surprise_score -= surprise['impact']
-            signal = "BEARISH"
-        else:
-            positive_impact += surprise['impact']
-            total_surprise_score += surprise['impact']
-            signal = "BULLISH"
-
-        surprises.append({
-            "indicator": "CPI_YOY",
-            "actual": round(cpi_yoy, 2),
-            "consensus": CONSENSUS.get("CPI_YOY", 3.2),
-            "surprise": surprise,
-            "market_signal": signal
-        })
-
-    # Unemployment (UNRATE)
-    unemp_data = fetch_fred_series("UNRATE", 6)
-    if unemp_data:
-        unemp_current = unemp_data[0]['value']
-        surprise = calculate_surprise(unemp_current, CONSENSUS.get("UNEMPLOYMENT", 4.0))
-
-        if surprise['direction'] == 'POSITIVE':
-            # Безработица выше ожиданий = негатив
-            negative_impact += surprise['impact']
-            total_surprise_score -= surprise['impact']
-            signal = "BEARISH"
-        else:
-            # Безработица ниже = позитив
-            positive_impact += surprise['impact']
-            total_surprise_score += surprise['impact']
-            signal = "BULLISH"
-
-        surprises.append({
-            "indicator": "UNEMPLOYMENT",
-            "actual": round(unemp_current, 2),
-            "consensus": CONSENSUS.get("UNEMPLOYMENT", 4.0),
-            "surprise": surprise,
-            "market_signal": signal
-        })
-
-    # FOMC — через новости
-    fomc_surprise = fetch_fomc_surprise()
-    if fomc_surprise.get('impact', 0) != 0:
-        surprises.append(fomc_surprise)
-        total_surprise_score += fomc_surprise.get('impact', 0)
-        if fomc_surprise.get('direction') == 'HAWKISH':
-            negative_impact += abs(fomc_surprise.get('impact', 0))
-        else:
-            positive_impact += abs(fomc_surprise.get('impact', 0))
-
-    # Нормализация
-    total_surprise_score = max(-50, min(50, total_surprise_score))
-    surprise_index = 50 + total_surprise_score
+    total_score = 0.0
+    weights = {"CPI_YOY": 0.30, "NFP": 0.25, "FOMC": 0.20, "ISM_MANUF": 0.10, "GDP_QOQ": 0.10, "RETAIL_SALES": 0.05}
+
+    # CPI YoY (корректный)
+    cpi_yoy = get_yoy_change(cpi_data, current_month_str)
+    if cpi_yoy is not None:
+        s = calc_surprise(cpi_yoy, CONSENSUS["CPI_YOY"])
+        impact = s['impact'] * (1 if s['direction'] == 'NEGATIVE' else -0.5)  # высокая инфляция = риск-офф
+        total_score += impact * weights["CPI_YOY"]
+        surprises.append({"indicator": "CPI_YOY", "actual": round(cpi_yoy, 2), "consensus": CONSENSUS["CPI_YOY"], "surprise": s})
+
+    # NFP (последний месяц)
+    if nfp_data:
+        nfp_actual = nfp_data[0]['value']  # абсолютное значение в тысячах
+        s = calc_surprise(nfp_actual, CONSENSUS["NFP"])
+        impact = s['impact'] * (1 if s['direction'] == 'POSITIVE' else -1)  # высокий NFP = риск-он
+        total_score += impact * weights["NFP"]
+        surprises.append({"indicator": "NFP", "actual": int(nfp_actual), "consensus": CONSENSUS["NFP"], "surprise": s})
+
+    # GDP (квартальный, берём последний)
+    if gdp_data:
+        gdp_actual = gdp_data[0]['value']  # квартальное изменение в %
+        s = calc_surprise(gdp_actual, CONSENSUS["GDP_QOQ"])
+        impact = s['impact'] * (1 if s['direction'] == 'POSITIVE' else -1)
+        total_score += impact * weights["GDP_QOQ"]
+        surprises.append({"indicator": "GDP_QOQ", "actual": round(gdp_actual, 2), "consensus": CONSENSUS["GDP_QOQ"], "surprise": s})
+
+    # ISM Manufacturing
+    if ism_data:
+        ism_actual = ism_data[0]['value']
+        s = calc_surprise(ism_actual, CONSENSUS["ISM_MANUF"])
+        impact = s['impact'] * (1 if s['direction'] == 'POSITIVE' else -1)
+        total_score += impact * weights["ISM_MANUF"]
+        surprises.append({"indicator": "ISM_MANUF", "actual": round(ism_actual, 2), "consensus": CONSENSUS["ISM_MANUF"], "surprise": s})
+
+    # Retail Sales
+    if retail_data:
+        retail_actual = retail_data[0]['value']
+        s = calc_surprise(retail_actual, CONSENSUS["RETAIL_SALES"])
+        impact = s['impact'] * (1 if s['direction'] == 'POSITIVE' else -1)
+        total_score += impact * weights["RETAIL_SALES"]
+        surprises.append({"indicator": "RETAIL_SALES", "actual": round(retail_actual, 2), "consensus": CONSENSUS["RETAIL_SALES"], "surprise": s})
+
+    # FOMC
+    if fomc_surprise['impact'] != 0:
+        total_score += fomc_surprise['impact'] * weights["FOMC"]
+        surprises.append({"indicator": "FOMC", "signal": fomc_surprise['direction'], "impact": fomc_surprise['impact']})
+
+    total_score = max(-50, min(50, total_score))
+    surprise_index = 50 + total_score
     surprise_index = max(0, min(100, surprise_index))
 
     if surprise_index > 65:
-        market_regime = "RISK_ON"
-        direction = "LONG"
+        regime, direction = "RISK_ON", "LONG"
         confidence = surprise_index / 100
     elif surprise_index < 35:
-        market_regime = "RISK_OFF"
-        direction = "SHORT"
+        regime, direction = "RISK_OFF", "SHORT"
         confidence = (100 - surprise_index) / 100
     else:
-        market_regime = "NEUTRAL"
-        direction = "WAIT"
+        regime, direction = "NEUTRAL", "WAIT"
         confidence = 0.0
 
+    # Сохраняем историю
+    SURPRISE_HISTORY.append({
+        "timestamp": today.isoformat(),
+        "surprise_index": round(surprise_index, 2),
+        "regime": regime,
+        "surprises": surprises
+    })
+    save_history()
+
     return {
         "surprise_index": round(surprise_index, 2),
-        "market_regime": market_regime,
+        "market_regime": regime,
         "direction": direction,
         "confidence": round(confidence, 4),
-        "total_surprise_score": round(total_surprise_score, 2),
-        "positive_impact": round(positive_impact, 2),
-        "negative_impact": round(negative_impact, 2),
-        "surprises": surprises
+        "surprises": surprises,
+        "total_score": round(total_score, 2)
     }
 
-# ================= FOMC СЮРПРИЗ =================
-def fetch_fomc_surprise() -> Dict[str, Any]:
-    """Оценивает сюрприз от решений ФРС через новости."""
-    cache_key = "fomc_surprise"
-    if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 3600:
-        return CACHE[cache_key]
-
-    try:
-        key = get_next_newsapi_key()
-        url = f"https://newsapi.org/v2/everything?q=fomc+federal+reserve+surprise+rate&pageSize=10&apiKey={key}"
-        r = requests.get(url, timeout=10)
-        if r.status_code == 200:
-            articles = r.json().get('articles', [])
-
-            hawkish_count = 0
-            dovish_count = 0
-
-            for a in articles:
-                title = a.get('title', '').lower()
-                desc = a.get('description', '').lower()
-                text = title + ' ' + desc
-
-                if any(kw in text for kw in ['hawkish', 'raise', 'tighten', 'surprise hike']):
-                    hawkish_count += 1
-                if any(kw in text for kw in ['dovish', 'cut', 'ease', 'surprise cut']):
-                    dovish_count += 1
-
-            if hawkish_count > dovish_count * 2:
-                signal = "HAWKISH_SURPRISE"
-                impact = -15
-            elif dovish_count > hawkish_count * 2:
-                signal = "DOVISH_SURPRISE"
-                impact = 15
-            else:
-                signal = "NO_SURPRISE"
-                impact = 0
-
-            result = {
-                "indicator": "FOMC",
-                "signal": signal,
-                "impact": impact,
-                "hawkish_articles": hawkish_count,
-                "dovish_articles": dovish_count,
-                "direction": "HAWKISH" if impact < 0 else "DOVISH" if impact > 0 else "NEUTRAL"
-            }
-
-            CACHE[cache_key] = result
-            CACHE_TIMES[cache_key] = time.time()
-            return result
-    except:
-        pass
-
-    return {"indicator": "FOMC", "impact": 0, "direction": "NEUTRAL"}
-
-# ================= АНАЛИЗ ИЗ MT5 =================
-def analyze_from_mt5(mt5_features: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-    try:
-        score = 50.0
-        now = datetime.utcnow()
-        hour = now.hour
-        weekday = now.weekday()
-
-        # В часы выхода важных данных (12-14 UTC) — ожидаем сюрпризов
-        if hour in [12, 13, 14]:
-            if weekday in [2, 3, 4]:  # Ср-Пт — дни NFP/CPI
-                score -= 10
-
-        rsi = mt5_features.get('H1_rsi', 50)
-        atr = mt5_features.get('H1_atr_pct', 1)
-
-        if isinstance(rsi, (int, float)) and isinstance(atr, (int, float)):
-            if atr > 2 and rsi > 70:
-                score += 15
-            elif atr > 2 and rsi < 30:
-                score -= 15
-
-        score = max(0, min(100, score))
-
-        if score > 60:
-            direction, confidence = "LONG", score / 100
-        elif score < 40:
-            direction, confidence = "SHORT", (100 - score) / 100
-        else:
-            direction, confidence = "WAIT", 0.0
-
-        return {
-            "direction": direction,
-            "confidence": round(confidence, 4),
-            "surprise_index": score,
-            "source": "MT5"
-        }
-    except:
-        return None
-
 # ================= ГЛАВНЫЙ СИГНАЛ =================
-def get_macro_surprise_signal() -> Dict[str, Any]:
+async def get_macro_surprise_signal() -> Dict[str, Any]:
     start = time.time()
-
-    # Проверка MT5
-    for symbol in SYMBOLS:
-        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 and mt5_result["confidence"] > 0.3:
-                        result = {
-                            "space": "space_29_macro_surprise",
-                            "timestamp": int(time.time()),
-                            "signals": {
-                                s: {"direction": mt5_result["direction"], "confidence": mt5_result["confidence"]}
-                                for s in SYMBOLS
-                            },
-                            "surprise_index": mt5_result["surprise_index"],
-                            "data_source": "MT5",
-                            "meta": {"latency_ms": int((time.time() - start) * 1000)}
-                        }
-                        send_to_arbiter(result)
-                        print(f"📈 MACRO SURPRISE: {mt5_result['direction']} | Index={mt5_result['surprise_index']} (MT5)")
-                        return result
-
-    # Fallback
-    analysis = analyze_macro_surprises()
+    analysis = await analyze_macro_surprises()
     latency = int((time.time() - start) * 1000)
 
     result = {
         "space": "space_29_macro_surprise",
         "timestamp": int(time.time()),
-        "signals": {
-            s: {
-                "direction": analysis['direction'],
-                "confidence": analysis['confidence']
-            }
-            for s in SYMBOLS
-        },
-        "surprise_analysis": {
-            "surprise_index": analysis['surprise_index'],
-            "market_regime": analysis['market_regime'],
-            "surprises": analysis['surprises'],
-            "positive_impact": analysis['positive_impact'],
-            "negative_impact": analysis['negative_impact']
-        },
-        "data_source": "FRED+NEWS",
-        "meta": {"latency_ms": latency}
+        "signals": {sym: {"direction": analysis['direction'], "confidence": analysis['confidence']} for sym in SYMBOLS},
+        "surprise_analysis": analysis,
+        "latency_ms": latency
     }
 
-    send_to_arbiter(result)
-    print(f"📈 MACRO SURPRISE v1: Index={analysis['surprise_index']:.0f} | Regime={analysis['market_regime']} | Surprises={len(analysis['surprises'])}")
+    # Отправка в Arbiter
+    try:
+        await http_client.post(f"{ARBITER_URL}/log_signal", json={
+            "space": "space_29_macro_surprise",
+            "symbol": "XAU/USD",
+            "signal": result["signals"]["XAU/USD"],
+            "surprise_details": analysis
+        })
+    except:
+        pass
+
+    logger.info(f"📈 Macro Surprise: Index={analysis['surprise_index']:.1f} Regime={analysis['market_regime']}")
     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 29 v2.0 — Macro Surprise Engine")
 
-threading.Thread(target=keep_alive, daemon=True).start()
+@app.on_event("startup")
+async def startup(): pass
 
-# ================= FASTAPI =================
-app = FastAPI(title="TOMIRIS SPACE 29 v1.0 — MACRO SURPRISE INDEX")
+@app.on_event("shutdown")
+async def shutdown(): await http_client.aclose()
 
 @app.get("/health")
-@app.head("/health")
 async def health():
-    return {
-        "space": "Space 29 - Macro Surprise Index v1.0",
-        "status": "operational",
-        "symbols": SYMBOLS,
-        "indicators": list(CONSENSUS.keys()),
-        "features": ["CPI Surprise", "NFP Surprise", "FOMC Surprise", "Citigroup Surprise Index"]
-    }
+    return {"status": "operational", "version": "2.0", "async": True, "no_mt5": True,
+            "indicators": list(CONSENSUS.keys()), "history_length": len(SURPRISE_HISTORY)}
 
 @app.get("/consilium")
 async def consilium():
-    return get_macro_surprise_signal()
+    return await get_macro_surprise_signal()
 
 @app.get("/surprise_index")
 async def surprise_index():
-    return analyze_macro_surprises()
+    return await analyze_macro_surprises()
 
 @app.get("/fomc")
 async def fomc():
-    return fetch_fomc_surprise()
-
-@app.get("/indicator/{name}")
-async def indicator(name: str):
-    consensus = CONSENSUS.get(name.upper())
-    if consensus is None:
-        return {"error": f"Unknown: {name}", "available": list(CONSENSUS.keys())}
-    return {"indicator": name, "consensus": consensus}
-
-@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"}
+    return await fetch_fomc_surprise()
+
+@app.get("/history")
+async def history(limit: int = 50):
+    return list(SURPRISE_HISTORY)[-limit:]
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)
 
-print(f"🚀 SPACE 29 v1.0 — MACRO SURPRISE INDEX ЗАПУЩЕН!")
-print(f"📈 Анализ: CPI | NFP | FOMC | GDP | ISM | Сравнение с консенсусом")
-print(f"✅ Готов к бою!")
+print("🚀 SPACE 29 v2.0 — MACRO SURPRISE ENGINE (REAL FRED, ASYNC) ЗАПУЩЕН!")