Upload app.py

app.py

@@ -79,7 +79,7 @@ except:
 
 # --- DB & SYNC ---
 REPO_ID = "Nexo-S/AlphaV15-Quant-Engine"
-DB_NAME = "alphatrade_v10.db" # 🎮 NOUVEAU MONDE - NIVEAU 0
+DB_NAME = "alphatrade_v22_scalp.db" # 🎮 NOUVEAU MONDE - NIVEAU 0
 HF_TOKEN = os.environ.get("HF_TOKEN")
 
 def init_db():
@@ -90,7 +90,6 @@ def init_db():
             cursor = conn.execute("PRAGMA table_info(signals)")
             columns = [col[1] for col in cursor.fetchall()]
             conn.close()
-            # 🔍 On ajoute 'confirmed' dans la vérification de structure
             if 'date' not in columns or 'peak_price' not in columns or 'confirmed' not in columns:
                 reset_needed = True
         except Exception as e:
@@ -98,21 +97,19 @@ def init_db():
             reset_needed = True
 
     if reset_needed:
-        print("⚠️ Structure obsolète. Reset de la base de données pour la Poignée de Main V14...")
+        print("⚠️ Structure obsolète. Reset de la base de données...")
         if os.path.exists(DB_NAME): os.remove(DB_NAME)
 
     try:
         with sqlite3.connect(DB_NAME) as conn:
-            # --- 🛡️ TABLE DES SIGNAUX (MISE À JOUR) ---
             conn.execute('''CREATE TABLE IF NOT EXISTS signals (
                 id INTEGER PRIMARY KEY AUTOINCREMENT, 
                 date TEXT, symbol TEXT, timeframe 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,
                 peak_price REAL,
-                confirmed INTEGER DEFAULT 0)''') # <--- AJOUTE CETTE COLONNE ICI
+                confirmed INTEGER DEFAULT 0)''')
             
-            # --- 🚀 AUTO-MIGRATION V12 (Reste inchangé) ---
             cursor = conn.cursor()
             cursor.execute("PRAGMA table_info(agent_logic)")
             al_cols = [col[1] for col in cursor.fetchall()]
@@ -135,11 +132,14 @@ def init_db():
 
             cursor.execute("SELECT COUNT(*) FROM agent_logic")
             if cursor.fetchone()[0] == 0:
-                defaults = [('ALL', '5m', 1.5, 1.0, 0, 0, 0.60, 0.003), ('ALL', '15m', 2.0, 1.2, 0, 0, 0.55, 0.004),
-                            ('ALL', '1h', 2.5, 1.5, 0, 0, 0.52, 0.005), ('ALL', '4h', 3.0, 2.0, 0, 0, 0.50, 0.008),
-                            ('ALL', '1d', 4.0, 2.5, 0, 0, 0.50, 0.01)]
+                # ⚡ NOUVEAU: Defaults ultra-agressifs pour le Scalping
+                defaults = [('ALL', '1m', 1.0, 0.8, 0, 0, 0.65, 0.001), 
+                            ('ALL', '5m', 1.2, 0.9, 0, 0, 0.62, 0.002), 
+                            ('ALL', '15m', 1.5, 1.0, 0, 0, 0.60, 0.003), 
+                            ('ALL', '1h', 2.0, 1.5, 0, 0, 0.55, 0.005),
+                            ('ALL', '4h', 3.0, 2.0, 0, 0, 0.50, 0.008)]
                 conn.executemany("INSERT INTO agent_logic VALUES (?, ?, ?, ?, ?, ?, ?, ?)", defaults)
-        print("✅ Base de données V14 (Synchronisée avec Pterodactyl) opérationnelle.")
+        print("✅ Base de données Scalping (MT5 Exness) opérationnelle.")
     except Exception as e:
         print(f"❌ Erreur critique création DB: {e}")
 
@@ -191,6 +191,12 @@ try:
 except Exception as e: print(f"⚠️ Erreur IA : {e}")
 
 # --- 📊 FEATURES ENGINE ---
+def get_vwap(df):
+    """Calcul du Volume Weighted Average Price (Outil #1 du Scalpeur)"""
+    v = df['vol']
+    tp = (df['high'] + df['low'] + df['close']) / 3
+    return (tp * v).cumsum() / v.cumsum()
+
 def prepare_features_sync(symbol, timeframe='1h', limit_bars=600):
     try:
         now = datetime.now().timestamp()
@@ -208,21 +214,29 @@ def prepare_features_sync(symbol, timeframe='1h', limit_bars=600):
 
         if len(df) < 250: return pd.DataFrame()
 
+        # --- FONDATIONS TECHNIQUES ---
         df["RSI"] = get_rsi(df["close"])
+        df["RSI_9"] = get_rsi(df["close"], 9) # ⚡ NOUVEAU: RSI Nerveux pour Scalping
         df["EMA50"] = get_ema(df["close"], 50)
         df["EMA200"] = get_ema(df["close"], 200)
+        df["VWAP"] = get_vwap(df)             # ⚡ NOUVEAU: Le juge de paix
         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
+        
+        # --- DISTANCES & SLOPES ---
         df["High_24h"], df["Low_24h"] = df["high"].rolling(24).max(), 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["Price_vs_VWAP"] = (df["close"] - df["VWAP"]) / df["VWAP"] # ⚡ Distance au VWAP
         df["ATR_ratio"] = df["ATR"] / df["close"]
         df["VOL_ratio"] = df["vol"] / df["vol"].rolling(24).mean()
+        df["Vol_Spike"] = df["vol"] / df["vol"].rolling(5).mean()     # ⚡ NOUVEAU: Explosion de volume
         
+        # --- SMC & FIBO ---
         diff = df["High_24h"] - df["Low_24h"]
         df["Fib_618"] = df["Low_24h"] + (diff * 0.618)
         df["Dist_Fib_618"] = (df["close"] - df["Fib_618"]) / df["close"]
@@ -245,6 +259,8 @@ def prepare_features_sync(symbol, timeframe='1h', limit_bars=600):
         p_low, p_high = df["low"].rolling(24).min().shift(1), df["high"].rolling(24).max().shift(1)
         df["Sweep_Low"] = ((df["low"] < p_low) & (df["close"] > p_low)).astype(int)
         df["Sweep_High"] = ((df["high"] > p_high) & (df["close"] < p_high)).astype(int)
+        
+        # --- FEATURES POUR LES MODELES ---
         df['return_1h'], df['return_3h'], df['return_12h'] = df['close'].pct_change(1), df['close'].pct_change(3), df['close'].pct_change(12)
         df['RSI_lag1'], df['RSI_lag2'] = df["RSI"].shift(1), df["RSI"].shift(2)
         df['VOL_RATIO'] = df['vol'] / df['vol'].rolling(20).mean()
@@ -258,14 +274,16 @@ async def predict_signal(symbol, timeframe="1h"):
         memory_guard()
         symbol = str(symbol).strip().upper()
         
-        # 1. Préparation des données
         df = prepare_features_sync(symbol, timeframe)
         if df.empty: return {"status": "error", "message": f"Data insuffisante pour {timeframe}"}
         
         last_row = df.iloc[[-1]]
         prix, atr = float(last_row['close'].iloc[0]), float(last_row['ATR'].iloc[0])
+        vwap = float(last_row['VWAP'].iloc[0])           # ⚡ Extraction VWAP
+        vol_spike = float(last_row['Vol_Spike'].iloc[0]) # ⚡ Extraction Spike
+        rsi_9 = float(last_row['RSI_9'].iloc[0])         # ⚡ Extraction RSI Rapide
         
-        # 2. Analyse des 3 cerveaux
+        # --- 🧠 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"]
@@ -277,14 +295,17 @@ async def predict_signal(symbol, timeframe="1h"):
         lstm_prob = float(lstm_brain.predict(np.expand_dims(lstm_data.values, axis=0), verbose=0)[0][0])
         p_sent = await get_crypto_sentiment(symbol)
 
-        # 3. Pondération adaptative
-        if timeframe in ["5m", "15m"]: wm, wt, wl, ws = 0.45, 0.35, 0.15, 0.05
-        elif timeframe in ["4h", "1d"]: wl, wm, wt, ws = 0.60, 0.15, 0.15, 0.10
-        else: wt, wm, wl, ws = 0.25, 0.25, 0.25, 0.25
+        # --- ⚖️ PONDÉRATION ADAPTATIVE (FOCUS MOMENTUM SCALPING) ---
+        if timeframe in ["1m", "5m", "15m"]: 
+            wt, wm, wl, ws = 0.50, 0.25, 0.15, 0.10 # On fait confiance au TimeModel pour la vitesse
+        elif timeframe in ["1h", "4h", "1d"]: 
+            wl, wm, wt, ws = 0.60, 0.15, 0.15, 0.10
+        else: 
+            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. Bonus Smart Money (SMC)
+        # --- 🐋 BONUS SMART MONEY & SCALPING NITRO ---
         sweep_low, sweep_high = int(last_row["Sweep_Low"].iloc[0]), int(last_row["Sweep_High"].iloc[0])
         smc_status = "AUCUN"
         if sweep_low == 1:
@@ -293,18 +314,22 @@ async def predict_signal(symbol, timeframe="1h"):
         elif sweep_high == 1:
             final_p = max(0.05, final_p - 0.20)
             smc_status = "SHORT SWEEP 🐋"
-
-        # 5. Calcul TP/SL (V12 ISOLATION PAR SYMBOLE)
+            
+        # ⚡ NITRO SCALPING : Si on a un pic de volume dans le sens de la tendance
+        if timeframe in ["1m", "5m"]:
+            if final_p > 0.5 and vol_spike > 1.5 and rsi_9 < 70:
+                final_p = min(0.95, final_p + 0.10) # Coup de boost à l'achat
+            elif final_p < 0.5 and vol_spike > 1.5 and rsi_9 > 30:
+                final_p = max(0.05, final_p - 0.10) # Coup de boost à la vente
+
+        # --- 🛡️ CALCUL TP/SL (BASE DE DONNÉES ISOLÉE) ---
         with sqlite3.connect(DB_NAME) as conn:
-            # On cherche les stats pour CE symbole précis
             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
             else:
-                # Si le symbole n'existe pas encore, on prend les stats de base ('ALL')
                 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 (3.0, 1.5, 0.55, 0.004)
-                # On initialise immédiatement le nouveau cerveau dans la DB
+                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)
                 conn.execute("INSERT OR IGNORE INTO agent_logic (symbol, timeframe, tp_mult, sl_mult, score, last_pnl, min_prob, min_tp_dist) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", 
                              (symbol, timeframe, tp_m, sl_m, 0, 0, agent_min_prob, agent_min_tp_dist))
                 conn.commit()
@@ -312,7 +337,7 @@ async def predict_signal(symbol, timeframe="1h"):
         tp = prix + (atr * tp_m) if final_p > 0.5 else prix - (atr * tp_m)
         sl = prix - (atr * sl_m) if final_p > 0.5 else prix + (atr * sl_m)
 
-        # 6. Scores
+        # Scores et Regimes
         strength = abs(final_p - 0.5) * 2
         conf_val = max(0, min(1, 1 - np.std([time_prob, ml_prob, lstm_prob, p_sent])))
         score_base = (strength * 45) + (conf_val * 40)
@@ -320,15 +345,14 @@ async def predict_signal(symbol, timeframe="1h"):
         composite_score = max(0, min(100, score_base + regime_bonus))
 
         # ==========================================
-        # 🛑 LE VETO DYNAMIQUE (BOUCLIER EMA200)
+        # 🛑 LE VETO DYNAMIQUE (BOUCLIER EMA200 + VWAP)
         # ==========================================
         veto = False
         veto_reason = ""
         dist_tp_pct = abs(tp - prix) / prix
         dist_fib = float(last_row["Dist_Fib_618"].iloc[0])
         mkt_trend = float(last_row["Market_Trend"].iloc[0])
-        ema200_slope_val = float(last_row["EMA200_slope"].iloc[0])
-        ema200_val = float(last_row["EMA200"].iloc[0]) # 🚀 NOUVEAU: On extrait la ligne EMA 200
+        ema200_val = float(last_row["EMA200"].iloc[0]) 
 
         if final_p < agent_min_prob and final_p > (1 - agent_min_prob):
             veto, veto_reason = True, f"Confiance ({round(final_p, 2)}) < {round(agent_min_prob, 2)}"
@@ -339,14 +363,13 @@ 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 timeframe in ["5m", "15m"] and smc_status == "AUCUN": veto, veto_reason = True, "Aucun Sweep SMC"
         elif dist_tp_pct < agent_min_tp_dist: veto, veto_reason = True, "Gain potentiel trop faible"
         
-        # 🛡️ LE GARDE-FOU ABSOLU (Interdiction stricte de contrer le TGV)
-        elif final_p < 0.5 and prix > ema200_val: 
-            veto, veto_reason = True, "Garde-Fou: Prix > EMA200 (Short Suicide 🚫)"
-        elif final_p > 0.5 and prix < ema200_val: 
-            veto, veto_reason = True, "Garde-Fou: Prix < EMA200 (Long Suicide 🚫)"
+        # 🛡️ LE GARDE-FOU ABSOLU (Interdiction stricte de contrer le TGV institutionnel)
+        elif final_p < 0.5 and (prix > ema200_val or prix > vwap): 
+            veto, veto_reason = True, "Garde-Fou: Prix > EMA200/VWAP (Short Interdit 🚫)"
+        elif final_p > 0.5 and (prix < ema200_val or prix < vwap): 
+            veto, veto_reason = True, "Garde-Fou: Prix < EMA200/VWAP (Long Interdit 🚫)"
 
         if veto:
             print(f"🛑 [VETO] {symbol}: {veto_reason}")
@@ -405,8 +428,8 @@ def trigger_training(symbol="BTC/USD"):
         return f"❌ Erreur Training : {str(e)}"
 
 # --- 🚀 MOTEUR AUTO-PILOTE ---
-AUTO_SYMBOLS = ["BTC/USD", "ETH/USD", "SOL/USD", "BNB/USD"]
-AUTO_TIMEFRAMES = ["5m", "15m", "1h", "4h", "1d"]
+AUTO_SYMBOLS = ["BTC/USD"]
+AUTO_TIMEFRAMES = ["1m", "5m", "15m", "1h", "4h"]
 
 async def auto_predict_loop():
     while True:
@@ -522,7 +545,7 @@ def run_judge_api():
                     ticker = exchange_sync.fetch_ticker(fetch_symbol)
                     current_price = ticker['last']
                     
-                    # --- 🚀 LOGIQUE TRAILING STOP (RESPIRATION V16) ---
+                    # --- 🚀 LOGIQUE TRAILING STOP (SCALPING AGRESSIF) ---
                     sl_dynamique = t['sl']
                     peak = t['peak_price']
                     
@@ -534,26 +557,25 @@ def run_judge_api():
                     
                     nouveau_sl = sl_dynamique
                     
-                    # --- 🛡️ LA STRATÉGIE DE L'ÉTAU (DESSERRÉ) ---
-                    # On laisse le marché respirer pour éviter de se faire tuer par le Spread
+                    # --- 🛡️ LA STRATÉGIE DE L'ÉTAU (SERRÉ POUR SCALPING) ---
                     if t['direction'] == 'HAUSSIER':
-                        # PALIER 3 : 80% du but -> On verrouille 60%
-                        if progression >= 0.80:
+                        # PALIER 3 : 75% du but -> On verrouille 60%
+                        if progression >= 0.75:
                             nouveau_sl = max(sl_dynamique, t['price'] + (chemin_total * 0.60))
-                        # PALIER 2 : 60% du but -> On verrouille 30%
-                        elif progression >= 0.60:
-                            nouveau_sl = max(sl_dynamique, t['price'] + (chemin_total * 0.30))
-                        # PALIER 1 : 40% du but -> BREAK-EVEN (On a assez de marge pour couvrir les frais)
-                        elif progression >= 0.40:
-                            nouveau_sl = max(sl_dynamique, t['price'])
+                        # PALIER 2 : 50% du but -> On verrouille 25% (On est déjà en profit assuré)
+                        elif progression >= 0.50:
+                            nouveau_sl = max(sl_dynamique, t['price'] + (chemin_total * 0.25))
+                        # PALIER 1 : 25% du but -> BREAK-EVEN (Serrage très rapide)
+                        elif progression >= 0.25:
+                            nouveau_sl = max(sl_dynamique, t['price'] + (chemin_total * 0.05)) # BE + Micro profit pour couvrir commission
                             
                     else: # BAISSIER (SELL)
-                        if progression >= 0.80:
+                        if progression >= 0.75:
                             nouveau_sl = min(sl_dynamique, t['price'] - (chemin_total * 0.60))
-                        elif progression >= 0.60:
-                            nouveau_sl = min(sl_dynamique, t['price'] - (chemin_total * 0.30))
-                        elif progression >= 0.40:
-                            nouveau_sl = min(sl_dynamique, t['price'])
+                        elif progression >= 0.50:
+                            nouveau_sl = min(sl_dynamique, t['price'] - (chemin_total * 0.25))
+                        elif progression >= 0.25:
+                            nouveau_sl = min(sl_dynamique, t['price'] - (chemin_total * 0.05))
 
                     sl_dynamique = nouveau_sl
                     cursor.execute("UPDATE signals SET peak_price = ?, sl = ? WHERE id = ?", (new_peak, sl_dynamique, t['id']))
@@ -579,55 +601,47 @@ def run_judge_api():
 
                     if outcome:
                         # =========================================================
-                        # --- 🪞 LA VÉRITÉ BRUTALE (CALCUL PNL RÉEL V16) ---
+                        # --- 🪞 LA VÉRITÉ BRUTALE (EXNESS MT5 EDITION) ---
                         # =========================================================
-                        # On simule l'exposition réelle avec levier pour le calcul des centimes
-                        taille_position_virtuelle = 500.0 
+                        taille_position_virtuelle = 1000.0 # Standard pour estimer
                         
-                        # On simule la taxe invisible de Capital.com (le Spread)
-                        spread_commission = 0.50 
+                        # ⚡ NOUVEAU: Exness a des spreads très serrés (surtout Raw/Zero), on ajuste l'estimation
+                        # Sur BTC, le spread tourne autour de 0.5 à 2.0 pips. On compte aussi la commission.
+                        spread_commission_estimee = 0.25 
                         
-                        # 1. Calcul du gain brut basé sur le VRAI mouvement de prix
                         if t['direction'] == 'HAUSSIER':
                             pnl_brut = ((current_price - t['price']) / t['price']) * taille_position_virtuelle
                         else:
                             pnl_brut = ((t['price'] - current_price) / t['price']) * taille_position_virtuelle
                             
-                        # 2. Le vrai PNL net (Ce qui atterrit sur ton compte)
-                        pnl_dollars = pnl_brut - spread_commission
+                        pnl_dollars = pnl_brut - spread_commission_estimee
                         
-                        # 3. Correction honnête du statut Discord
                         if outcome == "SL TOUCHÉ 🛡️" and pnl_dollars < 0:
-                            outcome = "TUÉ PAR LE SPREAD 🩸"
+                            outcome = "TUÉ PAR LE SPREAD/COMM 🩸"
                         elif outcome == "GAGNÉ (PARTIEL) 💸" and pnl_dollars <= 0:
-                            outcome = "FAUX GAIN (SPREAD) 📉" 
+                            outcome = "FAUX GAIN (FRAIS EXNESS) 📉" 
 
-                        # =========================================================
-                        # --- 🎮 V12 : ÉVOLUTION RPG (ISOLATION + ANTI YO-YO) ---
-                        # =========================================================
+                        # --- 🎮 ÉVOLUTION RPG ---
                         cursor.execute("SELECT tp_mult, sl_mult, score, min_prob FROM agent_logic WHERE symbol = ? AND timeframe = ?", (t['symbol'], t['timeframe']))
                         row = cursor.fetchone()
                         
                         if row:
                             tp_m, sl_m, score_ia, min_p = row
                         else:
-                            # Fallback si jamais la DB a raté la création
-                            tp_m, sl_m, score_ia, min_p = (3.0, 1.5, 0, 0.55)
+                            tp_m, sl_m, score_ia, min_p = (1.5, 1.0, 0, 0.55)
                             cursor.execute("INSERT INTO agent_logic (symbol, timeframe, tp_mult, sl_mult, score, min_prob) VALUES (?, ?, ?, ?, ?, ?)", 
                                            (t['symbol'], t['timeframe'], tp_m, sl_m, score_ia, min_p))
 
-                        # LISSAGE ANTI YO-YO (Amortissement à 1.5%)
                         if reward > 0:
-                            tp_m = min(5.0, tp_m * 1.015) 
+                            tp_m = min(4.0, tp_m * 1.01) # Moins d'inflation de TP pour garder le mode Scalp
                             min_p = max(0.50, min_p - 0.005) 
                         elif reward < 0:
-                            sl_m = max(1.0, sl_m * 0.985) 
-                            tp_m = max(1.5, tp_m * 0.985) 
+                            sl_m = max(0.8, sl_m * 0.985) # On serre le SL si on perd
+                            tp_m = max(1.1, tp_m * 0.985) # On abaisse le TP si on perd trop (Scalping de survie)
                             min_p = min(0.65, min_p + 0.01) 
 
                         cursor.execute("UPDATE agent_logic SET tp_mult=?, sl_mult=?, score=score+?, min_prob=? WHERE symbol=? AND timeframe=?",
                                        (tp_m, sl_m, reward, min_p, t['symbol'], t['timeframe']))
-                        # =========================================================
 
                         cursor.execute("UPDATE signals SET status=? WHERE id=?", (outcome, t['id']))