Create app.py

app.py

@@ -0,0 +1,227 @@
+import gradio as gr
+import subprocess
+import threading
+import queue
+import os
+import tempfile
+import chess
+import chess.pgn
+import io
+
+# Global dict to track running processes by session
+running_processes = {}
+
+def parse_input(text):
+    """Parse input as either PGN or FEN and return FEN position"""
+    text = text.strip()
+    
+    # Check if it's a FEN (contains slashes and spaces typical of FEN)
+    if '/' in text and len(text.split()) >= 4:
+        try:
+            # Validate FEN
+            chess.Board(text)
+            return text, "fen"
+        except:
+            pass
+    
+    # Try to parse as PGN
+    try:
+        pgn = io.StringIO(text)
+        game = chess.pgn.read_game(pgn)
+        if game:
+            board = game.end().board()
+            return board.fen(), "pgn"
+    except:
+        pass
+    
+    return None, None
+
+def read_output(process, output_queue, stop_event):
+    """Read output from process line by line"""
+    try:
+        for line in iter(process.stdout.readline, ''):
+            if stop_event.is_set():
+                break
+            output_queue.put(line)
+        process.stdout.close()
+    except:
+        pass
+
+def run_engine(input_text, compile_mode, session_id, progress=gr.Progress()):
+    """Run the chess engine with the given input"""
+    
+    # Parse input
+    fen, input_type = parse_input(input_text)
+    
+    if not fen:
+        yield "Error: Could not parse input as valid PGN or FEN\n"
+        return
+    
+    # Create temporary files for this session
+    temp_dir = tempfile.mkdtemp()
+    
+    try:
+        if compile_mode == "PGN Mode (D_NOEDIT=1)":
+            # Create a PGN file with the position
+            pgn_path = os.path.join(temp_dir, "bench.pgn")
+            board = chess.Board(fen)
+            game = chess.pgn.Game()
+            game.setup(board)
+            with open(pgn_path, 'w') as f:
+                f.write(str(game))
+            
+            # Copy or symlink the engine expecting pgn/bench.pgn
+            os.makedirs(os.path.join(temp_dir, "pgn"), exist_ok=True)
+            pgn_target = os.path.join(temp_dir, "pgn", "bench.pgn")
+            with open(pgn_target, 'w') as f:
+                f.write(str(game))
+                
+        else:  # FEN Mode (D_NOEDIT=2)
+            # Create start.fen file
+            fen_path = os.path.join(temp_dir, "start.fen")
+            with open(fen_path, 'w') as f:
+                f.write(fen)
+        
+        # Start the engine process
+        engine_path = "./baeagn"  # Adjust if needed
+        process = subprocess.Popen(
+            [engine_path],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            cwd=temp_dir
+        )
+        
+        # Store process for this session
+        running_processes[session_id] = process
+        
+        # Setup queue and thread for reading output
+        output_queue = queue.Queue()
+        stop_event = threading.Event()
+        reader_thread = threading.Thread(
+            target=read_output,
+            args=(process, output_queue, stop_event)
+        )
+        reader_thread.daemon = True
+        reader_thread.start()
+        
+        # Stream output
+        full_output = f"Input type: {input_type.upper()}\nFEN: {fen}\n\n--- Engine Output ---\n"
+        yield full_output
+        
+        while True:
+            try:
+                # Check if process is still running
+                if process.poll() is not None:
+                    # Process finished, drain queue
+                    while not output_queue.empty():
+                        line = output_queue.get_nowait()
+                        full_output += line
+                        yield full_output
+                    break
+                
+                # Get output with timeout
+                try:
+                    line = output_queue.get(timeout=0.1)
+                    full_output += line
+                    yield full_output
+                except queue.Empty:
+                    continue
+                    
+            except Exception as e:
+                full_output += f"\nError: {str(e)}\n"
+                yield full_output
+                break
+        
+        # Cleanup
+        stop_event.set()
+        if session_id in running_processes:
+            del running_processes[session_id]
+            
+    finally:
+        # Cleanup temp directory
+        try:
+            import shutil
+            shutil.rmtree(temp_dir)
+        except:
+            pass
+
+def stop_engine(session_id):
+    """Stop the running engine for this session"""
+    if session_id in running_processes:
+        process = running_processes[session_id]
+        process.terminate()
+        try:
+            process.wait(timeout=2)
+        except:
+            process.kill()
+        del running_processes[session_id]
+        return "Engine stopped."
+    return "No running engine to stop."
+
+def create_interface():
+    """Create the Gradio interface"""
+    
+    with gr.Blocks(title="Baeagn Chess Engine") as demo:
+        gr.Markdown("# Baeagn Chess Engine Analyzer")
+        gr.Markdown("Paste a PGN game or FEN position to analyze the final/current position.")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                input_text = gr.Textbox(
+                    label="Input (PGN or FEN)",
+                    placeholder="Paste PGN game or FEN position here...",
+                    lines=10
+                )
+                
+                compile_mode = gr.Radio(
+                    choices=["PGN Mode (D_NOEDIT=1)", "FEN Mode (D_NOEDIT=2)"],
+                    value="FEN Mode (D_NOEDIT=2)",
+                    label="Engine Compile Mode"
+                )
+                
+                with gr.Row():
+                    analyze_btn = gr.Button("Analyze", variant="primary")
+                    stop_btn = gr.Button("Stop", variant="stop")
+                
+                # Hidden session ID
+                session_id = gr.State(value=lambda: os.urandom(16).hex())
+                
+            with gr.Column(scale=1):
+                output_text = gr.Textbox(
+                    label="Engine Output",
+                    lines=20,
+                    max_lines=30,
+                    autoscroll=True
+                )
+        
+        # Examples
+        gr.Examples(
+            examples=[
+                ["rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"],
+                ["rnbqkb1r/pppp1ppp/5n2/4p3/4P3/5N2/PPPP1PPP/RNBQKB1R w KQkq - 4 3"],
+                ['[Event "Example"]\n[Site "?"]\n[Date "????.??.??"]\n[Round "?"]\n[White "?"]\n[Black "?"]\n[Result "*"]\n\n1. e4 e5 2. Nf3 Nc6 3. Bb5 a6 *']
+            ],
+            inputs=input_text
+        )
+        
+        # Event handlers
+        analyze_btn.click(
+            fn=run_engine,
+            inputs=[input_text, compile_mode, session_id],
+            outputs=output_text
+        )
+        
+        stop_btn.click(
+            fn=stop_engine,
+            inputs=session_id,
+            outputs=output_text
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.queue()  # Enable queuing for streaming
+    demo.launch()