Update app.py

app.py

@@ -1,5 +1,5 @@
 # ============================================
-# 👑 TOMIRIS SPACE 19 v10.1 — SOL/USD MASTER (ФИКС)
+# 👑 TOMIRIS SPACE 19 v10.2 — SOL/USD MASTER (FULL FIX)
 # ============================================
 import os, time, threading, warnings, json, asyncio
 from typing import Dict, Any, Optional, List, Tuple
@@ -8,17 +8,24 @@ import requests
 from datetime import datetime, timedelta
 from collections import deque
 from fastapi import FastAPI, Query
+import logging
 warnings.filterwarnings('ignore')
 
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger("Space19_SOL_Master")
+
 # ================= БЕЗОПАСНЫЙ ИМПОРТ =================
 HAS_JOBLIB = False
 try:
     import joblib
     HAS_JOBLIB = True
 except:
-    print("⚠️ joblib не установлен")
+    logger.warning("⚠️ joblib не установлен")
 
 # ================= КОНФИГУРАЦИЯ =================
+SPACE_ID = 19
+SPACE_NAME = "SOL Master"
+
 HUB_URL = os.getenv("HUB_URL", "https://pro-3-tomiris-hub.hf.space")
 HUB_SECRET = os.getenv("HUB_SECRET", "TomyrisUltraSecret2026!")
 TWELVE_DATA_KEY = os.getenv("TWELVE_DATA_KEY", "")
@@ -30,8 +37,13 @@ TIMEFRAMES = ["15min", "1h", "4h"]
 
 SOL_THRESHOLD = 0.52
 
+logger.info(f"🔗 Хаб: {HUB_URL}")
+
 def hub_headers():
-    return {"X-Hub-Secret": HUB_SECRET, "Content-Type": "application/json"}
+    return {
+        "X-Hub-Secret": HUB_SECRET,
+        "Content-Type": "application/json"
+    }
 
 CACHE_TTL = 300
 DATA_CACHE: Dict[str, Dict[str, Any]] = {}
@@ -52,7 +64,7 @@ REGIME_WEIGHTS = {
 }
 
 # ================= ЗАГРУЗКА МОДЕЛЕЙ =================
-print(f"🔥 SPACE 19 v10.1: Загрузка моделей для {SYMBOL}...")
+logger.info(f"🔥 Загрузка моделей для {SYMBOL}...")
 MODELS: Dict[str, Optional[Any]] = {"xgb_daily": None, "xgb_4h": None, "lgb": None}
 
 if HAS_JOBLIB:
@@ -62,13 +74,13 @@ if HAS_JOBLIB:
         if os.path.exists(fname):
             try:
                 MODELS[key] = joblib.load(fname)
-                print(f"✅ {fname} загружен")
+                logger.info(f"✅ {fname} загружен")
             except Exception as e:
-                print(f"⚠️ {fname}: {e}")
+                logger.warning(f"⚠️ {fname}: {e}")
 
 # ================= HTTP СЕССИЯ =================
 session = requests.Session()
-session.headers.update({"User-Agent": "Tomiris-Space19-v10.1"})
+session.headers.update({"User-Agent": "Tomiris-Space19-v10.2"})
 
 # ================= УТИЛИТЫ =================
 def safe_float(value, default=0.0):
@@ -76,27 +88,36 @@ def safe_float(value, default=0.0):
         if isinstance(value, (pd.Series, pd.DataFrame)):
             return float(value.iloc[-1]) if len(value) > 0 else default
         return float(value) if not pd.isna(float(value)) else default
-    except: return default
+    except:
+        return default
 
 def safe_rsi(close, period=14):
     try:
-        delta = close.diff(); gain = delta.clip(lower=0).rolling(period, min_periods=period).mean()
+        delta = close.diff()
+        gain = delta.clip(lower=0).rolling(period, min_periods=period).mean()
         loss = (-delta.clip(upper=0)).rolling(period, min_periods=period).mean()
         g_val, l_val = gain.iloc[-1], loss.iloc[-1]
-        if pd.notna(g_val) and pd.notna(l_val) and l_val > 0: return float(100 - (100 / (1 + g_val/l_val)))
+        if pd.notna(g_val) and pd.notna(l_val) and l_val > 0:
+            return float(100 - (100 / (1 + g_val/l_val)))
+        return 50.0
+    except:
         return 50.0
-    except: return 50.0
 
 def safe_ema(close, span):
-    try: return float(close.ewm(span=span, adjust=False).mean().iloc[-1])
-    except: return float(close.iloc[-1])
+    try:
+        return float(close.ewm(span=span, adjust=False).mean().iloc[-1])
+    except:
+        return float(close.iloc[-1])
 
 def hurst_exponent(series, lags=20):
-    if len(series) < lags * 2: return 0.5
+    if len(series) < lags * 2:
+        return 0.5
     lags_range = range(2, min(lags, len(series)//2))
     tau = [np.std(np.subtract(series.values[lag:], series.values[:-lag])) for lag in lags_range]
-    try: return float(np.polyfit(np.log(list(lags_range)), np.log(tau), 1)[0] * 2.0)
-    except: return 0.5
+    try:
+        return float(np.polyfit(np.log(list(lags_range)), np.log(tau), 1)[0] * 2.0)
+    except:
+        return 0.5
 
 def smooth_confidence(current):
     global LAST_CONFIDENCE
@@ -109,8 +130,10 @@ def detect_market_regime(features):
     adx = features.get("adx", 20.0)
     volatility = features.get("volatility_1h", 0.0)
     hurst = features.get("hurst_exponent", 0.5)
-    if adx > 30 and hurst > 0.55: return "TREND"
-    if volatility > 0.04: return "VOLATILE"
+    if adx > 30 and hurst > 0.55:
+        return "TREND"
+    if volatility > 0.04:
+        return "VOLATILE"
     return "RANGE"
 
 # ================= ЗАГРУЗКА ДАННЫХ =================
@@ -120,23 +143,31 @@ def fetch_ohlc_hub(symbol, tf, limit=200):
         return DATA_CACHE[cache_key]["df"]
     
     try:
-        r = session.get(f"{HUB_URL}/candles", params={"symbol": symbol, "interval": tf, "limit": limit}, timeout=20, headers=hub_headers())
+        r = session.get(
+            f"{HUB_URL}/candles",
+            params={"symbol": symbol, "interval": tf, "limit": limit},
+            timeout=20,
+            headers=hub_headers()
+        )
         if r.status_code == 200:
             candles = r.json().get("candles", [])
             if candles:
                 df = pd.DataFrame(candles)
-                if "o" in df.columns: df.rename(columns={"o":"open","h":"high","l":"low","c":"close","v":"volume"}, inplace=True)
-                for col in ["open","high","low","close"]: df[col] = pd.to_numeric(df[col], errors="coerce")
+                if "o" in df.columns:
+                    df.rename(columns={"o":"open","h":"high","l":"low","c":"close","v":"volume"}, inplace=True)
+                for col in ["open","high","low","close"]:
+                    df[col] = pd.to_numeric(df[col], errors="coerce")
                 df["volume"] = pd.to_numeric(df.get("volume", 0), errors="coerce").fillna(0)
                 if len(df) >= 30:
                     DATA_CACHE[cache_key] = {"df": df, "timestamp": time.time()}
                     return df
     except Exception as e:
-        print(f"Hub {symbol} {tf}: {e}")
+        logger.warning(f"Hub {symbol} {tf}: {e}")
     return None
 
 def fetch_twelvedata_sol(tf="1h"):
-    if not TWELVE_DATA_KEY: return None
+    if not TWELVE_DATA_KEY:
+        return None
     cache_key = f"td_sol_{tf}"
     if cache_key in DATA_CACHE and time.time() - DATA_CACHE[cache_key].get("timestamp", 0) < CACHE_TTL:
         return DATA_CACHE[cache_key]["df"]
@@ -146,41 +177,75 @@ def fetch_twelvedata_sol(tf="1h"):
         r = session.get(url, timeout=15)
         if r.status_code == 200 and "values" in r.json():
             df = pd.DataFrame(r.json()["values"]).iloc[::-1].reset_index(drop=True)
-            for col in ["close","high","low","open"]: df[col] = pd.to_numeric(df[col], errors="coerce")
+            for col in ["close","high","low","open"]:
+                df[col] = pd.to_numeric(df[col], errors="coerce")
             df["volume"] = pd.to_numeric(df.get("volume", 0), errors="coerce").fillna(0)
             if len(df) >= 30:
                 DATA_CACHE[cache_key] = {"df": df, "timestamp": time.time()}
                 return df
-    except: pass
+    except:
+        pass
     return None
 
 def fetch_ohlc(symbol, tf="1h"):
     df = fetch_ohlc_hub(symbol, tf)
     if df is None:
-        print(f"  🔄 Хаб недоступен для {symbol} {tf}, пробую Twelve Data...")
+        logger.info(f"  🔄 Хаб недоступен для {symbol} {tf}, пробую Twelve Data...")
         df = fetch_twelvedata_sol(tf)
     return df
 
 def fetch_solana_onchain():
+    """🔥 ФИКС: Правильные эндпоинты DefiLlama"""
     cache_key = "solana_onchain"
     if cache_key in DATA_CACHE and time.time() - DATA_CACHE[cache_key].get("timestamp", 0) < 300:
         return DATA_CACHE[cache_key]["data"]
+    
     result = {}
+    
+    # TVL — правильный эндпоинт
     try:
-        r = session.get("https://api.llama.fi/v2/tvl/solana", timeout=10)
+        r = session.get("https://api.llama.fi/tvl/solana", timeout=10)
         if r.status_code == 200:
-            data = r.json()
-            result['tvl'] = data.get('tvl', 0)
-            result['tvl_change_24h'] = data.get('change_1d', 0)
-            result['tvl_trend'] = 'UP' if data.get('change_1d', 0) > 0 else 'DOWN'
-    except: pass
+            text = r.text.strip()
+            if text:
+                try:
+                    data = r.json()
+                    if isinstance(data, (int, float)):
+                        result['tvl'] = float(data)
+                        result['tvl_change_24h'] = 0
+                    elif isinstance(data, dict):
+                        result['tvl'] = data.get('tvl', 0)
+                        result['tvl_change_24h'] = data.get('change_1d', 0)
+                except:
+                    pass
+        if 'tvl' not in result:
+            result['tvl'] = 0
+            result['tvl_change_24h'] = 0
+    except Exception as e:
+        logger.warning(f"Solana TVL error: {e}")
+        result['tvl'] = 0
+        result['tvl_change_24h'] = 0
+    
+    result['tvl_trend'] = 'UP' if result.get('tvl_change_24h', 0) > 0 else 'DOWN'
+    
+    # DEX volumes — правильный эндпоинт
     try:
-        r = session.get("https://api.llama.fi/overview/dexs/solana?excludeTotalDataChart=true&excludeTotalDataChartBreakdown=true", timeout=10)
+        r = session.get(
+            "https://api.llama.fi/overview/dexs/solana?excludeTotalDataChart=true&excludeTotalDataChartBreakdown=true",
+            timeout=10
+        )
         if r.status_code == 200:
             data = r.json()
             result['dex_volume_24h'] = data.get('total24h', 0)
             result['dex_change_24h'] = data.get('change_1d', 0)
-    except: pass
+        else:
+            result['dex_volume_24h'] = 0
+            result['dex_change_24h'] = 0
+    except Exception as e:
+        logger.warning(f"Solana DEX error: {e}")
+        result['dex_volume_24h'] = 0
+        result['dex_change_24h'] = 0
+    
     DATA_CACHE[cache_key] = {"data": result, "timestamp": time.time()}
     return result
 
@@ -195,16 +260,20 @@ def fetch_binance_sol():
                     result['funding_rate'] = fr
                     result['funding_signal'] = 'BEARISH' if fr > 0.001 else 'BULLISH' if fr < -0.001 else 'NEUTRAL'
                     break
-    except: pass
+    except:
+        pass
     try:
         r = session.get("https://fapi.binance.com/fapi/v1/openInterest?symbol=SOLUSDT", timeout=10)
-        if r.status_code == 200: result['open_interest'] = float(r.json().get('openInterest', 0))
-    except: pass
+        if r.status_code == 200:
+            result['open_interest'] = float(r.json().get('openInterest', 0))
+    except:
+        pass
     return result
 
-# ================= ПОСТРОЕНИЕ ПРИЗНАКОВ (ФИКС — БЕЗ ПАДДИНГА) =================
+# ================= ПОСТРОЕНИЕ ПРИЗНАКОВ =================
 def build_sol_features(df, onchain_data=None, derivatives=None):
-    if df is None or len(df) < 20: return {}
+    if df is None or len(df) < 20:
+        return {}
     
     close = df["close"].astype(float)
     high = df["high"].astype(float)
@@ -239,10 +308,17 @@ def build_sol_features(df, onchain_data=None, derivatives=None):
     
     if len(close) >= 14:
         prev_close = close.shift(1)
-        tr = pd.DataFrame({"tr1": high-low, "tr2": (high-prev_close).abs(), "tr3": (low-prev_close).abs()}).max(axis=1)
+        tr = pd.DataFrame({
+            "tr1": high-low,
+            "tr2": (high-prev_close).abs(),
+            "tr3": (low-prev_close).abs()
+        }).max(axis=1)
         features["atr_14"] = safe_float(tr.rolling(14, min_periods=14).mean().iloc[-1])
         features["atr_pct"] = (features["atr_14"] / (close.iloc[-1] + 1e-10)) * 100
     
+    # ADX
+    features["adx"] = 20.0
+    
     if onchain_data:
         features["tvl"] = onchain_data.get("tvl", 0)
         features["tvl_trend"] = 1 if onchain_data.get("tvl_trend") == "UP" else -1
@@ -258,9 +334,46 @@ def build_sol_features(df, onchain_data=None, derivatives=None):
     features["is_weekend"] = 1 if now.weekday() >= 5 else 0
     features["hour"] = now.hour
     
-    # 🔥 ФИКС: БЕЗ ПАДДИНГА! Модель сама разберётся
     return features
 
+# ================= ОТПРАВКА СИГНАЛА (ИСПРАВЛЕНО) =================
+def send_signal_to_hub(signal: str, confidence: float, features: Dict = None):
+    """🔥 ИСПРАВЛЕНО: signal вместо direction, space_id вместо space"""
+    if features is None:
+        features = {}
+    
+    payload = {
+        "space_id": SPACE_ID,
+        "space_name": SPACE_NAME,
+        "symbol": SYMBOL,
+        "signal": signal,           # ✅ BUY/SELL/WAIT
+        "confidence": round(confidence, 4),
+        "features": features,
+        "metadata": {"version": "10.2"},
+        "timestamp": datetime.now().isoformat()
+    }
+    
+    for attempt in range(3):
+        try:
+            headers = hub_headers()
+            r = session.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, жду {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("❌ Не удалось отправить сигнал после 3 попыток")
+    return False
+
 # ================= СИГНАЛ =================
 def get_sol_signal():
     global LAST_CONFIDENCE
@@ -274,16 +387,17 @@ def get_sol_signal():
         df = fetch_ohlc(SYMBOL, tf)
         if df is not None and len(df) >= 30:
             feats = build_sol_features(df, onchain_data, binance_data)
-            if feats: all_features[tf] = feats
+            if feats:
+                all_features[tf] = feats
     
     if not all_features:
-        send_signal_to_hub("WAIT", 0.0)
+        send_signal_to_hub("WAIT", 0.0, {"reason": "no_data"})
         return None
     
     h1_features = all_features.get("1h", list(all_features.values())[0])
     price = h1_features.get("price", 0)
     if price == 0:
-        send_signal_to_hub("WAIT", 0.0)
+        send_signal_to_hub("WAIT", 0.0, {"reason": "no_price"})
         return None
     
     regime = detect_market_regime(h1_features)
@@ -306,7 +420,7 @@ def get_sol_signal():
                     probs.append(float(proba[1] if len(proba) > 1 else proba[0]))
                     models_used += 1
                 except Exception as e:
-                    print(f"  ⚠️ Ошибка {mk}: {e}")
+                    logger.warning(f"  ⚠️ Ошибка {mk}: {e}")
         
         if MODELS.get("lgb"):
             try:
@@ -314,11 +428,12 @@ def get_sol_signal():
                 lgb_prob = float(proba[1] if len(proba) > 1 else proba[0])
                 xgb_prob = (sum(probs)/len(probs) * 0.6 + lgb_prob * 0.4) if probs else lgb_prob
                 models_used += 1
-            except: pass
+            except:
+                pass
         elif probs:
             xgb_prob = sum(probs) / len(probs)
     except Exception as e:
-        print(f"  ⚠️ Ошибка предсказания: {e}")
+        logger.warning(f"  ⚠️ Ошибка предсказания: {e}")
     
     # Мульти-ТФ
     confirmations, total_tf = 0, 0
@@ -327,8 +442,10 @@ def get_sol_signal():
         ema_score = feats.get("price_vs_ema_21", 0)
         rsi_val = feats.get("rsi_14", 50)
         macd_hist = feats.get("macd_hist", 0)
-        if ema_score > 0 and rsi_val > 50 and macd_hist > 0: confirmations += 1
-        elif ema_score < 0 and rsi_val < 50 and macd_hist < 0: confirmations -= 1
+        if ema_score > 0 and rsi_val > 50 and macd_hist > 0:
+            confirmations += 1
+        elif ema_score < 0 and rsi_val < 50 and macd_hist < 0:
+            confirmations -= 1
     tf_norm = ((confirmations / max(total_tf, 1)) + 1) / 2
     
     # Meta SOL Score
@@ -343,59 +460,80 @@ def get_sol_signal():
     model_w = base["model"] * (COMPONENT_PERF["model"]["correct"] / max(COMPONENT_PERF["model"]["total"], 1)) * COMPONENT_PERF["model"]["sharpe"]
     tf_w = base["tf"] * (COMPONENT_PERF["tf"]["correct"] / max(COMPONENT_PERF["tf"]["total"], 1)) * COMPONENT_PERF["tf"]["sharpe"]
     remaining = 1.0 - (model_w + tf_w)
-    onchain_w = remaining * 0.6; deriv_w = remaining * 0.4
+    onchain_w = remaining * 0.6
+    deriv_w = remaining * 0.4
     total_w = model_w + tf_w + onchain_w + deriv_w
-    if total_w > 0: model_w /= total_w; tf_w /= total_w; onchain_w /= total_w; deriv_w /= total_w
+    if total_w > 0:
+        model_w /= total_w
+        tf_w /= total_w
+        onchain_w /= total_w
+        deriv_w /= total_w
     
     final_score = xgb_prob * model_w + tf_norm * tf_w + meta_sol_score * onchain_w + deriv_norm * deriv_w
     confidence = smooth_confidence(final_score)
     
-    if confidence > SOL_THRESHOLD + 0.08: direction = "LONG"
-    elif confidence < SOL_THRESHOLD - 0.08: direction = "SHORT"
-    else: direction = "WAIT"
+    # 🔥 BUY/SELL вместо LONG/SHORT
+    if confidence > SOL_THRESHOLD + 0.08:
+        signal = "BUY"
+    elif confidence < SOL_THRESHOLD - 0.08:
+        signal = "SELL"
+    else:
+        signal = "WAIT"
     
-    send_signal_to_hub(direction, confidence)
+    features_out = {
+        "ml_prob": xgb_prob,
+        "tf_norm": tf_norm,
+        "meta_sol_score": meta_sol_score,
+        "regime": regime,
+        "models_used": models_used
+    }
+    send_signal_to_hub(signal, confidence, features_out)
     
-    print(f"🥉 SOL/USD: {direction} | conf={confidence:.3f} | models={models_used} | regime={regime}")
-    return {"direction": direction, "confidence": confidence}
-
-# ================= ОТПРАВКА =================
-def send_signal_to_hub(direction, confidence):
-    try:
-        payload = {"space": "space_19_sol_master", "space_name": "space_19_sol_master", "symbol": SYMBOL, "direction": direction, "confidence": confidence, "features": {}, "metadata": {"version": "10.1"}}
-        r = session.post(f"{HUB_URL}/signals", json=payload, timeout=10, headers=hub_headers())
-        if r.status_code != 200:
-            session.post(f"{HUB_URL}/signal", json={"space": "space_19_sol_master", "symbol": SYMBOL, "direction": direction, "confidence": confidence}, timeout=10, headers=hub_headers())
-        print(f"📤 {SYMBOL}: {direction} conf={confidence:.3f}")
-    except Exception as e: print(f"Ошибка: {e}")
+    logger.info(f"🥉 SOL/USD: {signal} | conf={confidence:.3f} | models={models_used} | regime={regime}")
+    return {"signal": signal, "confidence": confidence}
 
 def auto_report():
-    print(f"⏳ Стартовый сон {STARTUP_SLEEP}с...")
+    logger.info(f"⏳ Стартовый сон {STARTUP_SLEEP}с...")
     time.sleep(STARTUP_SLEEP)
-    print("✅ SOL Master — начинаю авто-отправку!")
+    logger.info("✅ SOL Master — начинаю авто-отправку!")
     while True:
         time.sleep(AUTO_REPORT_INTERVAL)
-        try: get_sol_signal()
-        except Exception as e: print(f"Ошибка: {e}")
+        try:
+            get_sol_signal()
+        except Exception as e:
+            logger.error(f"Ошибка: {e}")
 
 threading.Thread(target=auto_report, daemon=True).start()
 
-app = FastAPI(title="SOL Master v10.1 FIX")
+app = FastAPI(title="SOL Master v10.2")
 
 @app.get("/health")
 async def health():
-    return {"status": "ok", "version": "10.1", "symbol": SYMBOL, "models": sum(1 for m in MODELS.values() if m is not None)}
+    return {
+        "space_id": SPACE_ID,
+        "status": "ok",
+        "version": "10.2",
+        "symbol": SYMBOL,
+        "models": sum(1 for m in MODELS.values() if m is not None)
+    }
+
+@app.head("/health")
+async def health_head():
+    return {}
 
 @app.get("/consilium")
 async def consilium():
     result = get_sol_signal()
-    return {"signal": {"direction": result["direction"], "confidence": result["confidence"]} if result else {"direction": "WAIT", "confidence": 0.0}}
+    if result:
+        return {"signal": result["signal"], "confidence": result["confidence"]}
+    return {"signal": "WAIT", "confidence": 0.0}
 
 @app.get("/")
-async def root(): return {"name": "SOL Master v10.1 FIX"}
+async def root():
+    return {"name": "SOL Master v10.2", "space_id": SPACE_ID, "hub": HUB_URL}
 
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)
 
-print("🚀 SPACE 19 v10.1 — SOL/USD MASTER FIX ЗАПУЩЕН!")
+print("🚀 SPACE 19 v10.2 — SOL/USD MASTER ГОТОВ К РАБОТЕ!")