Update app.py

app.py

@@ -5,18 +5,16 @@ import chess.engine
 import pandas as pd
 import os
 import uuid
+import time
 from openai import OpenAI
 
 # --- CONFIGURATION ---
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-# On n'utilise plus ElevenLabs cause blocage IP HuggingFace
-# ELEVEN_API_KEY = os.getenv("ELEVEN_API_KEY") 
-
 openai_client = OpenAI(api_key=OPENAI_API_KEY) if OPENAI_API_KEY else None
 
 STOCKFISH_PATH = "/usr/games/stockfish"
 
-# --- CHARGEMENT OUVERTURES ---
+# --- 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")]
@@ -32,29 +30,45 @@ def _load_lichess_openings(path_prefix="/app/data/lichess_openings/dist/"):
 
 OPENINGS_DB = _load_lichess_openings()
 
-# --- MOTEUR STOCKFISH ---
-def get_stockfish_analysis(board, time_limit=0.1):
-    if not os.path.exists(STOCKFISH_PATH): return 0, "Inconnu"
+# --- ANALYSE TECHNIQUE ---
+
+def get_technical_data(board, time_limit=0.1):
+    """Récupère les données brutes pour l'IA."""
+    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()
+            
+            # Score lisible
             if score.is_mate(): 
                 score_val = f"Mat en {score.mate()}"
             else:
                 score_val = score.score()
+            
+            # Meilleur coup (Format UCI: e2e4)
             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
+            best_move_uci = best_move.uci() if best_move else "Aucun"
+            
+            # Nom de la pièce à bouger pour le meilleur coup (pour aider l'IA à expliquer)
+            piece_name = "Inconnue"
+            if best_move:
+                piece = board.piece_at(best_move.from_square)
+                if piece: piece_name = chess.piece_name(piece.piece_type)
+
+            return score_val, best_move_uci, piece_name
     except Exception as e:
-        return 0, "Erreur Engine"
+        print(f"Engine Error: {e}")
+        return 0, "Erreur", "Erreur"
 
 def get_ai_move(board, level):
+    """Stockfish joue les noirs."""
     levels = {
-        "Débutant": {"time": 0.01, "skill": 0, "depth": 1},
-        "Intermédiaire": {"time": 0.1, "skill": 5, "depth": 5},
-        "Avancé": {"time": 0.5, "skill": 10, "depth": 10},
-        "Grand Maître": {"time": 1.0, "skill": 20, "depth": 15}
+        "Débutant": {"time": 0.01, "skill": 1, "depth": 1},
+        "Intermédiaire": {"time": 0.1, "skill": 8, "depth": 6},
+        "Avancé": {"time": 0.5, "skill": 15, "depth": 12},
+        "Grand Maître": {"time": 1.0, "skill": 20, "depth": 18}
     }
     config = levels.get(level, levels["Débutant"])
     try:
@@ -65,118 +79,166 @@ def get_ai_move(board, level):
     except:
         return None
 
-# --- AUDIO OPENAI (LA SOLUTION) ---
-def generate_voice_openai(text):
-    """Génère l'audio via OpenAI TTS (Stable et non bloqué)."""
-    if not openai_client: 
-        return None, "ERREUR: Clé OpenAI manquante."
-    if not text: return None, "Pas de texte."
+# --- ORCHESTRATION OPENAI (Audio & Chat) ---
+
+def transcribe_audio(audio_path):
+    """Transforme la voix du joueur en texte (Whisper)."""
+    if not audio_path or not openai_client: return None
+    try:
+        with open(audio_path, "rb") as audio_file:
+            transcript = openai_client.audio.transcriptions.create(
+                model="whisper-1", 
+                file=audio_file,
+                language="fr" # On force le français
+            )
+        return transcript.text
+    except Exception as e:
+        return f"Erreur transcription: {e}"
 
+def generate_garry_voice(text, voice_model="onyx"):
+    """Génère la voix de Garry."""
+    if not openai_client or not text: return None
     try:
-        # Génération via OpenAI
         response = openai_client.audio.speech.create(
             model="tts-1",
-            voice="onyx", # Voix masculine grave type 'Coach'
+            voice=voice_model,
             input=text
         )
-        
-        # Sauvegarde fichier temporaire unique
-        unique_filename = f"coach_{uuid.uuid4()}.mp3"
+        unique_filename = f"garry_{uuid.uuid4()}.mp3"
         path = os.path.join("/tmp", unique_filename)
-        
         response.stream_to_file(path)
-        return path, None
-            
-    except Exception as e:
-        return None, f"Erreur OpenAI TTS: {str(e)}"
+        return path
+    except:
+        return None
+
+# --- LE CERVEAU DE KASPAROV (PROMPT AMÉLIORÉ) ---
 
-# --- PROMPT COACH ---
 SYSTEM_PROMPT = """
-Tu es Garry, un coach d'échecs légendaire et mentor.
-Tu analyses le dernier coup du joueur (Blancs).
-1. Dis si le coup est bon ou mauvais.
-2. Donne un conseil tactique précis pour la suite (ex: "Développe ton cavalier", "Contrôle d4", "Attention à la fourchette").
-3. Adopte un ton encourageant mais ferme.
-4. Fais court (max 25 mots) pour que l'audio soit fluide.
+Tu es Garry Kasparov, le plus grand joueur d'échecs de l'histoire.
+Tu t'adresses à un DÉBUTANT COMPLET.
+Ton objectif : Expliquer les échecs simplement, sans jargon.
+
+RÈGLES D'OR :
+1. **INTERDIT** d'utiliser la notation algébrique (ex: NE DIS PAS "Cavalier f3", "e4", "Fxe5").
+2. **UTILISE** le langage naturel (ex: "Sors ton cavalier de droite", "Avance le pion devant ton Roi", "Mange sa Dame !").
+3. **EXPLIQUE POURQUOI** : "Il faut contrôler le centre", "Ton Roi est en danger", "C'est une pièce gratuite".
+4. Si le joueur te pose une question, réponds-y directement.
+5. Sois charismatique, encourageant, mais exigeant.
+6. Fais court (2 ou 3 phrases max) pour que la conversation soit fluide.
 """
 
-def process_turn(fen, level):
-    if not fen: return fen, "", None, {}
+def chat_with_garry(fen, user_audio, history_text, voice_choice="onyx"):
+    """Fonction appelée quand le joueur parle au micro."""
+    if not fen: return history_text, None
+    board = chess.Board(fen)
+    
+    # 1. Transcription de la question du joueur
+    user_question = "Analyse la situation stp."
+    if user_audio:
+        user_question = transcribe_audio(user_audio)
+    
+    # 2. Analyse technique pour donner des yeux à Garry
+    score, best_move_uci, piece_to_move = get_technical_data(board)
+    opening = "Non définie"
+    if not OPENINGS_DB.empty:
+        match = OPENINGS_DB[OPENINGS_DB["epd"] == board.epd()]
+        if not match.empty: opening = match.iloc[0]['name']
+
+    # 3. Construction du contexte pour l'IA
+    turn_color = "Blancs" if board.turn == chess.WHITE else "Noirs"
+    context = f"""
+    [SITUATION PLATEAU]
+    Trait aux : {turn_color}.
+    Ouverture : {opening}.
+    Avantage numérique (Score) : {score} (Positif = Blancs gagnent, Négatif = Noirs gagnent).
+    Meilleur coup suggéré par l'ordi : Bouger la pièce '{piece_to_move}' (coordonnées internes: {best_move_uci}).
     
+    [JOUEUR]
+    Le joueur te demande : "{user_question}"
+    """
+
+    # 4. Réponse de Garry
+    reply_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}
+                ]
+            )
+            reply_text = response.choices[0].message.content
+        except Exception as e:
+            reply_text = f"Erreur de connexion à mon cerveau : {e}"
+    
+    # 5. Audio
+    reply_audio = generate_garry_voice(reply_text, voice_choice)
+    
+    # Mise à jour historique chat
+    new_history = f"Vous : {user_question}\nGarry : {reply_text}\n\n" + history_text
+    
+    return new_history, reply_audio
+
+
+def process_game_move(fen, level, history, voice_choice):
+    """Appelé quand une pièce bouge."""
     board = chess.Board(fen)
     
-    # Tour du joueur terminé (c'est aux noirs)
+    # Si c'est aux noirs, le joueur vient de jouer -> Garry commente
     if board.turn == chess.BLACK:
-        # 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. LLM
-        llm_context = f"Ouverture: {opening_name}. Score actuel (centipawns): {score}. Le 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 OpenAI Text: {e}"
-        else:
-            coach_text = "Clé OpenAI manquante."
-            
-        # 3. Audio (Via OpenAI TTS)
-        audio_path, error_audio = generate_voice_openai(coach_text)
-        
-        # Debug audio dans le texte si besoin
-        if error_audio:
-            coach_text += f"\n[AUDIO ERROR]: {error_audio}"
-        
-        # 4. Debug Data
-        debug_info = {
-            "Ouverture": opening_name,
-            "Score": str(score),
-            "Conseil Engine": best_move,
-            "Source Audio": "OpenAI TTS-1"
-        }
+        # On simule une question "Comment j'ai joué ?"
+        hist, audio = chat_with_garry(fen, None, history, voice_choice)
         
-        # 5. IA joue
+        # L'IA joue
         if not board.is_game_over():
             ai_move = get_ai_move(board, level)
             if ai_move: board.push(ai_move)
+            
+        return board.fen(), hist, audio
         
-        return board.fen(), coach_text, audio_path, debug_info
-
-    return fen, "À vous les Blancs !", None, {}
+    return fen, history, None
 
 # --- INTERFACE ---
-with gr.Blocks(title="ChessCoach Pro") as demo:
-    gr.Markdown("# ♟️ ChessCoach Pro - Entraînement Vocal")
-    gr.Markdown("Jouez les blancs. Garry vous coache vocalement à chaque coup.")
-    
+
+with gr.Blocks(title="Talk with Kasparov") as demo:
+    gr.Markdown("# 🗣️ Parlez avec Kasparov (IA Coach)")
+    gr.Markdown("Jouez les Blancs. Posez des questions au micro. Garry vous répond en langage naturel.")
+
     with gr.Row():
         with gr.Column(scale=2):
-            level_radio = gr.Radio(
-                ["Débutant", "Intermédiaire", "Avancé", "Grand Maître"],
-                label="Niveau IA", value="Débutant"
-            )
             board = Chessboard(label="Échiquier", value=chess.STARTING_FEN, game_mode=True, interactive=True)
-        
+            
+            with gr.Row():
+                mic_btn = gr.Audio(sources=["microphone"], type="filepath", label="Posez une question à Garry")
+                submit_mic = gr.Button("Envoyer la question")
+
         with gr.Column(scale=1):
-            coach_box = gr.Textbox(label="Conseils de Garry", interactive=False, lines=3)
-            audio_box = gr.Audio(label="Voix", autoplay=True, interactive=False, type="filepath")
-            debug_box = gr.JSON(label="Données Techniques")
+            voice_selector = gr.Dropdown(["onyx", "fable", "echo", "shimmer"], value="fable", label="Voix du Coach")
+            level_selector = gr.Dropdown(["Débutant", "Intermédiaire", "Avancé", "Grand Maître"], value="Débutant", label="Niveau IA")
+            
+            chat_display = gr.Textbox(label="Conversation", interactive=False, lines=10)
+            audio_output = gr.Audio(label="Réponse Vocale", autoplay=True, interactive=False)
+
+    # 1. Joueur bouge une pièce -> Garry commente + IA joue
+    board.move(
+        fn=process_game_move,
+        inputs=[board, level_selector, chat_display, voice_selector],
+        outputs=[board, chat_display, audio_output]
+    )
 
-    board.move(fn=process_turn, inputs=[board, level_radio], outputs=[board, coach_box, audio_box, debug_box])
+    # 2. Joueur parle au micro -> Garry répond
+    submit_mic.click(
+        fn=chat_with_garry,
+        inputs=[board, mic_btn, chat_display, voice_selector],
+        outputs=[chat_display, audio_output]
+    )
+    # Déclenchement automatique quand on arrête d'enregistrer
+    mic_btn.stop_recording(
+        fn=chat_with_garry,
+        inputs=[board, mic_btn, chat_display, voice_selector],
+        outputs=[chat_display, audio_output]
+    )
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False, allowed_paths=["/tmp"])