Update app.py

app.py

@@ -7,14 +7,14 @@ import pandas as pd
 import os
 import uuid
 from openai import OpenAI
-import io
+import time
 
 # --- 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"
 
-# --- DONNÉES OUVERTURES ---
+# --- 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")]
@@ -30,65 +30,53 @@ def _load_lichess_openings(path_prefix="/app/data/lichess_openings/dist/"):
 
 OPENINGS_DB = _load_lichess_openings()
 
-# --- ANALYSE TECHNIQUE ET TRADUCTION ---
+# --- OUTILS D'ANALYSE ---
 
 def describe_move_human(board, move):
-    """Traduit un coup UCI (e2e4) en phrase humaine explicite."""
-    if not move: return "Rien de spécial"
-    
+    """Traduction humaine du coup."""
+    if not move: return "Rien"
     piece = board.piece_at(move.from_square)
     if not piece: return move.uci()
     
-    piece_name = {
+    piece_names = {
         chess.PAWN: "Pion", chess.KNIGHT: "Cavalier", chess.BISHOP: "Fou",
         chess.ROOK: "Tour", chess.QUEEN: "Dame", chess.KING: "Roi"
-    }[piece.piece_type]
-    
-    dest_name = chess.square_name(move.to_square)
-    is_capture = board.is_capture(move)
-    is_check = board.gives_check(move)
-    
-    action = "mange sur" if is_capture else "va en"
-    desc = f"{piece_name} {action} {dest_name}"
-    
-    if is_check: desc += " (Echec !)"
-    return desc
+    }
+    name = piece_names.get(piece.piece_type, "Pièce")
+    dest = chess.square_name(move.to_square)
+    capture = "mange sur" if board.is_capture(move) else "va en"
+    return f"{name} {capture} {dest}"
 
-def get_engine_advice(board, time_limit=0.2):
-    """Demande à Stockfish : 'Que doit faire le joueur (Blancs) maintenant ?'"""
-    if not os.path.exists(STOCKFISH_PATH): return 0, "Inconnu", "Inconnu"
+def get_engine_analysis(board, time_limit=0.6):
+    """
+    Analyse plus profonde (0.6s) pour mieux voir les menaces.
+    Retourne : Score, Description Humaine du Meilleur Coup, Description de la Menace (si on ne joue pas ce coup).
+    """
+    if not os.path.exists(STOCKFISH_PATH): return "0", "Inconnu"
     
     try:
         with chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH) as engine:
-            # Analyse approfondie
+            # Analyse principale
             info = engine.analyse(board, chess.engine.Limit(time=time_limit))
             score = info["score"].white()
             
-            # Score lisible
+            # Gestion du score
             if score.is_mate():
-                score_val = f"Mat en {abs(score.mate())} coups"
-                evaluation = "Victoire imminente" if score.mate() > 0 else "Tu vas perdre !"
+                score_val = f"Mat en {abs(score.mate())}"
             else:
-                cp = score.score()
-                score_val = str(cp)
-                if cp > 100: evaluation = "Tu as l'avantage."
-                elif cp < -100: evaluation = "Tu es en difficulté."
-                else: evaluation = "Partie équilibrée."
-            
-            # Meilleur coup suggéré pour le joueur
+                score_val = str(score.score())
+
+            # Meilleur coup pour NOUS (Blancs)
             best_move = info.get("pv", [None])[0]
-            if best_move:
-                human_advice = describe_move_human(board, best_move)
-            else:
-                human_advice = "Aucun coup évident"
-                
-            return score_val, evaluation, human_advice
+            best_move_desc = describe_move_human(board, best_move) if best_move else "Aucun coup sûr"
+
+            return score_val, best_move_desc
     except Exception as e:
         print(f"Engine Error: {e}")
-        return 0, "Erreur", "Erreur"
+        return "0", "Erreur"
 
 def get_ai_move(board, level):
-    """L'IA (Noirs) joue."""
+    """L'adversaire (Noirs) joue."""
     levels = {
         "Débutant": {"time": 0.01, "skill": 1, "depth": 1},
         "Intermédiaire": {"time": 0.1, "skill": 8, "depth": 6},
@@ -104,152 +92,166 @@ def get_ai_move(board, level):
     except:
         return None
 
-# --- AUDIO OPENAI ---
-def generate_garry_voice(text):
+# --- AUDIO & TRANSCRIPTION ---
+
+def transcribe(audio_path):
+    """Transforme la voix du joueur en texte."""
+    if not openai_client or not audio_path: return None
+    try:
+        with open(audio_path, "rb") as f:
+            t = openai_client.audio.transcriptions.create(model="whisper-1", file=f, language="fr")
+        return t.text
+    except:
+        return None
+
+def generate_voice(text):
+    """Génère la voix de Garry (Accélérée x1.25)."""
     if not openai_client or not text: return None
     try:
         response = openai_client.audio.speech.create(
             model="tts-1",
-            voice="fable", # Voix plus narrative/impérieuse
-            input=text
+            voice="fable",
+            input=text,
+            speed=1.25 # ACCÉLÉRATION DU COACH
         )
-        unique_filename = f"garry_{uuid.uuid4()}.mp3"
-        path = os.path.join("/tmp", unique_filename)
+        unique = f"garry_{uuid.uuid4()}.mp3"
+        path = os.path.join("/tmp", unique)
         response.stream_to_file(path)
         return path
     except:
         return None
 
-# --- INTELLIGENCE DU COACH ---
+# --- CERVEAU KASPAROV ---
 
 SYSTEM_PROMPT = """
-Tu es Garry Kasparov. Tu coaches le joueur qui joue les BLANCS.
-L'adversaire (Noirs) est l'ordinateur.
+Tu es Garry Kasparov, coach des Blancs.
+Tu parles à un débutant.
 
-TES INSTRUCTIONS :
-1. **Identifie toi aux Blancs** : Dis "Tu", "Nous". Ne parle des Noirs que comme "l'adversaire".
-2. **Contextualise** : Utilise l'historique des coups pour comprendre le plan.
-3. **Donne LA solution** : Je te fournis le "Meilleur coup calculé" par l'ordinateur. TA MISSION PRINCIPALE est de faire deviner ou d'expliquer ce coup au joueur sans jargon technique.
-   - Au lieu de dire "Joue Cf3", dis "Sors ton cavalier pour contrôler le centre".
-   - Au lieu de dire "Joue h3", dis "Fais une petite case de fuite pour ton Roi".
-4. **État de la partie** : Si le score est mauvais, dis-lui comment tenir. Si le score est bon, dis-lui comment finir.
+RÈGLE D'OR DE STRUCTURE (RESPECTE L'ORDRE) :
+1. **L'ORDRE** : Dis D'ABORD le coup à jouer impérativement. (ex: "Sors ton Cavalier en f3 tout de suite !").
+2. **L'EXPLICATION** : ENSUITE, explique pourquoi en parlant du plan de l'adversaire (ex: "Sinon sa Dame va infiltrer ta défense et manger ton pion.").
 
-Sois bref, incisif, encourageant. Tu es un champion du monde qui parle à un élève.
+TON :
+- Dynamique, rapide, autoritaire mais bienveillant.
+- Ne parle JAMAIS en coordonnées pures (ex: dis "Pion du Roi" pas "e4").
+- Si le joueur pose une question, réponds précisément à sa question.
 """
 
-def process_game_cycle(fen, level, history_list):
+def consult_garry(fen, user_audio=None, history_list=[], mode="auto"):
     """
-    1. Joueur (Blancs) a joué.
-    2. Garry analyse la situation résultante.
-    3. Garry donne son avis + CONSEIL pour le PROCHAIN coup blanc.
-    4. IA (Noirs) répond.
+    Mode 'auto' : Garry commente après un coup.
+    Mode 'question' : Garry répond à la question vocale du joueur.
     """
     board = chess.Board(fen)
     
-    # Récupération de l'historique PGN pour le contexte
-    pgn_game = chess.pgn.Game()
-    node = pgn_game
-    for move_uci in history_list:
-        move = chess.Move.from_uci(move_uci)
-        if move in node.board().legal_moves:
-            node = node.add_variation(move)
+    # 1. Analyse Technique
+    score, best_move_human = get_engine_analysis(board)
     
-    # Si c'est aux noirs, le joueur vient de jouer son coup blanc
-    if board.turn == chess.BLACK:
-        # On enregistre le dernier coup blanc dans l'historique (c'est le dernier move stack du board)
+    opening = "Inconnue"
+    if not OPENINGS_DB.empty:
+        match = OPENINGS_DB[OPENINGS_DB["epd"] == board.epd()]
+        if not match.empty: opening = match.iloc[0]['name']
+
+    # 2. Contexte pour le LLM
+    context = f"""
+    [SITUATION]
+    Trait aux : {'Blancs' if board.turn == chess.WHITE else 'Noirs'}.
+    Ouverture : {opening}.
+    Score : {score} (Positif=Bien pour nous).
+    MEILLEUR COUP CALCULÉ PAR STOCKFISH : {best_move_human}.
+    """
+    
+    if mode == "question" and user_audio:
+        user_text = transcribe(user_audio)
+        context += f"\n[QUESTION DU JOUEUR] : '{user_text}'. Réponds à ça en t'aidant de l'analyse."
+    else:
+        context += f"\n[ACTION] : Le joueur attend tes instructions. Dis-lui de jouer le meilleur coup et explique la menace adverse."
+
+    # 3. Appel LLM
+    reply = "..."
+    if openai_client:
         try:
-            last_white_move = board.peek()
-            history_list.append(last_white_move.uci())
-        except:
-            pass
+            response = openai_client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": context}
+                ]
+            )
+            reply = response.choices[0].message.content
+        except Exception as e:
+            reply = f"Erreur IA: {e}"
+            
+    # 4. Audio
+    audio_path = generate_voice(reply)
+    
+    return reply, audio_path
 
-        # --- 1. ANALYSE TECHNIQUE (Ce que voit Garry) ---
-        opening = "Inconnue"
-        if not OPENINGS_DB.empty:
-            match = OPENINGS_DB[OPENINGS_DB["epd"] == board.epd()]
-            if not match.empty: opening = match.iloc[0]['name']
-        
-        # On regarde le score actuel (pour juger le coup du joueur)
-        score_val, evaluation, _ = get_engine_advice(board)
-        
-        # --- 2. IA JOUE (Noirs) ---
+# --- ORCHESTRATION DU JEU ---
+
+def game_cycle(fen, level, history_list):
+    """Cycle : Joueur joue -> Garry conseille -> IA joue."""
+    board = chess.Board(fen)
+    
+    # Si c'est aux noirs, le joueur vient de jouer
+    if board.turn == chess.BLACK:
+        # L'IA joue
         ai_move = get_ai_move(board, level)
-        ai_move_desc = "..."
-        if ai_move:
-            board.push(ai_move) # Les noirs ont joué
-            history_list.append(ai_move.uci())
-            ai_move_desc = describe_move_human(board, ai_move) # Description du coup noir
-            
-        # --- 3. CONSEIL POUR LE FUTUR (Ce que le joueur doit faire maintenant) ---
-        # Maintenant c'est de nouveau aux Blancs. Quel est le meilleur coup ?
-        _, _, best_move_human_desc = get_engine_advice(board)
-        
-        # --- 4. PRÉPARATION DU MESSAGE LLM ---
-        pgn_exporter = chess.pgn.StringExporter(headers=False, variations=False, comments=False)
-        pgn_string = pgn_game.accept(pgn_exporter)
-        
-        context = f"""
-        [CONTEXTE]
-        Tu es le coach des BLANCS.
-        Historique de la partie : {pgn_string}
-        Ouverture : {opening}.
-        
-        [SITUATION ACTUELLE]
-        L'adversaire (Noirs) vient de répondre : {ai_move_desc}.
-        C'est au joueur (Blancs) de jouer.
+        if ai_move: board.push(ai_move)
         
-        [ANALYSE TECHNIQUE]
-        Score : {score_val} ({evaluation}).
-        LE MEILLEUR COUP À JOUER MAINTENANT POUR GAGNER EST : {best_move_human_desc}.
+        # Maintenant c'est aux blancs (nous)
+        # On demande conseil à Garry pour notre PROCHAIN coup
+        text, audio = consult_garry(board.fen(), mode="auto")
         
-        [TA TÂCHE]
-        1. Commente brièvement la réponse des noirs.
-        2. Conseille fortement au joueur de jouer le "Meilleur coup" indiqué ci-dessus, mais explique-le avec des mots simples (stratégie), pas juste les coordonnées.
-        """
-        
-        garry_text = "..."
-        if openai_client:
-            try:
-                response = openai_client.chat.completions.create(
-                    model="gpt-4o-mini",
-                    messages=[
-                        {"role": "system", "content": SYSTEM_PROMPT},
-                        {"role": "user", "content": context}
-                    ]
-                )
-                garry_text = response.choices[0].message.content
-            except Exception as e:
-                garry_text = f"Erreur OpenAI: {e}"
-        
-        audio_path = generate_garry_voice(garry_text)
-        
-        return board.fen(), history_list, garry_text, audio_path
+        return board.fen(), history_list, text, audio
 
-    return fen, history_list, "À toi de jouer les Blancs !", None
+    return fen, history_list, "À vous !", None
+
+def ask_question(fen, audio_file):
+    """Le joueur pose une question sans jouer."""
+    text, audio = consult_garry(fen, user_audio=audio_file, mode="question")
+    return text, audio
 
 # --- INTERFACE ---
 
-with gr.Blocks(title="ChessCoach Ultimate") as demo:
-    gr.Markdown("# ♟️ ChessCoach Ultimate")
-    gr.Markdown("Vous êtes les **Blancs**. Garry Kasparov vous regarde. Il analyse votre jeu et vous souffle les meilleurs coups à l'oreille.")
+with gr.Blocks(title="ChessCoach Ultimate V2") as demo:
+    gr.Markdown("# ♟️ ChessCoach Ultimate V2")
+    gr.Markdown("Coach : Garry Kasparov (Voix Rapide & Stratège). Jouez les Blancs.")
     
-    # Variable d'état pour garder l'historique complet de la partie
-    history_state = gr.State([]) 
+    state_history = gr.State([])
 
     with gr.Row():
         with gr.Column(scale=2):
-            level_select = gr.Dropdown(["Débutant", "Intermédiaire", "Avancé", "Grand Maître"], value="Débutant", label="Niveau IA Adverse")
-            board = Chessboard(label="Partie en cours", value=chess.STARTING_FEN, game_mode=True, interactive=True)
-        
+            board = Chessboard(label="Jeu", value=chess.STARTING_FEN, game_mode=True, interactive=True)
+            
+            with gr.Row():
+                # Bouton Micro
+                mic = gr.Audio(sources=["microphone"], type="filepath", label="Posez une question à Garry")
+                btn_ask = gr.Button("Envoyer la question")
+
         with gr.Column(scale=1):
-            coach_box = gr.Textbox(label="Conseils de Garry", interactive=False, lines=5)
-            audio_box = gr.Audio(label="Voix du Coach", autoplay=True, interactive=False, type="filepath")
+            level = gr.Dropdown(["Débutant", "Intermédiaire", "Avancé", "Grand Maître"], value="Débutant", label="Niveau Adversaire")
+            coach_txt = gr.Textbox(label="Conseil", interactive=False, lines=4)
+            coach_audio = gr.Audio(label="Voix", autoplay=True, interactive=False, type="filepath")
 
-    # Boucle de jeu
+    # 1. Jeu Automatique
     board.move(
-        fn=process_game_cycle,
-        inputs=[board, level_select, history_state],
-        outputs=[board, history_state, coach_box, audio_box]
+        fn=game_cycle,
+        inputs=[board, level, state_history],
+        outputs=[board, state_history, coach_txt, coach_audio]
+    )
+    
+    # 2. Questions Vocales
+    # Quand on clique sur envoyer OU qu'on arrête de parler
+    btn_ask.click(
+        fn=ask_question,
+        inputs=[board, mic],
+        outputs=[coach_txt, coach_audio]
+    )
+    mic.stop_recording(
+        fn=ask_question,
+        inputs=[board, mic],
+        outputs=[coach_txt, coach_audio]
     )
 
 if __name__ == "__main__":