Update app.py

app.py

@@ -1,11 +1,18 @@
-import sys, os, sqlite3, shutil, pandas as pd, asyncio, joblib, json, numpy as np, gc, warnings, psutil
+# ================================
+# 🚀 ALPHA ENGINE V22.1 (ULTIMATE)
+# ================================
+
+import sys, os, sqlite3, shutil, pandas as pd, asyncio, joblib, json, numpy as np, gc, warnings, psutil, time
 import ccxt.async_support as ccxt_async
+import ccxt
 from datetime import datetime, timezone
-from huggingface_hub import HfApi, hf_hub_download
 import gradio as gr
-import ccxt
-# --- 🛑 ANTI-CRASH & CPU OPTIMIZATION ---
-os.environ["CUDA_VISIBLE_DEVICES"] = "-1" 
+
+# --- CPU / STABILITY ---
+warnings.filterwarnings("ignore")
+pd.options.mode.chained_assignment = None
+os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
+
 import tensorflow as tf
 from tensorflow.keras.models import load_model
 from tensorflow.keras import backend as K
@@ -13,69 +20,56 @@ from tensorflow.keras import backend as K
 tf.config.threading.set_intra_op_parallelism_threads(2)
 tf.config.threading.set_inter_op_parallelism_threads(2)
 
-# --- CONFIGURATION GPS ---
-current_dir = os.path.dirname(os.path.abspath(__file__))
-if current_dir not in sys.path:
-    sys.path.append(current_dir)
+# ================================
+# 🛰️ SENTIMENT SATELLITE
+# ================================
+try:
+    from sentiment_engine import get_crypto_sentiment
+    print("✅ Sentiment Engine : Connecté.")
+except Exception as e:
+    print(f"⚠️ Erreur Sentiment : {e}")
+    async def get_crypto_sentiment(symbol): return 0.5
 
-# --- SINGLETON EXCHANGE ---
+# ================================
+# 📡 EXCHANGE SINGLETON
+# ================================
 class ExchangeManager:
     _instance = None
     @classmethod
     def get_instance(cls):
         if cls._instance is None:
-            cls._instance = ccxt_async.kucoin({"enableRateLimit": True, "timeout": 30000})
+            cls._instance = ccxt_async.kucoin({
+                "enableRateLimit": True,
+                "timeout": 30000
+            })
         return cls._instance
 
-exchange_sync = ccxt.kucoin({"enableRateLimit": True, "timeout": 30000})
+exchange_sync = ccxt.kucoin({
+    "enableRateLimit": True,
+    "timeout": 30000
+})
 
-# --- CACHE ---
+# ================================
+# 📦 CACHE SYSTEM
+# ================================
 market_cache = {}
 last_fetch_time = {}
-CACHE_DURATION = 300 
-
-# --- 🛰️ IMPORT SÉCURISÉ DES SATELLITES ---
-try:
-    # Correction du nom de la fonction importée
-    from sentiment_engine import get_crypto_sentiment
-    print("✅ Sentiment Engine : Connecté.")
-except Exception as e:
-    print(f"⚠️ Erreur Liaison Sentiment : {e}")
-    # Fallback si le fichier ou la lib vaderSentiment manque
-    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
-
-# --- DB & SYNC ---
-REPO_ID = "Nexo-S/AlphaV15-Quant-Engine"
-DB_NAME = "alphatrade_v9.db"
-HF_TOKEN = os.environ.get("HF_TOKEN")
-
-def init_db():
-    with sqlite3.connect(DB_NAME) as conn:
-        conn.execute('''CREATE TABLE IF NOT EXISTS signals (
-            id INTEGER PRIMARY KEY AUTOINCREMENT, date TEXT, symbol TEXT, direction TEXT, 
-            prob REAL, price REAL, tp REAL, sl REAL, status TEXT, regime INTEGER, 
-            prob_time REAL, prob_ml REAL, prob_lstm REAL, prob_sent REAL)''')
-
-async def save_to_db(data):
-    try:
-        with sqlite3.connect(DB_NAME) as conn:
-            conn.execute('INSERT INTO signals (date, symbol, direction, prob, price, tp, sl, status, regime, prob_time, prob_ml, prob_lstm, prob_sent) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)', data)
-    except Exception as e: print(f"❌ DB Error: {e}")
-
-init_db()
+CACHE_DURATION = 300
 
-# --- 🛡️ RAM GUARD ---
+# ================================
+# 🛡️ MEMORY GUARD
+# ================================
 def memory_guard():
     if psutil.virtual_memory().percent > 80:
         K.clear_session()
         gc.collect()
 
-# --- 🛠️ MOTEUR MATHS ---
-def get_ema(series, period): return series.ewm(span=period, adjust=False).mean()
+# ================================
+# 📊 INDICATORS
+# ================================
+def get_ema(series, period):
+    return series.ewm(span=period, adjust=False).mean()
+
 def get_rsi(series, period=14):
     delta = series.diff()
     gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
@@ -86,329 +80,249 @@ def get_atr(df, period=14):
     h_l = df['high'] - df['low']
     h_c = (df['high'] - df['close'].shift()).abs()
     l_c = (df['low'] - df['close'].shift()).abs()
-    return pd.concat([h_l, h_c, l_c], axis=1).max(axis=1).rolling(period).mean()
+    atr = pd.concat([h_l, h_c, l_c], axis=1).max(axis=1).rolling(period).mean()
+    return atr
 
-# --- 🧠 CHARGEMENT IA ---
+# ================================
+# 🧠 LOAD MODELS
+# ================================
 try:
     ml_model = joblib.load("ml_model_v9.pkl")
     time_model = joblib.load("time_model.pkl")
     regime_model = joblib.load("regime_model.pkl")
     regime_scaler = joblib.load("regime_scaler.pkl")
     lstm_brain = load_model("lstm_model.keras")
-    print("✅ Cerveaux opérationnels.")
-except Exception as e: print(f"⚠️ Erreur IA : {e}")
+    print("✅ IA chargées")
+except Exception as e:
+    print("⚠️ erreur chargement IA", e)
 
-# --- 📊 FEATURES ENGINE ---
+# ================================
+# 📊 FEATURE ENGINE
+# ================================
 async def prepare_all_features(symbol, timeframe='1h'):
     try:
         ex = ExchangeManager.get_instance()
-        now = datetime.now().timestamp()
-        
-        # 1. CLÉ DE CACHE UNIQUE (Symbol + Timeframe)
-        # Indispensable pour ne pas mélanger les bougies 5m avec le 1h
+        now = time.time()
         cache_key = f"{symbol}_{timeframe}"
 
-        if cache_key in market_cache and now - last_fetch_time[cache_key] < CACHE_DURATION:
+        if cache_key in market_cache and cache_key in last_fetch_time and now - last_fetch_time[cache_key] < CACHE_DURATION:
             df = market_cache[cache_key].copy()
-            # print(f"🚀 [CACHE] Data récupérée pour {cache_key}")
         else:
-            # 2. RÉCUPÉRATION DYNAMIQUE
-            # On utilise le paramètre 'timeframe' envoyé par le prédicteur
             bars = await ex.fetch_ohlcv(symbol, timeframe=timeframe, limit=600)
-            df = pd.DataFrame(bars, columns=['ts', 'open', 'high', 'low', 'close', 'vol'])
-            
-            # Stockage en cache avec la clé spécifique
+            df = pd.DataFrame(bars, columns=['ts','open','high','low','close','vol'])
             market_cache[cache_key] = df.copy()
             last_fetch_time[cache_key] = now
-            # print(f"📡 [NETWORK] Data fraîche pour {cache_key}")
 
-        if len(df) < 250: 
-            return pd.DataFrame()
+        if len(df) < 250: return pd.DataFrame()
 
-        # --- CALCUL DES INDICATEURS (VECTORISÉS) ---
         df["RSI"] = get_rsi(df["close"])
-        df["EMA50"] = get_ema(df["close"], 50)
-        df["EMA200"] = get_ema(df["close"], 200)
+        df["EMA50"] = get_ema(df["close"],50)
+        df["EMA200"] = get_ema(df["close"],200)
         df["ATR"] = get_atr(df)
-        df["ATR_pct"] = (df["ATR"] / df["close"]) * 100
-        df["EMA200_slope"] = (df["EMA200"] / df["EMA200"].shift(10)) - 1
-        df["Drawdown"] = (df["close"] / df["close"].rolling(14).max()) - 1
-        
-        # Features pour les modèles ML
+        df["ATR_pct"] = (df["ATR"]/df["close"])*100
+        df["EMA200_slope"] = (df["EMA200"]/df["EMA200"].shift(10))-1
+        df["Drawdown"] = (df["close"]/df["close"].rolling(14).max())-1
         df["High_24h"] = df["high"].rolling(24).max()
         df["Low_24h"] = df["low"].rolling(24).min()
-        df["Dist_High_24h"] = (df["High_24h"] - df["close"]) / df["close"]
-        df["Dist_Low_24h"] = (df["close"] - df["Low_24h"]) / df["close"]
-        df["EMA_dist"] = (df["close"] - df["EMA50"]) / df["EMA50"]
-        df["EMA_slope"] = (df["EMA50"] / df["EMA50"].shift(5)) - 1
-        df["ATR_ratio"] = df["ATR"] / df["close"]
-        df["VOL_ratio"] = df["vol"] / df["vol"].rolling(24).mean()
-        
-        # --- RENDEMENTS (BARS ADAPTATIVES) ---
-        # Note : pct_change(1) devient le rendement de la bougie actuelle 
-        # (5m, 1h, ou 1d selon ton choix)
-        df['return_1h'] = df['close'].pct_change(1)   # 1 bougie
-        df['return_3h'] = df['close'].pct_change(3)   # 3 bougies
-        df['return_12h'] = df['close'].pct_change(12) # 12 bougies
-        
-        df['RSI_lag1'] = df["RSI"].shift(1)
-        df['RSI_lag2'] = df["RSI"].shift(2)
-        df['VOL_RATIO'] = df['vol'] / df['vol'].rolling(20).mean()
-        df['vol_lag1'] = df['vol'].shift(1)
-        df["RSI_Macro"] = df["RSI"]
-        
-        return df.dropna().copy()
-        
+        df["Dist_High_24h"] = (df["High_24h"]-df["close"])/df["close"]
+        df["Dist_Low_24h"] = (df["close"]-df["Low_24h"])/df["close"]
+        df["EMA_dist"] = (df["close"]-df["EMA50"])/df["EMA50"]
+        df["EMA_slope"] = (df["EMA50"]/df["EMA50"].shift(5))-1
+        df["ATR_ratio"] = df["ATR"]/df["close"]
+        df["VOL_ratio"] = df["vol"]/df["vol"].rolling(24).mean()
+        df["return_1h"]=df["close"].pct_change(1)
+        df["return_3h"]=df["close"].pct_change(3)
+        df["return_12h"]=df["close"].pct_change(12)
+        df["RSI_lag1"]=df["RSI"].shift(1)
+        df["RSI_lag2"]=df["RSI"].shift(2)
+        df["vol_lag1"]=df["vol"].shift(1)
+        df["VOL_RATIO"]=df["vol"]/df["vol"].rolling(20).mean()
+        df["RSI_Macro"]=df["RSI"]
+
+        return df.dropna()
     except Exception as e:
-        print(f"❌ prepare_all_features Error ({symbol} - {timeframe}): {e}")
+        print("❌ feature error",e)
         return pd.DataFrame()
-# --- 🎯 API PRÉDICTION ---
-async def predict_signal(symbol, timeframe="1h"): 
+
+# ================================
+# 🎯 PREDICTION ENGINE (SMART MONEY)
+# ================================
+async def predict_signal(symbol, timeframe="1h"):
     try:
         memory_guard()
-        symbol = str(symbol).strip().upper()
+        symbol = symbol.upper()
         if "/USDT" not in symbol: symbol += "/USDT"
-        
-        # 1. Acquisition des données selon la Timeframe choisie
+
         df = await prepare_all_features(symbol, timeframe)
-        if df.empty: return {"status": "error", "message": f"Data insuffisante pour {timeframe}"}
-        
-        last_row = df.iloc[[-1]]
-        
-        # 2. Inférence des modèles individuels
-        # --- Modèle de Régime ---
-        regime_scaled = regime_scaler.transform(last_row[["ATR_pct", "EMA200_slope", "Drawdown", "RSI_Macro"]])
-        regime_pred = int(regime_model.predict(regime_scaled)[0])
-        
-        # --- Modèles Arbres (ML) ---
-        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])
-        
-        # --- Modèle Temporel (XGB) ---
-        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])
-        
-        # --- Modèle Deep Learning (LSTM) ---
-        lstm_seq = np.expand_dims(df[["close", "RSI", "EMA50", "EMA200", "ATR"]].iloc[-30:].values, axis=0)
-        lstm_prob = float(lstm_brain.predict(lstm_seq, verbose=0)[0][0])
-        
-        # --- Sentiment ---
+        if df.empty: return {"status":"error", "message": "No data"}
+
+        last = df.iloc[-1:]
+        price = float(last["close"].iloc[0])
+        atr = float(last["ATR"].iloc[0])
+        if np.isnan(atr): atr = price * 0.01
+
+        # --- FILTRES DE MARCHÉ ---
+        if float(last["ATR_pct"].iloc[0]) < 0.3:
+            return {"status":"skip", "reason":"low_volatility"}
+
+        pump = abs(df["close"].pct_change().iloc[-1])
+        if pump > 0.05:
+            return {"status":"skip", "reason":"pump_detected"}
+
+        # --- INFERENCE DES MODÈLES ---
+        regime_scaled = regime_scaler.transform(last[["ATR_pct","EMA200_slope","Drawdown","RSI_Macro"]])
+        regime = 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[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[time_cols])[0][1])
+
+        seq = df[["close","RSI","EMA50","EMA200","ATR"]].iloc[-30:]
+        seq = (seq - seq.mean()) / (seq.std() + 1e-9)
+        seq = np.expand_dims(seq.values, axis=0)
+        lstm_prob = float(lstm_brain.predict(seq, verbose=0)[0][0])
+        del seq
+        gc.collect()
+
         p_sent = await get_crypto_sentiment(symbol)
 
-        # 3. PONDÉRATION HYBRIDE DYNAMIQUE (V22.6)
-        # On définit les poids selon l'horizon de temps pour maximiser l'edge
+        # --- PONDÉRATION HYBRIDE ---
         if timeframe in ["5m", "15m"]:
-            # Mode Scalping : Priorité aux Arbres (Réaction rapide)
             wm, wt, wl, ws = 0.45, 0.35, 0.15, 0.05
-        elif timeframe in ["4h", "1d"]:
-            # Mode Swing : Priorité au LSTM (Mémoire des cycles)
+        elif timeframe in ["4h", "1d", "1D"]:
             wl, wm, wt, ws = 0.60, 0.15, 0.15, 0.10
         else:
-            # Mode Standard (1h) : Équilibre parfait
             wt, wm, wl, ws = 0.25, 0.25, 0.25, 0.25
         
         final_p = (time_prob * wt) + (ml_prob * wm) + (lstm_prob * wl) + (p_sent * ws)
 
-        # 4. CALCUL DU SCORE & RISK (INSTITUTIONAL GRADE)
-        # Force du signal (0.0 à 1.0)
+        # --- CALCUL DU SCORE & RISQUE ---
         strength = abs(final_p - 0.5) * 2
-        # Confluence (0.0 à 1.0) - Accord entre les 4 modèles
-        conf_val = (1 - np.std([time_prob, ml_prob, lstm_prob, p_sent]))
+        conf = max(0, min(1, 1 - np.std([ml_prob, time_prob, lstm_prob, p_sent])))
         
-        # Score Composite (0-100)
-        score_base = (strength * 45) + (conf_val * 40)
-        regime_bonus = 15 if regime_pred in [0, 1] else 5
+        score_base = (strength * 45) + (conf * 40)
+        regime_bonus = 15 if regime in [0, 1] else 5
         composite_score = max(0, min(100, score_base + regime_bonus))
 
-        # Risk Sizing Dynamique (0.2% à 2.5%)
         risk_pct = max(0.2, min(2.5, strength * 5.0))
 
-        # 5. SORTIES (TP/SL ADAPTATIFS)
-        prix, atr = float(last_row['close'].iloc[0]), float(last_row['ATR'].iloc[0])
-        # Multiplicateur plus large pour le Swing
-        mult = 4 if timeframe in ["4h", "1d"] else 3
-        tp = prix + (atr * mult) if final_p > 0.5 else prix - (atr * mult)
-        sl = prix - (atr * 1.5) if final_p > 0.5 else prix + (atr * 1.5)
+        # --- TP/SL DYNAMIQUES & GAIN USD ---
+        if timeframe == "5m": tp_m, sl_m = 1.5, 1.0
+        elif timeframe == "15m": tp_m, sl_m = 2.0, 1.2
+        elif timeframe == "1h": tp_m, sl_m = 3.0, 1.5
+        elif timeframe == "4h": tp_m, sl_m = 4.5, 2.0
+        elif timeframe in ["1d", "1D"]: tp_m, sl_m = 6.0, 2.5
+        else: tp_m, sl_m = 3.0, 1.5
+
+        tp = price + (atr * tp_m) if final_p > 0.5 else price - (atr * tp_m)
+        sl = price - (atr * sl_m) if final_p > 0.5 else price + (atr * sl_m)
 
-        # 6. SAUVEGARDE DB (Pour le Juge et le PnL)
-        db_task = (datetime.now(timezone.utc).isoformat(), symbol, 'HAUSSIER' if final_p > 0.5 else 'BAISSIER', 
-                   final_p, prix, tp, sl, 'EN_COURS', regime_pred, time_prob, ml_prob, lstm_prob, p_sent)
-        asyncio.create_task(save_to_db(db_task))
+        CAPITAL_VIRTUEL = 10000 
+        risk_usd = CAPITAL_VIRTUEL * (risk_pct / 100)
+        gain_estime_usd = risk_usd * (tp_m / sl_m)
 
-        # 7. RÉPONSE JSON COMPLÈTE
         return {
-            "symbol": symbol, 
+            "symbol": symbol,
             "timeframe": timeframe,
             "status": "success",
-            "final_score": round(final_p, 4), 
+            "final_score": round(final_p, 4),
             "score": int(composite_score),
             "risk_percent": round(risk_pct, 2),
-            "price": prix, 
-            "tp": round(tp, 6), 
+            "estimated_profit": round(gain_estime_usd, 2),
+            "price": price,
+            "volatility": round(float(last["ATR_pct"].iloc[0]), 2),
+            "tp": round(tp, 6),
             "sl": round(sl, 6),
-            "regime": regime_pred,
-            "confluence": round(conf_val * 100, 1),
-            "probs": {
-                "xgb": round(time_prob, 3), 
-                "rf": round(ml_prob, 3), 
-                "lstm": round(lstm_prob, 3), 
-                "sent": round(p_sent, 3)
-            },
-            "weights": {
-                "w_xgb": round(wt, 2), 
-                "w_rf": round(wm, 2), 
-                "w_lstm": round(wl, 2), 
-                "w_sent": round(ws, 2)
-            }
+            "regime": regime,
+            "confluence": round(conf * 100, 1),
+            "probs": {"xgb": round(time_prob, 3), "rf": round(ml_prob, 3), "lstm": round(lstm_prob, 3), "sent": round(p_sent, 3)},
+            "weights": {"w_xgb": round(wt, 2), "w_rf": round(wm, 2), "w_lstm": round(wl, 2), "w_sent": round(ws, 2)}
         }
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
-# --- 🧠 TRAINING ENGINE (RÉACTIVÉ) ---
-def trigger_training(symbol="BTC/USDT"):
-    try:
-        print(f"⚙️ Début de l'entraînement hebdomadaire pour {symbol}...")
-        memory_guard() # On vide la RAM avant de commencer
-        
-        from ml_model import train_model as train_ml
-        from time_model import train_time_model as train_time
-        
-        bars = exchange_sync.fetch_ohlcv(symbol, timeframe='1h', limit=1000)
-        df_train = pd.DataFrame(bars, columns=['ts', 'open', 'high', 'low', 'close', 'vol'])
-        
-        if len(df_train) < 300: return "❌ Erreur : Pas assez de bougies."
-        
-        train_ml(df_train)
-        train_time(df_train)
-        
-        # Rechargement à chaud
-        global ml_model, time_model
-        ml_model = joblib.load("ml_model_v9.pkl")
-        time_model = joblib.load("time_model.pkl")
-        
-        gc.collect()
-        return f"✅ IA ré-entraînée avec succès ({len(df_train)} bougies)."
-    except Exception as e: return f"❌ Erreur Training : {str(e)}"
 
-# --- ⚖️ TOOLS (FONCTIONS MANQUANTES) ---
-def keep_alive_ping():
-    """Répond au bot Discord pour confirmer que le cerveau est réveillé"""
-    return {"status": "awake", "time": datetime.now(timezone.utc).isoformat()}
-
-async def check_data_count(symbol):
-    """Vérifie la disponibilité des données OHLCV"""
-    try:
-        ex = ExchangeManager.get_instance()
-        bars = await ex.fetch_ohlcv(symbol, timeframe='1h', limit=1000)
-        count = len(bars)
-        needed = 250
-        percent = min(100, (count / needed) * 100)
-        return {"count": count, "percent": round(percent, 1), "needed": needed}
     except Exception as e:
         return {"status": "error", "message": str(e)}
 
+# ================================
+# ⚖️ LE JUGE (AVEC TRAILING STOP)
+# ================================
 async def run_judge_api():
     try:
-        conn = sqlite3.connect(DB_NAME)
-        conn.row_factory = sqlite3.Row
-        cursor = conn.cursor()
-
-        cursor.execute("SELECT * FROM signals WHERE status = 'EN_COURS'")
-        active_trades = cursor.fetchall()
-
-        if not active_trades:
-            conn.close()
-            return "⚖️ [JUGE] Aucun trade actif."
-
+        conn = sqlite3.connect("alphatrade_v9.db")
+        cur = conn.cursor()
+        # On ajoute le prix d'entrée à la requête pour calculer le Trailing
+        cur.execute("SELECT id, symbol, tp, sl, direction, price FROM signals WHERE status='EN_COURS'")
+        rows = cur.fetchall()
+        ex = exchange_sync
         updates = 0
         trailing_updates = 0
-        ex = exchange_sync 
 
-        for trade in active_trades:
-            symbol = trade['symbol']
+        for r in rows:
+            # Assure-toi que ta table a bien la colonne 'price'. Si elle ne l'a pas, enlève 'price' de la DB
+            # et retire la logique "potential_sl" qui en dépend.
+            id, symbol, tp, sl, dir, entry_price = r
             ticker = ex.fetch_ticker(symbol)
-            current_price = ticker['last']
+            current_price = ticker["last"]
             
-            trade_id = trade['id']
-            direction = trade['direction']
-            tp = trade['tp']
-            sl = trade['sl']
-            entry_price = trade['price']
-
-            # --- 1. CALCUL DU TRAILING STOP ---
-            # On utilise un écart de sécurité (Buffer). Ici, on peut ré-estimer l'ATR 
-            # ou utiliser un pourcentage (ex: 1.5%). 
-            # Utilisons 1.5% du prix actuel comme distance de suivi.
-            trail_buffer = current_price * 0.015 
-            
-            new_status = 'EN_COURS'
-
-            if direction == 'HAUSSIER':
-                # Vérification TP/SL classique
-                if current_price >= tp: new_status = 'GAGNÉ ✅'
-                elif current_price <= sl: new_status = 'PERDU ❌'
-                
-                # Logique Trailing : Si le prix monte, on remonte le SL
-                # Nouveau SL potentiel = Prix Actuel - Buffer
-                potential_sl = current_price - trail_buffer
-                if current_price > entry_price and potential_sl > sl:
-                    cursor.execute("UPDATE signals SET sl = ? WHERE id = ?", (potential_sl, trade_id))
-                    trailing_updates += 1
-
-            elif direction == 'BAISSIER':
-                # Vérification TP/SL classique
-                if current_price <= tp: new_status = 'GAGNÉ ✅'
-                elif current_price >= sl: new_status = 'PERDU ❌'
-                
-                # Logique Trailing : Si le prix baisse, on descend le SL
-                potential_sl = current_price + trail_buffer
-                if current_price < entry_price and potential_sl < sl:
-                    cursor.execute("UPDATE signals SET sl = ? WHERE id = ?", (potential_sl, trade_id))
-                    trailing_updates += 1
-
-            # --- 2. MISE À JOUR DU STATUT FINAL ---
-            if new_status != 'EN_COURS':
-                cursor.execute("UPDATE signals SET status = ? WHERE id = ?", (new_status, trade_id))
-                updates += 1
+            trail_buffer = current_price * 0.015 # 1.5% de buffer pour le suiveur
+
+            if dir == "HAUSSIER":
+                if current_price >= tp:
+                    cur.execute("UPDATE signals SET status='WIN' WHERE id=?", (id,))
+                    updates += 1
+                elif current_price <= sl:
+                    cur.execute("UPDATE signals SET status='LOSS' WHERE id=?", (id,))
+                    updates += 1
+                else:
+                    # Trailing Stop Long
+                    potential_sl = current_price - trail_buffer
+                    if current_price > entry_price and potential_sl > sl:
+                        cur.execute("UPDATE signals SET sl=? WHERE id=?", (potential_sl, id))
+                        trailing_updates += 1
+
+            else: # BAISSIER
+                if current_price <= tp:
+                    cur.execute("UPDATE signals SET status='WIN' WHERE id=?", (id,))
+                    updates += 1
+                elif current_price >= sl:
+                    cur.execute("UPDATE signals SET status='LOSS' WHERE id=?", (id,))
+                    updates += 1
+                else:
+                    # Trailing Stop Short
+                    potential_sl = current_price + trail_buffer
+                    if current_price < entry_price and potential_sl < sl:
+                        cur.execute("UPDATE signals SET sl=? WHERE id=?", (potential_sl, id))
+                        trailing_updates += 1
 
         conn.commit()
         conn.close()
-        
-        return f"✅ Juge : {updates} terminés | {trailing_updates} Stop-Loss ajustés (Trailing)."
+        return f"✅ Juge : {updates} trades terminés | {trailing_updates} Trailing Stops ajustés"
 
     except Exception as e:
-        if 'conn' in locals(): conn.close()
-        return f"❌ Erreur Juge : {str(e)}"
-# --- 🎨 INTERFACE GRADIO ---
-with gr.Blocks(theme=gr.themes.Monochrome()) as iface:
-    gr.Markdown("# 📡 Alpha V21.2 Master Engine")
-    with gr.Tab("Admin"):
-        train_btn = gr.Button("Forcer Entraînement Hebdomadaire", variant="stop")
-        train_out = gr.Textbox(label="Résultat")
-        train_btn.click(fn=trigger_training, outputs=train_out, api_name="trigger_training")
-    with gr.Tab("🎯 Prédictions"):
-        sym_input = gr.Textbox(label="Symbole")
-        tf_input = gr.Dropdown(choices=["5m", "15m", "1h", "4h", "1d"], value="1h", label="Timeframe")
-        btn_pred = gr.Button("Predict", variant="primary")
-        out_json = gr.JSON()
-    # On ajoute tf_input dans les entrées du clic
-    btn_pred.click(fn=predict_signal, inputs=[sym_input, tf_input], outputs=out_json)
-    with gr.Tab("⚖️ Système"):
-        btn_j = gr.Button("Judge")
-        out_j = gr.Textbox()
-        btn_j.click(fn=run_judge_api, outputs=out_j, api_name="run_judge_api")
-        
-        # ✅ FIX : On utilise 'out_json' au lieu de 'out'
-        # Et on utilise 'sym_input' qui est le nom défini dans ton onglet Prédictions
-        data_check_btn = gr.Button("Vérifier Données", visible=False)
-        data_check_btn.click(
-            fn=check_data_count, 
-            inputs=sym_input, 
-            outputs=out_json, 
-            api_name="check_data_status"
-        )
-        
-        btn_ping = gr.Button("Ping", visible=False)
-        btn_ping.click(fn=keep_alive_ping, outputs=gr.JSON(), api_name="keep_alive_ping")
+        return str(e)
+
+# ================================
+# 🔌 SHUTDOWN SAFE
+# ================================
+async def shutdown():
+    ex = ExchangeManager.get_instance()
+    await ex.close()
+
+# ================================
+# 🌐 API
+# ================================
+with gr.Blocks() as iface:
+    gr.Markdown("# 🚀 Alpha Engine V22.1 (Institutional Grade)")
+    sym = gr.Textbox(label="Symbol")
+    tf = gr.Dropdown(["5m","15m","1h","4h","1d"], value="1h")
+    btn = gr.Button("Predict Signal")
+    out = gr.JSON()
+    btn.click(fn=predict_signal, inputs=[sym, tf], outputs=out)
+    
+    judge_btn = gr.Button("Run Judge")
+    judge_out = gr.Textbox()
+    judge_btn.click(fn=run_judge_api, outputs=judge_out)
 
 if __name__ == "__main__":
     iface.launch(show_api=True)