Update app.py

app.py

@@ -1,5 +1,5 @@
 # ============================================
-# 👑 TOMIRIS SPACE 19 v10.2 — SOL/USD MASTER (FULL FIX)
+# 👑 TOMIRIS SPACE 19 v10.3 — SOL/USD MASTER (LIGHT)
 # ============================================
 import os, time, threading, warnings, json, asyncio
 from typing import Dict, Any, Optional, List, Tuple
@@ -28,7 +28,6 @@ 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", "")
 
 STARTUP_SLEEP = int(os.getenv("STARTUP_SLEEP", "600"))
 AUTO_REPORT_INTERVAL = 600
@@ -40,12 +39,9 @@ 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
+CACHE_TTL = 600  # 🔥 10 минут кэш!
 DATA_CACHE: Dict[str, Dict[str, Any]] = {}
 PREDICTION_HISTORY = deque(maxlen=500)
 LAST_CONFIDENCE = 0.5
@@ -80,7 +76,7 @@ if HAS_JOBLIB:
 
 # ================= HTTP СЕССИЯ =================
 session = requests.Session()
-session.headers.update({"User-Agent": "Tomiris-Space19-v10.2"})
+session.headers.update({"User-Agent": "Tomiris-Space19-v10.3"})
 
 # ================= УТИЛИТЫ =================
 def safe_float(value, default=0.0):
@@ -88,8 +84,7 @@ 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:
@@ -100,24 +95,18 @@ def safe_rsi(close, period=14):
         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
@@ -130,13 +119,11 @@ 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"
 
-# ================= ЗАГРУЗКА ДАННЫХ =================
+# ================= ЗАГРУЗКА ДАННЫХ (ТОЛЬКО ХАБ!) =================
 def fetch_ohlc_hub(symbol, tf, limit=200):
     cache_key = f"hub_{symbol}_{tf}"
     if cache_key in DATA_CACHE and time.time() - DATA_CACHE[cache_key].get("timestamp", 0) < CACHE_TTL:
@@ -146,7 +133,7 @@ def fetch_ohlc_hub(symbol, tf, limit=200):
         r = session.get(
             f"{HUB_URL}/candles",
             params={"symbol": symbol, "interval": tf, "limit": limit},
-            timeout=20,
+            timeout=30,  # 🔥 Увеличен таймаут
             headers=hub_headers()
         )
         if r.status_code == 200:
@@ -161,48 +148,23 @@ def fetch_ohlc_hub(symbol, tf, limit=200):
                 if len(df) >= 30:
                     DATA_CACHE[cache_key] = {"df": df, "timestamp": time.time()}
                     return df
+        else:
+            logger.warning(f"Hub {symbol} {tf}: HTTP {r.status_code}")
     except Exception as e:
         logger.warning(f"Hub {symbol} {tf}: {e}")
     return None
 
-def fetch_twelvedata_sol(tf="1h"):
-    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"]
-    
-    try:
-        url = f"https://api.twelvedata.com/time_series?symbol=SOL/USD&interval={tf}&outputsize=200&apikey={TWELVE_DATA_KEY}"
-        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")
-            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
-    return None
-
 def fetch_ohlc(symbol, tf="1h"):
-    df = fetch_ohlc_hub(symbol, tf)
-    if df is None:
-        logger.info(f"  🔄 Хаб недоступен для {symbol} {tf}, пробую Twelve Data...")
-        df = fetch_twelvedata_sol(tf)
-    return df
+    # 🔥 ТОЛЬКО ХАБ! Без Twelve Data!
+    return fetch_ohlc_hub(symbol, tf)
 
 def fetch_solana_onchain():
-    """🔥 ФИКС: Правильные эндпоинты DefiLlama"""
+    """Ончейн данные Solana"""
     cache_key = "solana_onchain"
-    if cache_key in DATA_CACHE and time.time() - DATA_CACHE[cache_key].get("timestamp", 0) < 300:
+    if cache_key in DATA_CACHE and time.time() - DATA_CACHE[cache_key].get("timestamp", 0) < CACHE_TTL:
         return DATA_CACHE[cache_key]["data"]
     
     result = {}
-    
-    # TVL — правильный эндпоинт
     try:
         r = session.get("https://api.llama.fi/tvl/solana", timeout=10)
         if r.status_code == 200:
@@ -216,35 +178,23 @@ def fetch_solana_onchain():
                     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
+                except: pass
+    except: pass
     
+    result['tvl'] = result.get('tvl', 0)
+    result['tvl_change_24h'] = result.get('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)
-        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
+    except: pass
+    
+    result['dex_volume_24h'] = result.get('dex_volume_24h', 0)
+    result['dex_change_24h'] = result.get('dex_change_24h', 0)
     
     DATA_CACHE[cache_key] = {"data": result, "timestamp": time.time()}
     return result
@@ -260,14 +210,12 @@ 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
+    except: pass
     return result
 
 # ================= ПОСТРОЕНИЕ ПРИЗНАКОВ =================
@@ -308,15 +256,10 @@ 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:
@@ -336,9 +279,8 @@ def build_sol_features(df, onchain_data=None, derivatives=None):
     
     return features
 
-# ================= ОТПРАВКА СИГНАЛА (ИСПРАВЛЕНО) =================
+# ================= ОТПРАВКА СИГНАЛА =================
 def send_signal_to_hub(signal: str, confidence: float, features: Dict = None):
-    """🔥 ИСПРАВЛЕНО: signal вместо direction, space_id вместо space"""
     if features is None:
         features = {}
     
@@ -346,30 +288,30 @@ def send_signal_to_hub(signal: str, confidence: float, features: Dict = None):
         "space_id": SPACE_ID,
         "space_name": SPACE_NAME,
         "symbol": SYMBOL,
-        "signal": signal,           # ✅ BUY/SELL/WAIT
+        "signal": signal,
         "confidence": round(confidence, 4),
         "features": features,
-        "metadata": {"version": "10.2"},
+        "metadata": {"version": "10.3"},
         "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)
+            r = session.post(f"{HUB_URL}/signals", json=payload, timeout=30, 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)
+                wait = 5 * (attempt + 1)
                 logger.warning(f"⏳ 429, жду {wait}с...")
                 time.sleep(wait)
             else:
                 logger.warning(f"Попытка {attempt+1}: HTTP {r.status_code}")
-                time.sleep(2)
+                time.sleep(3)
         except Exception as e:
             logger.warning(f"Попытка {attempt+1}: {e}")
-            time.sleep(2)
+            time.sleep(3)
     
     logger.error("❌ Не удалось отправить сигнал после 3 попыток")
     return False
@@ -419,8 +361,7 @@ def get_sol_signal():
                         proba = MODELS[mk].predict_proba(X)[0]
                     probs.append(float(proba[1] if len(proba) > 1 else proba[0]))
                     models_used += 1
-                except Exception as e:
-                    logger.warning(f"  ⚠️ Ошибка {mk}: {e}")
+                except: pass
         
         if MODELS.get("lgb"):
             try:
@@ -428,12 +369,10 @@ 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:
-        logger.warning(f"  ⚠️ Ошибка предсказания: {e}")
+    except: pass
     
     # Мульти-ТФ
     confirmations, total_tf = 0, 0
@@ -455,24 +394,19 @@ def get_sol_signal():
     
     deriv_norm = 0.7 if binance_data.get("funding_signal") == "BULLISH" else 0.3 if binance_data.get("funding_signal") == "BEARISH" else 0.5
     
-    # Динамические веса
     base = REGIME_WEIGHTS.get(regime, REGIME_WEIGHTS["RANGE"])
-    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"]
+    model_w = base["model"] * (COMPONENT_PERF["model"]["correct"] / max(COMPONENT_PERF["model"]["total"], 1))
+    tf_w = base["tf"] * (COMPONENT_PERF["tf"]["correct"] / max(COMPONENT_PERF["tf"]["total"], 1))
     remaining = 1.0 - (model_w + tf_w)
     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
+        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)
     
-    # 🔥 BUY/SELL вместо LONG/SHORT
     if confidence > SOL_THRESHOLD + 0.08:
         signal = "BUY"
     elif confidence < SOL_THRESHOLD - 0.08:
@@ -480,13 +414,7 @@ def get_sol_signal():
     else:
         signal = "WAIT"
     
-    features_out = {
-        "ml_prob": xgb_prob,
-        "tf_norm": tf_norm,
-        "meta_sol_score": meta_sol_score,
-        "regime": regime,
-        "models_used": models_used
-    }
+    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)
     
     logger.info(f"🥉 SOL/USD: {signal} | conf={confidence:.3f} | models={models_used} | regime={regime}")
@@ -505,17 +433,11 @@ def auto_report():
 
 threading.Thread(target=auto_report, daemon=True).start()
 
-app = FastAPI(title="SOL Master v10.2")
+app = FastAPI(title="SOL Master v10.3 LIGHT")
 
 @app.get("/health")
 async def health():
-    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)
-    }
+    return {"space_id": SPACE_ID, "status": "ok", "version": "10.3", "symbol": SYMBOL, "models": sum(1 for m in MODELS.values() if m is not None)}
 
 @app.head("/health")
 async def health_head():
@@ -530,10 +452,10 @@ async def consilium():
 
 @app.get("/")
 async def root():
-    return {"name": "SOL Master v10.2", "space_id": SPACE_ID, "hub": HUB_URL}
+    return {"name": "SOL Master v10.3 LIGHT", "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.2 — SOL/USD MASTER ГОТОВ К РАБОТЕ!")
+print("🚀 SPACE 19 v10.3 LIGHT — ГОТОВ!")