Delete app.py

app.py

@@ -1,247 +0,0 @@
-#!/usr/bin/env python3
-"""
-Chess Analyzer — Flask server
-Stockfish-powered analysis with Chess.com-style move classification.
-"""
-
-from flask import Flask, render_template, request, jsonify, Response
-import chess
-import chess.pgn
-import json
-import io
-import threading
-import time
-import uuid
-import os
-import sys
-
-sys.path.insert(0, os.path.dirname(__file__))
-from chess_analyzer import (
-    ChessAnalyzer, classify_move, Classification,
-    MULTIPV, DEFAULT_DEPTH, score_to_cp, pv_to_san,
-    wdl_to_expected, cp_to_expected,
-)
-
-app = Flask(__name__,
-            template_folder=os.path.join(os.path.dirname(__file__), 'templates'))
-app.config['MAX_CONTENT_LENGTH'] = 5 * 1024 * 1024  # 5 MB
-
-STOCKFISH_PATH = os.environ.get('STOCKFISH_PATH', 'stockfish')
-DEPTH          = int(os.environ.get('ANALYSIS_DEPTH', str(DEFAULT_DEPTH)))
-
-# In-memory stores — fine for a single-user local/Colab session
-games    = {}   # game_id → full game dict
-progress = {}   # game_id → progress dict
-
-
-# ─── Helpers ──────────────────────────────────────────────────────────────────
-
-def eval_from_white(lines_after: list, board_turn: chess.Color) -> float:
-    """Convert side-to-move cp to always-positive-for-White."""
-    if not lines_after:
-        return 0.0
-    cp = lines_after[0].cp
-    return cp if board_turn == chess.WHITE else -cp
-
-
-def format_eval(cp: float) -> str:
-    if cp >=  9000: return f"M{int(10000 - cp)}"
-    if cp <= -9000: return f"-M{int(10000 + cp)}"
-    return f"{cp / 100:+.2f}"
-
-
-# ─── Background analysis thread ───────────────────────────────────────────────
-
-def analyze_game_thread(game_id: str, pgn_text: str,
-                        depth: int = DEFAULT_DEPTH,
-                        time_ms: int = None):
-    try:
-        game = chess.pgn.read_game(io.StringIO(pgn_text))
-        if game is None:
-            progress[game_id].update({'error': 'Could not parse PGN.', 'complete': True})
-            return
-
-        moves = list(game.mainline_moves())
-        progress[game_id]['total'] = len(moves)
-
-        board     = game.board()
-        positions = []
-
-        with ChessAnalyzer(STOCKFISH_PATH, depth, MULTIPV, time_ms=time_ms) as analyzer:
-
-            # ── Starting position ─────────────────────────────────────────────
-            init_lines = analyzer._top_moves(board)
-            init_cp    = init_lines[0].cp if init_lines else 0.0
-            positions.append({
-                'fen':                  board.fen(),
-                'move_uci':             None,
-                'san':                  None,
-                'move_number':          0,
-                'color':                None,
-                'classification':       None,
-                'classification_label': None,
-                'eval_white':           init_cp,
-                'eval_display':         format_eval(init_cp),
-                'cp_loss':              0,
-                'e_loss':               0.0,
-                'best_move':            init_lines[0].move.uci() if init_lines else None,
-                'best_san':             None,
-                'best_pv':              [],
-                'player_pv':            [],
-                'notes':                [],
-                'from_sq':              None,
-                'to_sq':                None,
-            })
-
-            # ── Each move ─────────────────────────────────────────────────────
-            lines_before = init_lines
-            prev_move    = None
-
-            for i, move in enumerate(moves):
-                best_move_uci = lines_before[0].move.uci() if lines_before else None
-
-                # Best-move SAN and its continuation (PV after the best move)
-                best_san    = None
-                best_pv_san = []
-                if lines_before and lines_before[0].move != move:
-                    best_san    = board.san(lines_before[0].move)
-                    best_pv_san = pv_to_san(board, lines_before[0].pv[1:], max_moves=5)
-
-                # Analyse position after the played move
-                board.push(move)
-                lines_after = analyzer._top_moves(board, multipv=1)
-
-                # Continuation after the played move
-                player_pv_san = []
-                if lines_after and lines_after[0].pv:
-                    player_pv_san = pv_to_san(board, lines_after[0].pv, max_moves=5)
-
-                white_eval = eval_from_white(lines_after, board.turn)
-                board.pop()
-
-                # Classify (board is back to pre-move state)
-                analysis = classify_move(board, move, lines_before, lines_after,
-                                         half_move_idx=i, prev_move=prev_move)
-                board.push(move)
-
-                positions.append({
-                    'fen':                  board.fen(),
-                    'move_uci':             move.uci(),
-                    'san':                  analysis.san,
-                    'move_number':          (i // 2) + 1,
-                    'color':                'white' if i % 2 == 0 else 'black',
-                    'classification':       analysis.classification.name,
-                    'classification_label': analysis.classification.value,
-                    'eval_white':           white_eval,
-                    'eval_display':         format_eval(white_eval),
-                    'cp_loss':              round(analysis.cp_loss, 1),
-                    'e_loss':               round(analysis.e_loss, 4),
-                    'best_move':            best_move_uci,
-                    'best_san':             best_san,
-                    'best_pv':              best_pv_san,
-                    'player_pv':            player_pv_san,
-                    'notes':                analysis.notes,
-                    'from_sq':              chess.square_name(move.from_square),
-                    'to_sq':                chess.square_name(move.to_square),
-                })
-
-                progress[game_id]['done'] = i + 1
-                prev_move = move
-
-                if i + 1 < len(moves):
-                    lines_before = analyzer._top_moves(board)
-
-        games[game_id] = {
-            'positions': positions,
-            'headers': {
-                'White':  game.headers.get('White',  '?'),
-                'Black':  game.headers.get('Black',  '?'),
-                'Event':  game.headers.get('Event',  '?'),
-                'Date':   game.headers.get('Date',   '?'),
-                'Result': game.headers.get('Result', '*'),
-            },
-        }
-        progress[game_id]['complete'] = True
-
-    except Exception as exc:
-        import traceback
-        progress[game_id].update({
-            'error':     str(exc),
-            'traceback': traceback.format_exc(),
-            'complete':  True,
-        })
-
-
-# ─── Routes ───────────────────────────────────────────────────────────────────
-
-@app.route('/')
-def index():
-    return render_template('index.html')
-
-
-@app.route('/upload', methods=['POST'])
-def upload():
-    pgn_text = ''
-    if 'pgn_text' in request.form and request.form['pgn_text'].strip():
-        pgn_text = request.form['pgn_text']
-    elif 'pgn_file' in request.files:
-        pgn_text = request.files['pgn_file'].read().decode('utf-8', errors='ignore')
-
-    if not pgn_text.strip():
-        return jsonify({'error': 'No PGN provided.'}), 400
-
-    game_id = str(uuid.uuid4())
-    progress[game_id] = {'done': 0, 'total': 0, 'complete': False, 'error': None}
-
-    try:
-        depth_val = int(request.form.get('depth', DEFAULT_DEPTH))
-        depth_val = max(6, min(30, depth_val))
-    except (ValueError, TypeError):
-        depth_val = DEFAULT_DEPTH
-
-    try:
-        time_val = int(request.form.get('time_ms', 0))
-        time_val = time_val if time_val > 0 else None
-    except (ValueError, TypeError):
-        time_val = None
-
-    t = threading.Thread(
-        target=analyze_game_thread,
-        args=(game_id, pgn_text, depth_val, time_val),
-        daemon=True,
-    )
-    t.start()
-    return jsonify({'game_id': game_id})
-
-
-@app.route('/progress/<game_id>')
-def get_progress(game_id):
-    def stream():
-        while True:
-            p = progress.get(game_id, {'error': 'Game not found.', 'complete': True})
-            yield f"data: {json.dumps(p)}\n\n"
-            if p.get('complete'):
-                break
-            time.sleep(0.35)
-    return Response(
-        stream(),
-        mimetype='text/event-stream',
-        headers={'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'},
-    )
-
-
-@app.route('/game/<game_id>')
-def get_game(game_id):
-    g = games.get(game_id)
-    if not g:
-        return jsonify({'error': 'Not found or still analyzing.'}), 404
-    return jsonify(g)
-
-
-# ─── Entry point ──────────────────────────────────────────────────────────────
-
-if __name__ == '__main__':
-    print(f"  Stockfish: {STOCKFISH_PATH}")
-    print(f"  Depth:     {DEPTH}")
-    print(f"  MultiPV:   {MULTIPV}")
-    app.run(host='0.0.0.0', port=7860, debug=False, threaded=True)