Update app.py

app.py

@@ -4,16 +4,15 @@ import chess
 import chess.engine
 import pandas as pd
 import os
-import uuid  # Pour des noms de fichiers uniques
+import uuid
+import requests  # On utilise requests direct, plus fiable que la lib elevenlabs
 from openai import OpenAI
-from elevenlabs.client import ElevenLabs
 
 # --- CONFIGURATION ---
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 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
 
 STOCKFISH_PATH = "/usr/games/stockfish"
 
@@ -34,32 +33,23 @@ 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):
-    """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"
+        return 0, "Erreur Engine"
 
 def get_ai_move(board, level):
-    """L'IA joue son coup."""
     levels = {
         "Débutant": {"time": 0.01, "skill": 0, "depth": 1},
         "Intermédiaire": {"time": 0.1, "skill": 10, "depth": 5},
@@ -67,7 +57,6 @@ def get_ai_move(board, level):
         "Grand Maître": {"time": 1.0, "skill": 20, "depth": 18}
     }
     config = levels.get(level, levels["Débutant"])
-    
     try:
         with chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH) as engine:
             engine.configure({"Skill Level": config["skill"]})
@@ -76,56 +65,68 @@ def get_ai_move(board, level):
     except:
         return None
 
-# --- CERVEAU DU COACH (LLM + AUDIO) ---
-
-SYSTEM_PROMPT = """
-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.
-"""
+# --- AUDIO SANS LIBRAIRIE (HTTP REQUESTS) ---
+def generate_voice_direct(text):
+    """Génère l'audio via requête HTTP directe pour éviter les bugs de librairie."""
+    if not ELEVEN_API_KEY: 
+        return None, "ERREUR: Pas de clé API ElevenLabs configurée."
+    if not text: return None, "Pas de texte."
 
-def generate_voice(text):
-    """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
+    # ID de la voix Rachel (standard)
+    VOICE_ID = "21m00Tcm4TlvDq8ikWAM" 
+    
+    url = f"https://api.elevenlabs.io/v1/text-to-speech/{VOICE_ID}"
+    
+    headers = {
+        "Accept": "audio/mpeg",
+        "Content-Type": "application/json",
+        "xi-api-key": ELEVEN_API_KEY
+    }
+    
+    data = {
+        "text": text,
+        "model_id": "eleven_multilingual_v2",
+        "voice_settings": {
+            "stability": 0.5,
+            "similarity_boost": 0.75
+        }
+    }
 
     try:
-        print(f"🎤 Génération audio pour : {text[:20]}...")
-        audio_stream = eleven_client.generate(
-            text=text,
-            voice="Rachel",
-            model="eleven_multilingual_v2"
-        )
+        response = requests.post(url, json=data, headers=headers)
         
-        # 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:
-                f.write(chunk)
-        
-        print(f"✅ Fichier audio créé : {path}")
-        return path
+        if response.status_code == 200:
+            # Succès ! On sauvegarde
+            unique_filename = f"coach_{uuid.uuid4()}.mp3"
+            path = os.path.join("/tmp", unique_filename)
+            with open(path, "wb") as f:
+                f.write(response.content)
+            return path, None # Path, Pas d'erreur
+        else:
+            # Erreur renvoyée par ElevenLabs (ex: quota dépassé, mauvaise clé)
+            error_msg = f"Erreur ElevenLabs ({response.status_code}): {response.text}"
+            print(error_msg)
+            return None, error_msg
+            
     except Exception as e:
-        print(f"❌ Erreur ElevenLabs: {e}")
-        return None
+        return None, f"Exception Python: {str(e)}"
+
+# --- PROMPT COACH ---
+SYSTEM_PROMPT = """
+Tu es Garry, un coach d'échecs légendaire.
+Tu analyses le dernier coup du joueur (Blancs).
+1. Dis si le coup est bon ou mauvais.
+2. Donne un conseil tactique précis (ex: "Tu laisses ton Fou en prise", "Contrôle le centre").
+3. Sois bref (20 mots max).
+"""
 
 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, le joueur (Blancs) vient de jouer
+    # Tour du joueur terminé (c'est aux noirs)
     if board.turn == chess.BLACK:
-        
         # 1. Analyse Technique
         opening_name = "Inconnue"
         if not OPENINGS_DB.empty:
@@ -134,10 +135,10 @@ def process_turn(fen, level):
             
         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}."
-        
+        # 2. LLM
+        llm_context = f"Ouverture: {opening_name}. Score: {score}. Meilleur coup aurait été: {best_move}."
         coach_text = "..."
+        
         if openai_client:
             try:
                 response = openai_client.chat.completions.create(
@@ -149,74 +150,52 @@ def process_turn(fen, level):
                 )
                 coach_text = response.choices[0].message.content
             except Exception as e:
-                coach_text = f"Erreur LLM: {e}"
+                coach_text = f"Erreur OpenAI: {e}"
         else:
-            coach_text = "Configurez votre clé OpenAI !"
+            coach_text = "Clé OpenAI manquante."
             
-        # 3. Génération Audio
-        audio_path = generate_voice(coach_text)
+        # 3. Audio (Méthode Directe)
+        audio_path, error_audio = generate_voice_direct(coach_text)
+        
+        # Si erreur audio, on l'affiche dans le texte du coach pour debugger !
+        if error_audio:
+            coach_text += f"\n[DEBUG AUDIO]: {error_audio}"
         
         # 4. Debug Data
         debug_info = {
             "Ouverture": opening_name,
-            "Score Centipawns": str(score),
-            "Conseil Stockfish": best_move
+            "Score": str(score),
+            "Conseil Engine": best_move,
+            "Audio Status": "OK" if audio_path else error_audio
         }
         
-        # 5. L'IA joue son coup (Noirs)
+        # 5. IA joue
         if not board.is_game_over():
             ai_move = get_ai_move(board, level)
-            if ai_move:
-                board.push(ai_move)
+            if ai_move: board.push(ai_move)
         
-        # 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, {}
+    return fen, "À vous les Blancs !", None, {}
 
 # --- INTERFACE ---
-
 with gr.Blocks(title="ChessCoach Pro") as demo:
-    gr.Markdown(
-        """
-        # ♟️ ChessCoach Pro
-        **Votre Coach IA personnel.** Jouez les Blancs. Garry analyse vos coups et vous donne des conseils stratégiques vocalement.
-        """
-    )
+    gr.Markdown("# ♟️ ChessCoach Pro - Entraînement Vocal")
     
     with gr.Row():
         with gr.Column(scale=2):
             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,
-                game_mode=True,
-                interactive=True
+                label="Niveau IA", value="Débutant"
             )
+            board = Chessboard(label="Échiquier", value=chess.STARTING_FEN, game_mode=True, interactive=True)
         
         with gr.Column(scale=1):
-            coach_box = gr.Textbox(label="Conseils de Garry", interactive=False, lines=4)
+            coach_box = gr.Textbox(label="Conseils de Garry (et Erreurs)", interactive=False, lines=4)
             audio_box = gr.Audio(label="Voix", autoplay=True, interactive=False, type="filepath")
             debug_box = gr.JSON(label="Données Techniques")
 
-    # Logique
-    board.move(
-        fn=process_turn,
-        inputs=[board, level_radio],
-        outputs=[board, coach_box, audio_box, debug_box]
-    )
+    board.move(fn=process_turn, inputs=[board, level_radio], outputs=[board, coach_box, audio_box, debug_box])
 
 if __name__ == "__main__":
-    # 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"]
-    )
+    demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False, allowed_paths=["/tmp"])