Update app.py

app.py

@@ -4,9 +4,9 @@ import chess
 import chess.engine
 import pandas as pd
 import os
+import tempfile
 from openai import OpenAI
 from elevenlabs.client import ElevenLabs
-from collections import Counter
 
 # --- CONFIGURATION ---
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
@@ -15,13 +15,10 @@ ELEVEN_API_KEY = os.getenv("ELEVEN_API_KEY")
 openai_client = OpenAI(api_key=OPENAI_API_KEY) if OPENAI_API_KEY else None
 eleven_client = ElevenLabs(api_key=ELEVEN_API_KEY) if ELEVEN_API_KEY else None
 
-# Chemin vers Stockfish (installé via Docker)
 STOCKFISH_PATH = "/usr/games/stockfish"
 
-# --- MOTEUR D'ANALYSE (Outils MCP) ---
-
+# --- CHARGEMENT DONNÉES (MCP) ---
 def _load_lichess_openings(path_prefix="/app/data/lichess_openings/dist/"):
-    """Charge la base de données d'ouvertures."""
     try:
         files = [f"{path_prefix}{vol}.tsv" for vol in ("a", "b", "c", "d", "e")]
         dfs = []
@@ -31,79 +28,64 @@ 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 as e:
-        print(f"Erreur chargement ouvertures: {e}")
+    except Exception:
         return pd.DataFrame()
 
-# Chargement unique au démarrage pour la performance
 OPENINGS_DB = _load_lichess_openings()
 
-def get_opening_info(board):
-    """Trouve le nom de l'ouverture."""
-    if OPENINGS_DB.empty: return "Base de données non chargée"
+# --- MOTEUR IA (JEU) ---
+
+def get_ai_move(board, level):
+    """Fait jouer Stockfish selon le niveau."""
+    if not os.path.exists(STOCKFISH_PATH):
+        return None
     
-    epd = board.epd()
-    match = OPENINGS_DB[OPENINGS_DB["epd"] == epd]
+    # Configuration des niveaux
+    levels = {
+        "Débutant": {"time": 0.01, "skill": 0, "depth": 1},
+        "Intermédiaire": {"time": 0.1, "skill": 10, "depth": 5},
+        "Avancé": {"time": 0.5, "skill": 15, "depth": 10},
+        "Grand Maître": {"time": 1.0, "skill": 20, "depth": 18}
+    }
+    config = levels.get(level, levels["Débutant"])
     
-    if not match.empty:
-        return f"{match.iloc[0]['eco']} - {match.iloc[0]['name']}"
-    return "Ouverture inconnue ou transition"
-
-def get_stockfish_eval(fen, time_limit=0.1):
-    """Utilise Stockfish pour évaluer la position (Centipawns)."""
-    board = chess.Board(fen)
     try:
-        if not os.path.exists(STOCKFISH_PATH):
-            return "Stockfish non trouvé"
-            
         with chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH) as engine:
-            info = engine.analyse(board, chess.engine.Limit(time=time_limit))
-            score = info["score"].white()
+            # On configure le niveau de compétence (UCI option Skill Level 0-20)
+            engine.configure({"Skill Level": config["skill"]})
             
-            if score.is_mate():
-                return f"Mat en {score.mate()}"
-            return score.score()
+            # 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:
-        return f"Erreur Engine: {e}"
+        print(f"Erreur Stockfish Play: {e}")
+        return None
 
-def analyze_full_context(fen):
-    """Agrège toutes les données pour le LLM."""
-    if not fen: return {}
+def get_stockfish_eval(fen):
+    """Analyse pure pour le coach."""
     board = chess.Board(fen)
-    
-    # Matériel
-    values = {chess.PAWN: 1, chess.KNIGHT: 3, chess.BISHOP: 3, chess.ROOK: 5, chess.QUEEN: 9}
-    w_mat = sum(len(board.pieces(pt, chess.WHITE)) * val for pt, val in values.items())
-    b_mat = sum(len(board.pieces(pt, chess.BLACK)) * val for pt, val in values.items())
-    
-    # Ouverture
-    opening = get_opening_info(board)
-    
-    # Engine
-    eval_score = get_stockfish_eval(fen)
-    
-    return {
-        "turn": "White" if board.turn == chess.WHITE else "Black",
-        "opening": opening,
-        "material": {"white": w_mat, "black": b_mat, "diff": w_mat - b_mat},
-        "stockfish_eval": eval_score,
-        "is_check": board.is_check(),
-        "is_game_over": board.is_game_over()
-    }
+    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
 
-# --- COEUR DU COACH (IA & VOIX) ---
+# --- COACH (LLM & VOIX) ---
 
 SYSTEM_PROMPT = """
-Tu es Garry, un coach d'échecs légendaire, sarcastique mais brillant.
-Tu analyses la partie en direct.
-Basé sur les données JSON (Score Stockfish, Ouverture, Matériel) :
-1. Si l'ouverture est reconnue, nomme-la avec classe.
-2. Si Stockfish indique une erreur brutale (changement de score important), moque-toi gentiment.
-3. Si le joueur trouve un bon coup, sois bref et approbateur.
-4. Reste court (2 phrases max) pour l'audio.
+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.
 """
 
 def generate_voice(text):
+    """Version corrigée avec fichier temporaire."""
     if not eleven_client or not text: return None
     try:
         audio_stream = eleven_client.generate(
@@ -111,51 +93,93 @@ def generate_voice(text):
             voice="Rachel",
             model="eleven_multilingual_v2"
         )
-        path = "commentary.mp3"
-        with open(path, "wb") as f:
+        # Création d'un fichier temporaire sécurisé
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as fp:
             for chunk in audio_stream:
-                f.write(chunk)
-        return path
+                fp.write(chunk)
+            return fp.name
     except Exception as e:
         print(f"ElevenLabs Error: {e}")
         return None
 
-def game_loop(fen):
-    """Boucle principale appelée à chaque coup."""
-    if not fen: return "", None, {}
-    
-    # 1. Analyse Technique
-    analysis_data = analyze_full_context(fen)
+def analyze_and_coach(fen):
+    """Génère le texte et l'audio."""
+    board = chess.Board(fen)
     
-    # 2. Génération Texte (LLM)
-    commentary = "Analyse..."
+    # 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": f"Données techniques: {str(analysis_data)}"}
+                    {"role": "user", "content": context}
                 ]
             )
             commentary = response.choices[0].message.content
         except Exception as e:
-            commentary = f"Erreur LLM: {e}"
-    else:
-        commentary = "Clés API manquantes (OpenAI)."
-
-    # 3. Génération Audio
+            commentary = f"Erreur IA: {e}"
+    
     audio_path = generate_voice(commentary)
     
-    return commentary, audio_path, analysis_data
+    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.
+    """
+    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
+    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)
+        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, {}
 
-# --- INTERFACE GRADIO ---
+# --- INTERFACE ---
 
 with gr.Blocks(title="ChessCoach Pro") as demo:
-    gr.Markdown("# ♟️ ChessCoach Pro (Docker + Stockfish + MCP)")
+    gr.Markdown("# ♟️ ChessCoach Pro - Entraînement IA")
     
     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)", 
+                value="Débutant"
+            )
+            
             board = Chessboard(
                 label="Échiquier",
                 value=chess.STARTING_FEN,
@@ -164,16 +188,16 @@ with gr.Blocks(title="ChessCoach Pro") as demo:
             )
         
         with gr.Column(scale=1):
-            coach_output = gr.Textbox(label="Coach Garry", interactive=False, lines=3)
+            coach_output = gr.Textbox(label="Coach Garry", interactive=False, lines=2)
             audio_output = gr.Audio(label="Voix", autoplay=True, interactive=False)
-            
-            with gr.Accordion("Données Techniques (MCP)", open=True):
-                debug_json = gr.JSON(label="Analyse Temps Réel")
+            debug_json = gr.JSON(label="Données MCP")
 
-    # Événement : Quand on joue un coup
-    board.move(fn=game_loop, inputs=[board], outputs=[coach_output, audio_output, debug_json])
+    # Quand le joueur fait un move sur le plateau
+    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
+    )
 
-# --- LANCEMENT ---
-# IMPORTANT: ssr_mode=False est vital pour gradio_chessboard sur les versions récentes
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False)