Spaces:
Paused
Paused
File size: 6,762 Bytes
37d841f ec62aa2 37d841f ec62aa2 37d841f ec62aa2 37d841f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 | """Wrapper UCI para Stockfish usando python-chess.
Singleton lazy: el motor se inicia en la primera llamada y se reutiliza
entre requests. Si el binario no existe, se lanza FileNotFoundError con
un mensaje claro para que el frontend lo reporte.
"""
import os
import threading
import chess
import chess.engine
import chess.pgn
import io
from config import STOCKFISH_PATH, STOCKFISH_DEPTH, STOCKFISH_THREADS, STOCKFISH_HASH_MB
_engine = None
_lock = threading.Lock()
def _get_engine() -> chess.engine.SimpleEngine:
global _engine
if _engine is not None:
return _engine
with _lock:
if _engine is not None:
return _engine
if not os.path.isfile(STOCKFISH_PATH):
raise FileNotFoundError(
f"Stockfish no encontrado en '{STOCKFISH_PATH}'. "
f"Descargalo de https://stockfishchess.org/download/ y "
f"coloca el binario en backend/engines/ (ver AGENTS.md)."
)
print(f"[Stockfish] Iniciando motor: {STOCKFISH_PATH}")
eng = chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH)
eng.configure({"Threads": STOCKFISH_THREADS, "Hash": STOCKFISH_HASH_MB})
_engine = eng
print(f"[Stockfish] Listo (threads={STOCKFISH_THREADS}, hash={STOCKFISH_HASH_MB}MB, depth={STOCKFISH_DEPTH})")
return _engine
def shutdown():
"""Cierra el motor (llamar al apagar el servidor; opcional)."""
global _engine
if _engine is not None:
try:
_engine.quit()
except Exception:
pass
_engine = None
def _score_to_cp(score: chess.engine.PovScore) -> int:
"""Convierte un PovScore a centipawns desde el punto de vista de BLANCAS.
Mate se mapea a ±100000 cp para que las diferencias sigan siendo comparables.
"""
white = score.white()
if white.is_mate():
mate_in = white.mate()
return 100000 if mate_in > 0 else -100000
return white.score(mate_score=100000)
def _cp_for_terminal(board: chess.Board) -> int:
"""Eval en centipawns para una posición terminal (mate/ahogado/tablas)."""
outcome = board.outcome()
if outcome is None or outcome.winner is None:
return 0 # tablas
return 100000 if outcome.winner == chess.WHITE else -100000
def analyze_pgn(pgn_text: str, depth: int | None = None) -> dict:
"""Analiza un PGN jugada a jugada con Stockfish.
Args:
pgn_text: Movimientos en notación inglesa (SAN). Acepta con o sin headers.
depth: Profundidad. Si es None usa STOCKFISH_DEPTH de config.
Returns:
{
'depth': int,
'total_moves': int,
'moves': [
{
'number': int,
'color': 'white' | 'black',
'move': str, # SAN jugado
'eval_antes_cp': int, # eval desde POV blancas, antes de jugar
'eval_despues_cp': int, # eval desde POV blancas, después de jugar
'diferencia_cp': int, # eval_despues - eval_antes (signo según color)
'mejor_jugada': str | None, # SAN de la mejor jugada según Stockfish
'mejor_eval_cp': int, # eval si se hubiera jugado la mejor
},
...
]
}
"""
engine = _get_engine()
used_depth = depth if depth is not None else STOCKFISH_DEPTH
limit = chess.engine.Limit(depth=used_depth, time=1.0)
# Parsear el PGN. Acepta con headers o solo línea de movimientos.
game = chess.pgn.read_game(io.StringIO(pgn_text))
if game is None or not list(game.mainline_moves()):
# Intentar como línea suelta de movimientos
board = chess.Board()
moves = []
for token in pgn_text.split():
if token.endswith('.') or token.replace('.', '').isdigit():
continue
try:
moves.append(board.parse_san(token))
board.push(moves[-1])
except ValueError:
continue
if not moves:
return {'depth': used_depth, 'total_moves': 0, 'moves': []}
game = chess.pgn.Game()
node = game
for mv in moves:
node = node.add_variation(mv)
board = game.board()
results: list[dict] = []
for ply_idx, move in enumerate(game.mainline_moves()):
is_white_to_move = board.turn == chess.WHITE
move_san = board.san(move)
# Eval ANTES de la jugada (posición actual) + mejor jugada sugerida
info_before = engine.analyse(board, limit)
score_before = info_before.get("score")
eval_antes_cp = _score_to_cp(score_before) if score_before is not None else 0
pv = info_before.get("pv") or []
best_move_san = board.san(pv[0]) if pv else None
# Línea principal (PV) en SAN, para el botón "Explicar" (HU-011): la
# secuencia de mejores jugadas desde esta posición, que el frontend
# reproduce en el tablero. Se limita para no inflar la respuesta.
pv_san = []
if pv:
tmp = board.copy()
for mv in pv[:8]: # hasta 8 medias jugadas (4 completas)
try:
pv_san.append(tmp.san(mv))
tmp.push(mv)
except ValueError:
break
# eval_antes_cp ya representa el valor óptimo de esta posición
best_eval_cp = eval_antes_cp
# Aplicar la jugada y evaluar DESPUÉS
board.push(move)
if board.is_game_over():
eval_despues_cp = _cp_for_terminal(board)
else:
info_after = engine.analyse(board, limit)
score_after = info_after.get("score")
eval_despues_cp = _score_to_cp(score_after) if score_after is not None else eval_antes_cp
# Diferencia desde la perspectiva del jugador que movió.
# Si jugó blancas, perder centipawns es negativo. Si jugó negras, ganar
# centipawns para negras es que white_eval bajó → invertimos signo.
delta = eval_despues_cp - eval_antes_cp
if not is_white_to_move:
delta = -delta
results.append({
'number': ply_idx // 2 + 1,
'color': 'white' if is_white_to_move else 'black',
'move': move_san,
'eval_antes_cp': eval_antes_cp,
'eval_despues_cp': eval_despues_cp,
'diferencia_cp': delta,
'mejor_jugada': best_move_san,
'mejor_eval_cp': best_eval_cp,
'pv_san': pv_san,
})
return {
'depth': used_depth,
'total_moves': len(results),
'moves': results,
}
|