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 -- import chess import chess.svg 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" if IS_DEBUG_MODE: app.secret_key = 'dev_secret_key_pour_eviter_perte_session_rechargement_et_tests_v2' logging.warning("MODE DEBUG ACTIVÉ. Utilisation d'une clé secrète statique.") app.debug = True # S'assurer que Flask est aussi en mode debug else: app.secret_key = os.environ.get("FLASK_SECRET_KEY") if not app.secret_key: app.secret_key = os.urandom(32) 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, SESSION_COOKIE_HTTPONLY=True, SESSION_COOKIE_SAMESITE='Lax', ) 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 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"] 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}") 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 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.") 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}) 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.get_best_move() engine.set_fen_position(chess.STARTING_FEN) app.logger.info(f"Moteur Stockfish initialisé avec succès depuis {STOCKFISH_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) 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. # (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())}") if 'board_fen' not in session or 'game_mode' not in session: 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 board = chess.Board(session['board_fen']) app.logger.debug(f"Session à la fin de GET /: {dict(session.items())}") return render_template('index.html', initial_board_svg=chess.svg.board(board=board, size=400), initial_fen=session['board_fen'], game_mode=session['game_mode'], player_color=session.get('player_color', 'white'), is_game_over=board.is_game_over(), 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" return f"Échec et mat ! {winner_color} gagnent." if board.is_stalemate(): return "Pat ! Partie nulle." if board.is_insufficient_material(): return "Matériel insuffisant. Partie nulle." if board.is_seventyfive_moves(): return "Règle des 75 coups. Partie nulle." if board.is_fivefold_repetition(): return "Répétition (5 fois). Partie nulle." if board.is_game_over(): return "Partie terminée." return "" @app.route('/make_move', methods=['POST']) def make_move_impl(): # Renommé pour éviter conflit de nom si vous avez collé 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 board = chess.Board(session['board_fen']) if board.is_game_over(): app.logger.info("Tentative de jouer alors que la partie est terminée.") return jsonify({'error': 'La partie est terminée.', 'fen': board.fen(), 'game_over': True, 'outcome': get_outcome_message(board), 'board_svg': chess.svg.board(board=board, size=400)}) move_uci_san = request.json.get('move') if not move_uci_san: app.logger.warning("Aucun mouvement fourni dans la requête POST /make_move.") return jsonify({'error': 'Mouvement non fourni.', 'fen': board.fen(), 'game_over': board.is_game_over(), 'board_svg': chess.svg.board(board=board, size=400)}) ai_move_made = False ai_move_uci = None last_player_move = None move_to_highlight = None move = None # initialisation try: move = board.parse_uci(move_uci_san) app.logger.info(f"Mouvement joueur (tentative UCI): {move.uci()}") except ValueError: try: move = board.parse_san(move_uci_san) app.logger.info(f"Mouvement joueur (tentative SAN): {board.san(move)}") except ValueError: 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 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()}") if session.get('game_mode') == 'ai' and not board.is_game_over(): app.logger.info(f"Mode IA, tour de l'IA. Joueur humain est {session.get('player_color')}.") current_turn_is_ai_turn = (session.get('player_color') == 'white' and board.turn == chess.BLACK) or \ (session.get('player_color') == 'black' and board.turn == chess.WHITE) if not current_turn_is_ai_turn: app.logger.error(f"Logique d'alternance erronée: C'est le tour de {'Blanc' if board.turn == chess.WHITE else 'Noir'}, mais l'IA ne devrait pas jouer.") else: stockfish_engine = get_stockfish_engine() if stockfish_engine: stockfish_engine.set_fen_position(board.fen()) best_move_ai = stockfish_engine.get_best_move() if best_move_ai: app.logger.info(f"Stockfish propose le coup: {best_move_ai}") try: ai_move_obj = board.parse_uci(best_move_ai) board.push(ai_move_obj) session['board_fen'] = board.fen() ai_move_made = True ai_move_uci = best_move_ai move_to_highlight = ai_move_obj app.logger.info(f"Mouvement IA {ai_move_uci} appliqué. Nouveau FEN: {board.fen()}") except Exception as e: app.logger.error(f"Erreur en appliquant le coup de l'IA {best_move_ai}: {e}", exc_info=True) 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.") else: app.logger.error("Moteur Stockfish non disponible pour le coup de l'IA.") elif move: # 'move' est défini mais pas légal 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. 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: app.logger.info(f"Partie terminée. Résultat: {outcome}") app.logger.debug(f"Session à la fin de POST /make_move: {dict(session.items())}") return jsonify({ 'fen': board.fen(), 'board_svg': chess.svg.board(board=board, size=400, lastmove=move_to_highlight), 'game_over': game_over, 'outcome': outcome, 'ai_move_uci': ai_move_uci, 'turn': 'white' if board.turn == chess.WHITE else 'black' }) @app.route('/reset_game', methods=['POST']) def reset_game(): app.logger.debug(f"Session au début de POST /reset_game: {dict(session.items())}") session['board_fen'] = chess.Board().fen() if 'game_mode' not in session: session['game_mode'] = 'pvp' if 'player_color' not in session: session['player_color'] = 'white' app.logger.info(f"Jeu réinitialisé. Nouveau FEN: {session['board_fen']}. Mode: {session.get('game_mode')}, Couleur joueur: {session.get('player_color')}") board = chess.Board(session['board_fen']) app.logger.debug(f"Session à la fin de POST /reset_game: {dict(session.items())}") return jsonify({ 'fen': session['board_fen'], 'board_svg': chess.svg.board(board=board, size=400), 'game_mode': session.get('game_mode'), 'player_color': session.get('player_color'), 'turn': 'white' if board.turn == chess.WHITE else 'black', 'game_over': False, 'outcome': "" }) @app.route('/set_mode', methods=['POST']) def set_mode_route(): app.logger.debug(f"Session au début de POST /set_mode: {dict(session.items())}") mode = request.json.get('game_mode') player_color = request.json.get('player_color', 'white') if mode in ['pvp', 'ai']: session['game_mode'] = mode session['player_color'] = player_color session['board_fen'] = chess.Board().fen() app.logger.info(f"Mode de jeu réglé sur {mode}. Joueur humain: {player_color if mode == 'ai' else 'N/A'}. FEN réinitialisé.") board = chess.Board() initial_ai_move_uci = None move_to_highlight_init = None if mode == 'ai' and player_color == 'black': app.logger.info("L'IA (Blancs) commence la partie.") stockfish_engine = get_stockfish_engine() if stockfish_engine: stockfish_engine.set_fen_position(board.fen()) best_move_ai = stockfish_engine.get_best_move() if best_move_ai: try: ai_move_obj = board.parse_uci(best_move_ai) board.push(ai_move_obj) session['board_fen'] = board.fen() initial_ai_move_uci = best_move_ai move_to_highlight_init = ai_move_obj app.logger.info(f"Premier coup de l'IA (Blancs): {initial_ai_move_uci}. Nouveau FEN: {board.fen()}") 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).") else: app.logger.error("Moteur Stockfish non disponible pour le premier coup de l'IA.") app.logger.debug(f"Session à la fin de POST /set_mode: {dict(session.items())}") return jsonify({ 'message': f'Mode de jeu réglé sur {mode.upper()}. {"Vous jouez " + player_color.capitalize() if mode == "ai" else ""}', 'fen': session['board_fen'], 'board_svg': chess.svg.board(board=board, size=400, lastmove=move_to_highlight_init), 'game_mode': mode, 'player_color': player_color, 'turn': 'white' if board.turn == chess.WHITE else 'black', 'initial_ai_move_uci': initial_ai_move_uci, 'game_over': board.is_game_over(), 'outcome': get_outcome_message(board) if board.is_game_over() else "" }) else: 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