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,104 +21,48 @@ for module_name, pip_name in REQUIRED_PACKAGES.items():
         print(f"✅ {pip_name} установлен!")
 
 # ============================================
-# 👑 TOMIRIS SPACE 21 v1.0 — GOLD MACRO & FLOW ANALYZER
+# 👑 TOMIRIS SPACE 21 v3.0 — GOLD MACRO & FLOW ENGINE (No MT5, Real AUM, COT Index)
 # ============================================
-# Специализируется на золоте: ETF-потоки (GLD/IAU/GDX),
-# COT-отчёты (Commitment of Traders), DXY, TIPS, GPR, потоки капитала.
-# Сигнализирует о притоке/оттоке "умных денег" в золото.
-# ============================================
-
-from fastapi import FastAPI, Query
-from typing import Optional, Dict, Any, List, Tuple
-import time
-import requests
-import threading
+import os, time, json, logging, asyncio
+from typing import Dict, Any, List, Optional
+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("Space21_GoldMacro")
 
 # ================= КОНФИГУРАЦИЯ =================
-SYMBOL: str = "XAU/USD"
-
-# ETF тикеры для отслеживания
-GOLD_ETFS: Dict[str, str] = {
-    "GLD": "GLD",      # SPDR Gold Trust (крупнейший)
-    "IAU": "IAU",      # iShares Gold Trust
-    "GDX": "GDX",      # Gold Miners ETF
-    "GDXJ": "GDXJ"     # Junior Gold Miners
-}
+SYMBOL = "XAU/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")
+TWELVE_DATA_KEY = os.getenv("TWELVE_DATA_KEY", "f33e660d8c1945d19e3c4ded72a2875e")
+FRED_KEY = os.getenv("FRED_KEY", "faa11c8e2e4beee08c5b966e8b63a513")
+NEWSAPI_KEY = os.getenv("NEWSAPI_KEY", "948c7816beea47baa23b054592472d0e")
 
-SPACE_18_ARBITER: str = "https://tomiris-ai-name6-6.hf.space"
-
-# API ключи
-TWELVE_KEYS: List[str] = [
-    "f33e660d8c1945d19e3c4ded72a2875e",
-    "03737d2862224ac6a10ed601d053cce5"
-]
-FRED_KEYS: List[str] = ["faa11c8e2e4beee08c5b966e8b63a513"]
-
-CACHE: Dict[str, Dict[str, Any]] = {}
-CACHE_TIMES: Dict[str, float] = {}
-FEATURES_STORE: Dict[str, Dict[str, Any]] = {}
-MT5_MAX_AGE_SEC: int = 300
-
-twelve_counter: int = 0
-fred_counter: int = 0
-api_lock = threading.Lock()
-
-def get_next_twelve_key() -> str:
-    global twelve_counter
-    with api_lock:
-        key = TWELVE_KEYS[twelve_counter % len(TWELVE_KEYS)]
-        twelve_counter += 1
-        return key
-
-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 send_to_arbiter(signal_data: Dict[str, Any]) -> None:
-    try:
-        requests.post(
-            f"{SPACE_18_ARBITER}/log_signal",
-            json={'space': 'space_21_gold_macro', 'symbol': SYMBOL, 'signal': signal_data.get('signal', {})},
-            timeout=5
-        )
-    except:
-        pass
+GOLD_ETFS = ["GLD", "IAU", "GDX"]  # только крупнейшие
+CACHE_TTL = {"fred": 3600, "etf_aum": 600, "cot": 86400, "gpr": 900}
 
-# ================= FRED ДАННЫЕ =================
-def fetch_fred_series(series_id: str, days: int = 30) -> 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]
+# ================= HTTP КЛИЕНТ =================
+http_client = httpx.AsyncClient(timeout=15.0)
 
+# ================= ЗАГРУЗКА ДАННЫХ =================
+async def fetch_fred_series(series_id: str, days: int = 30) -> List[Dict]:
     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={days}")
         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()
-            return values
-    except:
-        pass
+            return [{'date': obs['date'], 'value': float(obs['value'])} for obs in data.get('observations', []) if obs['value'] != '.']
+    except Exception as e:
+        logger.warning(f"FRED {series_id}: {e}")
     return []
 
-def fetch_dxy() -> Dict[str, Any]:
-    """Индекс доллара DXY."""
-    values = fetch_fred_series("DTWEXBGS", 30)
+async def fetch_dxy() -> Dict[str, Any]:
+    values = await fetch_fred_series("DTWEXBGS", 30)
     if len(values) >= 2:
         current = values[0]['value']
         month_ago = values[-1]['value']
@@ -126,225 +71,138 @@ def fetch_dxy() -> Dict[str, Any]:
             'dxy': round(current, 2),
             'change_1m': round(change, 2),
             'trend': 'STRENGTHENING' if change > 2 else 'WEAKENING' if change < -2 else 'STABLE',
-            'gold_signal': 'BEARISH' if change > 2 else 'BULLISH' if change < -2 else 'NEUTRAL'
+            'gold_signal': 'BULLISH' if change < -2 else 'BEARISH' if change > 2 else 'NEUTRAL'
         }
-    return {'dxy': 104.5, 'trend': 'STABLE', 'gold_signal': 'NEUTRAL'}
+    return {'dxy': 104.5, 'gold_signal': 'NEUTRAL'}
 
-def fetch_tips_yield() -> Dict[str, Any]:
-    """Реальная доходность TIPS (Treasury Inflation-Protected Securities)."""
-    values = fetch_fred_series("DFII10", 30)
+async def fetch_tips_yield() -> Dict[str, Any]:
+    values = await fetch_fred_series("DFII10", 30)
     if values:
         current = values[0]['value']
         return {
             'tips_yield': round(current, 4),
             'gold_signal': 'BULLISH' if current < 0 else 'BEARISH',
-            'analysis': 'Отрицательная реальная доходность = золото растёт' if current < 0 else 'Положительная доходность = давление на золото'
+            'analysis': 'Отрицательная реальная доходность — золото растёт' if current < 0 else 'Положительная доходность — давление на золото'
         }
     return {'tips_yield': 0.5, 'gold_signal': 'NEUTRAL'}
 
-# ================= ETF ПОТОКИ =================
-def fetch_etf_data(ticker: str) -> Optional[Dict[str, Any]]:
-    cache_key = f"etf_{ticker}"
-    if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 900:
-        return CACHE[cache_key]
-
+# ================= ETF ПОТОКИ (ЧЕРЕЗ AUM) =================
+async def fetch_etf_aum(ticker: str) -> Optional[float]:
+    """Получает Total Assets Under Management через TwelveData statistics."""
     try:
-        key = get_next_twelve_key()
-        url = f"https://api.twelvedata.com/quote?symbol={ticker}&apikey={key}"
-        r = requests.get(url, timeout=10)
+        r = await http_client.get(f"https://api.twelvedata.com/statistics?symbol={ticker}&apikey={TWELVE_DATA_KEY}")
         if r.status_code == 200:
             data = r.json()
-            result = {
-                'ticker': ticker,
-                'price': float(data.get('close', 0)),
-                'change_pct': float(data.get('change_percent', 0)),
-                'volume': int(data.get('volume', 0)),
-                'signal': 'INFLOW' if float(data.get('change_percent', 0)) > 0 else 'OUTFLOW'
-            }
-            CACHE[cache_key] = result
-            CACHE_TIMES[cache_key] = time.time()
-            return result
+            # total_assets в поле statistics -> fundamental
+            aum = data.get("statistics", {}).get("fundamental", {}).get("total_assets", 0)
+            return float(aum)
     except:
         pass
     return None
 
-def analyze_etf_flows() -> Dict[str, Any]:
-    etf_data: Dict[str, Any] = {}
-    inflow_count = 0
-    outflow_count = 0
-
-    for name, ticker in GOLD_ETFS.items():
-        data = fetch_etf_data(ticker)
-        if data:
-            etf_data[name] = data
-            if data['signal'] == 'INFLOW':
-                inflow_count += 1
-            else:
-                outflow_count += 1
-        else:
-            etf_data[name] = {"error": "no_data"}
-
-    total = inflow_count + outflow_count
-    inflow_pct = (inflow_count / total * 100) if total > 0 else 50
-
-    if inflow_pct >= 75:
-        signal = "STRONG_INFLOW"
-        gold_signal = "BULLISH"
-    elif inflow_pct >= 50:
-        signal = "MODERATE_INFLOW"
-        gold_signal = "SLIGHTLY_BULLISH"
-    elif inflow_pct >= 25:
-        signal = "MODERATE_OUTFLOW"
-        gold_signal = "SLIGHTLY_BEARISH"
+async def analyze_etf_flows() -> Dict[str, Any]:
+    """Рассчитывает притоки/оттоки по изменению AUM за последние 24 часа (если данные есть)."""
+    etf_data = {}
+    total_change = 0.0
+    count = 0
+    for ticker in GOLD_ETFS:
+        # Запрашиваем текущий AUM
+        aum_now = await fetch_etf_aum(ticker)
+        if aum_now is None:
+            continue
+        # Сохраняем предыдущее значение в кэше
+        prev_key = f"aum_{ticker}_prev"
+        prev_aum = CACHE.get(prev_key, aum_now)
+        change = aum_now - prev_aum
+        change_pct = (change / prev_aum * 100) if prev_aum > 0 else 0
+        etf_data[ticker] = {
+            "aum": aum_now,
+            "change_24h": round(change_pct, 2),
+            "signal": "INFLOW" if change > 0 else "OUTFLOW"
+        }
+        total_change += change_pct
+        count += 1
+        # Кэшируем текущее значение для следующего сравнения
+        CACHE[prev_key] = aum_now
+
+    avg_change = total_change / count if count else 0
+    if avg_change > 1:
+        flow_signal, gold_signal = "STRONG_INFLOW", "BULLISH"
+    elif avg_change > 0:
+        flow_signal, gold_signal = "MODERATE_INFLOW", "SLIGHTLY_BULLISH"
+    elif avg_change < -1:
+        flow_signal, gold_signal = "STRONG_OUTFLOW", "BEARISH"
     else:
-        signal = "STRONG_OUTFLOW"
-        gold_signal = "BEARISH"
+        flow_signal, gold_signal = "NEUTRAL", "NEUTRAL"
 
     return {
-        'etfs': etf_data,
-        'inflow_count': inflow_count,
-        'outflow_count': outflow_count,
-        'inflow_pct': round(inflow_pct, 1),
-        'flow_signal': signal,
-        'gold_signal': gold_signal
+        "etfs": etf_data,
+        "avg_change_pct": round(avg_change, 2),
+        "flow_signal": flow_signal,
+        "gold_signal": gold_signal
     }
 
-# ================= COT REPORT =================
-def fetch_cot_report() -> Dict[str, Any]:
-    cache_key = "cot_gold"
-    if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 86400:
-        return CACHE[cache_key]
-
+# ================= COT С ИНДЕКСОМ =================
+async def fetch_cot_report() -> Dict[str, Any]:
     try:
-        url = "https://raw.githubusercontent.com/datasets/cftc-commitment-of-traders/main/data/gold.csv"
-        df = pd.read_csv(url)
+        df = pd.read_csv("https://raw.githubusercontent.com/datasets/cftc-commitment-of-traders/main/data/gold.csv")
         if not df.empty:
-            latest = df.iloc[-1]
-            comm_long = latest.get('Commercial_Long', 0)
-            comm_short = latest.get('Commercial_Short', 0)
-            noncomm_long = latest.get('Noncommercial_Long', 0)
-            noncomm_short = latest.get('Noncommercial_Short', 0)
-
-            comm_net = comm_long - comm_short
-            noncomm_net = noncomm_long - noncomm_short
-
-            # Спекулянты в лонг + хеджеры сокращают шорт = бычий сигнал
-            if noncomm_net > 0 and comm_net > 0:
+            # Вычисляем нетто спекулянтов
+            noncomm_net = df['Noncommercial_Long'] - df['Noncommercial_Short']
+            # Текущее значение
+            latest_net = int(noncomm_net.iloc[-1])
+            # Процентиль за последние 3 года (около 156 недель)
+            lookback = min(156, len(noncomm_net))
+            recent = noncomm_net.iloc[-lookback:]
+            percentile = (recent < latest_net).mean() * 100
+            if percentile > 80:
+                cot_signal = "BULLISH_EXTREME"
+            elif percentile > 60:
                 cot_signal = "BULLISH"
-            elif noncomm_net < 0 and comm_net < 0:
+            elif percentile < 20:
+                cot_signal = "BEARISH_EXTREME"
+            elif percentile < 40:
                 cot_signal = "BEARISH"
             else:
-                cot_signal = "MIXED"
+                cot_signal = "NEUTRAL"
 
-            result = {
-                'report_date': str(latest.get('Date', 'Unknown')),
-                'commercial_net': int(comm_net),
-                'noncommercial_net': int(noncomm_net),
+            return {
+                'report_date': str(df['Date'].iloc[-1]),
+                'noncommercial_net': latest_net,
+                'percentile': round(percentile, 1),
                 'cot_signal': cot_signal,
-                'gold_signal': 'BULLISH' if cot_signal == 'BULLISH' else 'BEARISH' if cot_signal == 'BEARISH' else 'NEUTRAL'
+                'gold_signal': 'BULLISH' if 'BULLISH' in cot_signal else 'BEARISH' if 'BEARISH' in cot_signal else 'NEUTRAL'
             }
-            CACHE[cache_key] = result
-            CACHE_TIMES[cache_key] = time.time()
-            return result
-    except:
-        pass
-
+    except Exception as e:
+        logger.warning(f"COT error: {e}")
     return {'cot_signal': 'NEUTRAL', 'gold_signal': 'NEUTRAL'}
 
-# ================= GPR (ГЕОПОЛИТИЧЕСКИЙ РИСК) =================
-def fetch_gpr() -> Dict[str, Any]:
-    """Геополитический риск — качественная оценка."""
+# ================= GPR (УЛУЧШЕННЫЙ) =================
+async def fetch_gpr() -> Dict[str, Any]:
     try:
-        # Используем новости как прокси GPR
-        r = requests.get(
-            "https://newsapi.org/v2/everything?q=geopolitical+war+sanctions&pageSize=10&apiKey=948c7816beea47baa23b054592472d0e",
-            timeout=10
-        )
+        r = await http_client.get(f"https://newsapi.org/v2/everything?q=geopolitical+war+sanctions&pageSize=5&apiKey={NEWSAPI_KEY}")
         if r.status_code == 200:
             total = r.json().get('totalResults', 0)
-            if total > 1000:
-                level = "HIGH"
-                gold_signal = "BULLISH"
-            elif total > 500:
-                level = "ELEVATED"
-                gold_signal = "SLIGHTLY_BULLISH"
+            # Нормализуем относительно общего количества новостей (грубо)
+            r_all = await http_client.get(f"https://newsapi.org/v2/everything?q=all&pageSize=5&apiKey={NEWSAPI_KEY}")
+            total_all = r_all.json().get('totalResults', 1) if r_all.status_code == 200 else 1000
+            ratio = total / max(total_all, 1)
+            if ratio > 0.15:
+                level, gold_signal = "HIGH", "BULLISH"
+            elif ratio > 0.08:
+                level, gold_signal = "ELEVATED", "SLIGHTLY_BULLISH"
             else:
-                level = "LOW"
-                gold_signal = "NEUTRAL"
-
-            return {
-                'gpr_level': level,
-                'mentions_24h': total,
-                'gold_signal': gold_signal
-            }
+                level, gold_signal = "LOW", "NEUTRAL"
+            return {'gpr_level': level, 'mentions_share': round(ratio, 4), 'gold_signal': gold_signal}
     except:
         pass
-
     return {'gpr_level': 'LOW', 'gold_signal': 'NEUTRAL'}
 
-# ================= ЦЕНТРАЛЬНЫЕ БАНКИ =================
-def fetch_central_bank_demand() -> Dict[str, Any]:
-    """Спрос на золото со стороны центробанков."""
-    try:
-        r = requests.get("https://api.coingecko.com/api/v3/coins/gold?community_data=true", timeout=10)
-        if r.status_code == 200:
-            data = r.json()
-            community = data.get('community_data', {})
-            # Используем упоминания как прокси интереса
-            mentions = community.get('twitter_followers', 0)
-            return {
-                'interest_level': 'HIGH' if mentions > 100000 else 'MODERATE',
-                'gold_signal': 'BULLISH'
-            }
-    except:
-        pass
-    return {'interest_level': 'MODERATE', 'gold_signal': 'NEUTRAL'}
-
-# ================= АНАЛИЗ ИЗ MT5 =================
-def analyze_from_mt5(mt5_features: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-    try:
-        score = 50.0
-
-        rsi = mt5_features.get('H1_rsi', 50)
-        if isinstance(rsi, (int, float)):
-            if rsi > 70:
-                score -= 10
-            elif rsi < 30:
-                score += 10
-
-        ema = mt5_features.get('H1_price_vs_ema_21', 0)
-        if isinstance(ema, (int, float)):
-            if ema > 1.0:
-                score += 10
-            elif ema < -1.0:
-                score -= 10
-
-        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),
-            "macro_score": score,
-            "source": "MT5"
-        }
-    except:
-        return None
-
-# ================= ГЛАВНЫЙ АНАЛИЗ =================
-def analyze_gold_macro() -> Dict[str, Any]:
-    dxy = fetch_dxy()
-    tips = fetch_tips_yield()
-    etf = analyze_etf_flows()
-    cot = fetch_cot_report()
-    gpr = fetch_gpr()
-    central_bank = fetch_central_bank_demand()
+# ================= ГЛАВНЫЙ МАКРО‑АНАЛИЗ =================
+async def analyze_gold_macro() -> Dict[str, Any]:
+    dxy, tips, etf, cot, gpr = await asyncio.gather(
+        fetch_dxy(), fetch_tips_yield(), analyze_etf_flows(), fetch_cot_report(), fetch_gpr()
+    )
 
     signals = []
     score = 50.0
@@ -352,10 +210,10 @@ def analyze_gold_macro() -> Dict[str, Any]:
     # DXY
     if dxy.get('gold_signal') == 'BULLISH':
         signals.append({"factor": "DXY", "signal": "BULLISH", "reason": "Доллар слабеет"})
-        score += 10
+        score += 12
     elif dxy.get('gold_signal') == 'BEARISH':
         signals.append({"factor": "DXY", "signal": "BEARISH", "reason": "Доллар укрепляется"})
-        score -= 10
+        score -= 12
 
     # TIPS
     if tips.get('gold_signal') == 'BULLISH':
@@ -363,34 +221,31 @@ def analyze_gold_macro() -> Dict[str, Any]:
         score += 15
     elif tips.get('gold_signal') == 'BEARISH':
         signals.append({"factor": "TIPS", "signal": "BEARISH", "reason": "Положительная реальная доходность"})
-        score -= 10
+        score -= 12
 
     # ETF
-    if etf.get('gold_signal') == 'BULLISH' or etf.get('gold_signal') == 'SLIGHTLY_BULLISH':
-        signals.append({"factor": "ETF", "signal": "BULLISH", "reason": f"Приток в ETF ({etf.get('inflow_pct', 0)}% в плюсе)"})
+    etf_signal = etf.get('gold_signal')
+    if etf_signal == 'BULLISH':
+        signals.append({"factor": "ETF Flow", "signal": "BULLISH", "reason": f"Приток в ETF ({etf['avg_change_pct']:.2f}%)"})
         score += 15
-    elif etf.get('gold_signal') == 'BEARISH' or etf.get('gold_signal') == 'SLIGHTLY_BEARISH':
-        signals.append({"factor": "ETF", "signal": "BEARISH", "reason": f"Отток из ETF"})
+    elif etf_signal == 'BEARISH':
+        signals.append({"factor": "ETF Flow", "signal": "BEARISH", "reason": f"Отток из ETF ({etf['avg_change_pct']:.2f}%)"})
         score -= 15
 
     # COT
-    if cot.get('gold_signal') == 'BULLISH':
-        signals.append({"factor": "COT", "signal": "BULLISH", "reason": "Крупные игроки в лонг"})
+    cot_signal = cot.get('gold_signal')
+    if cot_signal == 'BULLISH':
+        signals.append({"factor": "COT", "signal": "BULLISH", "reason": f"Спекулянты в лонг (процентиль {cot.get('percentile', 50)}%)"})
         score += 12
-    elif cot.get('gold_signal') == 'BEARISH':
-        signals.append({"factor": "COT", "signal": "BEARISH", "reason": "Крупные игроки в шорт"})
+    elif cot_signal == 'BEARISH':
+        signals.append({"factor": "COT", "signal": "BEARISH", "reason": f"Спекулянты в шорт (процентиль {cot.get('percentile', 50)}%)"})
         score -= 12
 
     # GPR
     if gpr.get('gold_signal') == 'BULLISH':
-        signals.append({"factor": "GPR", "signal": "BULLISH", "reason": f"Геополитический риск: {gpr.get('gpr_level')}"})
+        signals.append({"factor": "GPR", "signal": "BULLISH", "reason": f"Геополитический риск повышен ({gpr.get('gpr_level')})"})
         score += 10
 
-    # Центробанки
-    if central_bank.get('gold_signal') == 'BULLISH':
-        signals.append({"factor": "CENTRAL_BANKS", "signal": "BULLISH", "reason": "Спрос центробанков"})
-        score += 5
-
     score = max(0, min(100, score))
 
     if score > 60:
@@ -410,45 +265,14 @@ def analyze_gold_macro() -> Dict[str, Any]:
             "tips": tips,
             "etf_flows": etf,
             "cot_report": cot,
-            "geopolitical_risk": gpr,
-            "central_bank_demand": central_bank
+            "geopolitical_risk": gpr
         }
     }
 
 # ================= ГЛАВНЫЙ СИГНАЛ =================
-def get_gold_macro_signal() -> Dict[str, Any]:
+async def get_gold_macro_signal() -> Dict[str, Any]:
     start = time.time()
-
-    # Проверка MT5
-    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:
-                    result = {
-                        "space": "space_21_gold_macro",
-                        "timestamp": int(time.time()),
-                        "symbol": SYMBOL,
-                        "signal": {
-                            "direction": mt5_result["direction"],
-                            "confidence": mt5_result["confidence"]
-                        },
-                        "macro_analysis": {
-                            "score": mt5_result["macro_score"],
-                            "signals": [{"factor": "MT5", "signal": mt5_result["direction"], "reason": "Технический анализ"}]
-                        },
-                        "data_source": "MT5",
-                        "meta": {"latency_ms": int((time.time() - start) * 1000)}
-                    }
-                    send_to_arbiter(result)
-                    print(f"🥇 GOLD MACRO: {mt5_result['direction']} | Score={mt5_result['macro_score']} (MT5)")
-                    return result
-
-    # Fallback
-    analysis = analyze_gold_macro()
+    analysis = await analyze_gold_macro()
     latency = int((time.time() - start) * 1000)
 
     result = {
@@ -464,77 +288,67 @@ def get_gold_macro_signal() -> Dict[str, Any]:
             "signals": analysis['signals'],
             "metrics": analysis['metrics']
         },
-        "data_source": "FRED+ETF+COT",
-        "meta": {"latency_ms": latency}
+        "latency_ms": latency
     }
 
-    send_to_arbiter(result)
-    print(f"🥇 GOLD MACRO v1: {analysis['direction']} | Score={analysis['macro_score']} | ETF={analysis['metrics']['etf_flows'].get('flow_signal')} | COT={analysis['metrics']['cot_report'].get('cot_signal')}")
+    # Отправка в Arbiter
+    try:
+        await http_client.post(f"{ARBITER_URL}/log_signal", json={
+            "space": "space_21_gold_macro",
+            "symbol": SYMBOL,
+            "signal": result["signal"]
+        })
+    except:
+        pass
+
+    logger.info(f"🥇 Gold Macro: {analysis['direction']} | Score={analysis['macro_score']} | ETF={analysis['metrics']['etf_flows'].get('flow_signal')} | COT={analysis['metrics']['cot_report'].get('cot_signal')}")
     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 21 v3.0 — Gold Macro & Flow Engine")
 
-threading.Thread(target=keep_alive, daemon=True).start()
+@app.on_event("startup")
+async def startup():
+    pass
 
-# ================= FASTAPI =================
-app = FastAPI(title="TOMIRIS SPACE 21 v1.0 — GOLD MACRO & FLOW ANALYZER")
+@app.on_event("shutdown")
+async def shutdown():
+    await http_client.aclose()
 
 @app.get("/health")
-@app.head("/health")
 async def health():
-    return {
-        "space": "Space 21 - Gold Macro & Flow Analyzer v1.0",
-        "status": "operational",
-        "symbol": SYMBOL,
-        "features": ["DXY", "TIPS Yield", "ETF Flows", "COT Report", "GPR", "Central Bank Demand"]
-    }
+    return {"status": "operational", "version": "3.0", "async": True, "no_mt5": True}
 
 @app.get("/consilium")
 async def consilium():
-    return get_gold_macro_signal()
+    return await get_gold_macro_signal()
 
 @app.get("/dxy")
 async def dxy():
-    return fetch_dxy()
+    return await fetch_dxy()
 
 @app.get("/tips")
 async def tips():
-    return fetch_tips_yield()
+    return await fetch_tips_yield()
 
 @app.get("/etf")
 async def etf():
-    return analyze_etf_flows()
+    return await analyze_etf_flows()
 
 @app.get("/cot")
 async def cot():
-    return fetch_cot_report()
+    return await fetch_cot_report()
 
 @app.get("/gpr")
 async def gpr():
-    return fetch_gpr()
+    return await fetch_gpr()
 
 @app.get("/full")
 async def full():
-    return analyze_gold_macro()
-
-@app.post("/features")
-async def receive_features(data: Dict[str, Any]):
-    symbol = data.get("symbol", SYMBOL)
-    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 analyze_gold_macro()
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)
 
-print(f"🚀 SPACE 21 v1.0 — GOLD MACRO & FLOW ANALYZER ЗАПУЩЕН!")
-print(f"🥇 Анализ: DXY | TIPS | ETF GLD/IAU/GDX | COT | GPR | Центробанки")
-print(f"✅ Готов к бою!")
+print("🚀 SPACE 21 v3.0 — GOLD MACRO & FLOW ENGINE ЗАПУЩЕН!")