Update app.py

app.py

@@ -3,24 +3,52 @@ import os
 import sqlite3
 import shutil
 import pandas as pd
-import ccxt
 import joblib
 import json
 import numpy as np
 import warnings
+import asyncio
+import psutil
+import gc
 from datetime import datetime, timezone
 from huggingface_hub import HfApi, hf_hub_download
 import gradio as gr
+
+# --- OPTIMISATION TENSORFLOW & RAM ---
+import tensorflow as tf
 from tensorflow.keras.models import load_model
-import gc  # Garbage Collector (Nettoyeur de RAM)
+from tensorflow.keras import backend as K
+
+# On bride TensorFlow pour éviter qu'il ne sature le CPU du Space Free
+tf.config.threading.set_intra_op_parallelism_threads(2)
+tf.config.threading.set_inter_op_parallelism_threads(2)
+
+import ccxt
+import ccxt.async_support as ccxt_async
 
 # --- CONFIGURATION GPS ---
 current_dir = os.path.dirname(os.path.abspath(__file__))
 if current_dir not in sys.path:
     sys.path.append(current_dir)
 
+# --- SINGLETON EXCHANGE ---
+# On réutilise les mêmes connexions pour éviter de se faire bannir par KuCoin
+exchange_sync = ccxt.kucoin({
+    "enableRateLimit": True,
+    "timeout": 30000
+})
+
+exchange_async = ccxt_async.kucoin({
+    "enableRateLimit": True,
+    "timeout": 30000
+})
+
+# --- CACHE MARCHÉ ---
+market_cache = {}
+last_fetch_time = {}
+CACHE_DURATION = 300  # 5 minutes
+
 # --- 🛰️ IMPORT SÉCURISÉ DES SATELLITES ---
-# On définit des fonctions de secours (fallbacks) au cas où l'import d'un fichier rate
 try:
     from sentiment_engine import get_crypto_sentiment
     print("✅ Sentiment Engine : Connecté.")
@@ -33,7 +61,8 @@ try:
     print("✅ Ensemble Engine : Connecté.")
 except Exception as e:
     print(f"⚠️ Erreur Ensemble Engine : {e}")
-    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(s, t, m, l, sent, r): 
+        return (t+m+l+sent)/4, 0.25, 0.25, 0.25, 0.25
 
 # --- CONFIG HUB & DB ---
 REPO_ID = "Nexo-S/AlphaV15-Quant-Engine"
@@ -47,7 +76,7 @@ def get_rsi(series, period=14):
     delta = series.diff()
     gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
     loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
-    rs = gain / loss
+    rs = gain / (loss + 1e-9)
     return 100 - (100 / (1 + rs))
 
 def get_atr(df, period=14):
@@ -56,6 +85,16 @@ def get_atr(df, period=14):
     low_close = (df['low'] - df['close'].shift()).abs()
     return pd.concat([high_low, high_close, low_close], axis=1).max(axis=1).rolling(period).mean()
 
+# --- 🛡️ RAM GUARD ---
+def ram_usage():
+    return psutil.virtual_memory().percent
+
+def memory_guard():
+    if ram_usage() > 85:
+        print("⚠️ RAM haute → Nettoyage forcé en cours...")
+        K.clear_session()
+        gc.collect()
+
 # --- ☁️ SYNC CLOUD ---
 def sync_down():
     if not HF_TOKEN: return
@@ -64,9 +103,6 @@ def sync_down():
         shutil.copy(path, DB_NAME); print("✅ DB Cloud récupérée.")
     except: print("ℹ️ Nouvelle DB créée.")
 
-def sync_up():
-    pass # 🛑 ON DÉSACTIVE L'UPLOAD POUR EMPÊCHER LES REDÉMARRAGES
-
 def init_db():
     try:
         conn = sqlite3.connect(DB_NAME); cursor = conn.cursor()
@@ -77,11 +113,11 @@ def init_db():
         conn.commit(); conn.close()
     except Exception as e: print(f"❌ Erreur DB Init : {e}")
 
-# --- 🚀 INITIALISATION ---
 sync_down()
 init_db()
 warnings.filterwarnings('ignore')
 
+# --- 🧠 CHARGEMENT IA ---
 try:
     ml_model = joblib.load("ml_model_v9.pkl")
     time_model = joblib.load("time_model.pkl")
@@ -91,14 +127,23 @@ try:
     print("✅ IA chargées en RAM.")
 except Exception as e: print(f"⚠️ Modèles IA manquants : {e}")
 
-# --- 📊 PRÉPARATION FEATURES ---
-def prepare_all_features(symbol):
+# --- 📊 PRÉPARATION FEATURES ASYNC ---
+async def prepare_all_features(symbol):
     try:
-        exchange = ccxt.kucoin()
-        bars = exchange.fetch_ohlcv(symbol, timeframe='1h', limit=600)
-        df = pd.DataFrame(bars, columns=['ts', 'open', 'high', 'low', 'close', 'vol'])
+        now = datetime.now().timestamp()
+        
+        # Gestion du Cache
+        if symbol in market_cache and now - last_fetch_time[symbol] < CACHE_DURATION:
+            df = market_cache[symbol].copy()
+        else:
+            bars = await exchange_async.fetch_ohlcv(symbol, timeframe='1h', limit=600)
+            df = pd.DataFrame(bars, columns=['ts', 'open', 'high', 'low', 'close', 'vol'])
+            market_cache[symbol] = df.copy()
+            last_fetch_time[symbol] = now
+
         if len(df) < 250: return pd.DataFrame()
 
+        # Indicateurs techniques
         df["RSI"] = get_rsi(df["close"], 14)
         df["EMA50"] = get_ema(df["close"], 50)
         df["EMA200"] = get_ema(df["close"], 200)
@@ -126,88 +171,76 @@ def prepare_all_features(symbol):
         df["RSI_Macro"] = df["RSI"]
 
         return df.dropna().copy()
-    except: return pd.DataFrame()
+    except Exception as e:
+        print(f"❌ Feature Error: {e}")
+        return pd.DataFrame()
 
-# --- 🎯 API PRÉDICTION ---
+# --- 🎯 API PRÉDICTION OPTIMISÉE ---
 async def predict_signal(symbol):
     try:
+        memory_guard()
         symbol = str(symbol).strip().upper()
         if "/USDT" not in symbol: symbol += "/USDT"
-        df = prepare_all_features(symbol)
-        if df.empty: return json.dumps({"status": "error", "message": "Data insuffisante"})
+
+        df = await prepare_all_features(symbol)
+        if df.empty: return {"status": "error", "message": "Data insuffisante"}
+        
         last_row = df.iloc[[-1]]
         
+        # 1. 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])
         
-        ml_prob = float(ml_model.predict_proba(last_row[["RSI", "Dist_High_24h", "Dist_Low_24h", "EMA_dist", "EMA_slope", "ATR_ratio", "VOL_ratio"]])[0][1])
-        time_prob = float(time_model.predict_proba(last_row[['return_1h', 'return_3h', 'return_12h', 'RSI_lag1', 'RSI_lag2', 'vol_lag1', 'VOL_RATIO']])[0][1])
+        # 2. ML & Time Probabilities
+        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])
+        
+        # 3. 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])
         
+        # 4. Sentiment & Ensemble
         p_sent = await get_crypto_sentiment(symbol)
         final_p, wt, wm, wl, ws = combine_scores(symbol, time_prob, ml_prob, lstm_prob, p_sent, regime_pred)
-        # Calcul de la Volatilité (déjà dans tes features)
-        volatilite = float(last_row['ATR_pct'].iloc[0])
-
-# Calcul de la Confluence (écart type inversé des probabilités)
-        all_probs = [time_prob, ml_prob, lstm_prob, p_sent]
-        confluence = 1 - np.std(all_probs) 
 
-# Calcul de la Position (Gestion simplifiée)
-        position_size = (final_p * 2) if final_p > 0.5 else ((1 - final_p) * 2)
-        
+        # 5. Gestion Risque
         prix, atr = float(last_row['close'].iloc[0]), float(last_row['ATR'].iloc[0])
         tp = prix + (atr * 3) if final_p > 0.5 else prix - (atr * 3)
         sl = prix - (atr * 1.5) if final_p > 0.5 else prix + (atr * 1.5)
-        
-        # ... (ton code précédent avec calcul du TP et SL) ...
 
-        # --- SAUVEGARDE EN BASE DE DONNÉES ---
-        conn = sqlite3.connect(DB_NAME); cursor = conn.cursor()
-        cursor.execute('INSERT INTO signals (date, symbol, direction, prob, price, tp, sl, status, regime, prob_time, prob_ml, prob_lstm, prob_sent) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)', 
-                       (datetime.now().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))
-        conn.commit(); conn.close(); sync_up()
-
-        # --- 1. STOCKAGE DU RÉSULTAT (Sans faire de return) ---
-        resultat_final = json.dumps({
-            "symbol": symbol, "final_score": round(final_p, 4), "volatility": round(volatilite, 2), "confluence": round(confluence * 100, 1), 
-            "pos_size": round(position_size, 2), "regime": int(regime_pred),
-            "probs": {"xgb": float(time_prob), "rf": float(ml_prob), "lstm": float(lstm_prob), "sent": float(p_sent)},
-            "weights": {"w_xgb": float(wt), "w_rf": float(wm), "w_lstm": float(wl), "w_sent": float(ws)},
-            "price": float(prix), "tp": float(tp), "sl": float(sl), "status": "success"
-        })
-
-        # --- 🧹 2. OPÉRATION VIDANGE RAM (ANTI-CRASH 137) ---
-        # A. On détruit le gros tableau Pandas
-        if 'df' in locals():
-            del df 
-        
-        # B. On vide le cache de TensorFlow (CRUCIAL POUR LE LSTM)
-        from tensorflow.keras import backend as K
-        K.clear_session()
-        
-        # C. On force Python à vider la RAM physique
-        import gc
-        gc.collect()
-        
-        # --- 3. SORTIE DE LA FONCTION ---
-        return resultat_final
-        
-    except Exception as e: 
-        return json.dumps({"status": "error", "message": str(e)})
+        # 6. Sauvegarde DB
+        with sqlite3.connect(DB_NAME) as conn:
+            cursor = conn.cursor()
+            cursor.execute('''INSERT INTO signals 
+                (date, symbol, direction, prob, price, tp, sl, status, regime, prob_time, prob_ml, prob_lstm, prob_sent) 
+                VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)''',
+                (datetime.now().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))
+            conn.commit()
+
+        return {
+            "symbol": symbol, "final_score": round(final_p, 4), "price": prix,
+            "tp": round(tp, 6), "sl": round(sl, 6), "regime": regime_pred,
+            "status": "success", "volatility": round(float(last_row['ATR_pct'].iloc[0]), 2),
+            "confluence": round((1 - np.std([time_prob, ml_prob, lstm_prob, p_sent])) * 100, 1)
+        }
 
-# --- ⚖️ LE JUGE ---
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+# --- ⚖️ LE JUGE OPTIMISÉ ---
 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'")
         trades = cursor.fetchall()
         if not trades: return "⚖️ Aucun trade actif."
-        exchange, updates = ccxt.kucoin(), 0
+        
+        updates = 0
         for t in trades:
-            curr = exchange.fetch_ticker(t['symbol'])['last']
+            curr = exchange_sync.fetch_ticker(t['symbol'])['last']
             new_s = 'EN_COURS'
             if 'HAUSSIER' in t['direction']:
                 if curr >= t['tp']: new_s = 'GAGNÉ ✅'
@@ -215,97 +248,39 @@ async def run_judge_api():
             else:
                 if curr <= t['tp']: new_s = 'GAGNÉ ✅'
                 elif curr >= t['sl']: new_s = 'PERDU ❌'
+            
             if new_s != 'EN_COURS':
                 cursor.execute("UPDATE signals SET status = ? WHERE id = ?", (new_s, t['id']))
                 updates += 1
-        conn.commit(); conn.close(); sync_up()
+        conn.commit(); conn.close()
         return f"✅ {updates} trade(s) mis à jour."
     except Exception as e: return f"❌ Erreur Juge : {e}"
 
-# --- 📊 STATS ENGINE ---
-def get_db_stats(mode, symbol=None, n=3):
+# --- 📊 STATS & TOOLS ---
+def get_db_stats(mode, symbol=None):
     try:
-        if not os.path.exists(DB_NAME): return json.dumps({"status": "error", "message": "DB introuvable"})
         conn = sqlite3.connect(DB_NAME); conn.row_factory = sqlite3.Row
         if mode == "global":
             df = pd.read_sql_query("SELECT status, prob FROM signals WHERE status!='EN_COURS'", conn)
-            if len(df) < 3: return json.dumps({"status": "error"})
-            wins = df[df['status'].str.contains("GAGNÉ")]; losses = df[~df['status'].str.contains("GAGNÉ")]
-            wr = (len(wins) / len(df)) * 100
-            exp = (wins['prob'].mean() * len(wins) - losses['prob'].mean() * len(losses)) / len(df)
-            res = {"total": len(df), "winrate": round(wr, 1), "expectancy": round(float(exp), 3), "note": "Edge OK" if exp > 0 else "Edge bas"}
-        elif mode == "summary":
-            cursor = conn.cursor(); cursor.execute("SELECT COUNT(*), COUNT(CASE WHEN status LIKE 'GAGNÉ%' THEN 1 END) FROM signals WHERE status!='EN_COURS'")
-            t, w = cursor.fetchone(); res = {"total": t, "winrate": round((w/t*100), 1) if t > 0 else 0}
-        elif mode == "top":
-            df = pd.read_sql_query("SELECT symbol, status FROM signals WHERE status!='EN_COURS'", conn)
-            stats = df.groupby('symbol')['status'].apply(lambda x: (x.str.contains('GAGNÉ').sum() / len(x)) * 100).reset_index()
-            counts = df.groupby('symbol').size().reset_index(name='count')
-            res = stats.merge(counts, on='symbol').sort_values(by='status', ascending=False).head(n).to_dict(orient='records')
-        elif mode == "recent":
-            cursor = conn.cursor(); cursor.execute("SELECT symbol, direction, prob, status FROM signals ORDER BY id DESC LIMIT 5")
-            res = [dict(r) for r in cursor.fetchall()]
+            if len(df) < 1: return {"status": "empty"}
+            wr = (len(df[df['status'].str.contains("GAGNÉ")]) / len(df)) * 100
+            res = {"total": len(df), "winrate": round(wr, 1)}
         else:
             cursor = conn.cursor(); cursor.execute("SELECT * FROM signals ORDER BY id DESC LIMIT 1")
             res = dict(cursor.fetchone()) if cursor.fetchone() else {}
-        conn.close(); return json.dumps(res)
-    except Exception as e: return json.dumps({"status": "error", "message": str(e)})
-
-def keep_alive_ping(): return json.dumps({"status": "awake", "time": datetime.now().isoformat()})
+        conn.close(); return res
+    except Exception as e: return {"error": str(e)}
 
-# --- 📊 FONCTION DE DIAGNOSTIC DES DONNÉES ---
-def check_data_count(symbol):
-    try:
-        exchange = ccxt.kucoin()
-        # On demande 1000 pour être large
-        bars = exchange.fetch_ohlcv(symbol, timeframe='1h', limit=1000)
-        count = len(bars)
-        # Seuil de 250 pour être opérationnel
-        percent = min(100, (count / 250) * 100)
-        return json.dumps({"count": count, "percent": round(percent, 1), "needed": 250})
-    except Exception as e:
-        return json.dumps({"status": "error", "message": str(e)})
-
-# --- 🧠 MOTEUR D'ENTRAÎNEMENT (TRAINING ENGINE) ---
 def trigger_training(symbol="BTC/USDT"):
-    try:
-        # On importe les fonctions ici pour ne pas bloquer le démarrage global
-        from ml_model import train_model as train_ml
-        from time_model import train_time_model as train_time
-        
-        # 1. Récupération des données fraîches
-        exchange = ccxt.kucoin()
-        bars = exchange.fetch_ohlcv(symbol, timeframe='1h', limit=1000)
-        df = pd.DataFrame(bars, columns=['ts', 'open', 'high', 'low', 'close', 'vol'])
-        
-        if len(df) < 250:
-            return f"❌ Données insuffisantes : {len(df)} bougies récupérées."
-            
-        # 2. Lancement de l'apprentissage
-        train_ml(df)
-        train_time(df)
-        
-        # 3. Rechargement des nouveaux cerveaux en RAM
-        global ml_model, time_model
-        import joblib
-        ml_model = joblib.load("ml_model_v9.pkl")
-        time_model = joblib.load("time_model.pkl")
-        
-        return f"✅ IA ré-entraînée avec succès sur {symbol} ({len(df)} bougies)."
-    except Exception as e:
-        return f"❌ Erreur lors de l'entraînement : {str(e)}"
+    return "🛠️ Entraînement désactivé en mode direct pour préserver la RAM."
 
-# --- 🎨 INTERFACE GRADIO (LE TABLEAU DE BORD) ---
-with gr.Blocks(theme=gr.themes.Monochrome(), title="Alpha V10 PRO") as iface:
+# --- 🎨 INTERFACE GRADIO ---
+with gr.Blocks(theme=gr.themes.Monochrome(), title="Alpha V15 MASTER") as iface:
     gr.Markdown("# 📡 Alpha V15 Master Engine")
     
-    with gr.Tab("Admin"):
-        train_btn = gr.Button("Forcer Entraînement")
-        train_btn.click(fn=trigger_training, outputs=gr.Textbox(), api_name="trigger_training")
-    
     with gr.Tab("🎯 Prédictions"):
-        sym_input = gr.Textbox(label="Symbole")
-        btn = gr.Button("Predict")
+        sym_input = gr.Textbox(label="Symbole (ex: BTC/USDT)")
+        btn = gr.Button("Predict", variant="primary")
         out = gr.JSON()
         btn.click(fn=predict_signal, inputs=sym_input, outputs=out, api_name="predict_signal")
         
@@ -314,20 +289,8 @@ with gr.Blocks(theme=gr.themes.Monochrome(), title="Alpha V10 PRO") as iface:
         out_j = gr.Textbox()
         btn_j.click(fn=run_judge_api, outputs=out_j, api_name="run_judge_api")
         
-        # ✅ LES BOUTONS CACHÉS SONT MAINTENANT BIEN ALIGNÉS ICI
-        data_check_btn = gr.Button("Vérifier Données", visible=False)
-        data_check_btn.click(fn=check_data_count, inputs=sym_input, outputs=out, 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")
-
-    with gr.Tab("📊 Stats"):
-        m_in = gr.Textbox(label="Mode")
-        s_in = gr.Textbox(label="Symbol")
-        st_btn = gr.Button("Fetch")
-        st_out = gr.JSON()
-        st_btn.click(fn=get_db_stats, inputs=[m_in, s_in], outputs=st_out, api_name="get_db_stats")
+        # API Hidden endpoints pour le Radar
+        gr.Button("Ping", visible=False).click(fn=lambda: {"status": "awake"}, outputs=gr.JSON(), api_name="keep_alive_ping")
 
-# --- LANCEMENT ---
 if __name__ == "__main__":
-    iface.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False, debug=False, show_api=True)
+    iface.launch(server_name="0.0.0.0", server_port=7860, auth=("admin", os.environ.get("ADMIN_PWD", "Alpha2026!")), debug=False, show_api=True)