Update app.py

app.py

@@ -4,7 +4,7 @@ import chess
 import chess.engine
 import pandas as pd
 import os
-import tempfile
+import uuid  # Pour des noms de fichiers uniques
 from openai import OpenAI
 from elevenlabs.client import ElevenLabs
 
@@ -17,7 +17,7 @@ eleven_client = ElevenLabs(api_key=ELEVEN_API_KEY) if ELEVEN_API_KEY else None
 
 STOCKFISH_PATH = "/usr/games/stockfish"
 
-# --- CHARGEMENT DONNÉES (MCP) ---
+# --- DONNÉES OUVERTURES ---
 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")]
@@ -28,19 +28,38 @@ def _load_lichess_openings(path_prefix="/app/data/lichess_openings/dist/"):
                 dfs.append(df)
         if not dfs: return pd.DataFrame()
         return pd.concat(dfs, ignore_index=True)
-    except Exception:
+    except:
         return pd.DataFrame()
 
 OPENINGS_DB = _load_lichess_openings()
 
-# --- MOTEUR IA (JEU) ---
+# --- MOTEUR STOCKFISH ---
+
+def get_stockfish_analysis(board, time_limit=0.1):
+    """Récupère le score et le meilleur coup suggéré."""
+    if not os.path.exists(STOCKFISH_PATH): return 0, "Inconnu"
+    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()
+            
+            # Récupérer le score numérique
+            if score.is_mate(): 
+                score_val = f"Mat en {score.mate()}"
+            else:
+                score_val = score.score()
+            
+            # Récupérer le meilleur coup (conseil)
+            best_move = info.get("pv", [None])[0]
+            best_move_san = board.san(best_move) if best_move else "Aucun"
+            
+            return score_val, best_move_san
+    except Exception as e:
+        print(f"Stockfish Error: {e}")
+        return 0, "Erreur"
 
 def get_ai_move(board, level):
-    """Fait jouer Stockfish selon le niveau."""
-    if not os.path.exists(STOCKFISH_PATH):
-        return None
-    
-    # Configuration des niveaux
+    """L'IA joue son coup."""
     levels = {
         "Débutant": {"time": 0.01, "skill": 0, "depth": 1},
         "Intermédiaire": {"time": 0.1, "skill": 10, "depth": 5},
@@ -51,135 +70,128 @@ def get_ai_move(board, level):
     
     try:
         with chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH) as engine:
-            # On configure le niveau de compétence (UCI option Skill Level 0-20)
             engine.configure({"Skill Level": config["skill"]})
-            
-            # On cherche le meilleur coup
             result = engine.play(board, chess.engine.Limit(time=config["time"], depth=config["depth"]))
             return result.move
-    except Exception as e:
-        print(f"Erreur Stockfish Play: {e}")
-        return None
-
-def get_stockfish_eval(fen):
-    """Analyse pure pour le coach."""
-    board = chess.Board(fen)
-    try:
-        with chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH) as engine:
-            info = engine.analyse(board, chess.engine.Limit(time=0.1))
-            score = info["score"].white()
-            if score.is_mate(): return f"Mat en {score.mate()}"
-            return score.score()
     except:
-        return 0
+        return None
 
-# --- COACH (LLM & VOIX) ---
+# --- CERVEAU DU COACH (LLM + AUDIO) ---
 
 SYSTEM_PROMPT = """
-Tu es Garry, coach d'échecs.
-1. Analyse le DERNIER coup joué par le joueur (blancs).
-2. Si le score chute brutalement, moque-toi.
-3. Si l'ouverture est connue, dis-le.
-4. Reste très court (max 20 mots) pour l'audio.
-5. Ne commente pas le coup que l'ordinateur va jouer ensuite.
+Tu es Garry, un coach d'échecs légendaire.
+Tu analyses le dernier coup du joueur (Blancs) et la situation actuelle.
+Tes objectifs :
+1. **Jugement** : Dis si le coup était bon ou mauvais.
+2. **Conseil** : Donne un conseil stratégique pour le prochain tour (ex: "Contrôle la colonne ouverte", "Attention à ton Cavalier", "Attaque le Roi").
+3. **Ton** : Pédagogique mais direct.
+4. **Format** : 2 phrases maximum. Très court pour l'audio.
 """
 
 def generate_voice(text):
-    """Version corrigée avec fichier temporaire."""
-    if not eleven_client or not text: return None
+    """Génère l'audio avec un nom unique dans /tmp"""
+    if not eleven_client: 
+        print("❌ Pas de clé ElevenLabs")
+        return None
+    if not text: return None
+
     try:
+        print(f"🎤 Génération audio pour : {text[:20]}...")
         audio_stream = eleven_client.generate(
             text=text,
             voice="Rachel",
             model="eleven_multilingual_v2"
         )
-        # Création d'un fichier temporaire sécurisé
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as fp:
+        
+        # Utilisation d'un UUID pour éviter le cache navigateur
+        unique_filename = f"coach_{uuid.uuid4()}.mp3"
+        path = os.path.join("/tmp", unique_filename)
+        
+        with open(path, "wb") as f:
             for chunk in audio_stream:
-                fp.write(chunk)
-            return fp.name
+                f.write(chunk)
+        
+        print(f"✅ Fichier audio créé : {path}")
+        return path
     except Exception as e:
-        print(f"ElevenLabs Error: {e}")
+        print(f"❌ Erreur ElevenLabs: {e}")
         return None
 
-def analyze_and_coach(fen):
-    """Génère le texte et l'audio."""
-    board = chess.Board(fen)
-    
-    # Récupérer l'ouverture
-    opening = "Inconnue"
-    if not OPENINGS_DB.empty:
-        match = OPENINGS_DB[OPENINGS_DB["epd"] == board.epd()]
-        if not match.empty: opening = match.iloc[0]['name']
-
-    # Récupérer score
-    score = get_stockfish_eval(fen)
-
-    # Context pour le LLM
-    context = f"Ouverture: {opening}. Score (centipawns): {score}. Trait: {'Blancs' if board.turn == chess.WHITE else 'Noirs'}."
-
-    commentary = "..."
-    if openai_client:
-        try:
-            response = openai_client.chat.completions.create(
-                model="gpt-4o-mini",
-                messages=[
-                    {"role": "system", "content": SYSTEM_PROMPT},
-                    {"role": "user", "content": context}
-                ]
-            )
-            commentary = response.choices[0].message.content
-        except Exception as e:
-            commentary = f"Erreur IA: {e}"
-    
-    audio_path = generate_voice(commentary)
-    
-    return commentary, audio_path, {"opening": opening, "score": score}
-
-# --- BOUCLE PRINCIPALE ---
-
-def game_step(fen, level):
-    """
-    1. Le joueur vient de jouer (fen contient le coup du joueur).
-    2. Le Coach analyse le coup du joueur.
-    3. L'IA (Noirs) joue son coup.
-    4. On renvoie le tout.
-    """
+def process_turn(fen, level):
+    """Orchestration du tour complet."""
     if not fen: return fen, "", None, {}
     
     board = chess.Board(fen)
     
-    # Si c'est aux noirs de jouer, c'est que le joueur vient de jouer son coup
-    # Donc on lance le coach MAINTENANT sur la position actuelle
+    # Si c'est aux Noirs de jouer, le joueur (Blancs) vient de jouer
     if board.turn == chess.BLACK:
-        coach_text, coach_audio, debug = analyze_and_coach(fen)
         
-        # Ensuite, l'IA joue (si la partie n'est pas finie)
+        # 1. Analyse Technique
+        opening_name = "Inconnue"
+        if not OPENINGS_DB.empty:
+            match = OPENINGS_DB[OPENINGS_DB["epd"] == board.epd()]
+            if not match.empty: opening_name = match.iloc[0]['name']
+            
+        score, best_move = get_stockfish_analysis(board)
+        
+        # 2. Génération Commentaire (Coach)
+        llm_context = f"Ouverture: {opening_name}. Score actuel: {score}. Meilleur coup théorique était: {best_move}."
+        
+        coach_text = "..."
+        if openai_client:
+            try:
+                response = openai_client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=[
+                        {"role": "system", "content": SYSTEM_PROMPT},
+                        {"role": "user", "content": llm_context}
+                    ]
+                )
+                coach_text = response.choices[0].message.content
+            except Exception as e:
+                coach_text = f"Erreur LLM: {e}"
+        else:
+            coach_text = "Configurez votre clé OpenAI !"
+            
+        # 3. Génération Audio
+        audio_path = generate_voice(coach_text)
+        
+        # 4. Debug Data
+        debug_info = {
+            "Ouverture": opening_name,
+            "Score Centipawns": str(score),
+            "Conseil Stockfish": best_move
+        }
+        
+        # 5. L'IA joue son coup (Noirs)
         if not board.is_game_over():
             ai_move = get_ai_move(board, level)
             if ai_move:
                 board.push(ai_move)
         
-        # On retourne : Nouvelle position (après coup IA), Texte Coach, Audio, Debug
-        return board.fen(), coach_text, coach_audio, debug
-    
-    # Si c'est aux blancs, rien ne se passe (attente joueur)
-    return fen, "À vous de jouer !", None, {}
+        # Retourne tout
+        return board.fen(), coach_text, audio_path, debug_info
+
+    # Si c'est au tour des Blancs (début de partie ou après reset)
+    return fen, "À vous de jouer les Blancs !", None, {}
 
 # --- INTERFACE ---
 
 with gr.Blocks(title="ChessCoach Pro") as demo:
-    gr.Markdown("# ♟️ ChessCoach Pro - Entraînement IA")
+    gr.Markdown(
+        """
+        # ♟️ ChessCoach Pro
+        **Votre Coach IA personnel.** Jouez les Blancs. Garry analyse vos coups et vous donne des conseils stratégiques vocalement.
+        """
+    )
     
     with gr.Row():
         with gr.Column(scale=2):
-            # Sélecteur de niveau
-            level_selector = gr.Radio(
-                ["Débutant", "Intermédiaire", "Avancé", "Grand Maître"], 
-                label="Niveau de l'IA (Noirs)", 
+            level_radio = gr.Radio(
+                ["Débutant", "Intermédiaire", "Avancé", "Grand Maître"],
+                label="Niveau de l'adversaire",
                 value="Débutant"
             )
-            
             board = Chessboard(
                 label="Échiquier",
                 value=chess.STARTING_FEN,
@@ -188,16 +200,23 @@ with gr.Blocks(title="ChessCoach Pro") as demo:
             )
         
         with gr.Column(scale=1):
-            coach_output = gr.Textbox(label="Coach Garry", interactive=False, lines=2)
-            audio_output = gr.Audio(label="Voix", autoplay=True, interactive=False)
-            debug_json = gr.JSON(label="Données MCP")
+            coach_box = gr.Textbox(label="Conseils de Garry", interactive=False, lines=4)
+            audio_box = gr.Audio(label="Voix", autoplay=True, interactive=False, type="filepath")
+            debug_box = gr.JSON(label="Données Techniques")
 
-    # Quand le joueur fait un move sur le plateau
+    # Logique
     board.move(
-        fn=game_step, 
-        inputs=[board, level_selector], 
-        outputs=[board, coach_output, audio_output, debug_json] # Note: board est output aussi pour afficher le coup de l'IA
+        fn=process_turn,
+        inputs=[board, level_radio],
+        outputs=[board, coach_box, audio_box, debug_box]
     )
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False)
+    # ssr_mode=False est vital.
+    # allowed_paths=["/tmp"] permet à Gradio de lire les fichiers audio qu'on génère.
+    demo.launch(
+        server_name="0.0.0.0", 
+        server_port=7860, 
+        ssr_mode=False, 
+        allowed_paths=["/tmp"]
+    )