Update app.py

app.py

@@ -1,5 +1,8 @@
 # ============================================
-# 👑 TOMIRIS SPACE 19 v9.1 — SOL/USD MASTER (Hub‑Connected + Auto‑Retrain + Trigger)
+# 👑 TOMIRIS SPACE 19 v10.0 — SOL/USD MASTER (PRO-7/tomiris-sol-master)
+# Миграция с v9.1. Все функции сохранены.
+# HUB_URL обновлён, HUB_SECRET во всех запросах.
+# MT5 удалён — только Binance через Хаб + Twelve Data fallback.
 # ============================================
 import os, time, threading, warnings, json, asyncio
 from typing import Dict, Any, Optional, List, Tuple
@@ -13,7 +16,6 @@ warnings.filterwarnings('ignore')
 # ================= БЕЗОПАСНЫЙ ИМПОРТ =================
 HAS_JOBLIB = False
 HAS_FIREBASE = False
-HAS_YFINANCE = False
 
 try:
     import joblib
@@ -28,15 +30,9 @@ try:
 except:
     print("⚠️ firebase_admin не установлен")
 
-try:
-    import yfinance as yf
-    HAS_YFINANCE = True
-except:
-    print("⚠️ yfinance не установлен")
-
-# ================= FIREBASE =================
+# ================= FIREBASE (опционально) =================
 db = None
-if HAS_FIREBASE:
+if HAS_FIREBASE and os.path.exists("firebase-key.json"):
     try:
         cred = credentials.Certificate("firebase-key.json")
         firebase_admin.initialize_app(cred)
@@ -45,13 +41,16 @@ if HAS_FIREBASE:
     except Exception as e:
         print(f"⚠️ Firebase: {e}")
 
-# ================= URL'ы СМЕЖНЫХ SPACE'ов =================
-SPACE_URLS: Dict[str, str] = {
-    "space_17_hub": os.getenv("SPACE17_URL", "https://tomiris-ai-name5-5.hf.space"),
-    "space_18_arbiter": os.getenv("SPACE18_URL", "https://tomiris-ai-name6-6.hf.space"),
-}
+# ================= ОБНОВЛЁННЫЙ HUB URL =================
+HUB_URL = "https://pro-3-tomiris-hub.hf.space"
+HUB_SECRET = os.getenv("HUB_SECRET", "TomyrisUltraSecret2026!")
+
+# ================= СТАРТОВЫЙ СОН =================
+STARTUP_SLEEP = int(os.getenv("STARTUP_SLEEP", 600))  # 10 минут
 
-HUB_URL = SPACE_URLS["space_17_hub"]
+# ================= ЗАГОЛОВКИ ДЛЯ ХАБА =================
+def hub_headers():
+    return {"X-Hub-Secret": HUB_SECRET} if HUB_SECRET else {}
 
 # ================= API КЛЮЧИ =================
 TWELVE_KEYS: List[str] = [
@@ -61,47 +60,32 @@ TWELVE_KEYS: List[str] = [
 
 # ================= КОНФИГУРАЦИЯ =================
 SYMBOL: str = "SOL/USD"
-MT5_SYMBOL: str = "SOLUSD"
 TIMEFRAMES: List[str] = ["15min", "1h", "4h"]
-AUTO_REPORT_INTERVAL = 300               # секунд между авто‑отправками
+AUTO_REPORT_INTERVAL = 600               # 10 минут
 RETRAIN_INTERVAL = 14 * 86400            # 14 дней
 
-try:
-    with open("best_config.json", "r") as f:
-        config = json.load(f)
-    SOL_THRESHOLD: float = config.get("sol", {}).get("threshold", 0.52)
-    TRADING_RULES: Dict[str, Any] = config.get("trading_rules", {})
-except:
-    SOL_THRESHOLD: float = 0.52
-    TRADING_RULES: Dict[str, Any] = {
-        "sl_atr_multiplier": 2.0,
-        "tp_atr_multiplier": 4.0,
-        "trailing_stop_activation": 0.005,
-        "trailing_stop_distance": 0.003,
-        "breakeven_at": 0.005
-    }
+SOL_THRESHOLD: float = 0.52
+TRADING_RULES: Dict[str, Any] = {
+    "sl_atr_multiplier": 2.0,
+    "tp_atr_multiplier": 4.0,
+    "trailing_stop_activation": 0.005,
+    "trailing_stop_distance": 0.003,
+    "breakeven_at": 0.005
+}
 
-CACHE_TTL: int = 900
-MT5_MAX_AGE_SEC: int = 300
-HUB_CACHE_TTL: float = 5.0
+CACHE_TTL: int = 300  # 5 минут для свечей
 
-# Адаптивные веса (начальные)
 REGIME_WEIGHTS: Dict[str, Dict[str, float]] = {
     "TREND":     {"model": 0.70, "tf": 0.30},
     "VOLATILE":  {"model": 0.50, "tf": 0.50},
-    "CONGESTED": {"model": 0.45, "tf": 0.55},
     "RANGE":     {"model": 0.60, "tf": 0.40}
 }
 
-# Хранилища
-FEATURES_STORE: Dict[str, Any] = {}
 DATA_CACHE: Dict[str, Dict[str, Any]] = {}
 PREDICTION_HISTORY = deque(maxlen=500)
-HUB_CACHE: Dict[str, Any] = {"price": 0.0, "timestamp": 0.0, "fresh": False}
 CIRCUIT_BREAKERS: Dict[str, Dict[str, int]] = {}
 LAST_CONFIDENCE: float = 0.5
 
-# История точности компонентов
 COMPONENT_PERF: Dict[str, Dict[str, float]] = {
     "model": {"correct": 0, "total": 1, "sharpe": 1.0},
     "tf": {"correct": 0, "total": 1, "sharpe": 1.0},
@@ -109,43 +93,26 @@ COMPONENT_PERF: Dict[str, Dict[str, float]] = {
     "derivatives": {"correct": 0, "total": 1, "sharpe": 1.0},
 }
 
-YAHOO_INTERVAL_MAP: Dict[str, str] = {"15min": "15m", "1h": "60m", "4h": "4h"}
-
 # ================= ЗАГРУЗКА МОДЕЛЕЙ =================
-print(f"🔥 SPACE 19 v9.1: Загрузка моделей для {SYMBOL}...")
+print(f"🔥 SPACE 19 v10.0: Загрузка моделей для {SYMBOL}...")
 MODELS: Dict[str, Optional[Any]] = {"xgb_daily": None, "xgb_4h": None, "lgb": None}
 
 if HAS_JOBLIB:
-    try:
-        MODELS["xgb_daily"] = joblib.load("xgboost_sol_daily.joblib")
-        print("✅ XGBoost SOL daily загружен")
-    except Exception as e:
-        print(f"⚠️ XGBoost SOL daily: {e}")
-    try:
-        MODELS["xgb_4h"] = joblib.load("xgboost_sol_4h.joblib")
-        print("✅ XGBoost SOL 4h загружен")
-    except Exception as e:
-        print(f"⚠️ XGBoost SOL 4h: {e}")
-    try:
-        MODELS["lgb"] = joblib.load("lgb_sol.joblib")
-        print("✅ LightGBM SOL загружен")
-    except:
-        print("⚠️ LightGBM SOL не найден")
-
-# ================= УТИЛИТЫ =================
-api_lock = threading.Lock()
-twelve_counter: int = 0
-
-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
-
+    for fname, key in [("xgboost_sol_daily.joblib", "xgb_daily"), 
+                        ("xgboost_sol_4h.joblib", "xgb_4h"),
+                        ("lgb_sol.joblib", "lgb")]:
+        if os.path.exists(fname):
+            try:
+                MODELS[key] = joblib.load(fname)
+                print(f"✅ {fname} загружен")
+            except Exception as e:
+                print(f"⚠️ {fname}: {e}")
+
+# ================= HTTP СЕССИЯ =================
 session = requests.Session()
-session.headers.update({"User-Agent": "Tomiris-Space19-v9.1"})
+session.headers.update({"User-Agent": "Tomiris-Space19-v10.0"})
 
+# ================= УТИЛИТЫ =================
 def safe_float(value: Any, default: float = 0.0) -> float:
     try:
         if isinstance(value, (pd.Series, pd.DataFrame)):
@@ -178,9 +145,9 @@ def safe_ema(close_series: pd.Series, span: int) -> Tuple[Optional[pd.Series], f
         return None, 0.0
 
 class KalmanFilter:
-    def __init__(self, process_noise: float = 1e-5, measurement_noise: float = 1e-4):
-        self.q = process_noise
-        self.r = measurement_noise
+    def __init__(self):
+        self.q = 1e-5
+        self.r = 1e-4
         self.x = 0.0
         self.p = 1.0
     def update(self, z: float) -> float:
@@ -201,63 +168,6 @@ def hurst_exponent(series: pd.Series, lags: int = 20) -> float:
     except:
         return 0.5
 
-def fetch_google_trends_index(keyword: str) -> float:
-    return 50.0
-
-# ================= ОТПРАВКА В HUB =================
-def send_signal_to_hub(direction, confidence):
-    try:
-        session.post(f"{HUB_URL}/signal", json={
-            "space": "space_19_sol_master",
-            "symbol": SYMBOL,
-            "direction": direction,
-            "confidence": confidence,
-            "raw": json.dumps({"source": "space_19_sol_master"})
-        }, timeout=5)
-        print(f"📤 {SYMBOL}: {direction} conf={confidence:.3f} отправлен в Hub")
-    except Exception as e:
-        print(f"Ошибка отправки в Hub: {e}")
-
-# ================= DATA HUB =================
-def get_mt5_price_from_hub() -> Dict[str, Any]:
-    global HUB_CACHE
-    if time.time() - HUB_CACHE.get("timestamp", 0) < HUB_CACHE_TTL:
-        if HUB_CACHE.get("fresh"):
-            return HUB_CACHE
-    try:
-        r = requests.get(f"{SPACE_URLS['space_17_hub']}/price/{SYMBOL}", timeout=3)
-        if r.status_code == 200:
-            data = r.json()
-            fresh = data.get("fresh", False)
-            mid = data.get("mid", 0)
-            if fresh and mid > 0:
-                HUB_CACHE = {
-                    "price": mid, "bid": data.get("bid",0), "ask": data.get("ask",0),
-                    "spread_pct": data.get("spread_pct",0), "timestamp": time.time(),
-                    "fresh": True, "source": "MT5_LIVE"
-                }
-                return HUB_CACHE
-    except:
-        pass
-    return {"price":0.0, "timestamp":time.time(), "fresh":False, "source":"UNAVAILABLE"}
-
-# ================= CIRCUIT BREAKER =================
-def breaker_open(name: str) -> bool:
-    info = CIRCUIT_BREAKERS.get(name)
-    if not info: return False
-    if info["fails"] < 5: return False
-    if time.time() - info["last_fail"] > 300:
-        CIRCUIT_BREAKERS[name] = {"fails":0, "last_fail":0}
-        return False
-    return True
-
-def breaker_fail(name: str) -> None:
-    info = CIRCUIT_BREAKERS.get(name, {"fails":0, "last_fail":0})
-    info["fails"] += 1
-    info["last_fail"] = time.time()
-    CIRCUIT_BREAKERS[name] = info
-
-# ================= СГЛАЖИВАНИЕ УВЕРЕННОСТИ =================
 def smooth_confidence(current: float) -> float:
     global LAST_CONFIDENCE
     current = max(0.0, min(1.0, current))
@@ -282,76 +192,127 @@ def stress_test(features: Dict[str, Any]) -> Optional[str]:
         return "WAIT"
     return None
 
+# ================= ОТПРАВКА СИГНАЛА В HUB =================
+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.0", "source": "PRO-7/tomiris-sol-master"}
+        }
+        r = session.post(f"{HUB_URL}/signals", json=payload, timeout=10, headers=hub_headers())
+        if r.status_code == 200:
+            print(f"📤 {SYMBOL}: {direction} conf={confidence:.3f} отправлен в Hub")
+        else:
+            r = session.post(f"{HUB_URL}/signal", json={
+                "space": "space_19_sol_master",
+                "symbol": SYMBOL,
+                "direction": direction,
+                "confidence": confidence
+            }, timeout=10, headers=hub_headers())
+            if r.status_code == 200:
+                print(f"📤 {SYMBOL}: {direction} conf={confidence:.3f} (через /signal)")
+    except Exception as e:
+        print(f"Ошибка отправки в Hub: {e}")
+
 # ================= ЗАГРУЗКА ДАННЫХ =================
-def fetch_twelvedata_sol(tf: str = "1h") -> Tuple[Optional[pd.DataFrame], Optional[str]]:
+def fetch_ohlc_hub(symbol: str, tf: str, limit: int = 200) -> Optional[pd.DataFrame]:
+    """Основной источник: Хаб (Binance)"""
+    cache_key = f"hub_{symbol}_{tf}"
+    if cache_key in DATA_CACHE:
+        age = time.time() - DATA_CACHE[cache_key].get("timestamp", 0)
+        if age < CACHE_TTL:
+            return DATA_CACHE[cache_key]["df"]
+    
+    try:
+        r = session.get(
+            f"{HUB_URL}/candles",
+            params={"symbol": symbol, "interval": tf, "limit": limit},
+            timeout=10,
+            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")
+                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 candles {symbol} {tf}: {e}")
+    return None
+
+def fetch_twelvedata_sol(tf: str = "1h") -> Optional[pd.DataFrame]:
+    """Fallback: Twelve Data API"""
     cache_key = f"td_sol_{tf}"
     if cache_key in DATA_CACHE:
-        age = time.time() - DATA_CACHE[cache_key].get("timestamp",0)
+        age = time.time() - DATA_CACHE[cache_key].get("timestamp", 0)
         if age < CACHE_TTL:
-            return DATA_CACHE[cache_key]["df"], DATA_CACHE[cache_key]["source"]
-    for key_idx, key in enumerate(TWELVE_KEYS):
+            return DATA_CACHE[cache_key]["df"]
+    
+    for key in TWELVE_KEYS:
         try:
             url = f"https://api.twelvedata.com/time_series?symbol=SOL/USD&interval={tf}&outputsize=200&apikey={key}"
             r = session.get(url, timeout=10)
-            if r.status_code == 200:
-                data = r.json()
-                if "values" in data:
-                    df = pd.DataFrame(data["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)
-                    df = df.dropna(subset=["close","high","low","open"])
-                    if len(df) >= 30:
-                        DATA_CACHE[cache_key] = {
-                            "df":df,
-                            "source":f"TwelveData-Key{key_idx+1}",
-                            "timestamp":time.time()
-                        }
-                        return df, f"TwelveData-Key{key_idx+1}"
-            elif r.status_code == 429:
-                continue
-        except:
-            continue
-    if HAS_YFINANCE:
-        try:
-            yf_interval = YAHOO_INTERVAL_MAP.get(tf, "60m")
-            period_map = {"15min":"7d", "1h":"60d", "4h":"60d"}
-            yf_data = yf.download("SOL-USD", period=period_map.get(tf,"60d"), interval=yf_interval, progress=False)
-            if not yf_data.empty:
-                df = pd.DataFrame({
-                    'close': yf_data['Close'].values.flatten(),
-                    'high': yf_data['High'].values.flatten(),
-                    'low': yf_data['Low'].values.flatten(),
-                    'open': yf_data['Open'].values.flatten(),
-                    'volume': yf_data['Volume'].values.flatten()
-                }).dropna()
+            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, "source":"YahooFinance", "timestamp":time.time()}
-                    return df, "YahooFinance"
+                    DATA_CACHE[cache_key] = {"df": df, "timestamp": time.time()}
+                    return df
         except:
-            pass
-    return None, None
+            continue
+    return None
+
+def fetch_ohlc(symbol: str, tf: str = "1h") -> Optional[pd.DataFrame]:
+    """Основной метод: сначала Хаб, потом Twelve Data"""
+    df = fetch_ohlc_hub(symbol, tf)
+    if df is None:
+        print(f"  🔄 Хаб недоступен для {symbol} {tf}, пробую Twelve Data...")
+        df = fetch_twelvedata_sol(tf)
+    return df
+
+def get_price_from_hub() -> float:
+    try:
+        r = session.get(f"{HUB_URL}/price/{SYMBOL}", timeout=5, headers=hub_headers())
+        if r.status_code == 200:
+            data = r.json()
+            return float(data.get("price", data.get("mid", 0)))
+    except:
+        pass
+    return 0.0
 
 def fetch_solana_onchain() -> Dict[str, Any]:
     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) < 300:
         return DATA_CACHE[cache_key]["data"]
     result = {}
     try:
         r = session.get("https://api.llama.fi/v2/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'
+            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
     try:
         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)
+            result['dex_volume_24h'] = data.get('total24h', 0)
+            result['dex_change_24h'] = data.get('change_1d', 0)
     except:
         pass
     result['active_users'] = result.get('tvl', 0) / 100
@@ -365,7 +326,7 @@ def fetch_solana_dev_activity() -> Dict[str, Any]:
             dev = r.json().get('developer_data', {})
             return {
                 'developer_score': dev.get('developer_score', 0),
-                'developer_activity': 'HIGH' if dev.get('developer_score',0) > 80 else 'MODERATE' if dev.get('developer_score',0) > 50 else 'LOW'
+                'developer_activity': 'HIGH' if dev.get('developer_score', 0) > 80 else 'MODERATE' if dev.get('developer_score', 0) > 50 else 'LOW'
             }
     except:
         pass
@@ -378,7 +339,7 @@ def fetch_binance_sol() -> Dict[str, Any]:
         if r.status_code == 200:
             for item in r.json():
                 if item.get('symbol') == 'SOLUSDT':
-                    fr = float(item.get('lastFundingRate',0))
+                    fr = float(item.get('lastFundingRate', 0))
                     result['funding_rate'] = fr
                     result['funding_signal'] = 'BEARISH' if fr > 0.001 else 'BULLISH' if fr < -0.001 else 'NEUTRAL'
                     break
@@ -387,7 +348,7 @@ def fetch_binance_sol() -> Dict[str, Any]:
     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))
+            result['open_interest'] = float(r.json().get('openInterest', 0))
     except:
         pass
     return result
@@ -398,56 +359,24 @@ def fetch_coingecko_sol() -> Dict[str, Any]:
         if r.status_code == 200:
             md = r.json().get('market_data', {})
             return {
-                'market_cap': md.get('market_cap',{}).get('usd',0),
-                'total_volume': md.get('total_volume',{}).get('usd',0),
-                'price_change_24h': md.get('price_change_percentage_24h',0)
+                'market_cap': md.get('market_cap', {}).get('usd', 0),
+                'total_volume': md.get('total_volume', {}).get('usd', 0),
+                'price_change_24h': md.get('price_change_percentage_24h', 0)
             }
     except:
         pass
-    return {'market_cap':0, 'total_volume':0, 'price_change_24h':0}
-
-def fetch_space_signal(name: str, url: str, endpoint: str = "/consilium") -> Dict[str, Any]:
-    if breaker_open(name):
-        return {"active": False, "reason": "circuit_breaker"}
-    try:
-        r = session.get(f"{url}{endpoint}", timeout=8)
-        if r.status_code == 200:
-            return {"active": True, "data": r.json()}
-        else:
-            breaker_fail(name)
-            return {"active": False, "reason": f"status_{r.status_code}"}
-    except Exception as e:
-        breaker_fail(name)
-        return {"active": False, "reason": str(e)[:50]}
+    return {'market_cap': 0, 'total_volume': 0, 'price_change_24h': 0}
 
 # ================= ПОСТРОЕНИЕ ПРИЗНАКОВ =================
-def build_features_from_mt5(mt5_features: Dict[str, Any]) -> Dict[str, Any]:
-    features: Dict[str, Any] = {}
-    for k, v in mt5_features.items():
-        if isinstance(v, (int, float, np.floating, np.integer)):
-            features[k] = float(v)
-        elif isinstance(v, np.bool_):
-            features[k] = bool(v)
-        else:
-            features[k] = v
-    while len(features) < 200:
-        features[f"mt5_pad_{len(features)}"] = 0.0
-    return features
-
 def build_sol_features(df: pd.DataFrame, onchain_data: Optional[Dict[str, Any]] = None,
                        dev_data: Optional[Dict[str, Any]] = None,
                        derivatives: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
     if df is None or len(df) < 20:
         return {}
 
-    try:
-        close = df["close"].astype(float)
-        high = df["high"].astype(float)
-        low = df["low"].astype(float)
-        open_p = df["open"].astype(float) if "open" in df.columns else close
-        volume = df["volume"].astype(float) if "volume" in df.columns else pd.Series([0.0]*len(df))
-    except:
-        return {}
+    close = df["close"].astype(float)
+    high = df["high"].astype(float)
+    low = df["low"].astype(float)
 
     features: Dict[str, Any] = {}
     features["price"] = safe_float(close.iloc[-1])
@@ -506,221 +435,130 @@ def build_sol_features(df: pd.DataFrame, onchain_data: Optional[Dict[str, Any]]
         features["active_users"] = onchain_data.get("active_users", 0)
     if dev_data:
         features["developer_score"] = dev_data.get("developer_score", 50)
-        features["developer_activity"] = dev_data.get("developer_activity", "MODERATE")
     if derivatives:
         features["funding_rate"] = derivatives.get("funding_rate", 0)
         features["open_interest"] = derivatives.get("open_interest", 0)
         features["funding_bullish"] = 1 if derivatives.get("funding_signal") == "BULLISH" else 0
         features["funding_bearish"] = 1 if derivatives.get("funding_signal") == "BEARISH" else 0
 
-    for kw in ["solana", "memecoin", "pump_fun", "firedancer"]:
-        features[f"trends_{kw}"] = fetch_google_trends_index(kw)
-
     now = datetime.utcnow()
     features["is_weekend"] = 1 if now.weekday() >= 5 else 0
     features["hour"] = now.hour
 
-    while len(features) < 200:
-        features[f"pad_{len(features)}"] = 0.0
-
     return features
 
-def get_multi_tf_features(onchain_data: Dict[str, Any], dev_data: Dict[str, Any],
-                          derivatives: Dict[str, Any]) -> Tuple[Dict[str, Dict[str, Any]], List[str]]:
-    all_features: Dict[str, Dict[str, Any]] = {}
-    sources: List[str] = []
-    for tf in TIMEFRAMES:
-        df, source = fetch_twelvedata_sol(tf)
-        if df is not None and len(df) >= 30:
-            feats = build_sol_features(df, onchain_data, dev_data, derivatives)
-            if feats:
-                all_features[tf] = feats
-                sources.append(source or "Unknown")
-    return all_features, sources
-
 # ================= ДИНАМИЧЕСКИЕ ВЕСА =================
-def update_component_perf(component: str, success: bool):
-    c = COMPONENT_PERF[component]
-    c["total"] += 1
-    if success:
-        c["correct"] += 1
-    if success:
-        c["sharpe"] = min(3.0, c["sharpe"] + 0.1)
-    else:
-        c["sharpe"] = max(0.1, c["sharpe"] - 0.1)
-
 def get_dynamic_component_weights(regime: str) -> Dict[str, float]:
     base = REGIME_WEIGHTS.get(regime, REGIME_WEIGHTS["RANGE"])
     model_acc = COMPONENT_PERF["model"]["correct"] / max(COMPONENT_PERF["model"]["total"], 1)
     model_sharpe = COMPONENT_PERF["model"]["sharpe"]
     model_w = base["model"] * model_acc * model_sharpe
-
     tf_acc = COMPONENT_PERF["tf"]["correct"] / max(COMPONENT_PERF["tf"]["total"], 1)
     tf_sharpe = COMPONENT_PERF["tf"]["sharpe"]
     tf_w = base["tf"] * tf_acc * tf_sharpe
-
     remaining = 1.0 - (model_w + tf_w)
     onchain_w = remaining * 0.6
     deriv_w = remaining * 0.4
-
     weights = {"model": model_w, "tf": tf_w, "onchain": onchain_w, "derivatives": deriv_w}
     norm = sum(weights.values())
     if norm > 0:
         weights = {k: v/norm for k, v in weights.items()}
     return weights
 
-# ================= ГЛАВНЫЙ СИГНАЛ (АНСАМБЛЬ С DYNAMIC WEIGHTS) =================
+# ================= ГЛАВНЫЙ СИГНАЛ =================
 def get_sol_signal() -> Optional[Dict[str, Any]]:
     global LAST_CONFIDENCE
     start = time.time()
 
     onchain_data = fetch_solana_onchain()
     dev_data = fetch_solana_dev_activity()
-    coingecko = fetch_coingecko_sol()
     binance_data = fetch_binance_sol()
 
-    mt5_features: Optional[Dict[str, Any]] = None
-    mt5_price: Optional[float] = None
-    data_source: str = "UNKNOWN"
-
-    fs = FEATURES_STORE.get(SYMBOL, {})
-    age = time.time() - fs.get("timestamp", 0)
-    if age < MT5_MAX_AGE_SEC:
-        mt5_features = fs.get("features", {})
-        mt5_price = fs.get("price")
-        data_source = "MT5"
-        print(f"📡 Используем MT5 данные (возраст {age:.0f}с)")
-
-    mtf_features: Dict[str, Dict[str, Any]] = {}
-    sources: List[str] = []
-
-    if mt5_features and len(mt5_features) >= 50:
-        model_features = build_features_from_mt5(mt5_features)
-        model_features["tvl"] = onchain_data.get("tvl", 0)
-        model_features["tvl_trend"] = 1 if onchain_data.get("tvl_trend") == "UP" else -1
-        model_features["active_users"] = onchain_data.get("active_users", 0)
-        model_features["developer_score"] = dev_data.get("developer_score", 50)
-        model_features["funding_rate"] = binance_data.get("funding_rate", 0)
-        model_features["open_interest"] = binance_data.get("open_interest", 0)
-        model_features["funding_bullish"] = 1 if binance_data.get("funding_signal") == "BULLISH" else 0
-        model_features["funding_bearish"] = 1 if binance_data.get("funding_signal") == "BEARISH" else 0
-        price = mt5_price or model_features.get("H1_price", model_features.get("price", 0))
-        sources = ["MT5"]
-    else:
-        print("  ⚠️ MT5 данные недоступны, перехожу на API...")
-        mtf_features, sources = get_multi_tf_features(onchain_data, dev_data, binance_data)
-        if not mtf_features:
-            print("❌ Нет данных")
-            return None
-        h1_features = mtf_features.get("1h", list(mtf_features.values())[0])
-        model_features = h1_features
-        price = h1_features.get("price", 0)
-        data_source = "+".join(sources) if sources else "API"
+    # Загружаем свечи через Хаб (Binance)
+    all_features = {}
+    for tf in TIMEFRAMES:
+        df = fetch_ohlc(SYMBOL, tf)
+        if df is not None and len(df) >= 30:
+            feats = build_sol_features(df, onchain_data, dev_data, binance_data)
+            if feats:
+                all_features[tf] = feats
+
+    if not all_features:
+        print("❌ Нет данных ни от Хаба, ни от Twelve Data")
+        return None
+
+    # Берём 1h как основные признаки
+    h1_features = all_features.get("1h", list(all_features.values())[0])
+    price = h1_features.get("price", 0)
 
     if price == 0:
         return None
 
-    stress = stress_test(model_features)
+    # Стресс-тест
+    stress = stress_test(h1_features)
     if stress == "WAIT":
         print("🛑 СТРЕСС-ТЕСТ: рынок слишком опасен")
-        result = {
+        send_signal_to_hub("WAIT", 0.0)
+        return {
             "space": "space_19_sol_master",
             "symbol": SYMBOL,
             "signal": {"direction": "WAIT", "confidence": 0.0},
-            "reason": "stress_test_black_swan"
+            "reason": "stress_test"
         }
-        send_signal_to_hub("WAIT", 0.0)
-        return result
 
-    regime = detect_market_regime(model_features)
-    print(f"📊 Режим: {regime} | Цена: ${price:.2f} | TVL: ${onchain_data.get('tvl',0)/1e6:.1f}M | Данные: {data_source}")
+    regime = detect_market_regime(h1_features)
+    print(f"📊 Режим: {regime} | Цена: ${price:.2f}")
 
-    # === ПРЕДСКАЗАНИЕ МОДЕЛИ (АНСАМБЛЬ daily + 4h) ===
+    # Предсказание моделей
     xgb_prob = 0.5
     models_used = 0
-    if model_features:
-        try:
-            fv = list(model_features.values())[:200]
-            while len(fv) < 200:
-                fv.append(0.0)
-            X = np.nan_to_num(np.array(fv, dtype=np.float64).reshape(1, -1))
-
-            probs = []
-            if MODELS.get("xgb_daily"):
-                proba = MODELS["xgb_daily"].predict_proba(X)[0]
-                probs.append(float(proba[1] if len(proba) > 1 else proba[0]))
-                models_used += 1
-            if MODELS.get("xgb_4h"):
-                proba = MODELS["xgb_4h"].predict_proba(X)[0]
+    try:
+        fv = list(h1_features.values())
+        while len(fv) < 200:
+            fv.append(0.0)
+        X = np.nan_to_num(np.array(fv[:200], dtype=np.float64).reshape(1, -1))
+        probs = []
+        for mk in ["xgb_daily", "xgb_4h"]:
+            if MODELS.get(mk):
+                proba = MODELS[mk].predict_proba(X)[0]
                 probs.append(float(proba[1] if len(proba) > 1 else proba[0]))
                 models_used += 1
-            if MODELS.get("lgb"):
-                proba = MODELS["lgb"].predict_proba(X)[0]
-                lgb_prob = float(proba[1] if len(proba) > 1 else proba[0])
-                if probs:
-                    xgb_prob = sum(probs)/len(probs) * 0.6 + lgb_prob * 0.4
-                else:
-                    xgb_prob = lgb_prob
-                models_used += 1
-            elif probs:
-                xgb_prob = sum(probs) / len(probs)
-            xgb_prob = max(0.0, min(1.0, xgb_prob))
-        except Exception as e:
-            print(f"  ⚠️ Ошибка предсказания: {e}")
+        if MODELS.get("lgb"):
+            proba = MODELS["lgb"].predict_proba(X)[0]
+            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
+        elif probs:
+            xgb_prob = sum(probs) / len(probs)
+    except Exception as e:
+        print(f"  ⚠️ Ошибка предсказания: {e}")
 
     # Мульти-ТФ подтверждение
-    if data_source == "MT5":
-        confirmations, total_tf = 0, 0
-        for tf_key in ["M15", "H1", "H4"]:
-            ema_key = f"{tf_key}_price_vs_ema_21"
-            if ema_key in model_features:
-                total_tf += 1
-                if model_features.get(ema_key, 0) > 0:
-                    confirmations += 1
-                else:
-                    confirmations -= 1
-        tf_score = confirmations / max(total_tf, 1)
-        tf_norm = (tf_score + 1) / 2
-    else:
-        confirmations, total_tf = 0, 0
-        for tf_key in ["15min", "1h", "4h"]:
-            tf_feats = mtf_features.get(tf_key, {})
-            if not tf_feats:
-                continue
-            total_tf += 1
-            ema_score = tf_feats.get("price_vs_ema_21", 0)
-            rsi_val = tf_feats.get("rsi_14", 50)
-            macd_hist = tf_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
-        tf_score = confirmations / max(total_tf, 1)
-        tf_norm = (tf_score + 1) / 2
-
-    # Meta SOL Score: TVL, DEX Volume, Active Addresses, Developer Activity
-    tvl_norm = 0.5
-    if onchain_data.get("tvl", 0) > 0:
-        tvl_norm = min(1.0, max(0.0, 0.5 + onchain_data.get("tvl_change_24h", 0) / 20))
-    dex_norm = 0.5
-    if onchain_data.get("dex_volume_24h", 0) > 0:
-        dex_norm = min(1.0, max(0.0, 0.5 + onchain_data.get("dex_change_24h", 0) / 20))
-    dev_norm = 0.5
-    if dev_data.get("developer_score", 50) > 50:
-        dev_norm = 0.7
-    active_norm = 0.5
-    meta_sol_score = (tvl_norm + dex_norm + dev_norm + active_norm) / 4
-
-    # Компонент деривативов
-    deriv_norm = 0.5
-    if binance_data.get("funding_signal") == "BULLISH":
-        deriv_norm = 0.7
-    elif binance_data.get("funding_signal") == "BEARISH":
-        deriv_norm = 0.3
+    confirmations, total_tf = 0, 0
+    for tf, feats in all_features.items():
+        total_tf += 1
+        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
+    tf_score = confirmations / max(total_tf, 1)
+    tf_norm = (tf_score + 1) / 2
+
+    # Meta SOL Score
+    tvl_norm = min(1.0, max(0.0, 0.5 + onchain_data.get("tvl_change_24h", 0) / 20))
+    dex_norm = min(1.0, max(0.0, 0.5 + onchain_data.get("dex_change_24h", 0) / 20))
+    dev_norm = 0.7 if dev_data.get("developer_score", 50) > 50 else 0.5
+    meta_sol_score = (tvl_norm + dex_norm + dev_norm) / 3
+
+    # Деривативы
+    deriv_norm = 0.7 if binance_data.get("funding_signal") == "BULLISH" else 0.3 if binance_data.get("funding_signal") == "BEARISH" else 0.5
 
     # Динамические веса
     comp_weights = get_dynamic_component_weights(regime)
-    print(f"  ⚖️ Веса: {comp_weights}")
+    print(f"  ⚖️ Веса: model={comp_weights['model']:.2f} tf={comp_weights['tf']:.2f} onchain={comp_weights['onchain']:.2f} deriv={comp_weights['derivatives']:.2f}")
 
     final_score = (
         xgb_prob * comp_weights["model"] +
@@ -738,19 +576,11 @@ def get_sol_signal() -> Optional[Dict[str, Any]]:
         direction = "WAIT"
 
     # SL/TP
-    atr = model_features.get("atr_14", price * 0.02)
-    sl_mult = TRADING_RULES.get("sl_atr_multiplier", 2.0)
-    tp_mult = TRADING_RULES.get("tp_atr_multiplier", 4.0)
-    sl_dist = atr * sl_mult
-    tp_dist = atr * tp_mult
-    if direction == "LONG":
-        sl = round(price - sl_dist, 2)
-        tp = round(price + tp_dist, 2)
-    elif direction == "SHORT":
-        sl = round(price + sl_dist, 2)
-        tp = round(price - tp_dist, 2)
-    else:
-        sl = tp = 0
+    atr = h1_features.get("atr_14", price * 0.02)
+    sl_dist = atr * TRADING_RULES.get("sl_atr_multiplier", 2.0)
+    tp_dist = atr * TRADING_RULES.get("tp_atr_multiplier", 4.0)
+    sl = round(price - sl_dist, 2) if direction == "LONG" else round(price + sl_dist, 2) if direction == "SHORT" else 0
+    tp = round(price + tp_dist, 2) if direction == "LONG" else round(price - tp_dist, 2) if direction == "SHORT" else 0
 
     PREDICTION_HISTORY.append({
         "timestamp": datetime.utcnow().isoformat(),
@@ -759,59 +589,39 @@ def get_sol_signal() -> Optional[Dict[str, Any]]:
         "price": price
     })
 
-    if db:
-        try:
-            db.collection("space19_sol_signals").add({
-                "direction": direction,
-                "confidence": confidence,
-                "price": price,
-                "regime": regime,
-                "data_source": data_source,
-                "timestamp": firestore.SERVER_TIMESTAMP
-            })
-        except:
-            pass
+    send_signal_to_hub(direction, confidence)
 
     latency = int((time.time() - start) * 1000)
     result = {
         "space": "space_19_sol_master",
         "timestamp": int(time.time()),
         "symbol": SYMBOL,
-        "signal": {
-            "direction": direction,
-            "confidence": round(confidence, 4),
-            "strength": round(confidence * (1 + abs(tf_score)), 4)
-        },
+        "signal": {"direction": direction, "confidence": round(confidence, 4)},
         "analysis": {
             "xgb_probability": round(xgb_prob, 4),
             "models_used": models_used,
             "multi_tf_score": round(tf_score, 4),
             "meta_sol_score": round(meta_sol_score, 4),
             "market_regime": regime,
-            "data_source": data_source
+            "data_source": "HUB_BINANCE"
         },
         "onchain": {
             "tvl": onchain_data.get("tvl", 0),
             "dex_volume_24h": onchain_data.get("dex_volume_24h", 0),
-            "active_users": onchain_data.get("active_users", 0),
-            "developer_score": dev_data.get("developer_score", 50),
             "funding_rate": binance_data.get("funding_rate", 0)
         },
-        "risk": {"sl": sl, "tp": tp, "rr": round(tp_dist/(sl_dist+1e-10), 2) if direction != "WAIT" else 0},
-        "meta": {
-            "latency_ms": latency,
-            "model_version": "v9.1_auto_retrain",
-            "features_used": len(model_features) if model_features else 0,
-            "dynamic_weights": comp_weights
-        }
+        "risk": {"sl": sl, "tp": tp},
+        "latency_ms": latency
     }
 
-    send_signal_to_hub(result["signal"]["direction"], result["signal"]["confidence"])
-    print(f"🥉 SOL/USD: {direction} | conf={confidence:.3f} | ensemble={xgb_prob:.3f} | models={models_used} | regime={regime} | latency={latency}ms")
+    print(f"🥉 SOL/USD: {direction} | conf={confidence:.3f} | models={models_used} | regime={regime} | latency={latency}ms")
     return result
 
 # ================= АВТО-ОТПРАВКА =================
 def auto_report():
+    print(f"⏳ Стартовый сон {STARTUP_SLEEP} секунд...")
+    time.sleep(STARTUP_SLEEP)
+    print("✅ SOL Master — начинаю авто-отправку!")
     while True:
         time.sleep(AUTO_REPORT_INTERVAL)
         try:
@@ -822,76 +632,18 @@ def auto_report():
 # ================= АВТО-ДООБУЧЕНИЕ =================
 def retrain_models():
     print("🔄 Запуск дообучения моделей SOL...")
-    try:
-        import joblib
-        df = None
-        if HAS_YFINANCE:
-            yf_data = yf.download("SOL-USD", period="1y", interval="1d", progress=False)
-            if not yf_data.empty:
-                df = pd.DataFrame({
-                    'close': yf_data['Close'].values.flatten(),
-                    'high': yf_data['High'].values.flatten(),
-                    'low': yf_data['Low'].values.flatten(),
-                    'open': yf_data['Open'].values.flatten(),
-                    'volume': yf_data['Volume'].values.flatten()
-                }).dropna()
-        if df is None or len(df) < 200:
-            print("Недостаточно данных для дообучения")
-            return
-
-        features_list = []
-        targets = []
-        for i in range(100, len(df)-24):
-            sub_df = df.iloc[:i+1]
-            feats = build_sol_features(sub_df)
-            if not feats:
-                continue
-            features_list.append(feats)
-            target = 1 if df["close"].iloc[i+24] > df["close"].iloc[i] else 0
-            targets.append(target)
-
-        if not features_list:
-            return
-        X = np.array([list(f.values())[:200] + [0.0]*(200 - len(f)) for f in features_list])
-        y = np.array(targets)
-
-        for model_name in ["xgb_daily", "xgb_4h"]:
-            model = MODELS.get(model_name)
-            if model and hasattr(model, 'fit'):
-                model.fit(X, y)
-                joblib.dump(model, f"{model_name}_retrained.joblib")
-                print(f"✅ {model_name} дообучена")
-        if MODELS.get("lgb") and hasattr(MODELS["lgb"], 'fit'):
-            MODELS["lgb"].fit(X, y)
-            joblib.dump(MODELS["lgb"], "lgb_retrained.joblib")
-            print("✅ LightGBM дообучена")
-    except Exception as e:
-        print(f"Ошибка дообуче��ия: {e}")
+    # Заглушка — дообучение через yfinance убрано, используем данные Хаба
+    print("⚠️ Дообучение через Hub пока не реализовано")
 
 def auto_retrain():
+    time.sleep(STARTUP_SLEEP + 3600)
     while True:
-        # Проверяем винрейт каждый час
-        time.sleep(3600)
-        try:
-            resp = session.get(f"{HUB_URL}/metrics", params={"space": "space_19_sol"}, timeout=10)
-            if resp.status_code == 200:
-                data = resp.json()
-                if data and len(data) > 0:
-                    acc = data[0].get("accuracy", 0.5)
-                    total = data[0].get("total_trades", 0)
-                    if total >= 20 and acc < 0.4:
-                        print(f"Точность SOL Master упала до {acc:.2f}, экстренное дообучение!")
-                        retrain_models()
-                        time.sleep(RETRAIN_INTERVAL)
-                        continue
-        except Exception as e:
-            print(f"Ошибка проверки винрейта: {e}")
-        # Ждём оставшееся время до планового дообучения
-        time.sleep(RETRAIN_INTERVAL - 3600)
+        time.sleep(RETRAIN_INTERVAL)
         retrain_models()
 
 # ================= KEEP-ALIVE =================
 def keep_alive():
+    time.sleep(STARTUP_SLEEP)
     while True:
         time.sleep(840)
         try:
@@ -904,30 +656,27 @@ threading.Thread(target=auto_report, daemon=True).start()
 threading.Thread(target=auto_retrain, daemon=True).start()
 
 # ================= FASTAPI =================
-app = FastAPI(title="TOMIRIS SOL/USD MASTER v9.1 Auto-Retrain + Trigger")
+app = FastAPI(title="TOMIRIS SOL/USD MASTER v10.0 (PRO-7)")
 
 @app.get("/health")
 async def health():
-    models_loaded = sum(1 for m in ["xgb_daily","xgb_4h","lgb"] if MODELS.get(m) is not None)
+    models_loaded = sum(1 for m in ["xgb_daily", "xgb_4h", "lgb"] if MODELS.get(m) is not None)
     return {
-        "space": "Space 19 v9.1 Auto-Retrain + Trigger",
+        "space": "PRO-7/tomiris-sol-master",
+        "version": "10.0",
         "status": "operational",
         "symbol": SYMBOL,
         "models_loaded": models_loaded,
-        "hub_connected": True,
-        "auto_retrain": True,
-        "retrain_trigger": "accuracy < 0.4"
+        "data_source": "HUB_BINANCE",
+        "startup_sleep": STARTUP_SLEEP
     }
 
 @app.get("/consilium")
 async def consilium():
-    try:
-        signal = get_sol_signal()
-        if signal:
-            return signal
-        return {"space":"space_19_sol_master","symbol":SYMBOL,"signal":{"direction":"WAIT","confidence":0.0},"error":"no_data"}
-    except Exception as e:
-        return {"space":"space_19_sol_master","symbol":SYMBOL,"signal":{"direction":"WAIT","confidence":0.0},"error": str(e)[:100]}
+    signal = get_sol_signal()
+    if signal:
+        return signal
+    return {"space": "space_19_sol_master", "symbol": SYMBOL, "signal": {"direction": "WAIT", "confidence": 0.0}}
 
 @app.get("/signal")
 async def signal():
@@ -938,41 +687,21 @@ async def onchain():
     return {
         "solana": fetch_solana_onchain(),
         "dev_activity": fetch_solana_dev_activity(),
-        "coingecko": fetch_coingecko_sol(),
         "binance": fetch_binance_sol()
     }
 
 @app.get("/price")
 async def current_price():
-    hub = get_mt5_price_from_hub()
-    return {"symbol": SYMBOL, "price": hub["price"] if hub["fresh"] else HUB_CACHE.get("price",0.0), "source": hub["source"], "fresh": hub["fresh"]}
-
-@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("/metrics")
-async def metrics():
-    return {"symbol": SYMBOL, "predictions_stored": len(PREDICTION_HISTORY), "last_confidence": LAST_CONFIDENCE, "component_performance": COMPONENT_PERF}
+    price = get_price_from_hub()
+    return {"symbol": SYMBOL, "price": price, "source": "HUB"}
 
-@app.get("/explain")
-async def explain():
-    if PREDICTION_HISTORY:
-        last = PREDICTION_HISTORY[-1]
-        return {
-            "last_direction": last["direction"],
-            "confidence": last["confidence"],
-            "note": "Explainability via dynamic weights"
-        }
-    return {"error": "No prediction yet"}
+@app.get("/")
+async def root():
+    return {
+        "name": "SOL Master v10.0",
+        "space": "PRO-7/tomiris-sol-master",
+        "hub": HUB_URL,
+        "data_source": "HUB_BINANCE"
+    }
 
-print("🚀 SPACE 19 v9.1 — SOL/USD MASTER (Hub-Connected + Auto-Retrain + Trigger) ЗАПУЩЕН!")
-print("🥉 Ансамбль daily+4h + Meta SOL Score + Dynamic Weights + Auto-Retrain + Trigger")
-print("✅ Готов к бою!")
+print("🚀 SPACE 19 v10.0 — SOL/USD MASTER (PRO-7/tomiris-sol-master) ЗАПУЩЕН!")