Update app.py

app.py

@@ -1,12 +1,13 @@
 # ============================================
 # АВТО-УСТАНОВКА ПАКЕТОВ
 # ============================================
-import subprocess
-import sys
-import importlib
+import subprocess, sys, importlib
 
 REQUIRED_PACKAGES = {
     'numpy': 'numpy',
+    'httpx': 'httpx',
+    'fastapi': 'fastapi',
+    'uvicorn': 'uvicorn',
     'requests': 'requests'
 }
 
@@ -19,176 +20,236 @@ for module_name, pip_name in REQUIRED_PACKAGES.items():
         print(f"✅ {pip_name} установлен!")
 
 # ============================================
-# 👑 TOMIRIS SPACE 24 v1.0 — ECOSYSTEM AGGREGATOR
+# 👑 TOMIRIS SPACE 24 v2.0 — ECOSYSTEM AGGREGATOR PRO (Async, Dynamic Weights, No MT5)
 # ============================================
-# Агрегирует сигналы от Space 19-23 и выдаёт единый
-# экосистемный вердикт для XAU/USD, ETH/USD, SOL/USD.
-# ============================================
-
-from fastapi import FastAPI, Query
-from typing import Dict, Any, List, Optional, Tuple
-import time
-import requests
-import threading
-import numpy as np
-from datetime import datetime
+import os, time, json, logging, asyncio
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timezone
 from collections import deque
-import warnings
-warnings.filterwarnings('ignore')
+import numpy as np
+import httpx
+from fastapi import FastAPI, Query
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger("Space24_EcosystemAggregator")
 
 # ================= КОНФИГУРАЦИЯ =================
-SYMBOLS: List[str] = ["XAU/USD", "ETH/USD", "SOL/USD"]
+SYMBOLS = ["XAU/USD", "ETH/USD", "SOL/USD"]
 
-# URL'ы экосистемных Space'ов (19-23)
-ECOSYSTEM_SPACES: Dict[str, Dict[str, Any]] = {
+# Реальные URL'ы экосистемных Space'ов
+ECOSYSTEM_SPACES = {
     "space_19_sol": {
-        "url": "https://tomiris-ecosystem-sol-master.hf.space",
+        "url": "https://tomirisai80-tomirisanal.hf.space",
         "weight": 0.25,
         "symbols": ["SOL/USD"],
-        "description": "SOL Master"
+        "description": "SOL Master",
+        "cache_ttl": 300
     },
     "space_20_l2_defi": {
-        "url": "https://tomiris-ecosystem-l2-defi.hf.space",
+        "url": "https://tomirisai80-tomirisanal2.hf.space",
         "weight": 0.25,
         "symbols": ["ETH/USD"],
-        "description": "L2 & DeFi Pulse"
+        "description": "L2 & DeFi Pulse",
+        "cache_ttl": 300
     },
     "space_21_gold_macro": {
-        "url": "https://tomiris-ecosystem-gold-macro.hf.space",
+        "url": "https://tomirisai80-tomirisanal3.hf.space",
         "weight": 0.25,
         "symbols": ["XAU/USD"],
-        "description": "Gold Macro & Flow"
+        "description": "Gold Macro & Flow",
+        "cache_ttl": 600
     },
     "space_22_sentiment": {
-        "url": "https://tomiris-ecosystem-sentiment.hf.space",
+        "url": "https://tomirisai80-tomirisanal4.hf.space",
         "weight": 0.15,
         "symbols": ["XAU/USD", "ETH/USD", "SOL/USD"],
-        "description": "Cross-Asset Sentiment"
+        "description": "Cross-Asset Sentiment",
+        "cache_ttl": 300
     },
     "space_23_anomaly": {
-        "url": "https://tomiris-ecosystem-anomaly.hf.space",
+        "url": "https://tomirisai80-tomirisai5.hf.space",
         "weight": 0.10,
         "symbols": ["ETH/USD", "SOL/USD"],
-        "description": "On-Chain Anomaly"
+        "description": "On-Chain Anomaly",
+        "cache_ttl": 60
     }
 }
 
-SPACE_18_ARBITER: str = "https://tomiris-ai-name6-6.hf.space"
-
-CACHE: Dict[str, Dict[str, Any]] = {}
-CACHE_TIMES: Dict[str, float] = {}
-FEATURES_STORE: Dict[str, Dict[str, Any]] = {}
-MT5_MAX_AGE_SEC: int = 300
-
-def send_to_arbiter(signal_data: Dict[str, Any]) -> None:
+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")
+SPACE31_URL = os.getenv("SPACE31_URL", "https://nuxotetotmailsvoboden-tomiris-perf.hf.space")
+
+# ================= HTTP КЛИЕНТ =================
+http_client = httpx.AsyncClient(timeout=15.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
+
+# ================= ДИНАМИЧЕСКИЕ ВЕСА =================
+async def fetch_dynamic_weights() -> Dict[str, float]:
+    """Пытается получить веса из Space 31, затем из Space 17. Если нет — базовые."""
+    # Space 31
+    if SPACE31_URL:
+        try:
+            r = await http_client.get(f"{SPACE31_URL}/weights", timeout=8)
+            if r.status_code == 200:
+                data = r.json()
+                if data:
+                    return {k: v.get("weight", 0.1) for k, v in data.items() if k in ECOSYSTEM_SPACES}
+        except:
+            pass
+    # Space 17 (analyst_metrics)
     try:
-        requests.post(
-            f"{SPACE_18_ARBITER}/log_signal",
-            json={'space': 'space_24_ecosystem', 'symbol': 'ALL', 'signal': signal_data.get('signal', {})},
-            timeout=5
-        )
+        r = await http_client.get(f"{HUB_URL}/metrics", timeout=8)
+        if r.status_code == 200:
+            metrics = r.json()
+            weights = {}
+            for m in metrics:
+                name = m.get("space_name", "")
+                if name in ECOSYSTEM_SPACES:
+                    acc = m.get("accuracy", 0.5)
+                    pf = m.get("profit_factor", 1.0)
+                    weights[name] = acc * min(pf, 3.0) / 3.0
+            return weights
     except:
         pass
+    # Базовые
+    return {name: cfg["weight"] for name, cfg in ECOSYSTEM_SPACES.items()}
 
-# ================= ЗАГРУЗКА СИГНАЛОВ =================
-def fetch_space_signal(space_name: str, url: str, symbol: str) -> Optional[Dict[str, Any]]:
-    cache_key = f"{space_name}_{symbol}"
-    if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 60:
-        return CACHE[cache_key]
+# ================= ОПРОС ОДНОГО SPACE =================
+async def fetch_space_signal(name: str, config: Dict, symbol: str) -> Optional[Dict]:
+    if breaker_open(name):
+        return None
+    cache_key = f"{name}_{symbol}"
+    ttl = config.get("cache_ttl", 60)
+    now = time.time()
+    if cache_key in cache_store and (now - cache_times.get(cache_key, 0)) < ttl:
+        return cache_store[cache_key]
 
     try:
-        r = requests.get(f"{url}/consilium?symbol={symbol}", timeout=10)
+        r = await http_client.get(f"{config['url']}/consilium?symbol={symbol}", timeout=10)
         if r.status_code == 200:
             data = r.json()
-            CACHE[cache_key] = data
-            CACHE_TIMES[cache_key] = time.time()
+            breaker_record(name, True)
+            cache_store[cache_key] = data
+            cache_times[cache_key] = time.time()
             return data
-    except Exception as e:
-        print(f"⚠️ {space_name}: {e}")
+    except:
+        breaker_record(name, False)
     return None
 
-def fetch_all_ecosystem_signals(symbol: str) -> Dict[str, Dict[str, Any]]:
-    signals = {}
-    errors = []
+# ================= АГРЕГАЦИЯ =================
+async def aggregate_ecosystem(symbol: str) -> Dict[str, Any]:
+    dynamic_weights = await fetch_dynamic_weights()
+    tasks = []
+    space_names = []
+    for name, cfg in ECOSYSTEM_SPACES.items():
+        if symbol in cfg["symbols"]:
+            tasks.append(fetch_space_signal(name, cfg, symbol))
+            space_names.append(name)
 
-    for space_name, config in ECOSYSTEM_SPACES.items():
-        if symbol not in config['symbols']:
-            continue
+    results = await asyncio.gather(*tasks)
 
-        signal = fetch_space_signal(space_name, config['url'], symbol)
-        if signal:
-            signals[space_name] = signal
+    signals = {}
+    errors = []
+    for name, res in zip(space_names, results):
+        if res and isinstance(res, dict):
+            signals[name] = res
         else:
-            errors.append(space_name)
-
-    return signals, errors
-
-# ================= АГРЕГАЦИЯ =================
-def aggregate_ecosystem(symbol: str) -> Dict[str, Any]:
-    signals, errors = fetch_all_ecosystem_signals(symbol)
-
-    if not signals:
-        return {
-            "ecosystem_score": 50.0,
-            "direction": "WAIT",
-            "confidence": 0.0,
-            "active_spaces": 0,
-            "error_spaces": len(errors),
-            "signals_detail": {},
-            "votes": {"LONG": 0.0, "SHORT": 0.0}
-        }
+            errors.append(name)
 
     total_weight = 0.0
     long_votes = 0.0
     short_votes = 0.0
+    wait_votes = 0.0
     details = {}
 
-    for space_name, data in signals.items():
-        config = ECOSYSTEM_SPACES.get(space_name, {})
-        weight = config.get('weight', 0.1)
-        sig = data.get('signal', {})
-        direction = sig.get('direction', 'WAIT')
-        confidence = sig.get('confidence', 0)
+    for name, data in signals.items():
+        weight = dynamic_weights.get(name, ECOSYSTEM_SPACES[name]["weight"])
+        sig = data.get("signal", {})
+        direction = sig.get("direction", "WAIT")
+        confidence = sig.get("confidence", 0)
 
-        # Взвешенное голосование
-        if direction == 'LONG':
+        if direction == "LONG":
             long_votes += weight * confidence
-        elif direction == 'SHORT':
+        elif direction == "SHORT":
             short_votes += weight * confidence
-
+        else:
+            wait_votes += weight * confidence
         total_weight += weight
-        details[space_name] = {
+        details[name] = {
             "direction": direction,
             "confidence": confidence,
             "weight": weight,
             "status": "active",
-            "description": config.get('description', '')
+            "description": ECOSYSTEM_SPACES[name]["description"]
         }
 
     for name in errors:
-        config = ECOSYSTEM_SPACES.get(name, {})
+        weight = dynamic_weights.get(name, ECOSYSTEM_SPACES[name]["weight"])
         details[name] = {
             "direction": "ERROR",
             "confidence": 0,
-            "weight": config.get('weight', 0),
+            "weight": weight,
             "status": "error",
-            "description": config.get('description', '')
+            "description": ECOSYSTEM_SPACES[name]["description"]
+        }
+
+    if total_weight == 0:
+        # Ни одного активного Space
+        return {
+            "ecosystem_score": 50.0,
+            "direction": "WAIT",
+            "confidence": 0.0,
+            "active_spaces": 0,
+            "error_spaces": len(errors),
+            "signals_detail": details,
+            "votes": {"LONG": 0.0, "SHORT": 0.0, "WAIT": 0.0}
         }
 
-    # Определяем направление
-    if long_votes > short_votes * 1.3:
+    # Баланс голосов
+    bias = (long_votes - short_votes) / total_weight
+    ecosystem_score = 50.0 + bias * 50.0
+    ecosystem_score = max(0, min(100, ecosystem_score))
+
+    # Определение направления с учётом WAIT
+    wait_ratio = wait_votes / total_weight
+    if wait_ratio > 0.6:
+        direction = "WAIT"
+        confidence = wait_ratio
+    elif long_votes > short_votes * 1.3:
         direction = "LONG"
-        confidence = min(0.85, long_votes / max(total_weight, 0.1))
+        confidence = min(0.9, long_votes / total_weight)
     elif short_votes > long_votes * 1.3:
         direction = "SHORT"
-        confidence = min(0.85, short_votes / max(total_weight, 0.1))
+        confidence = min(0.9, short_votes / total_weight)
     else:
         direction = "WAIT"
-        confidence = max(long_votes, short_votes) / max(total_weight, 0.1)
+        confidence = max(long_votes, short_votes) / total_weight
 
-    # Экосистемный скор (0-100)
-    ecosystem_score = ((long_votes + short_votes) / max(total_weight, 0.1)) * 50
-    ecosystem_score = min(100, max(0, ecosystem_score))
+    # Снижаем confidence при малом числе активных Space
+    active_ratio = len(signals) / len(space_names) if space_names else 0
+    confidence *= 0.5 + 0.5 * active_ratio
 
     return {
         "ecosystem_score": round(ecosystem_score, 2),
@@ -199,81 +260,15 @@ def aggregate_ecosystem(symbol: str) -> Dict[str, Any]:
         "signals_detail": details,
         "votes": {
             "LONG": round(long_votes, 4),
-            "SHORT": round(short_votes, 4)
+            "SHORT": round(short_votes, 4),
+            "WAIT": round(wait_votes, 4)
         }
     }
 
-# ================= АНАЛИЗ ИЗ 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),
-            "score": score,
-            "source": "MT5"
-        }
-    except:
-        return None
-
 # ================= ГЛАВНЫЙ СИГНАЛ =================
-def get_ecosystem_aggregate(symbol: str = "XAU/USD") -> Dict[str, Any]:
+async def get_ecosystem_aggregate(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)
-        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_24_ecosystem_aggregator",
-                        "timestamp": int(time.time()),
-                        "symbol": symbol,
-                        "signal": {
-                            "direction": mt5_result["direction"],
-                            "confidence": mt5_result["confidence"]
-                        },
-                        "ecosystem_analysis": {
-                            "score": mt5_result["score"],
-                            "active_spaces": 0,
-                            "data_source": "MT5"
-                        },
-                        "meta": {"latency_ms": int((time.time() - start) * 1000)}
-                    }
-                    send_to_arbiter(result)
-                    print(f"🌐 ECO AGG: {mt5_result['direction']} | Score={mt5_result['score']} (MT5)")
-                    return result
-
-    # Fallback: агрегация экосистемных Space'ов
-    agg = aggregate_ecosystem(symbol)
+    agg = await aggregate_ecosystem(symbol)
     latency = int((time.time() - start) * 1000)
 
     result = {
@@ -291,73 +286,65 @@ def get_ecosystem_aggregate(symbol: str = "XAU/USD") -> Dict[str, Any]:
             "votes": agg['votes'],
             "details": agg['signals_detail']
         },
-        "meta": {"latency_ms": latency}
+        "latency_ms": latency
     }
 
-    send_to_arbiter(result)
-    print(f"🌐 ECO AGG v1: {symbol} | {agg['direction']} | Active={agg['active_spaces']}/{len(ECOSYSTEM_SPACES)}")
+    # Отправка в Arbiter
+    try:
+        await http_client.post(f"{ARBITER_URL}/log_signal", json={
+            "space": "space_24_ecosystem",
+            "symbol": symbol,
+            "signal": result["signal"],
+            "ecosystem_details": result["ecosystem_analysis"]
+        })
+    except:
+        pass
+
+    logger.info(f"🌐 Ecosystem Agg: {symbol} {agg['direction']} conf={agg['confidence']:.3f} score={agg['ecosystem_score']:.1f} active={agg['active_spaces']}")
     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 24 v2.0 — Ecosystem Aggregator Pro")
 
-threading.Thread(target=keep_alive, daemon=True).start()
+@app.on_event("startup")
+async def startup():
+    pass
 
-# ================= FASTAPI =================
-app = FastAPI(title="TOMIRIS SPACE 24 v1.0 — ECOSYSTEM AGGREGATOR")
+@app.on_event("shutdown")
+async def shutdown():
+    await http_client.aclose()
 
 @app.get("/health")
-@app.head("/health")
 async def health():
     return {
-        "space": "Space 24 - Ecosystem Aggregator v1.0",
         "status": "operational",
+        "version": "2.0",
         "symbols": SYMBOLS,
-        "ecosystem_spaces": {k: v['description'] for k, v in ECOSYSTEM_SPACES.items()},
-        "total_spaces": len(ECOSYSTEM_SPACES)
+        "ecosystem_spaces": list(ECOSYSTEM_SPACES.keys()),
+        "no_mt5": True,
+        "async": True
     }
 
 @app.get("/consilium")
 async def consilium(symbol: str = Query("XAU/USD")):
     if symbol not in SYMBOLS:
-        return {"error": f"Unsupported: {symbol}"}
-    return get_ecosystem_aggregate(symbol)
+        return {"error": "Invalid symbol"}
+    return await get_ecosystem_aggregate(symbol)
 
 @app.get("/breakdown/{symbol}")
 async def breakdown(symbol: str):
-    """Детальный разбор всех экосистемных Space'ов."""
-    agg = aggregate_ecosystem(symbol)
-    return {
-        "symbol": symbol,
-        "aggregate": agg,
-        "spaces_detail": agg.get('signals_detail', {})
-    }
+    agg = await aggregate_ecosystem(symbol)
+    return {"symbol": symbol, "aggregate": agg, "spaces_detail": agg.get('signals_detail', {})}
 
 @app.get("/all")
 async def all_signals():
-    """Сигналы по всем трём активам."""
     results = {}
     for sym in SYMBOLS:
-        results[sym] = aggregate_ecosystem(sym)
+        results[sym] = await aggregate_ecosystem(sym)
     return results
 
-@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 24 v1.0 — ECOSYSTEM AGGREGATOR ЗАПУЩЕН!")
-print(f"🌐 Агрегирует Space 19-23 для XAU, ETH, SOL")
-print(f"✅ Готов к бою!")
+print("🚀 SPACE 24 v2.0 — ECOSYSTEM AGGREGATOR PRO ЗАПУЩЕН!")