Update app.py

app.py

@@ -22,7 +22,7 @@ for module_name, pip_name in REQUIRED_PACKAGES.items():
         print(f"✅ {pip_name} установлен!")
 
 # ============================================
-# 👑 TOMIRIS SPACE 20 v1.2 — ETHEREUM L2 & DEFI PULSE (АВТО-ОТПРАВКА)
+# 👑 TOMIRIS SPACE 20 v1.3 — ETHEREUM L2 & DEFI PULSE
 # ============================================
 from fastapi import FastAPI, Query
 from typing import Optional, Dict, Any, List
@@ -36,15 +36,27 @@ from collections import deque
 import warnings
 import os
 import json
+import logging
 
 warnings.filterwarnings('ignore')
 
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger("Space20_L2_DeFi")
+
 # ================= КОНФИГУРАЦИЯ =================
-SYMBOL: str = "ETH/USD"
-HUB_URL = os.getenv("SPACE17_URL", "https://tomiris-ai-name5-5.hf.space")
+SPACE_ID = 20
+SPACE_NAME = "L2 & DeFi Pulse"
+SYMBOL = "ETH/USD"
+
+# 🔥 ПРАВИЛЬНЫЙ URL ХАБА
+HUB_URL = os.getenv("HUB_URL", "https://pro-3-tomiris-hub.hf.space")
+HUB_SECRET = os.getenv("HUB_SECRET", "TomyrisUltraSecret2026!")
 
-# Интервал авто-отправки
-AUTO_SEND_INTERVAL = int(os.getenv("AUTO_SEND_INTERVAL", "300"))
+AUTO_SEND_INTERVAL = int(os.getenv("AUTO_SEND_INTERVAL", "600"))
+STARTUP_SLEEP = int(os.getenv("STARTUP_SLEEP", "600"))
+
+logger.info(f"🔗 Хаб: {HUB_URL}")
+logger.info(f"⏱️ Интервал: {AUTO_SEND_INTERVAL}с | Стартовый сон: {STARTUP_SLEEP}с")
 
 L2_CHAINS: Dict[str, str] = {
     "Arbitrum": "Arbitrum",
@@ -61,25 +73,50 @@ DEFI_PROTOCOLS: List[str] = [
 # ================= ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ =================
 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 hub_headers():
+    return {
+        "X-Hub-Secret": HUB_SECRET,
+        "Content-Type": "application/json"
+    }
 
 # ================= ОТПРАВКА В HUB =================
-def send_signal_to_hub(symbol: str, direction: str, confidence: float):
-    try:
-        resp = requests.post(f"{HUB_URL}/signal", json={
-            "space": "space_20_l2_defi",
-            "symbol": symbol,
-            "direction": direction,
-            "confidence": confidence,
-            "raw": json.dumps({"source": "space_20_l2_defi"})
-        }, timeout=10)
-        if resp.status_code == 200:
-            print(f"📤 {symbol}: {direction} conf={confidence:.3f} отправлен в Hub")
-        else:
-            print(f"⚠️ Hub вернул {resp.status_code}")
-    except Exception as e:
-        print(f"Ошибка отправки в Hub: {e}")
+def send_signal_to_hub(symbol: str, signal: str, confidence: float, features: Dict = None):
+    if features is None:
+        features = {}
+    
+    payload = {
+        "space_id": SPACE_ID,
+        "space_name": SPACE_NAME,
+        "symbol": symbol,
+        "signal": signal,
+        "confidence": round(confidence, 4),
+        "features": features,
+        "metadata": {"version": "1.3"},
+        "timestamp": datetime.now().isoformat()
+    }
+    
+    for attempt in range(3):
+        try:
+            headers = hub_headers()
+            r = requests.post(f"{HUB_URL}/signals", json=payload, timeout=15, headers=headers)
+            if r.status_code == 200:
+                logger.info(f"📤 {symbol}: {signal} conf={confidence:.3f}")
+                return True
+            elif r.status_code == 429:
+                wait = 3 * (attempt + 1)
+                logger.warning(f"⏳ 429 для {symbol}, жду {wait}с...")
+                time.sleep(wait)
+            else:
+                logger.warning(f"Попытка {attempt+1}: HTTP {r.status_code}")
+                time.sleep(2)
+        except Exception as e:
+            logger.warning(f"Попытка {attempt+1}: {e}")
+            time.sleep(2)
+    
+    logger.error(f"❌ Не удалось отправить {symbol}")
+    return False
 
 # ================= ЗАГРУЗКА ДАННЫХ DeFiLlama =================
 def fetch_chain_tvl(chain: str) -> Optional[Dict[str, Any]]:
@@ -88,22 +125,40 @@ def fetch_chain_tvl(chain: str) -> Optional[Dict[str, Any]]:
         return CACHE[cache_key]
 
     try:
-        r = requests.get(f"https://api.llama.fi/v2/tvl/{chain}", timeout=10)
+        r = requests.get(f"https://api.llama.fi/tvl/{chain}", timeout=10)
         if r.status_code == 200:
-            data = r.json()
+            text = r.text.strip()
+            if not text:
+                return None
+            try:
+                data = r.json()
+            except:
+                return None
+            
+            if isinstance(data, (int, float)):
+                tvl = float(data)
+                change_24h = 0
+                change_7d = 0
+            elif isinstance(data, dict):
+                tvl = data.get('tvl', 0)
+                change_24h = data.get('change_1d', 0)
+                change_7d = data.get('change_7d', 0)
+            else:
+                return None
+            
             result = {
                 'chain': chain,
-                'tvl': data.get('tvl', 0),
-                'tvl_billions': round(data.get('tvl', 0) / 1e9, 2),
-                'change_24h': data.get('change_1d', 0),
-                'change_7d': data.get('change_7d', 0),
-                'trend': 'UP' if data.get('change_1d', 0) > 0 else 'DOWN'
+                'tvl': tvl,
+                'tvl_billions': round(tvl / 1e9, 2),
+                'change_24h': change_24h,
+                'change_7d': change_7d,
+                'trend': 'UP' if change_24h > 0 else 'DOWN'
             }
             CACHE[cache_key] = result
             CACHE_TIMES[cache_key] = time.time()
             return result
     except Exception as e:
-        print(f"⚠️ TVL {chain}: {e}")
+        logger.warning(f"⚠️ TVL {chain}: {e}")
     return None
 
 def fetch_all_l2_tvl() -> Dict[str, Any]:
@@ -124,7 +179,7 @@ def fetch_all_l2_tvl() -> Dict[str, Any]:
 
     avg_change = total_change / active_chains if active_chains > 0 else 0
 
-    return {
+    result = {
         'chains': l2_data,
         'total_l2_tvl': round(total_tvl, 2),
         'total_l2_tvl_billions': round(total_tvl / 1e9, 2),
@@ -132,29 +187,20 @@ def fetch_all_l2_tvl() -> Dict[str, Any]:
         'trend': 'GROWING' if avg_change > 2 else 'SHRINKING' if avg_change < -2 else 'STABLE',
         'signal': 'BULLISH' if avg_change > 2 else 'BEARISH' if avg_change < -2 else 'NEUTRAL'
     }
+    logger.info(f"✅ L2 TVL: ${result['total_l2_tvl_billions']}B ({result['trend']})")
+    return result
 
 def fetch_ethereum_tvl() -> Dict[str, Any]:
     cache_key = "tvl_ethereum"
     if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 300:
         return CACHE[cache_key]
 
-    try:
-        r = requests.get("https://api.llama.fi/v2/tvl/ethereum", timeout=10)
-        if r.status_code == 200:
-            data = r.json()
-            result = {
-                'tvl': data.get('tvl', 0),
-                'tvl_billions': round(data.get('tvl', 0) / 1e9, 2),
-                'change_24h': data.get('change_1d', 0),
-                'change_7d': data.get('change_7d', 0),
-                'trend': 'UP' if data.get('change_1d', 0) > 0 else 'DOWN'
-            }
-            CACHE[cache_key] = result
-            CACHE_TIMES[cache_key] = time.time()
-            return result
-    except:
-        pass
-    return {'tvl': 0, 'trend': 'STABLE'}
+    data = fetch_chain_tvl("ethereum")
+    if data:
+        CACHE[cache_key] = data
+        CACHE_TIMES[cache_key] = time.time()
+        return data
+    return {'tvl': 0, 'tvl_billions': 0, 'change_24h': 0, 'trend': 'STABLE'}
 
 # ================= СТЕЙКИНГ =================
 def fetch_staking_metrics() -> Dict[str, Any]:
@@ -164,26 +210,54 @@ def fetch_staking_metrics() -> Dict[str, Any]:
 
     result: Dict[str, Any] = {}
 
+    # Lido TVL
     try:
-        r = requests.get("https://api.llama.fi/v2/tvl/lido", timeout=10)
+        r = requests.get("https://api.llama.fi/tvl/lido", timeout=10)
         if r.status_code == 200:
-            data = r.json()
-            result['lido_tvl'] = data.get('tvl', 0)
-            result['lido_tvl_billions'] = round(data.get('tvl', 0) / 1e9, 2)
-            result['lido_change_24h'] = data.get('change_1d', 0)
+            text = r.text.strip()
+            if text:
+                try:
+                    data = r.json()
+                    if isinstance(data, (int, float)):
+                        result['lido_tvl'] = float(data)
+                        result['lido_change_24h'] = 0
+                    elif isinstance(data, dict):
+                        result['lido_tvl'] = data.get('tvl', 0)
+                        result['lido_change_24h'] = data.get('change_1d', 0)
+                except:
+                    pass
     except:
         result['lido_tvl'] = 0
 
+    # EigenLayer TVL
     try:
-        r = requests.get("https://api.llama.fi/v2/tvl/eigenlayer", timeout=10)
+        r = requests.get("https://api.llama.fi/tvl/eigenlayer", timeout=10)
         if r.status_code == 200:
-            data = r.json()
-            result['eigenlayer_tvl'] = data.get('tvl', 0)
-            result['eigenlayer_change_24h'] = data.get('change_1d', 0)
-            result['restaking_growth'] = 'HIGH' if data.get('change_1d', 0) > 5 else 'MODERATE' if data.get('change_1d', 0) > 0 else 'DECLINING'
+            text = r.text.strip()
+            if text:
+                try:
+                    data = r.json()
+                    if isinstance(data, (int, float)):
+                        result['eigenlayer_tvl'] = float(data)
+                        result['eigenlayer_change_24h'] = 0
+                    elif isinstance(data, dict):
+                        result['eigenlayer_tvl'] = data.get('tvl', 0)
+                        result['eigenlayer_change_24h'] = data.get('change_1d', 0)
+                except:
+                    pass
     except:
         result['eigenlayer_tvl'] = 0
 
+    result['lido_tvl_billions'] = round(result.get('lido_tvl', 0) / 1e9, 2)
+    
+    eigen_change = result.get('eigenlayer_change_24h', 0) or 0
+    if eigen_change > 5:
+        result['restaking_growth'] = 'HIGH'
+    elif eigen_change > 0:
+        result['restaking_growth'] = 'MODERATE'
+    else:
+        result['restaking_growth'] = 'DECLINING'
+    
     result['signal'] = 'BULLISH' if result.get('lido_change_24h', 0) > 0 else 'NEUTRAL'
 
     CACHE[cache_key] = result
@@ -203,18 +277,20 @@ def fetch_dex_volumes() -> Dict[str, Any]:
         )
         if r.status_code == 200:
             data = r.json()
+            total24h = data.get('total24h', 0)
+            change24h = data.get('change_1d', 0)
             result = {
-                'total_volume_24h': data.get('total24h', 0),
-                'volume_billions': round(data.get('total24h', 0) / 1e9, 2),
-                'change_24h': data.get('change_1d', 0),
-                'trend': 'UP' if data.get('change_1d', 0) > 0 else 'DOWN',
-                'signal': 'BULLISH' if data.get('change_1d', 0) > 10 else 'BEARISH' if data.get('change_1d', 0) < -10 else 'NEUTRAL'
+                'total_volume_24h': total24h,
+                'volume_billions': round(total24h / 1e9, 2),
+                'change_24h': change24h,
+                'trend': 'UP' if change24h > 0 else 'DOWN',
+                'signal': 'BULLISH' if change24h > 10 else 'BEARISH' if change24h < -10 else 'NEUTRAL'
             }
             CACHE[cache_key] = result
             CACHE_TIMES[cache_key] = time.time()
             return result
-    except:
-        pass
+    except Exception as e:
+        logger.warning(f"DEX error: {e}")
     return {'total_volume_24h': 0, 'signal': 'NEUTRAL'}
 
 # ================= СЖИГАНИЕ ETH =================
@@ -236,8 +312,8 @@ def fetch_ultrasound_money() -> Dict[str, Any]:
             CACHE[cache_key] = result
             CACHE_TIMES[cache_key] = time.time()
             return result
-    except:
-        pass
+    except Exception as e:
+        logger.warning(f"Ultrasound error: {e}")
     return {'is_deflationary': False, 'signal': 'NEUTRAL'}
 
 # ================= РАЗРАБОТЧИКИ =================
@@ -255,43 +331,6 @@ def fetch_developer_activity() -> Dict[str, Any]:
         pass
     return {'activity': 'MODERATE'}
 
-# ================= АНАЛИЗ ИЗ MT5 =================
-def analyze_from_mt5(mt5_features: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-    try:
-        score = 50.0
-        signals = []
-
-        vol = mt5_features.get('H1_volume', 0)
-        if isinstance(vol, (int, float)) and vol > 1000:
-            signals.append({"signal": "BULLISH", "reason": "Высокий объём на H1"})
-            score += 5
-
-        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),
-            "ecosystem_score": score,
-            "signals": signals,
-            "source": "MT5"
-        }
-    except:
-        return None
-
 # ================= ГЛАВНЫЙ АНАЛИЗ =================
 def analyze_ecosystem() -> Dict[str, Any]:
     l2 = fetch_all_l2_tvl()
@@ -340,19 +379,23 @@ def analyze_ecosystem() -> Dict[str, Any]:
     score = max(0, min(100, score))
 
     if score > 60:
-        direction, confidence = "LONG", score / 100
+        signal = "BUY"
+        confidence = score / 100
     elif score < 40:
-        direction, confidence = "SHORT", (100 - score) / 100
+        signal = "SELL"
+        confidence = (100 - score) / 100
     else:
-        direction, confidence = "WAIT", 0.0
+        signal = "WAIT"
+        confidence = 0.0
 
     return {
         "ecosystem_score": score,
-        "direction": direction,
+        "signal": signal,
         "confidence": round(confidence, 4),
         "signals": signals,
         "metrics": {
-            "l2": l2,
+            "l2": {k: v for k, v in l2.items() if k != 'chains'},
+            "l2_chains": l2.get('chains', {}),
             "ethereum_tvl": eth_tvl,
             "staking": staking,
             "dex": dex,
@@ -364,68 +407,36 @@ def analyze_ecosystem() -> Dict[str, Any]:
 # ================= ГЛАВНЫЙ СИГНАЛ =================
 def get_ecosystem_signal() -> Dict[str, Any]:
     start = time.time()
-
-    if SYMBOL in FEATURES_STORE:
-        fs = FEATURES_STORE[SYMBOL]
-        age = time.time() - fs.get("timestamp", 0)
-        if age < MT5_MAX_AGE_SEC:
-            mt5_features = fs.get("features", {})
-            if mt5_features:
-                mt5_result = analyze_from_mt5(mt5_features)
-                if mt5_result:
-                    result = {
-                        "space": "space_20_l2_defi_pulse",
-                        "timestamp": int(time.time()),
-                        "symbol": SYMBOL,
-                        "signal": {
-                            "direction": mt5_result["direction"],
-                            "confidence": mt5_result["confidence"]
-                        },
-                        "ecosystem_analysis": {
-                            "score": mt5_result["ecosystem_score"],
-                            "signals": mt5_result["signals"]
-                        },
-                        "data_source": "MT5",
-                        "meta": {"latency_ms": int((time.time() - start) * 1000)}
-                    }
-                    send_signal_to_hub(SYMBOL, mt5_result["direction"], mt5_result["confidence"])
-                    print(f"🔷 L2+DeFi: {mt5_result['direction']} | Score={mt5_result['ecosystem_score']} (MT5)")
-                    return result
-
     analysis = analyze_ecosystem()
-    latency = int((time.time() - start) * 1000)
-
-    result = {
-        "space": "space_20_l2_defi_pulse",
-        "timestamp": int(time.time()),
+    
+    features = {
+        "ecosystem_score": analysis['ecosystem_score'],
+        "l2_tvl": analysis['metrics'].get('l2', {}).get('total_l2_tvl_billions', 0),
+        "eth_tvl_change": analysis['metrics'].get('ethereum_tvl', {}).get('change_24h', 0)
+    }
+    send_signal_to_hub(SYMBOL, analysis['signal'], analysis['confidence'], features)
+    
+    elapsed = int((time.time() - start) * 1000)
+    logger.info(f"🔷 L2+DeFi: {analysis['signal']} | Score={analysis['ecosystem_score']} | L2 TVL=${analysis['metrics'].get('l2', {}).get('total_l2_tvl_billions', 0)}B | {elapsed}ms")
+    
+    return {
+        "space_id": SPACE_ID,
         "symbol": SYMBOL,
-        "signal": {
-            "direction": analysis['direction'],
-            "confidence": analysis['confidence']
-        },
-        "ecosystem_analysis": {
-            "score": analysis['ecosystem_score'],
-            "signals": analysis['signals'],
-            "metrics": analysis['metrics']
-        },
-        "data_source": "DeFiLlama",
-        "meta": {"latency_ms": latency}
+        "signal": analysis['signal'],
+        "confidence": analysis['confidence'],
+        "ecosystem_score": analysis['ecosystem_score']
     }
 
-    send_signal_to_hub(SYMBOL, analysis['direction'], analysis['confidence'])
-    print(f"🔷 L2+DeFi v1.2: {analysis['direction']} | Score={analysis['ecosystem_score']} | L2 TVL=${analysis['metrics']['l2'].get('total_l2_tvl_billions', 0)}B")
-    return result
-
 # ================= АВТО-ОТПРАВКА =================
 async def auto_send_loop():
-    print(f"🔄 Авто-отправка L2/DeFi запущена (интервал {AUTO_SEND_INTERVAL}с)")
-    await asyncio.sleep(30)
+    logger.info(f"⏳ Стартовый сон {STARTUP_SLEEP}с...")
+    await asyncio.sleep(STARTUP_SLEEP)
+    logger.info(f"🔄 Авто-отправка L2/DeFi (интервал {AUTO_SEND_INTERVAL}с)")
     while True:
         try:
             get_ecosystem_signal()
-            print("✅ L2/DeFi авто-отправка завершена")
         except Exception as e:
-            print(f"Ошибка авто-отправки: {e}")
+            logger.error(f"Ошибка авто-отправки: {e}")
         await asyncio.sleep(AUTO_SEND_INTERVAL)
 
 # ================= KEEP-ALIVE =================
@@ -440,25 +451,27 @@ def keep_alive():
 threading.Thread(target=keep_alive, daemon=True).start()
 
 # ================= FASTAPI =================
-app = FastAPI(title="TOMIRIS SPACE 20 v1.2 — L2 & DEFI PULSE (Auto-Hub)")
+app = FastAPI(title="TOMIRIS SPACE 20 v1.3 — L2 & DEFI PULSE")
 
 @app.on_event("startup")
 async def startup():
     asyncio.create_task(auto_send_loop())
-    print("🚀 Space 20 v1.2 запущен с авто-отправкой в Hub")
+    logger.info(f"🚀 Space 20 v1.3 ЗАПУЩЕН | Хаб: {HUB_URL}")
 
 @app.get("/health")
-@app.head("/health")
 async def health():
     return {
-        "space": "Space 20 v1.2 Auto-Hub",
+        "space_id": SPACE_ID,
         "status": "operational",
-        "symbol": SYMBOL,
+        "version": "1.3",
         "hub_url": HUB_URL,
-        "auto_send_interval": AUTO_SEND_INTERVAL,
         "l2_chains": list(L2_CHAINS.keys())
     }
 
+@app.head("/health")
+async def health_head():
+    return {}
+
 @app.get("/consilium")
 async def consilium():
     return get_ecosystem_signal()
@@ -495,21 +508,14 @@ async def full_analysis():
 async def send_now():
     return get_ecosystem_signal()
 
-@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"}
+@app.get("/")
+async def root():
+    return {"name": "L2 & DeFi Pulse v1.3", "space_id": SPACE_ID, "hub": HUB_URL}
 
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)
 
-print(f"🚀 SPACE 20 v1.2 — L2 & DEFI PULSE (АВТО-ОТПРАВКА В HUB) ЗАПУЩЕН!")
+print(f"🚀 SPACE 20 v1.3 — L2 & DEFI PULSE ЗАПУЩЕН!")
 print(f"🔷 Мониторинг: Arbitrum, Optimism, Base, Polygon ZkEVM | DEX | Staking | Ultrasound")
 print(f"✅ Готов к бою!")