Update app.py

app.py

@@ -1,4 +1,4 @@
-# --- 🏴‍☠️ MONKEY PATCH : FIX HF_FOLDER ERROR ---
+# --- 🏴‍☠️ MONKEY PATCH & IMPORTS ---
 import huggingface_hub
 try:
     from huggingface_hub import HfFolder
@@ -24,27 +24,25 @@ import aiohttp
 from types import ModuleType
 import yfinance as yf
 
-# --- 🦖 IMPORT LIGHTGBM (LE NOUVEAU MOTEUR) ---
+# --- 🦖 IMPORT LIGHTGBM ---
 try:
     import lightgbm as lgb
     LGBM_AVAILABLE = True
 except ImportError:
     LGBM_AVAILABLE = False
-    print("⚠️ LightGBM non installé. Lance: pip install lightgbm")
+    print("⚠️ LightGBM non installé.")
 
 try:
     import MetaTrader5 as mt5
     MT5_AVAILABLE = True
 except ImportError:
     MT5_AVAILABLE = False
-    print("🌐 [CLOUD MODE] MetaTrader5 non détecté. Bascule sur CCXT.")
+    print("🌐 [CLOUD MODE] MetaTrader5 non détecté.")
 
 # --- 🥷 NINJA HACK : MOCK PANDAS_TA ---
 if "pandas_ta" not in sys.modules:
     mock_ta = ModuleType("pandas_ta")
     sys.modules["pandas_ta"] = mock_ta
-    print("🥷 Pandas-TA neutralisé (Mock actif).")
-
 if not hasattr(pd.DataFrame, "ta"):
     class FakeTA:
         def __getattr__(self, name): return lambda *args, **kwargs: None
@@ -75,21 +73,38 @@ exchange_sync = ccxt.kucoin({"enableRateLimit": True, "timeout": 30000})
 
 market_cache, last_fetch_time = {}, {}
 CACHE_DURATION = 300 
-DREAM_MODE_ACTIVE = True # 🌙 Contrôle du Sommeil
+DREAM_MODE_ACTIVE = True 
 
 try:
     from sentiment_engine import get_crypto_sentiment
-    print("✅ Sentiment Engine : Connecté.")
 except:
     async def get_crypto_sentiment(symbol): return 0.5
 try:
     from ensemble import combine_scores
 except:
-    def combine_scores(s, t, m, l, sent, r): return (t+m+l+sent)/4, 0.25, 0.25, 0.25, 0.25
+    def combine_scores(symbol, timeframe, t, m, l, sent, r): return (t+m+l+sent)/4, 0.25, 0.25, 0.25, 0.25
 
-# --- DB & SYNC (V30 DINOSAURE) ---
-DB_NAME = "alphatrade_v30_dino.db" # 🦖 RESET DB POUR L'ADN
+# --- DB, SYNC & HUGGING FACE BACKUP ---
+DB_NAME = "alphatrade_v30_dino.db"
 HF_TOKEN = os.environ.get("HF_TOKEN")
+HF_REPO_ID = "Nexo-S/AlphaTrade-DB"
+
+def restore_db_from_hf():
+    if not HF_TOKEN: return
+    try:
+        print("🔄 [SYSTEM] Restauration ADN depuis HF...")
+        file_path = hf_hub_download(repo_id=HF_REPO_ID, filename=DB_NAME, repo_type="dataset", token=HF_TOKEN)
+        shutil.copy(file_path, DB_NAME)
+        print("✅ [RESTORE] ADN récupéré !")
+    except Exception as e: print(f"⚠️ Aucun backup trouvé (1er lancement) : {e}")
+
+def backup_db_to_hf():
+    if not HF_TOKEN: return
+    try:
+        api = HfApi()
+        api.upload_file(path_or_fileobj=DB_NAME, path_in_repo=DB_NAME, repo_id=HF_REPO_ID, repo_type="dataset", token=HF_TOKEN)
+        print("☁️ [BACKUP] ADN sauvegardé sur Hugging Face !")
+    except Exception as e: print(f"❌ Erreur Backup HF : {e}")
 
 def init_db():
     try:
@@ -103,9 +118,7 @@ def init_db():
             
             cursor = conn.cursor()
             cursor.execute("PRAGMA table_info(agent_logic)")
-            al_cols = [col[1] for col in cursor.fetchall()]
-            
-            if not al_cols:
+            if not [col[1] for col in cursor.fetchall()]:
                 conn.execute('''CREATE TABLE IF NOT EXISTS agent_logic (
                     symbol TEXT, timeframe TEXT, tp_mult REAL, sl_mult REAL,
                     score REAL, last_pnl REAL, min_prob REAL, min_tp_dist REAL,
@@ -122,8 +135,7 @@ def init_db():
                     ('ALL', '4h', 3.0, 2.0, 0, 0, 0.50, 0.008, 1, 0, 0)
                 ]
                 conn.executemany("INSERT INTO agent_logic VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", defaults)
-        print("✅ Base de données V30 (Dinosaure) opérationnelle.")
-    except Exception as e: print(f"❌ Erreur critique DB: {e}")
+    except Exception as e: print(f"❌ Erreur DB: {e}")
 
 async def save_to_db(data):
     try:
@@ -132,9 +144,19 @@ async def save_to_db(data):
             conn.commit()
     except Exception as e: print(f"❌ DB Error : {e}")
 
-# --- INITIALISATION DB ---
-restore_db_from_hf() # ⬅️ 1. On télécharge la sauvegarde
-init_db()            # ⬅️ 2. Ensuite on vérifie que les tables existent bien
+# 🚀 INITIALISATION 
+restore_db_from_hf()
+init_db()
+
+# --- 🛡️ STATE MANAGER ---
+active_signals_state = {}
+
+def clean_old_db_signals(symbol, timeframe):
+    try:
+        with sqlite3.connect(DB_NAME) as conn:
+            conn.execute("UPDATE signals SET status = 'REMPLACÉ ♻️', confirmed = 0 WHERE symbol = ? AND timeframe = ? AND status = 'EN_COURS'", (symbol, timeframe))
+            conn.commit()
+    except Exception as e: print(f"⚠️ Erreur nettoyage DB : {e}")
 
 def memory_guard():
     if psutil.virtual_memory().percent > 80:
@@ -164,19 +186,15 @@ try:
     time_model = joblib.load("time_model.pkl")
     regime_model = joblib.load("regime_model.pkl")
     regime_scaler = joblib.load("regime_scaler.pkl")
-    print("✅ Cerveaux Classiques OK.")
 except Exception as e: print(f"⚠️ Erreur IA Classique : {e}")
 
 try:
     dino_brain = lgb.Booster(model_file='dino_lgbm_model.txt') if LGBM_AVAILABLE else None
-    if dino_brain: print("🦖 Cerveau LightGBM chargé.")
 except:
     dino_brain = None
-    print("⚠️ Modèle Dino non trouvé, utilisation de l'ensemble classique.")
 
 # --- 📊 FEATURES ENGINE ---
 async def fetch_kucoin_futures_data(symbol):
-    """Récupère l'OI et le CVD via KuCoin Futures API"""
     try:
         ku_sym = symbol.replace("/", "").replace("BTC", "XBT") + "M"
         async with aiohttp.ClientSession() as session:
@@ -184,8 +202,7 @@ async def fetch_kucoin_futures_data(symbol):
             trade_url = f"https://api-futures.kucoin.com/api/v1/trade/history?symbol={ku_sym}"
             async with session.get(oi_url) as r1, session.get(trade_url) as r2:
                 oi_json = await r1.json()
-                trade_json = await r2.json()
-                trades = trade_json.get("data", [])
+                trades = (await r2.json()).get("data", [])
                 cvd = sum([float(t.get("size", 0)) if t.get("side") == "buy" else -float(t.get("size", 0)) for t in trades])
                 return {"oi": float(oi_json.get("data", {}).get("value", 0)), "cvd": cvd}
     except: return {"oi": 0, "cvd": 0}
@@ -198,25 +215,16 @@ def prepare_features_sync(symbol, timeframe='1h', limit_bars=600):
         if cache_key in market_cache and now - last_fetch_time.get(cache_key, 0) < CACHE_DURATION:
             df = market_cache[cache_key].copy()
         else:
-            if "XAU" in symbol.upper():
-                ticker = "GC=F" 
-                yf_map = {"1m":"1m", "5m":"5m", "15m":"15m", "1h":"1h", "4h":"1h", "1d":"1d"}
-                data = yf.download(ticker, period="5d", interval=yf_map.get(timeframe, "1h"), progress=False)
-                if data.empty: return pd.DataFrame()
-                df = data.reset_index().iloc[:, [0, 1, 2, 3, 4, 6]] 
-                df.columns = ['ts', 'open', 'high', 'low', 'close', 'vol']
-            else:
-                fetch_symbol = symbol if "/USDT" in symbol else symbol.replace("/USD", "/USDT")
-                if "/" not in fetch_symbol: fetch_symbol += "/USDT"
-                
-                # 🛡️ TRIPLE CHECK KUCOIN
-                df = pd.DataFrame()
-                for attempt in range(3):
-                    try:
-                        bars = exchange_sync.fetch_ohlcv(fetch_symbol, timeframe, limit=limit_bars)
-                        df = pd.DataFrame(bars, columns=['ts', 'open', 'high', 'low', 'close', 'vol'])
-                        if not df.empty: break
-                    except: time.sleep(2)
+            fetch_symbol = symbol if "/USDT" in symbol else symbol.replace("/USD", "/USDT")
+            if "/" not in fetch_symbol: fetch_symbol += "/USDT"
+            
+            df = pd.DataFrame()
+            for attempt in range(3):
+                try:
+                    bars = exchange_sync.fetch_ohlcv(fetch_symbol, timeframe, limit=limit_bars)
+                    df = pd.DataFrame(bars, columns=['ts', 'open', 'high', 'low', 'close', 'vol'])
+                    if not df.empty: break
+                except: time.sleep(2)
             
             if df.empty: return pd.DataFrame()
             market_cache[cache_key], last_fetch_time[cache_key] = df.copy(), now
@@ -271,21 +279,17 @@ async def predict_signal(symbol, timeframe="1h"):
         vol_spike = float(last_row['Vol_Spike'].iloc[0]) 
         rsi_9 = float(last_row['RSI_9'].iloc[0])         
         
-        # 🌊 V30: Flux Futures KuCoin
         futures_data = await fetch_kucoin_futures_data(symbol)
         oi, cvd = futures_data["oi"], futures_data["cvd"]
 
-        # --- 🧠 CERVEAUX IA ---
         regime_scaled = regime_scaler.transform(last_row[["ATR_pct", "EMA200_slope", "Drawdown", "RSI_Macro"]])
         regime_pred = int(regime_model.predict(regime_scaled)[0])
         
         ml_cols = ["RSI", "Dist_High_24h", "Dist_Low_24h", "EMA_dist", "EMA_slope", "ATR_ratio", "VOL_ratio"]
         ml_prob = float(ml_model.predict_proba(last_row[ml_cols])[0][1])
-        
         time_cols = ['return_1h', 'return_3h', 'return_12h', 'RSI_lag1', 'RSI_lag2', 'vol_lag1', 'VOL_RATIO']
         time_prob = float(time_model.predict_proba(last_row[time_cols])[0][1])
         
-        # 🦖 DINO LightGBM (ou Fallback)
         dino_prob = 0.5
         if dino_brain:
             try: dino_prob = float(dino_brain.predict(last_row[ml_cols].values)[0])
@@ -293,10 +297,9 @@ async def predict_signal(symbol, timeframe="1h"):
         
         p_sent = await get_crypto_sentiment(symbol)
 
-        # NOUVEAU CODE V30
+        # ⚡ ENSEMBLE V30
         final_p, wt, wm, wl, ws = combine_scores(symbol, timeframe, time_prob, ml_prob, dino_prob, p_sent, regime_pred)
 
-        # --- 🐋 SMART MONEY & CVD BOOST ---
         smc_status = "AUCUN"
         if int(last_row["Sweep_Low"].iloc[0]) == 1 and cvd > 0:
             final_p = min(0.95, final_p + 0.20)
@@ -309,11 +312,9 @@ async def predict_signal(symbol, timeframe="1h"):
             if final_p > 0.5 and vol_spike > 1.5 and rsi_9 < 70: final_p = min(0.95, final_p + 0.10)
             elif final_p < 0.5 and vol_spike > 1.5 and rsi_9 > 30: final_p = max(0.05, final_p - 0.10)
 
-        # --- 🛡️ ADN DE LA BASE DE DONNÉES ---
         with sqlite3.connect(DB_NAME) as conn:
             res = conn.execute("SELECT tp_mult, sl_mult, min_prob, min_tp_dist FROM agent_logic WHERE symbol = ? AND timeframe = ?", (symbol, timeframe)).fetchone()
-            if res:
-                tp_m, sl_m, agent_min_prob, agent_min_tp_dist = res
+            if res: tp_m, sl_m, agent_min_prob, agent_min_tp_dist = res
             else:
                 res_fallback = conn.execute("SELECT tp_mult, sl_mult, min_prob, min_tp_dist FROM agent_logic WHERE symbol = 'ALL' AND timeframe = ?", (timeframe,)).fetchone()
                 tp_m, sl_m, agent_min_prob, agent_min_tp_dist = res_fallback if res_fallback else (1.5, 1.0, 0.55, 0.002)
@@ -327,7 +328,6 @@ async def predict_signal(symbol, timeframe="1h"):
         conf_val = max(0, min(1, 1 - np.std([time_prob, ml_prob, dino_prob, p_sent])))
         composite_score = max(0, min(100, (strength * 45) + (conf_val * 40) + (15 if regime_pred in [0, 1] else 5)))
 
-        # 🛑 VETO DYNAMIQUE
         veto, veto_reason = False, ""
         dist_tp_pct = abs(tp - prix) / prix
         dist_fib = float(last_row["Dist_Fib_618"].iloc[0])
@@ -341,11 +341,10 @@ async def predict_signal(symbol, timeframe="1h"):
         elif final_p > 0.5 and dist_fib < -0.03: veto, veto_reason = True, "Support Fib 61.8 trop loin"
         elif final_p < 0.5 and dist_fib > 0.03: veto, veto_reason = True, "Résistance Fib 61.8 trop loin"
         elif dist_tp_pct < agent_min_tp_dist: veto, veto_reason = True, "Gain potentiel trop faible"
-        elif final_p < 0.5 and (prix > ema200_val or prix > vwap): veto, veto_reason = True, "Short Interdit 🚫 (> EMA200/VWAP)"
-        elif final_p > 0.5 and (prix < ema200_val or prix < vwap): veto, veto_reason = True, "Long Interdit 🚫 (< EMA200/VWAP)"
+        elif final_p < 0.5 and (prix > ema200_val or prix > vwap): veto, veto_reason = True, "Short Interdit 🚫"
+        elif final_p > 0.5 and (prix < ema200_val or prix < vwap): veto, veto_reason = True, "Long Interdit 🚫"
 
         if veto:
-            print(f"🛑 [VETO] {symbol}: {veto_reason}")
             return {"symbol": symbol, "timeframe": timeframe, "status": "veto", "message": veto_reason, "price": prix, "final_score": round(final_p, 4)}
 
         db_task = (datetime.now(timezone.utc).isoformat(), symbol, timeframe, 'HAUSSIER' if final_p > 0.5 else 'BAISSIER', final_p, prix, tp, sl, 'EN_COURS', regime_pred, time_prob, ml_prob, dino_prob, p_sent, prix)
@@ -357,23 +356,7 @@ async def predict_signal(symbol, timeframe="1h"):
         }
     except Exception as e: return {"status": "error", "message": str(e)}
 
-# --- 🛡️ STATE MANAGER : LE DICTIONNAIRE D'ÉTAT GLOBAL ---
-# Clé : (symbol, timeframe) -> Valeur : Les données du dernier signal
-active_signals_state = {}
-
-def clean_old_db_signals(symbol, timeframe):
-    """Passe les anciens signaux non résolus en statut REMPLACÉ pour laisser la place aux nouveaux."""
-    try:
-        with sqlite3.connect(DB_NAME) as conn:
-            conn.execute(
-                "UPDATE signals SET status = 'REMPLACÉ ♻️', confirmed = 0 "
-                "WHERE symbol = ? AND timeframe = ? AND status = 'EN_COURS'", 
-                (symbol, timeframe)
-            )
-            conn.commit()
-    except Exception as e:
-        print(f"⚠️ Erreur nettoyage DB : {e}")
-# --- 🧬 FONCTION D'ÉVOLUTION (MUTATION) ---
+# --- 🧬 FONCTION D'ÉVOLUTION ---
 def mutate_agent(symbol, timeframe, success=True):
     try:
         with sqlite3.connect(DB_NAME) as conn:
@@ -382,136 +365,82 @@ def mutate_agent(symbol, timeframe, success=True):
             if not row: return
             
             tp, sl, prob = row['tp_mult'], row['sl_mult'], row['min_prob']
-            if success:
-                new_tp, new_sl, new_prob = tp * random.uniform(1.01, 1.05), sl * random.uniform(0.98, 1.00), max(0.60, prob - 0.01)
-            else:
-                new_tp, new_sl, new_prob = tp * random.uniform(0.90, 0.98), sl * random.uniform(1.02, 1.10), min(0.85, prob + 0.02)
+            if success: new_tp, new_sl, new_prob = tp * random.uniform(1.01, 1.05), sl * random.uniform(0.98, 1.00), max(0.60, prob - 0.01)
+            else: new_tp, new_sl, new_prob = tp * random.uniform(0.90, 0.98), sl * random.uniform(1.02, 1.10), min(0.85, prob + 0.02)
                 
             conn.execute('''UPDATE agent_logic SET tp_mult = ?, sl_mult = ?, min_prob = ?, generation = generation + 1 WHERE symbol = ? AND timeframe = ?''', (new_tp, new_sl, new_prob, symbol, timeframe))
-            backup_db_to_hf()
+        
+        # ☁️ SAUVEGARDE HF APRÈS MUTATION
+        backup_db_to_hf()
     except Exception as e: print(f"🧬 Erreur Mutation : {e}")
 
-# --- 🧠 TRAINING ENGINE ---
 # --- 🧠 TRAINING ENGINE ---
 def trigger_training(symbol="BTC/USD"):
     try:
-        print(f"⚙️ Tentative d'entraînement pour {symbol}...")
         memory_guard()
         bars = exchange_sync.fetch_ohlcv(symbol, timeframe='1h', limit=1500)
         df = pd.DataFrame(bars, columns=['ts', 'open', 'high', 'low', 'close', 'vol'])
         if len(df) < 500: return f"❌ Historique insuffisant."
         
         df_final = prepare_features_sync(symbol, '1h', limit_bars=1000)
-        if df_final.empty or len(df_final) < 100: return f"❌ Données vides après indicateurs."
+        if df_final.empty or len(df_final) < 100: return f"❌ Données vides."
 
-        # 1. Entraînement des vieux modèles (Fallback de sécurité)
-        try:
-            from ml_model import train_model as train_ml
-            from time_model import train_time_model as train_time
-            train_ml(df_final); train_time(df_final)
-        except Exception as e: print(f"⚠️ Erreur Classique: {e}")
-
-        # 2. 🦖 ENTRAÎNEMENT DU DINOSAURE (LightGBM)
         if LGBM_AVAILABLE:
-            print("🦖 [V30] Forgeage du Cerveau LightGBM en cours...")
             ml_cols = ["RSI", "Dist_High_24h", "Dist_Low_24h", "EMA_dist", "EMA_slope", "ATR_ratio", "VOL_ratio"]
-            
-            # On crée la cible (la prochaine bougie sera-t-elle verte ?)
             df_final['Target'] = (df_final['close'].shift(-1) > df_final['close']).astype(int)
             df_train = df_final.dropna(subset=ml_cols + ['Target'])
-            
-            X = df_train[ml_cols]
-            y = df_train['Target']
-            
-            params = {
-                'objective': 'binary', 
-                'metric': 'binary_logloss', 
-                'boosting_type': 'gbdt', 
-                'learning_rate': 0.05, 
-                'num_leaves': 31, 
-                'verbose': -1
-            }
-            dtrain = lgb.Dataset(X, label=y)
-            
-            # Entraînement ultra-rapide
-            model = lgb.train(params, dtrain, 100)
+            X, y = df_train[ml_cols], df_train['Target']
+            params = {'objective': 'binary', 'metric': 'binary_logloss', 'boosting_type': 'gbdt', 'learning_rate': 0.05, 'num_leaves': 31, 'verbose': -1}
+            model = lgb.train(params, lgb.Dataset(X, label=y), 100)
             model.save_model('dino_lgbm_model.txt')
-            
             global dino_brain
             dino_brain = lgb.Booster(model_file='dino_lgbm_model.txt')
-            print("✅ [V30] Cerveau LightGBM créé, sauvegardé et injecté !")
 
-        # Rechargement des vieux modèles en mémoire globale
         global ml_model, time_model
         ml_model, time_model = joblib.load("ml_model_v9.pkl"), joblib.load("time_model.pkl")
         gc.collect()
-        
-        return f"✅ IA ré-entraînée avec succès (T-Rex en ligne !)."
-    except Exception as e: 
-        return f"❌ Erreur Training : {e}"
+        return f"✅ IA ré-entraînée."
+    except Exception as e: return f"❌ Erreur Training : {e}"
 
-# --- 🚀 MOTEUR AUTO-PILOTE & DREAM MODE ---
+# --- 🚀 MOTEURS AUTO-PILOTE ---
 AUTO_SYMBOLS = ["BTC/USD", "ETH/USD"]
 AUTO_TIMEFRAMES = ["1m", "5m", "15m", "1h"]
 
 def set_bot_mode(mode):
     global DREAM_MODE_ACTIVE
     target_mode = mode[0] if isinstance(mode, list) else str(mode)
-    if "LIVE" in target_mode.upper():
-        DREAM_MODE_ACTIVE = False
-        msg = "🛰️ Mode LIVE activé : Le cerveau est en alerte."
-    else:
-        DREAM_MODE_ACTIVE = True
-        msg = "🌙 Mode DREAM activé : Début du Backtest Évolutif."
-    print(f"[SYSTEM] {msg}")
+    if "LIVE" in target_mode.upper(): DREAM_MODE_ACTIVE, msg = False, "🛰️ Mode LIVE activé"
+    else: DREAM_MODE_ACTIVE, msg = True, "🌙 Mode DREAM activé"
     return {"status": "success", "mode": "DREAM" if DREAM_MODE_ACTIVE else "LIVE", "message": msg}
 
-async def auto_predict_loop():
-    print("👁️ [SCANNER] Le Cerveau Global est en ligne (H24)...")
+async def universal_scanner_loop():
+    print("👁️ [SCANNER] Le Cerveau Global est en ligne H24...")
     while True:
         for symbol in AUTO_SYMBOLS:
             for tf in AUTO_TIMEFRAMES:
                 try:
-                    # 1️⃣ L'IA RÉFLÉCHIT EN CONTINU (Aucun blocage)
                     pred = await predict_signal(symbol, timeframe=tf)
-
                     if pred and pred.get("status") == "success":
-                        # 2️⃣ NETTOYAGE DB : On archive l'ancien signal avant d'enregistrer le nouveau
                         clean_old_db_signals(symbol, tf)
-                        
-                        # 3️⃣ ÉCRASEMENT MATHÉMATIQUE : Le nouveau signal tue l'ancien instantanément en RAM
                         active_signals_state[(symbol, tf)] = pred
-
-                        # 4️⃣ ACTION : C'est ici que le mode intervient !
+                        
                         if not DREAM_MODE_ACTIVE:
-                            print(f"🎯 [LIVE] Nouveau signal maître pris en compte : {symbol} [{tf}]")
-                            # C'est ici que tu déclencheras l'API KuCoin/MT5 pour prendre le trade
-                        else:
-                            # En mode DREAM, on log juste ou on laisse le backtest tourner
-                            pass
-
-                    await asyncio.sleep(5)  # Sécurité anti-spam API KuCoin
-                except Exception as e: 
-                    print(f"⚠️ Erreur Scanner sur {symbol} [{tf}] : {e}")
-                    
-        await asyncio.sleep(60) # Pause entre deux scans complets du marché
+                            print(f"🎯 [LIVE] Action requise pour {symbol} [{tf}] : Passage d'ordre.")
+                    await asyncio.sleep(5)
+                except Exception as e: print(f"⚠️ Erreur Scanner {symbol} [{tf}]: {e}")
+        await asyncio.sleep(60)
 
 async def dream_simulation_loop():
-    """Le Spinosaurus rêve sur TOUS les terrains (Multi-Timeframe)"""
     while True:
         if DREAM_MODE_ACTIVE:
-            print("🌙 [DREAM] Début de la session de backtest multi-timeframe...")
             for symbol in AUTO_SYMBOLS:
-                for tf in AUTO_TIMEFRAMES: # ⚡ LA BOUCLE MAGIQUE EST LÀ !
+                for tf in AUTO_TIMEFRAMES: 
                     try:
-                        # On utilise 'tf' au lieu de "1m"
                         df = prepare_features_sync(symbol, timeframe=tf, limit_bars=200)
                         if df.empty or len(df) < 50: continue
                         
                         idx = random.randint(10, len(df) - 30)
-                        test_row = df.iloc[[idx]]
-                        
-                        pred = await predict_signal(symbol, timeframe=tf) # ⚡ 'tf' ici aussi
+                        pred = await predict_signal(symbol, timeframe=tf)
                         if pred.get("status") == "success":
                             future_data = df.iloc[idx+1 : idx+25]
                             win = False
@@ -522,36 +451,29 @@ async def dream_simulation_loop():
                                 else:
                                     if row['low'] <= pred['tp']: win = True; break
                                     if row['high'] >= pred['sl']: win = False; break
-                            
-                            mutate_agent(symbol, tf, success=win) # ⚡ Et 'tf' ici !
-                            print(f"🧬 [DREAM] Mutation [{tf}] sur {symbol} : {'✅ GAGNANTE' if win else '❌ PERDANTE'}")
-                        
-                        await asyncio.sleep(3) # 🛡️ Sécurité anti-ban KuCoin
-                    except Exception as e: 
-                        print(f"⚠️ Erreur DREAM sur {symbol} [{tf}]: {e}")
-                        
+                            mutate_agent(symbol, tf, success=win)
+                        await asyncio.sleep(3) 
+                    except Exception: pass
         await asyncio.sleep(60)
 
-# --- ⚖️ TOOLS (API EXNESS & DB) ---
+# --- ⚖️ TOOLS ---
 def keep_alive_ping(): return {"status": "awake", "time": datetime.now(timezone.utc).isoformat()}
 def confirm_trade_api(trade_id, real_price):
     try:
-        t_id, r_price = int(trade_id), float(real_price)
         with sqlite3.connect(DB_NAME) as conn:
             conn.row_factory, cursor = sqlite3.Row, conn.cursor()
-            cursor.execute("SELECT price, tp, sl FROM signals WHERE id = ?", (t_id,))
+            cursor.execute("SELECT price, tp, sl FROM signals WHERE id = ?", (int(trade_id),))
             t = cursor.fetchone()
             if not t: return {"status": "error"}
-            ecart = r_price - t['price']
-            cursor.execute("UPDATE signals SET confirmed = 1, price = ?, tp = ?, sl = ?, peak_price = ? WHERE id = ?", (r_price, t['tp'] + ecart, t['sl'] + ecart, r_price, t_id))
+            ecart = float(real_price) - t['price']
+            cursor.execute("UPDATE signals SET confirmed = 1, price = ?, tp = ?, sl = ?, peak_price = ? WHERE id = ?", (float(real_price), t['tp'] + ecart, t['sl'] + ecart, float(real_price), int(trade_id)))
             conn.commit()
         return {"status": "success"}
-    except Exception as e: return {"status": "error"}
+    except: return {"status": "error"}
+
 def cancel_trade_api(trade_id):
     try:
-        with sqlite3.connect(DB_NAME) as conn:
-            conn.execute("UPDATE signals SET status = 'ANNULÉ 🗑️', confirmed = 0 WHERE id = ?", (int(trade_id),))
-            conn.commit()
+        with sqlite3.connect(DB_NAME) as conn: conn.execute("UPDATE signals SET status = 'ANNULÉ 🗑️', confirmed = 0 WHERE id = ?", (int(trade_id),)); conn.commit()
         return {"status": "success"}
     except: return {"status": "error"}
 
@@ -577,8 +499,6 @@ def run_judge_api():
                         current_price = exchange_sync.fetch_ticker(f_sym)['last']
 
                     diff = (t['price'] - current_price) if t['direction'] == 'BAISSIER' else (current_price - t['price'])
-                    pnl_live = diff * 0.1 * 10 
-                    
                     sl_dyn, peak = t['sl'], t['peak_price']
                     new_peak = max(peak, current_price) if t['direction'] == 'HAUSSIER' else min(peak, current_price)
                     progression = abs(current_price - t['price']) / abs(t['tp'] - t['price']) if abs(t['tp'] - t['price']) > 0 else 0
@@ -587,11 +507,9 @@ def run_judge_api():
                     if t['direction'] == 'HAUSSIER':
                         if progression >= 0.75: nouveau_sl = max(sl_dyn, t['price'] + (abs(t['tp'] - t['price']) * 0.60))
                         elif progression >= 0.50: nouveau_sl = max(sl_dyn, t['price'] + (abs(t['tp'] - t['price']) * 0.25))
-                        elif progression >= 0.25: nouveau_sl = max(sl_dyn, t['price'] + (abs(t['tp'] - t['price']) * 0.05))
                     else:
                         if progression >= 0.75: nouveau_sl = min(sl_dyn, t['price'] - (abs(t['tp'] - t['price']) * 0.60))
                         elif progression >= 0.50: nouveau_sl = min(sl_dyn, t['price'] - (abs(t['tp'] - t['price']) * 0.25))
-                        elif progression >= 0.25: nouveau_sl = min(sl_dyn, t['price'] - (abs(t['tp'] - t['price']) * 0.05))
 
                     cursor.execute("UPDATE signals SET peak_price = ?, sl = ? WHERE id = ?", (new_peak, nouveau_sl, t['id']))
                     outcome, reward = None, 0
@@ -603,139 +521,66 @@ def run_judge_api():
                         elif current_price >= nouveau_sl: outcome, reward = ("GAGNÉ (PARTIEL) 💸", 1) if nouveau_sl < t['price'] else ("PERDU ❌", -5)
 
                     if outcome:
-                        pnl_dollars = (((abs(current_price - t['price'])) / t['price']) * 1000.0) - 0.25
-                        if outcome == "SL TOUCHÉ 🛡️" and pnl_dollars < 0: outcome = "TUÉ PAR LE SPREAD 🩸"
-                        elif outcome == "GAGNÉ (PARTIEL) 💸" and pnl_dollars <= 0: outcome = "FAUX GAIN 📉" 
-                        
-                        # 🧬 MUTATION RÉELLE V30
-                        is_win = reward > 0
-                        mutate_agent(t['symbol'], t['timeframe'], success=is_win)
+                        mutate_agent(t['symbol'], t['timeframe'], success=(reward>0))
                         cursor.execute("UPDATE signals SET status=? WHERE id=?", (outcome, t['id']))
                         closed_trades.append({"symbol": t['symbol'], "id": t['id']})
-                except Exception as inner_e: print(f"⚠️ Erreur Juge: {inner_e}")
+                except: pass
             conn.commit()
-        if closed_trades: return {"status": "updates", "data": closed_trades}
-        return {"status": "waiting"}
+        return {"status": "updates", "data": closed_trades} if closed_trades else {"status": "waiting"}
     except Exception as e: return {"status": "error", "message": str(e)}
 
-def training_wrapper(symbol, *args):
-    s = "BTC/USD" if not isinstance(symbol, str) or len(str(symbol)) < 2 else str(symbol).strip().upper()
-    return trigger_training(s)
-
+def training_wrapper(symbol, *args): return trigger_training(str(symbol).strip().upper() if isinstance(symbol, str) else "BTC/USD")
 def get_bot_skills():
     try:
         with sqlite3.connect(DB_NAME) as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT symbol, timeframe, tp_mult, sl_mult, min_prob, generation FROM agent_logic ORDER BY symbol, timeframe")
-            return [[r[0], r[1], f"x{round(r[2], 2)}", f"x{round(r[3], 2)}", f"{round(r[4]*100)}%", f"🧬 Gen {r[5]}"] for r in cursor.fetchall()]
+            return [[r[0], r[1], f"x{round(r[2], 2)}", f"x{round(r[3], 2)}", f"{round(r[4]*100)}%", f"🧬 Gen {r[5]}"] for r in conn.cursor().execute("SELECT symbol, timeframe, tp_mult, sl_mult, min_prob, generation FROM agent_logic ORDER BY symbol, timeframe").fetchall()]
     except Exception as e: return [[f"Erreur: {str(e)}", "-", "-", "-", "-", "-"]]
-
 def force_scalping_mode():
     try:
-        with sqlite3.connect(DB_NAME) as conn:
-            conn.execute("UPDATE agent_logic SET tp_mult = 1.8")
-            conn.commit()
+        with sqlite3.connect(DB_NAME) as conn: conn.execute("UPDATE agent_logic SET tp_mult = 1.8"); conn.commit()
         return get_bot_skills()
     except: return [["Erreur", "-", "-", "-", "-", "-"]]
-
 def get_active_signals():
     try:
-        conn = sqlite3.connect(DB_NAME, timeout=10) 
-        conn.row_factory = sqlite3.Row
-        trades = [dict(row) for row in conn.cursor().execute("SELECT * FROM signals WHERE status = 'EN_COURS'").fetchall()]
-        conn.close()
-        return trades
+        with sqlite3.connect(DB_NAME, timeout=10) as conn:
+            conn.row_factory = sqlite3.Row
+            return [dict(row) for row in conn.cursor().execute("SELECT * FROM signals WHERE status = 'EN_COURS'").fetchall()]
     except: return []
 
-def backup_db_to_hf():
-    """Sauvegarde la DB sur Hugging Face pour survivre aux reboots."""
-    if not HF_TOKEN:
-        print("⚠️ HF_TOKEN manquant, backup impossible.")
-        return
-    
-    try:
-        api = HfApi()
-        # Remplace par ton vrai nom d'utilisateur et le nom d'un dataset privé que tu as créé
-        repo_id = "Nexo-S/AlphaTrade-DB" 
-        api.upload_file(
-            path_or_fileobj=DB_NAME,
-            path_in_repo=DB_NAME,
-            repo_id=repo_id,
-            repo_type="dataset",
-            token=HF_TOKEN
-        )
-        print("☁️ [BACKUP] Base de données sauvegardée sur Hugging Face !")
-    except Exception as e:
-        print(f"❌ Erreur Backup HF : {e}")
-
-def restore_db_from_hf():
-    """Récupère le dernier ADN du bot depuis HF au démarrage du Space."""
-    if not HF_TOKEN:
-        print("⚠️ HF_TOKEN manquant, restauration impossible.")
-        return
-    
-    try:
-        print("🔄 [SYSTEM] Tentative de récupération de l'ADN depuis Hugging Face...")
-        file_path = hf_hub_download(
-            repo_id="Nexo-S/AlphaTrade-DB", 
-            filename=DB_NAME, 
-            repo_type="dataset", 
-            token=HF_TOKEN
-        )
-        shutil.copy(file_path, DB_NAME)
-        print("✅ [RESTORE] Base de données (ADN) récupérée avec succès !")
-    except Exception as e:
-        print(f"⚠️ Aucun backup trouvé ou erreur (C'est normal si c'est le 1er lancement) : {e}")
-
 # --- 🎨 INTERFACE GRADIO V30 ---
 with gr.Blocks(theme=gr.themes.Monochrome()) as iface:
-    gr.Markdown("# 🦖 Alpha V30 Dinosaur Engine")
-    
-    with gr.Tab("Admin"):
-        admin_sym = gr.Textbox(label="Symbole à recalibrer", value="BTC/USDT")
-        gr.Button("Forcer Entraînement", variant="stop").click(fn=training_wrapper, inputs=admin_sym, outputs=gr.Textbox(), api_name="trigger_training")
-
-    with gr.Tab("🎯 Prédictions"):
-        btn_pred = gr.Button("Predict", variant="primary")
-        btn_pred.click(fn=predict_signal, inputs=[gr.Textbox(label="Symbole", value="BTC/USD"), gr.Dropdown(choices=["1m", "5m", "15m", "1h"], value="1h")], outputs=gr.JSON())
-
+    gr.Markdown("# 🦖 Alpha V30 Dinosaur Engine (Master Edition)")
+    with gr.Tab("Admin"): gr.Button("Forcer Entraînement", variant="stop").click(fn=training_wrapper, inputs=gr.Textbox(label="Symbole à recalibrer", value="BTC/USDT"), outputs=gr.Textbox(), api_name="trigger_training")
+    with gr.Tab("🎯 Prédictions"): gr.Button("Predict", variant="primary").click(fn=predict_signal, inputs=[gr.Textbox(label="Symbole", value="BTC/USD"), gr.Dropdown(choices=["1m", "5m", "15m", "1h"], value="1h")], outputs=gr.JSON())
     with gr.Tab("⚖️ Système"):
         gr.Button("Judge").click(fn=run_judge_api, outputs=gr.JSON(), api_name="run_judge_api")
         gr.Button("Get Active", visible=False).click(fn=get_active_signals, outputs=gr.JSON(), api_name="get_active_signals")
         gr.Button("Ping", visible=False).click(fn=keep_alive_ping, outputs=gr.JSON(), api_name="keep_alive_ping")
         gr.Button("Set Mode", visible=False).click(fn=set_bot_mode, inputs=gr.Textbox(visible=False), outputs=gr.JSON(), api_name="set_bot_mode")
-
     with gr.Tab("📊 Stats (ADN)"):
         skills_table = gr.Dataframe(headers=["Marché", "Timeframe", "Cible (TP)", "Risque (SL)", "Peur Min.", "Génération"], value=get_bot_skills(), interactive=False)
         with gr.Row():
             gr.Button("🔄 Actualiser").click(get_bot_skills, outputs=skills_table)
             gr.Button("⚡ Mode Scalping Force").click(force_scalping_mode, outputs=skills_table)
-
     gr.Button(visible=False).click(fn=confirm_trade_api, inputs=[gr.Textbox(visible=False), gr.Textbox(visible=False)], outputs=gr.JSON(), api_name="confirm_trade_api")
     gr.Button(visible=False).click(fn=cancel_trade_api, inputs=gr.Textbox(visible=False), outputs=gr.JSON(), api_name="cancel_trade_api")
     iface.load(get_bot_skills, outputs=skills_table)
 
 import threading
 _auto_pilot_started = False
-
 def run_auto_pilot():
     global _auto_pilot_started
     if _auto_pilot_started: return
     _auto_pilot_started = True
-    print("⏳ [SYSTEM] Attente 30s avant propulsion V30...")
-    time.sleep(30)
+    print("⏳ [SYSTEM] Attente 15s avant propulsion Master V30...")
+    time.sleep(15)
     try:
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
-        
-        # Le Cerveau (H24) + Le Rêve (Mutations) tournent en parallèle
-        loop.create_task(auto_predict_loop()) 
+        loop.create_task(universal_scanner_loop())
         loop.create_task(dream_simulation_loop())
         loop.run_forever()
-    except Exception as e:
-        print(f"⚠️ Erreur boucle Auto-Pilote : {e}")
-        _auto_pilot_started = False
-        _auto_pilot_started = False
+    except Exception as e: print(f"⚠️ Erreur Auto-Pilote : {e}")
 
 if __name__ == "__main__":
     try: threading.Thread(target=run_auto_pilot, daemon=True).start()