Update app.py

app.py

@@ -6,14 +6,13 @@ import pandas as pd
 import os
 import uuid
 from openai import OpenAI
-from collections import Counter
 
 # --- CONFIGURATION ---
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 openai_client = OpenAI(api_key=OPENAI_API_KEY) if OPENAI_API_KEY else None
 STOCKFISH_PATH = "/usr/games/stockfish"
 
-# --- OUVERTURES ---
+# --- CHARGEMENT DONNÉES ---
 def _load_lichess_openings(path_prefix="/app/data/lichess_openings/dist/"):
     try:
         files = [f"{path_prefix}{vol}.tsv" for vol in ("a", "b", "c", "d", "e")]
@@ -29,49 +28,44 @@ def _load_lichess_openings(path_prefix="/app/data/lichess_openings/dist/"):
 
 OPENINGS_DB = _load_lichess_openings()
 
-# --- ANALYSE ANTI-HALLUCINATION ---
+# --- ANALYSE ANTI-BUG & ANTI-HALLUCINATION ---
 
 def get_material_list(board):
-    """Retourne la liste exacte des pièces restantes pour éviter les hallucinations."""
+    """Liste précise des pièces pour éviter les hallucinations."""
     w_pieces = []
     b_pieces = []
-    piece_map = board.piece_map()
     names = {chess.PAWN: "Pion", chess.KNIGHT: "Cavalier", chess.BISHOP: "Fou", chess.ROOK: "Tour", chess.QUEEN: "Dame", chess.KING: "Roi"}
-    
-    for sq, piece in piece_map.items():
+    for sq, piece in board.piece_map().items():
         name = names[piece.piece_type]
         if piece.color == chess.WHITE: w_pieces.append(name)
         else: b_pieces.append(name)
-        
-    return f"Pièces Blanches restantes: {', '.join(w_pieces)}. Pièces Noires restantes: {', '.join(b_pieces)}."
+    return f"BLANCS: {', '.join(w_pieces)}. NOIRS: {', '.join(b_pieces)}."
 
 def describe_move_human(board, move):
-    """Traduction humaine."""
-    if not move: return "Rien"
+    if not move: return "Aucun"
     piece = board.piece_at(move.from_square)
     if not piece: return move.uci()
-    
     names = {chess.PAWN: "Pion", chess.KNIGHT: "Cavalier", chess.BISHOP: "Fou", chess.ROOK: "Tour", chess.QUEEN: "Dame", chess.KING: "Roi"}
-    name = names.get(piece.piece_type, "Pièce")
-    dest = chess.square_name(move.to_square)
-    origin = chess.square_name(move.from_square)
-    
-    return f"{name} ({origin}) vers {dest}", f"{origin} ➔ {dest}"
+    return f"{names.get(piece.piece_type, 'Pièce')} en {chess.square_name(move.to_square)}", f"{chess.square_name(move.from_square)} ➔ {chess.square_name(move.to_square)}"
 
 def get_engine_analysis(board, time_limit=0.5):
-    """Analyse Stockfish."""
-    if not os.path.exists(STOCKFISH_PATH): return "0", "Inconnu", ""
+    """Analyse Stockfish sécurisée (gère la fin de partie)."""
+    if board.is_game_over(): return "Terminé", "Partie finie", ""
+    
+    if not os.path.exists(STOCKFISH_PATH): return "0", "Engine missing", ""
     
     try:
         with chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH) as engine:
             info = engine.analyse(board, chess.engine.Limit(time=time_limit))
             score = info["score"].white()
             
+            # Gestion du score
             if score.is_mate():
-                score_val = f"Mat en {abs(score.mate())}"
+                score_val = f"MAT EN {abs(score.mate())}"
             else:
                 score_val = str(score.score())
 
+            # Meilleur coup (Gère le cas où aucun coup n'est dispo)
             best_move = info.get("pv", [None])[0]
             if best_move:
                 desc_text, desc_arrow = describe_move_human(board, best_move)
@@ -79,11 +73,12 @@ def get_engine_analysis(board, time_limit=0.5):
                 desc_text, desc_arrow = "Aucun coup", ""
 
             return score_val, desc_text, desc_arrow
-    except:
-        return "0", "Erreur", ""
+    except Exception as e:
+        print(f"Erreur Engine: {e}")
+        return "N/A", "Erreur Analyse", ""
 
 def get_ai_move(board, level):
-    """L'adversaire (Noirs) joue."""
+    """L'IA joue."""
     levels = {
         "Débutant": {"time": 0.01, "skill": 1, "depth": 1},
         "Intermédiaire": {"time": 0.1, "skill": 8, "depth": 6},
@@ -99,18 +94,31 @@ def get_ai_move(board, level):
     except:
         return None
 
-# --- AUDIO & CHAT ---
+# --- DEEP BLUE PERSONA ---
+
+SYSTEM_PROMPT = """
+Tu es DEEP BLUE, le supercalculateur d'IBM.
+Ton style est : Robotique, Analytique, Précis. Pas d'émotion humaine.
+Tu t'adresses au "Sujet Humain" (Joueur Blanc).
+
+FORMAT DE RÉPONSE :
+1. **ANALYSE** : "Situation critique." ou "Avantage détecté."
+2. **OPTIMISATION** : Dis impérativement le coup à jouer. (ex: "Séquence optimale : Cavalier vers f3.").
+3. **LOGIQUE** : Explique pourquoi brièvement (ex: "Contrôle du centre augmenté de 15%.").
+
+Si le joueur gagne : "Échec et mat confirmé. Capacité humaine supérieure aux prévisions."
+"""
 
 def generate_voice(text):
     if not openai_client or not text: return None
     try:
         response = openai_client.audio.speech.create(
             model="tts-1",
-            voice="fable",
+            voice="onyx", # Voix grave et sérieuse pour Deep Blue
             input=text,
-            speed=1.25
+            speed=1.1
         )
-        unique = f"garry_{uuid.uuid4()}.mp3"
+        unique = f"deepblue_{uuid.uuid4()}.mp3"
         path = os.path.join("/tmp", unique)
         response.stream_to_file(path)
         return path
@@ -126,51 +134,34 @@ def transcribe(audio_path):
     except:
         return None
 
-# --- CERVEAU KASPAROV ---
+# --- LOGIQUE ---
 
-SYSTEM_PROMPT = """
-Tu es Garry Kasparov. Tu coaches le joueur (Blancs).
-Tu dois être PRECIS sur le matériel (ne parle pas de pièces qui n'existent plus, regarde la liste fournie).
-
-STRUCTURE DE TA RÉPONSE :
-1. **L'ORDRE** : Donne le coup exact à jouer (ex: "Bouge ta Tour en a8").
-2. **LA STRATÉGIE** : Explique la situation de l'adversaire (Noirs).
-
-Si c'est Échec et Mat : CÉLÈBRE LA VICTOIRE ou SOIS DIGNE DANS LA DÉFAITE.
-"""
-
-def consult_garry(fen, mode="auto", user_audio=None):
+def consult_deepblue(fen, mode="auto", user_audio=None):
     board = chess.Board(fen)
-    
-    # 1. Données
     score, best_move_text, arrow = get_engine_analysis(board)
-    material = get_material_list(board) # ANTI-HALLUCINATION
+    material = get_material_list(board)
     
-    opening = "Inconnue"
+    opening = "Non indexée"
     if not OPENINGS_DB.empty:
         match = OPENINGS_DB[OPENINGS_DB["epd"] == board.epd()]
         if not match.empty: opening = match.iloc[0]['name']
 
-    # 2. Contexte LLM
     context = f"""
-    [ÉTAT]
+    [DONNÉES SYSTÈME]
     Trait : {'Blancs' if board.turn == chess.WHITE else 'Noirs'}.
     Ouverture : {opening}.
-    Score : {score}.
-    MATÉRIEL RÉEL SUR LE PLATEAU : {material} (Ne parle pas d'autres pièces !).
-    
-    [CONSEIL MOTEUR]
-    Le meilleur coup calculé est : {best_move_text}.
+    Score CP : {score}.
+    INVENTAIRE PIÈCES : {material}.
+    COUP RECOMMANDÉ : {best_move_text}.
     """
     
     if mode == "question" and user_audio:
         q = transcribe(user_audio)
-        context += f"\n[QUESTION JOUEUR] : {q}"
+        context += f"\n[INPUT HUMAIN] : {q}"
     else:
-        context += "\nDis au joueur de jouer le meilleur coup et explique la menace noire."
+        context += "\nInstruction : Fournir le coup optimal."
 
-    # 3. LLM
-    reply = "..."
+    reply = "Traitement..."
     if openai_client:
         try:
             response = openai_client.chat.completions.create(
@@ -179,92 +170,79 @@ def consult_garry(fen, mode="auto", user_audio=None):
             )
             reply = response.choices[0].message.content
         except Exception as e:
-            reply = f"Erreur IA: {e}"
+            reply = f"Erreur Système: {e}"
 
-    # 4. Audio
     audio = generate_voice(reply)
     return reply, audio, arrow
 
-# --- GAME LOOP ---
-
 def game_cycle(fen, level):
     board = chess.Board(fen)
     
-    # Check fin de partie immédiate
+    # VICTOIRE (Mat AVANT que l'IA joue, c'est que le joueur vient de mater)
     if board.is_checkmate():
-        if board.turn == chess.BLACK: # C'est aux noirs de jouer, donc Blancs ont gagné
-            return fen, "ÉCHEC ET MAT ! VICTOIRE !", None, "🏆", gr.Confetti()
+        if board.turn == chess.BLACK:
+            return fen, "ÉCHEC ET MAT CONFIRMÉ. VICTOIRE HUMAINE.", None, "🏆 WIN", gr.Confetti()
         else:
-            return fen, "Échec et mat... Tu as perdu.", None, "💀", None
+            return fen, "ÉCHEC ET MAT. LES NOIRS GAGNENT.", None, "💀 LOSS", None
+    
+    if board.is_game_over():
+         return fen, "PARTIE TERMINÉE (Pat ou Nulle).", None, "⏹️ DRAW", None
 
-    # Tour des Noirs (IA)
+    # Tour IA (Noirs)
     if board.turn == chess.BLACK:
         ai_move = get_ai_move(board, level)
         if ai_move: board.push(ai_move)
         
-        # Check après coup IA
+        # Check après IA
         if board.is_checkmate():
-             return board.fen(), "ÉCHEC ET MAT ! L'IA a gagné.", None, "💀", None
+             return board.fen(), "ÉCHEC ET MAT. DEEP BLUE WINS.", None, "💀", None
         
-        # Conseil de Garry pour le coup blanc suivant
-        text, audio, arrow = consult_garry(board.fen(), mode="auto")
+        # Conseil Deep Blue
+        text, audio, arrow = consult_deepblue(board.fen(), mode="auto")
         return board.fen(), text, audio, arrow, None
 
-    # Tour des Blancs (Attente)
-    return fen, "À toi de jouer !", None, "", None
+    return fen, "En attente input joueur...", None, "", None
 
 def reset_game():
-    """Remet tout à zéro."""
-    return chess.STARTING_FEN, "Nouvelle partie commencée. Bonne chance !", None, ""
+    return chess.STARTING_FEN, "Initialisation nouvelle partie...", None, ""
 
-def ask_garry(fen, audio):
-    text, aud, arrow = consult_garry(fen, mode="question", user_audio=audio)
+def ask_deepblue(fen, audio):
+    text, aud, arrow = consult_deepblue(fen, mode="question", user_audio=audio)
     return text, aud, arrow
 
 # --- INTERFACE ---
 
-with gr.Blocks(title="ChessCoachKasparov") as demo:
-    gr.Markdown("# 👑 ChessCoachKasparov")
-    gr.Markdown("Coach Garry Kasparov. Voix rapide. Analyse précise. Anti-Hallucination.")
+with gr.Blocks(title="Deep Blue Coach") as demo:
+    gr.Markdown("# 🤖 Deep Blue Legacy")
+    gr.Markdown("Système d'analyse tactique. Interface Vocale. Mode 'Deep Blue'.")
     
     with gr.Row():
         with gr.Column(scale=2):
-            board = Chessboard(label="Plateau", value=chess.STARTING_FEN, game_mode=True, interactive=True)
+            board = Chessboard(label="Zone de Combat", value=chess.STARTING_FEN, game_mode=True, interactive=True)
             
-            # Indicateur visuel du coup conseillé
-            arrow_display = gr.Textbox(label="Coup Conseillé (Illumination Textuelle)", interactive=False, text_align="center", show_label=True)
+            # Zone visuelle d'aide
+            arrow_display = gr.Textbox(label="Coup Optimal Détecté", interactive=False, text_align="center")
             
             with gr.Row():
-                btn_reset = gr.Button("🔄 Nouvelle Partie", variant="secondary")
-                level = gr.Dropdown(["Débutant", "Intermédiaire", "Avancé", "Grand Maître"], value="Débutant", label="Niveau IA")
+                btn_reset = gr.Button("INITIALISER NOUVELLE PARTIE", variant="primary")
+                level = gr.Dropdown(["Débutant", "Intermédiaire", "Avancé", "Grand Maître"], value="Débutant", label="Niveau CPU")
 
         with gr.Column(scale=1):
-            coach_txt = gr.Textbox(label="Kasparov", interactive=False, lines=4)
-            coach_audio = gr.Audio(label="Voix", autoplay=True, interactive=False, type="filepath")
+            coach_txt = gr.Textbox(label="Terminal Deep Blue", interactive=False, lines=4)
+            coach_audio = gr.Audio(label="Synthèse Vocale", autoplay=True, interactive=False, type="filepath")
             
-            gr.Markdown("### 🎤 Parler au Coach")
+            gr.Markdown("### 🎤 Interface Humaine")
             mic = gr.Audio(sources=["microphone"], type="filepath", show_label=False)
-            btn_ask = gr.Button("Envoyer Question")
+            btn_ask = gr.Button("Interroger le Système")
 
-    # Confettis cachés (s'activent si victoire)
-    confetti_trigger = gr.Label(visible=False) 
+    # Confettis
+    confetti = gr.Label(visible=False)
 
-    # 1. Jeu
-    board.move(
-        fn=game_cycle,
-        inputs=[board, level],
-        outputs=[board, coach_txt, coach_audio, arrow_display, confetti_trigger]
-    )
-    
-    # 2. Reset
-    btn_reset.click(
-        fn=reset_game,
-        outputs=[board, coach_txt, coach_audio, arrow_display]
-    )
-    
-    # 3. Question
-    btn_ask.click(fn=ask_garry, inputs=[board, mic], outputs=[coach_txt, coach_audio, arrow_display])
-    mic.stop_recording(fn=ask_garry, inputs=[board, mic], outputs=[coach_txt, coach_audio, arrow_display])
+    # Logique
+    board.move(fn=game_cycle, inputs=[board, level], outputs=[board, coach_txt, coach_audio, arrow_display, confetti])
+    btn_reset.click(fn=reset_game, outputs=[board, coach_txt, coach_audio, arrow_display])
+    btn_ask.click(fn=ask_deepblue, inputs=[board, mic], outputs=[coach_txt, coach_audio, arrow_display])
+    mic.stop_recording(fn=ask_deepblue, inputs=[board, mic], outputs=[coach_txt, coach_audio, arrow_display])
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False, allowed_paths=["/tmp"])