Update app.py

app.py

@@ -594,6 +594,10 @@ async def predict_signal(symbol, timeframe="1h"):
         if veto:
             return {"symbol": symbol, "timeframe": timeframe, "status": "veto", "message": veto_reason, "scenario": final_scenario}
 
+        # 🛑 8.5 ANTI-SPAM (On bloque ici si le signal a déjà été envoyé)
+        if not should_send_signal(symbol, timeframe, final_p):
+            return {"symbol": symbol, "timeframe": timeframe, "status": "veto", "message": "Anti-Spam Actif (Déjà envoyé)", "scenario": final_scenario}
+
         # 💾 9. ENREGISTREMENT DB
         db_task = (datetime.now(timezone.utc).isoformat(), symbol, timeframe, 'HAUSSIER' if final_p > 0.5 else 'BAISSIER', final_p, prix, tp, sl, 'EN_COURS', final_scenario, time_prob, ml_prob, dino_prob, p_sent, prix)
         await save_to_db(db_task)
@@ -605,55 +609,64 @@ async def predict_signal(symbol, timeframe="1h"):
         }
     except Exception as e: return {"status": "error", "message": str(e)}
         
-# =============================
 # =============================
 def mutate_agent(symbol, timeframe, regime, success=True):
-    try:
-        import sqlite3, random, numpy as np
-        with sqlite3.connect(DB_NAME) as conn:
-            conn.row_factory = sqlite3.Row
-            row = conn.execute(
-                "SELECT * FROM agent_logic WHERE symbol = ? AND timeframe = ? AND regime = ?",
-                (symbol, timeframe, regime)
-            ).fetchone()
-
-            if not row:
-                res_def = conn.execute(
-                    "SELECT * FROM agent_logic WHERE symbol = 'ALL' AND timeframe = ?",
-                    (timeframe,)
+    import sqlite3, random, numpy as np, time
+    
+    for tentative in range(5): # 🔄 Tente 5 fois si la base est verrouillée
+        try:
+            with sqlite3.connect(DB_NAME, timeout=20) as conn:
+                conn.row_factory = sqlite3.Row
+                row = conn.execute(
+                    "SELECT * FROM agent_logic WHERE symbol = ? AND timeframe = ? AND regime = ?",
+                    (symbol, timeframe, regime)
                 ).fetchone()
-                tp, sl, prob = (res_def['tp_mult'], res_def['sl_mult'], res_def['min_prob']) if res_def else (1.5, 1.0, 0.60)
-            else:
-                tp, sl, prob = row['tp_mult'], row['sl_mult'], row['min_prob']
 
-            # 🧠 MUTATION DOUCE
-            if success:
-                new_tp = tp * random.uniform(1.01, 1.05)
-                new_sl = sl * random.uniform(0.98, 1.00)
-                new_prob = max(0.55, prob - 0.003)
-            else:
-                new_tp = tp * random.uniform(0.95, 0.99)
-                new_sl = sl * random.uniform(1.01, 1.05)
-                new_prob = min(0.85, prob + 0.005)
-
-            # 🛡️ HARD CLAMP (ANTI-EXPLOSION)
-            new_tp = float(np.clip(new_tp, 0.5, 3.0))
-            new_sl = float(np.clip(new_sl, 0.5, 2.0))
-
-            conn.execute('''
-                INSERT OR REPLACE INTO agent_logic 
-                (symbol, timeframe, regime, tp_mult, sl_mult, min_prob, min_tp_dist, generation)
-                VALUES (?, ?, ?, ?, ?, ?, ?, 
-                    COALESCE((SELECT generation FROM agent_logic WHERE symbol=? AND timeframe=? AND regime=?)+1, 1))
-            ''', (
-                symbol, timeframe, regime,
-                new_tp, new_sl, new_prob, 0.001,
-                symbol, timeframe, regime
-            ))
-            conn.commit()
+                if not row:
+                    res_def = conn.execute(
+                        "SELECT * FROM agent_logic WHERE symbol = 'ALL' AND timeframe = ?",
+                        (timeframe,)
+                    ).fetchone()
+                    tp, sl, prob = (res_def['tp_mult'], res_def['sl_mult'], res_def['min_prob']) if res_def else (1.5, 1.0, 0.60)
+                else:
+                    tp, sl, prob = row['tp_mult'], row['sl_mult'], row['min_prob']
+
+                # 🧠 MUTATION DOUCE
+                if success:
+                    new_tp = tp * random.uniform(1.01, 1.05)
+                    new_sl = sl * random.uniform(0.98, 1.00)
+                    new_prob = max(0.55, prob - 0.003)
+                else:
+                    new_tp = tp * random.uniform(0.95, 0.99)
+                    new_sl = sl * random.uniform(1.01, 1.05)
+                    new_prob = min(0.85, prob + 0.005)
+
+                # 🛡️ HARD CLAMP (ANTI-EXPLOSION)
+                new_tp = float(np.clip(new_tp, 0.5, 3.0))
+                new_sl = float(np.clip(new_sl, 0.5, 2.0))
+
+                conn.execute('''
+                    INSERT OR REPLACE INTO agent_logic 
+                    (symbol, timeframe, regime, tp_mult, sl_mult, min_prob, min_tp_dist, generation)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, 
+                        COALESCE((SELECT generation FROM agent_logic WHERE symbol=? AND timeframe=? AND regime=?)+1, 1))
+                ''', (
+                    symbol, timeframe, regime,
+                    new_tp, new_sl, new_prob, 0.001,
+                    symbol, timeframe, regime
+                ))
+                conn.commit()
+                return # ✅ Succès, on sort de la fonction
 
-    except Exception as e:
-        print(f"🧬 Erreur Mutation V32: {e}")
+        except sqlite3.OperationalError as e:
+            if "locked" in str(e):
+                time.sleep(1) # La porte est bloquée, on attend 1 seconde
+            else:
+                print(f"❌ [ERREUR DB] Mutation échouée : {e}")
+                break
+        except Exception as e:
+            print(f"🧬 Erreur Mutation V32: {e}")
+            break
 
 
 # =============================
@@ -727,15 +740,14 @@ async def dream_simulation_loop():
         await asyncio.sleep(60)
 
 def should_send_signal(symbol, timeframe, proba):
+    global last_signals_sent
     key = (symbol, timeframe)
     now = time.time()
     
     if key in last_signals_sent:
         last_proba, last_time = last_signals_sent[key]
-        # 1. Filtre de similitude (LaTeX pour la précision)
-        # On ignore si la proba a bougé de moins de 2%
-        # 🔥 filtre proba (Tolérance augmentée à 10%)
-        if abs(last_proba - proba) < 0.10 and (now - last_time) < 900:
+        # 🛡️ Tolérance stricte : 5% d'écart max, et blocage pendant 1 heure (3600s)
+        if abs(last_proba - proba) < 0.05 and (now - last_time) < 3600:
             return False
             
     last_signals_sent[key] = (proba, now)