Update app.py

app.py

@@ -6,303 +6,154 @@ import git
 import sys
 import random
 from streamlit.components.v1 import html
+import logging
+
+# Configuration des logs
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
 
 # Configuration de la page
 st.set_page_config(page_title="Échecs contre IA", layout="wide")
 
 def render_board():
     """Rendre l'échiquier interactif"""
-    # Générer le SVG de l'échiquier
-    board_svg = chess.svg.board(
-        board=st.session_state.board,
-        size=400,
-        lastmove=st.session_state.board.peek() if st.session_state.board.move_stack else None,
-    )
-    
-    # Code HTML/JS pour rendre l'échiquier interactif
-    html_content = f"""
-        <style>
-            #chess-board {{
-                position: relative;
-                width: 400px;
-                margin: auto;
-            }}
-            #chess-board svg {{
-                position: absolute;
-                top: 0;
-                left: 0;
-                width: 100%;
-                height: 100%;
-                pointer-events: none;
-            }}
-            #chess-board svg * {{
-                pointer-events: auto;
-            }}
-            .piece {{
-                cursor: grab;
-                pointer-events: auto;
-            }}
-            .piece.dragging {{
-                cursor: grabbing;
-            }}
-            .square {{
-                pointer-events: auto;
-            }}
-            .highlight {{
-                fill: rgba(255, 255, 0, 0.3);
-            }}
-            .possible-move {{
-                fill: rgba(0, 255, 0, 0.3);
-            }}
-            .ghost-piece {{
-                opacity: 0.3;
-                pointer-events: none;
-            }}
-        </style>
+    try:
+        logger.debug("Génération du SVG de l'échiquier...")
+        # Générer le SVG de l'échiquier
+        board_svg = chess.svg.board(
+            board=st.session_state.board,
+            size=400,
+            lastmove=st.session_state.board.peek() if st.session_state.board.move_stack else None,
+        )
+        logger.debug("SVG généré avec succès")
         
-        <div id="chess-board">
-            {board_svg}
-            <div id="drag-layer" style="position: absolute; top: 0; left: 0; pointer-events: none;"></div>
-        </div>
-
-        <script>
-            (function() {{
-                const board = document.querySelector('#chess-board');
-                const svg = board.querySelector('svg');
-                const dragLayer = document.getElementById('drag-layer');
-                let selectedPiece = null;
-                let ghostPiece = null;
-                let startSquare = null;
-                let currentSquare = null;
-                let isDragging = false;
-                let offset = {{ x: 0, y: 0 }};
-
-                // Convertir les coordonnées en notation algébrique
-                function getSquareFromCoords(x, y) {{
-                    const boardRect = board.getBoundingClientRect();
-                    const squareSize = boardRect.width / 8;
-                    const file = Math.floor((x - boardRect.left) / squareSize);
-                    const rank = 7 - Math.floor((y - boardRect.top) / squareSize);
-                    if (file >= 0 && file < 8 && rank >= 0 && rank < 8) {{
-                        return String.fromCharCode(97 + file) + (rank + 1);
-                    }}
-                    return null;
-                }}
-
-                // Créer une copie fantôme de la pièce pour le glissement
-                function createGhostPiece(piece) {{
-                    const clone = piece.cloneNode(true);
-                    clone.classList.add('ghost-piece');
-                    return clone;
-                }}
-
-                // Mettre à jour la position du fantôme
-                function updateGhostPosition(x, y) {{
-                    if (ghostPiece) {{
-                        ghostPiece.style.transform = `translate(${{x - offset.x}}px, ${{y - offset.y}}px)`;
-                    }}
-                }}
-
-                // Gérer le début du glissement
-                svg.addEventListener('mousedown', function(e) {{
-                    const piece = e.target.closest('.piece');
-                    if (piece && piece.classList.contains('white')) {{
-                        e.preventDefault();
-                        selectedPiece = piece;
-                        const rect = piece.getBoundingClientRect();
-                        offset.x = e.clientX - rect.left;
-                        offset.y = e.clientY - rect.top;
-                        
-                        // Créer et positionner le fantôme
-                        ghostPiece = createGhostPiece(piece);
-                        dragLayer.appendChild(ghostPiece);
-                        updateGhostPosition(e.clientX, e.clientY);
-                        
-                        startSquare = getSquareFromCoords(e.clientX, e.clientY);
-                        isDragging = true;
-                        selectedPiece.classList.add('dragging');
-                    }}
-                }});
-
-                // Gérer le glissement
-                document.addEventListener('mousemove', function(e) {{
-                    if (isDragging && ghostPiece) {{
-                        e.preventDefault();
-                        updateGhostPosition(e.clientX, e.clientY);
-                        currentSquare = getSquareFromCoords(e.clientX, e.clientY);
-                    }}
+        logger.debug("Création du contenu HTML...")
+        # Code HTML/JS pour l'échiquier interactif
+        html_content = f'''
+            <div id="board-container" style="width: 400px; margin: auto;">
+                {board_svg}
+            </div>
+            
+            <script>
+                console.log("Initialisation du JavaScript...");
+                const boardContainer = document.getElementById('board-container');
+                console.log("Container trouvé:", boardContainer);
+                
+                // Ajouter des événements de débogage
+                boardContainer.addEventListener('mouseover', (e) => {{
+                    console.log("Survol:", e.target);
                 }});
-
-                // Gérer la fin du glissement
-                document.addEventListener('mouseup', function(e) {{
-                    if (isDragging && selectedPiece) {{
-                        const endSquare = getSquareFromCoords(e.clientX, e.clientY);
-                        
-                        if (startSquare && endSquare && startSquare !== endSquare) {{
-                            window.parent.postMessage({{
-                                type: 'chess_move',
-                                from: startSquare,
-                                to: endSquare
-                            }}, '*');
-                        }}
-                        
-                        // Nettoyer
-                        if (ghostPiece) {{
-                            dragLayer.removeChild(ghostPiece);
-                            ghostPiece = null;
-                        }}
-                        selectedPiece.classList.remove('dragging');
-                        selectedPiece = null;
-                        isDragging = false;
-                    }}
+                
+                // Trouver toutes les pièces
+                const pieces = boardContainer.getElementsByClassName('piece');
+                console.log("Pièces trouvées:", pieces.length);
+                
+                // Ajouter des gestionnaires d'événements à chaque pièce
+                Array.from(pieces).forEach(piece => {{
+                    piece.style.cursor = 'grab';
+                    piece.draggable = true;
+                    
+                    piece.addEventListener('dragstart', (e) => {{
+                        console.log("Début du glissement", e);
+                        e.target.classList.add('dragging');
+                    }});
+                    
+                    piece.addEventListener('dragend', (e) => {{
+                        console.log("Fin du glissement", e);
+                        e.target.classList.remove('dragging');
+                    }});
                 }});
-            }})();
-        </script>
-    """
-    
-    html(html_content, height=450)
-
-def calculate_max_length(move_count):
-    """Calcule le max_length optimal"""
-    base_length = 10
-    increment = 1
-    max_length = 100
-    return min(base_length + (move_count * increment), max_length)
+            </script>
+            
+            <style>
+                .piece {{
+                    cursor: grab;
+                }}
+                .dragging {{
+                    opacity: 0.5;
+                }}
+            </style>
+        '''
+        logger.debug("Contenu HTML créé")
+        
+        # Afficher le contenu
+        logger.debug("Affichage du composant HTML...")
+        html(html_content, height=450)
+        logger.debug("Composant HTML affiché")
+        
+    except Exception as e:
+        logger.error(f"Erreur lors du rendu de l'échiquier: {e}", exc_info=True)
+        st.error(f"Erreur lors de l'affichage de l'échiquier: {str(e)}")
 
+# Setup du modèle
 @st.cache_resource
 def setup_inference():
     """Initialise le modèle d'IA"""
-    if not os.path.exists('chess'):
-        git.Repo.clone_from('https://github.com/l-pommeret/chess.git', 'chess')
-    if 'chess' not in sys.path:
-        sys.path.append('chess')
-    from inference import InferenceConfig, ChessGenerator
-    
-    config = InferenceConfig(
-        model_name="Zual/chess",
-        temperature=0.8,
-        max_length=6
-    )
-    return ChessGenerator(config)
-
-def initialize_state():
-    """Initialise ou réinitialise l'état du jeu"""
-    if 'board' not in st.session_state:
-        st.session_state.board = chess.Board()
-    if 'moves' not in st.session_state:
-        st.session_state.moves = []
-
-def get_ai_move(prompt):
-    """Obtient le coup de l'IA"""
-    moves_count = len(st.session_state.moves)
-    dynamic_max_length = calculate_max_length(moves_count)
-    generator.config.max_length = dynamic_max_length
-    
+    logger.info("Initialisation du modèle d'IA...")
     try:
-        if not prompt:  # Premier coup
-            response = generator.generate("1.")
-        else:
-            moves = prompt.split()
-            last_moves = " ".join(moves[-4:])  # Garder seulement les 2 derniers coups
+        if not os.path.exists('chess'):
+            logger.info("Clonage du répertoire git...")
+            git.Repo.clone_from('https://github.com/l-pommeret/chess.git', 'chess')
             
-            if len(moves) % 2 == 0:  # Tour des blancs
-                next_move_num = f"{(len(moves)//2 + 1)}."
-                response = generator.generate(f"{last_moves} {next_move_num}")
-            else:  # Tour des noirs
-                response = generator.generate(f"{last_moves}")
-        
-        moves = response[0].split() if isinstance(response, list) else response.split()
-        next_move = moves[-1]
-        if '.' in next_move and len(moves) > 1:
-            next_move = moves[-2]
+        if 'chess' not in sys.path:
+            sys.path.append('chess')
             
-        # Vérifier si le coup est légal
-        try:
-            move = st.session_state.board.parse_san(next_move)
-            if move in st.session_state.board.legal_moves:
-                return next_move
-        except ValueError:
-            pass
+        from inference import InferenceConfig, ChessGenerator
         
-        # Si le coup n'est pas légal, jouer un coup aléatoire
-        legal_moves = list(st.session_state.board.legal_moves)
-        if legal_moves:
-            random_move = random.choice(legal_moves)
-            return st.session_state.board.san(random_move)
-            
+        config = InferenceConfig(
+            model_name="Zual/chess",
+            temperature=0.8,
+            max_length=6
+        )
+        logger.info("Modèle initialisé avec succès")
+        return ChessGenerator(config)
     except Exception as e:
-        st.error(f"Erreur lors de la génération du coup: {str(e)}")
-        return None
-
-def try_move(move_str):
-    """Tente d'appliquer un coup"""
-    try:
-        clean_move = move_str.split('.')[-1].strip()
-        move = st.session_state.board.parse_san(clean_move)
-        
-        if move in st.session_state.board.legal_moves:
-            st.session_state.board.push(move)
-            st.session_state.moves.append(clean_move)
-            return True
-        return False
-    except ValueError:
-        return False
+        logger.error(f"Erreur lors de l'initialisation du modèle: {e}", exc_info=True)
+        raise
 
-def get_game_string():
-    """Obtient la notation de la partie"""
-    result = []
-    for i in range(0, len(st.session_state.moves), 2):
-        move_num = i//2 + 1
-        result.append(f"{move_num}.{st.session_state.moves[i]}")
-        if i+1 < len(st.session_state.moves):
-            result.append(st.session_state.moves[i+1])
-    return " ".join(result)
-
-def handle_move(move_from, move_to):
-    """Gère un coup joué via l'interface graphique"""
-    move = chess.Move.from_uci(f"{move_from}{move_to}")
-    if move in st.session_state.board.legal_moves:
-        san_move = st.session_state.board.san(move)
-        if try_move(san_move):
-            return True
-    return False
+# Initialisation de l'état
+def initialize_state():
+    """Initialise l'état du jeu"""
+    logger.debug("Initialisation de l'état du jeu...")
+    if 'board' not in st.session_state:
+        st.session_state.board = chess.Board()
+        logger.debug("Nouvel échiquier créé")
+    if 'moves' not in st.session_state:
+        st.session_state.moves = []
+        logger.debug("Liste des coups initialisée")
 
 # Initialisation
 try:
+    logger.info("Démarrage de l'application...")
     generator = setup_inference()
+    initialize_state()
+    logger.info("Initialisation terminée")
 except Exception as e:
+    logger.error(f"Erreur lors de l'initialisation: {e}", exc_info=True)
     st.error(f"Erreur d'initialisation: {str(e)}")
     st.stop()
 
-initialize_state()
-
 # Interface utilisateur
 st.title("♟️ Échecs contre IA")
 
 col1, col2 = st.columns([2, 1])
 
 with col1:
-    # Échiquier interactif
+    logger.debug("Rendu de l'échiquier...")
     render_board()
     
-    # Input texte alternatif
+    # Input texte comme méthode alternative
     move = st.text_input(
-        "Ou saisissez votre coup ici",
+        "Saisissez votre coup",
         key=f"move_input_{len(st.session_state.moves)}",
         placeholder="ex: e4, Nf3, O-O"
     )
 
 with col2:
-    # Informations de la partie
-    st.subheader("Partie en cours")
-    game_str = get_game_string()
-    if game_str:
-        st.text_area("Historique", value=game_str, height=100, label_visibility="collapsed")
-    
     # Instructions
     st.markdown("""
     **Comment jouer:**
-    - Glissez et déposez les pièces blanches
+    - Glissez et déposez les pièces
     - Ou utilisez la notation algébrique :
         - Pion: e4, d5
         - Cavalier: Nf3, Nc6
@@ -315,47 +166,15 @@ with col2:
     
     # Nouvelle partie
     if st.button("Nouvelle partie"):
+        logger.info("Nouvelle partie demandée")
         st.session_state.board = chess.Board()
         st.session_state.moves = []
         st.rerun()
 
-# Gestion des coups (glisser-déposer et texte)
-if st.session_state.get("chess_move"):
-    move_data = st.session_state.chess_move
-    st.session_state.chess_move = None
-    if handle_move(move_data["from"], move_data["to"]):
-        game_str = get_game_string()
-        # Tour de l'IA
-        with st.spinner("L'IA réfléchit..."):
-            ai_move = get_ai_move(game_str)
-            if ai_move and try_move(ai_move):
-                if st.session_state.board.is_checkmate():
-                    st.success("Échec et mat!")
-                elif st.session_state.board.is_game_over():
-                    st.info("Partie terminée!")
-            else:
-                st.error("Problème avec le coup de l'IA")
-        st.rerun()
-    else:
-        st.error("Coup invalide")
-
-# Gestion des coups via input texte
-if move:
-    if try_move(move):
-        game_str = get_game_string()
-        with st.spinner("L'IA réfléchit..."):
-            ai_move = get_ai_move(game_str)
-            if ai_move and try_move(ai_move):
-                if st.session_state.board.is_checkmate():
-                    st.success("Échec et mat!")
-                elif st.session_state.board.is_game_over():
-                    st.info("Partie terminée!")
-            else:
-                st.error("Problème avec le coup de l'IA")
-        st.rerun()
-    else:
-        st.error("Coup invalide")
-
 # État du jeu
 if st.session_state.board.is_check():
-    st.warning("⚠️ Échec!")
+    st.warning("⚠️ Échec!")
+
+# Afficher les logs dans Streamlit
+if st.checkbox("Afficher les logs de débogage"):
+    st.code("\n".join(logging.getLogger().handlers[0].stream.getvalue().split("\n")[-50:]))