Update app.py

app.py

@@ -1,42 +1,19 @@
 from flask import Flask, render_template, request, jsonify, session
-# -- Modification pour vérifier l'import --
 import sys
 import os
 import inspect # Ajout pour inspecter
 
-# --- Forcer l'utilisation de la bibliothèque locale si elle est à côté ---
-# Supposons la structure:
-# votre_projet/
-#  ├── app.py
-#  └── zhelyabuzhsky-stockfish/  <-- le répertoire complet de la bibliothèque
-#      ├── stockfish/
-#      │   ├── __init__.py
-#      │   └── models.py
-#      └── ... autres fichiers de la lib (setup.py, etc.)
-
-# Pour que "from stockfish import Stockfish" fonctionne avec cette structure,
-# le répertoire "zhelyabuzhsky-stockfish" doit être traitable comme un package.
-# Python recherche d'abord dans le répertoire courant, puis dans PYTHONPATH, puis dans les sites-packages.
-# Si vous avez une autre lib "stockfish" installée globalement, elle pourrait prendre le dessus.
-# On peut ajouter le répertoire parent de zhelyabuzhsky-stockfish/stockfish au path,
-# ou directement le chemin vers zhelyabuzhsky-stockfish si on l'importe comme un package.
-
-# Option 1: Ajouter le répertoire parent de votre projet au sys.path
-# pour que zhelyabuzhsky-stockfish soit vu comme un package de haut niveau.
-# current_script_dir = os.path.dirname(os.path.abspath(__file__))
-# project_root = os.path.dirname(current_script_dir) # Si app.py est dans un sous-dossier
-# if project_root not in sys.path:
-# sys.path.insert(0, project_root)
-
-# Option plus simple si zhelyabuzhsky-stockfish est à côté de app.py
-# et que vous voulez importer "from stockfish import ..."
-# Cela suppose que Python va scanner "zhelyabuzhsky-stockfish" et trouver le sous-module "stockfish".
-# Le plus sûr est d'installer votre bibliothèque localement.
-# `pip install -e ./zhelyabuzhsky-stockfish` depuis le répertoire parent.
-
-from stockfish import Stockfish, StockfishException # L'import
-print(f"--- Stockfish class imported from: {inspect.getfile(Stockfish)} ---") # VÉRIFICATION
-# --- Fin de la modification pour vérifier l'import --
+# --- VÉRIFICATION DE L'IMPORT DE STOCKFISH (Doit être au tout début) ---
+# Cet import doit être celui de la bibliothèque zhelyabuzhsky-stockfish
+try:
+    from stockfish import Stockfish, StockfishException
+    STOCKFISH_LIB_PATH = inspect.getfile(Stockfish)
+    print(f"--- Stockfish class imported from: {STOCKFISH_LIB_PATH} ---")
+except ImportError as e:
+    print(f"ERREUR CRITIQUE: Impossible d'importer la bibliothèque Stockfish: {e}")
+    print("Assurez-vous que la bibliothèque zhelyabuzhsky-stockfish est dans votre PYTHONPATH ou installée.")
+    sys.exit(1) # Arrêter si la lib principale manque
+# --- Fin de la vérification ---
 
 import chess
 import chess.svg
@@ -45,15 +22,13 @@ import logging
 app = Flask(__name__)
 
 # --- Configuration de la clé secrète ---
-# FORCER LE MODE DEBUG POUR LE DÉVELOPPEMENT LOCAL
-IS_DEBUG_MODE = True # Modifier cette ligne manuellement pour tester en mode prod-like si besoin
-# OU utiliser la variable d'environnement:
-# IS_DEBUG_MODE = os.environ.get("FLASK_DEBUG", "0") == "1"
+IS_DEBUG_MODE = True # Forcer le mode debug pour le développement local
+# Pour la production, gérez FLASK_DEBUG et FLASK_SECRET_KEY via les variables d'environnement
 
 if IS_DEBUG_MODE:
-    app.secret_key = 'dev_secret_key_pour_eviter_perte_session_rechargement_et_tests_v2'
+    app.secret_key = 'dev_secret_key_pour_eviter_perte_session_rechargement_et_tests_v3' # Changez si besoin
     logging.warning("MODE DEBUG ACTIVÉ. Utilisation d'une clé secrète statique.")
-    app.debug = True # S'assurer que Flask est aussi en mode debug
+    app.debug = True
 else:
     app.secret_key = os.environ.get("FLASK_SECRET_KEY")
     if not app.secret_key:
@@ -61,7 +36,6 @@ else:
         logging.warning("MODE PRODUCTION. FLASK_SECRET_KEY non définie. Clé aléatoire générée.")
     app.debug = False
 
-
 # --- Configuration des Cookies de Session ---
 app.config.update(
     SESSION_COOKIE_SECURE=False,
@@ -71,69 +45,59 @@ app.config.update(
 
 logging.basicConfig(level=logging.DEBUG)
 
-# ... (le reste du code de app.py reste identique à la version précédente)
-# ... (find_stockfish, get_stockfish_engine, routes, etc.)
-
-# --- Assurez-vous que le find_stockfish et HAS_STOCKFISH sont définis globalement ---
-STOCKFISH_PATH_GLOBAL = "stockfish" # Variable globale pour le chemin
-HAS_STOCKFISH_GLOBAL = False
+# --- Configuration Globale de Stockfish (Exécutable) ---
+STOCKFISH_EXECUTABLE_PATH_GLOBAL = "stockfish" # Valeur par défaut
+HAS_STOCKFISH_EXECUTABLE_GLOBAL = False
 
 def find_stockfish_on_startup():
-    global STOCKFISH_PATH_GLOBAL, HAS_STOCKFISH_GLOBAL
-    # Tenter le chemin par défaut ou celui de l'env
-    stockfish_env_path = os.environ.get("STOCKFISH_EXECUTABLE_PATH", "stockfish")
-    paths_to_check = [stockfish_env_path, STOCKFISH_PATH_GLOBAL, "/usr/games/stockfish", "/usr/local/bin/stockfish", "/opt/homebrew/bin/stockfish", "stockfish.exe", "./stockfish"]
+    global STOCKFISH_EXECUTABLE_PATH_GLOBAL, HAS_STOCKFISH_EXECUTABLE_GLOBAL
+    
+    # Priorité à une variable d'environnement si définie
+    env_path = os.environ.get("STOCKFISH_EXECUTABLE_PATH")
+    paths_to_check = [env_path] if env_path else []
+    
+    paths_to_check.extend([
+        "stockfish", "./stockfish", # Relatif au répertoire de travail
+        "/usr/games/stockfish", "/usr/local/bin/stockfish", 
+        "/opt/homebrew/bin/stockfish", "stockfish.exe" # Chemins communs
+    ])
     
     for p in paths_to_check:
         if p and os.path.exists(p) and os.access(p, os.X_OK):
-            STOCKFISH_PATH_GLOBAL = p
-            HAS_STOCKFISH_GLOBAL = True
-            app.logger.info(f"Stockfish exécutable trouvé à: {STOCKFISH_PATH_GLOBAL}")
+            STOCKFISH_EXECUTABLE_PATH_GLOBAL = p
+            HAS_STOCKFISH_EXECUTABLE_GLOBAL = True
+            app.logger.info(f"Stockfish exécutable trouvé à: {STOCKFISH_EXECUTABLE_PATH_GLOBAL}")
             return
-    app.logger.warning(f"AVERTISSEMENT: Stockfish non trouvé. L'IA ne fonctionnera pas.")
-    HAS_STOCKFISH_GLOBAL = False
-
-find_stockfish_on_startup() # Exécuter au démarrage
+            
+    app.logger.warning(
+        "AVERTISSEMENT: Exécutable Stockfish non trouvé dans les chemins courants ou via STOCKFISH_EXECUTABLE_PATH. "
+        "L'IA ne fonctionnera pas. Veuillez installer Stockfish ou définir la variable d'environnement."
+    )
+    HAS_STOCKFISH_EXECUTABLE_GLOBAL = False
 
+find_stockfish_on_startup() # Exécuter au démarrage de l'application
 
 def get_stockfish_engine():
-    """Initialise et retourne une instance de Stockfish."""
-    if not HAS_STOCKFISH_GLOBAL:
-        app.logger.error("Stockfish non disponible (vérification au démarrage échouée). L'IA ne peut pas démarrer.")
+    """Initialise et retourne une instance de la classe Stockfish."""
+    if not HAS_STOCKFISH_EXECUTABLE_GLOBAL:
+        app.logger.error("Exécutable Stockfish non disponible. L'IA ne peut pas démarrer.")
         return None
     try:
-        # Utiliser STOCKFISH_PATH_GLOBAL qui a été déterminé au démarrage
-        engine = Stockfish(path=STOCKFISH_PATH_GLOBAL, depth=15, parameters={"Threads": 1, "Hash": 64})
+        engine = Stockfish(path=STOCKFISH_EXECUTABLE_PATH_GLOBAL, depth=15, parameters={"Threads": 1, "Hash": 64})
         if engine._stockfish.poll() is not None:
              app.logger.error("Le processus Stockfish s'est terminé de manière inattendue lors de l'initialisation.")
              raise StockfishException("Stockfish process terminated unexpectedly on init.")
-        engine.set_fen_position(chess.STARTING_FEN)
+        engine.set_fen_position(chess.STARTING_FEN) # Test léger
         engine.get_best_move() 
-        engine.set_fen_position(chess.STARTING_FEN)
-        app.logger.info(f"Moteur Stockfish initialisé avec succès depuis {STOCKFISH_PATH_GLOBAL}.")
+        engine.set_fen_position(chess.STARTING_FEN) # Reset après test
+        app.logger.info(f"Moteur Stockfish (classe) initialisé avec succès utilisant l'exécutable: {STOCKFISH_EXECUTABLE_PATH_GLOBAL}.")
         return engine
     except Exception as e:
-        app.logger.error(f"Erreur lors de l'initialisation de Stockfish ({STOCKFISH_PATH_GLOBAL}): {e}", exc_info=True)
+        app.logger.error(f"Erreur lors de l'initialisation de la classe Stockfish (exécutable: {STOCKFISH_EXECUTABLE_PATH_GLOBAL}): {e}", exc_info=True)
         return None
 
-# --- Collez ici le reste de vos routes : index, get_outcome_message, make_move, reset_game, set_mode_route ---
-# (Pour éviter de répéter 500 lignes, je ne les remets pas, mais elles restent inchangées par rapport à votre dernière version
-# SAUF si le AttributeError persiste, auquel cas il faudra vérifier la version de la lib Stockfish)
-
-# ... (Collez ici le reste des routes : index, get_outcome_message, make_move, reset_game, set_mode_route)
-# ... (depuis la version précédente que je vous ai donnée)
-
-# Par exemple, la route make_move commencerait comme ça:
-@app.route('/make_move', methods=['POST'])
-def make_move():
-    app.logger.debug(f"Session au début de POST /make_move: {dict(session.items())}")
-    if 'board_fen' not in session:
-        app.logger.error("ERREUR CRITIQUE: 'board_fen' non trouvé dans la session pour POST /make_move!")
-        return jsonify({'error': 'Erreur de session, "board_fen" manquant. Veuillez rafraîchir ou réinitialiser.',
-                        'fen': chess.Board().fen(), 'game_over': False, 'board_svg': chess.svg.board(board=chess.Board(), size=400)}), 500
-    # ... et ainsi de suite pour toute la fonction make_move et les autres routes.
+# --- Définition des Routes ---
 
-# (Le code des routes est omis pour la brièveté, mais doit être inclus)
 @app.route('/')
 def index():
     app.logger.debug(f"Session au début de GET /: {dict(session.items())}")
@@ -141,7 +105,7 @@ def index():
         app.logger.info("Initialisation de la session (board_fen, game_mode, player_color) dans GET /")
         session['board_fen'] = chess.Board().fen()
         session['game_mode'] = 'pvp'
-        session['player_color'] = 'white' # Couleur du joueur humain si mode AI
+        session['player_color'] = 'white'
 
     board = chess.Board(session['board_fen'])
     app.logger.debug(f"Session à la fin de GET /: {dict(session.items())}")
@@ -154,7 +118,6 @@ def index():
                            outcome=get_outcome_message(board) if board.is_game_over() else "",
                            current_turn = 'white' if board.turn == chess.WHITE else 'black')
 
-
 def get_outcome_message(board):
     if board.is_checkmate():
         winner_color = "Blancs" if board.turn == chess.BLACK else "Noirs"
@@ -167,7 +130,7 @@ def get_outcome_message(board):
     return ""
 
 @app.route('/make_move', methods=['POST'])
-def make_move_impl(): # Renommé pour éviter conflit de nom si vous avez collé
+def make_move():
     app.logger.debug(f"Session au début de POST /make_move: {dict(session.items())}")
     if 'board_fen' not in session:
         app.logger.error("ERREUR CRITIQUE: 'board_fen' non trouvé dans la session pour POST /make_move!")
@@ -186,9 +149,8 @@ def make_move_impl(): # Renommé pour éviter conflit de nom si vous avez collé
 
     ai_move_made = False
     ai_move_uci = None
-    last_player_move = None
     move_to_highlight = None
-    move = None # initialisation
+    move = None 
 
     try:
         move = board.parse_uci(move_uci_san)
@@ -201,9 +163,8 @@ def make_move_impl(): # Renommé pour éviter conflit de nom si vous avez collé
             app.logger.warning(f"Mouvement invalide (ni UCI ni SAN): {move_uci_san} pour FEN {board.fen()}")
             return jsonify({'error': f'Mouvement invalide: {move_uci_san}', 'fen': board.fen(), 'game_over': board.is_game_over(), 'board_svg': chess.svg.board(board=board, size=400)})
 
-    if move and move in board.legal_moves: # Vérifier que 'move' est non None
+    if move and move in board.legal_moves:
         board.push(move)
-        last_player_move = move
         move_to_highlight = move 
         session['board_fen'] = board.fen()
         app.logger.info(f"Mouvement joueur {move.uci()} appliqué. Nouveau FEN: {board.fen()}")
@@ -235,31 +196,26 @@ def make_move_impl(): # Renommé pour éviter conflit de nom si vous avez collé
                     else:
                         app.logger.warning("L'IA (Stockfish) n'a pas retourné de coup.")
                     
-                    # Vérifier si la méthode existe avant de l'appeler
-                    if hasattr(stockfish_engine, 'send_quit_command'):
-                        stockfish_engine.send_quit_command()
-                        app.logger.info("Moteur Stockfish arrêté après le coup de l'IA.")
-                    elif hasattr(stockfish_engine, '__del__'):
-                        # Si send_quit_command n'existe pas, on espère que __del__ fait le travail.
-                        # Ou on pourrait juste faire `del stockfish_engine` pour déclencher __del__
-                        app.logger.warning("send_quit_command() n'existe pas, __del__ sera utilisé implicitement.")
-                    else:
-                        app.logger.error("Ni send_quit_command ni __del__ ne semblent disponibles pour arrêter Stockfish proprement.")
+                    # APPEL À send_quit_command() COMMENTÉ COMME DEMANDÉ
+                    # if hasattr(stockfish_engine, 'send_quit_command'):
+                    #     stockfish_engine.send_quit_command()
+                    #     app.logger.info("Moteur Stockfish arrêté après le coup de l'IA.")
+                    # elif hasattr(stockfish_engine, '__del__') and callable(getattr(stockfish_engine, '__del__')):
+                    #     app.logger.warning("send_quit_command() n'existe pas, __del__ sera potentiellement utilisé.")
+                    # else:
+                    #     app.logger.error("Ni send_quit_command ni __del__ ne semblent disponibles pour arrêter Stockfish proprement.")
+                    app.logger.info("Appel explicite à send_quit_command retiré (après coup IA). Le processus Stockfish peut rester actif.")
+                    # del stockfish_engine # Optionnel: pour essayer de forcer __del__ si la lib le gère bien
 
                 else:
                     app.logger.error("Moteur Stockfish non disponible pour le coup de l'IA.")
-    elif move: # 'move' est défini mais pas légal
+    elif move: 
         app.logger.warning(f"Mouvement illégal tenté: {move.uci() if hasattr(move, 'uci') else move_uci_san} depuis FEN: {session['board_fen']}")
-        legal_moves_str = ", ".join([board.san(m) for m in board.legal_moves])
-        app.logger.debug(f"Coups légaux: {legal_moves_str[:200]}")
         return jsonify({'error': f'Mouvement illégal: {move.uci() if hasattr(move, "uci") else move_uci_san}', 'fen': board.fen(), 'game_over': board.is_game_over(), 'board_svg': chess.svg.board(board=board, size=400)})
-    else: # 'move' est None, n'a pas pu être parsé
-        # L'erreur a déjà été gérée par le bloc try/except du parsing
-        # Ce bloc else ne devrait pas être atteint si le parsing échoue et retourne.
+    else: 
         app.logger.error("La variable 'move' est None après la tentative de parsing, ce qui ne devrait pas arriver ici.")
         return jsonify({'error': 'Erreur interne de parsing de coup.', 'fen': board.fen(), 'game_over': board.is_game_over(), 'board_svg': chess.svg.board(board=board, size=400)}), 500
 
-
     game_over = board.is_game_over()
     outcome = get_outcome_message(board) if game_over else ""
     if game_over:
@@ -329,13 +285,17 @@ def set_mode_route():
                     except Exception as e:
                         app.logger.error(f"Erreur en appliquant le premier coup de l'IA {best_move_ai}: {e}", exc_info=True)
                 
-                if hasattr(stockfish_engine, 'send_quit_command'):
-                    stockfish_engine.send_quit_command()
-                    app.logger.info("Moteur Stockfish arrêté après le premier coup de l'IA.")
-                elif hasattr(stockfish_engine, '__del__'):
-                    app.logger.warning("send_quit_command() n'existe pas, __del__ sera utilisé implicitement pour le premier coup IA.")
-                else:
-                    app.logger.error("Ni send_quit_command ni __del__ pour arrêter Stockfish (premier coup IA).")
+                # APPEL À send_quit_command() COMMENTÉ COMME DEMANDÉ
+                # if hasattr(stockfish_engine, 'send_quit_command'):
+                #     stockfish_engine.send_quit_command()
+                #     app.logger.info("Moteur Stockfish arrêté après le premier coup de l'IA.")
+                # elif hasattr(stockfish_engine, '__del__') and callable(getattr(stockfish_engine, '__del__')):
+                #     app.logger.warning("send_quit_command() n'existe pas, __del__ sera potentiellement utilisé.")
+                # else:
+                #     app.logger.error("Ni send_quit_command ni __del__ pour arrêter Stockfish (premier coup IA).")
+                app.logger.info("Appel explicite à send_quit_command retiré (après premier coup IA). Le processus Stockfish peut rester actif.")
+                # del stockfish_engine # Optionnel
+
             else:
                 app.logger.error("Moteur Stockfish non disponible pour le premier coup de l'IA.")
 
@@ -355,6 +315,5 @@ def set_mode_route():
         app.logger.warning(f"Tentative de définir un mode de jeu invalide: {mode}")
         return jsonify({'error': 'Mode invalide'}), 400
 
-
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=5000) # IS_DEBUG_MODE et app.debug sont gérés plus haut