How dieg0r01/chesstrainer works
Para elaborar un diagrama de arquitectura claro y detallado de esta “Plataforma de Ajedrez con Motores Externos”, sigue estos pasos, adaptados al propósito y estructura del proyecto:
Identificación del tipo de proyecto y su propósito
• Es una aplicación web full-stack:
• Frontend en React.js (Vite) para la interfaz de usuario (UI).
• Backend en Python (FastAPI) que expone una API REST y sirve archivos estáticos.
• Integración con motores de ajedrez externos (REST y UCI).
• Objetivo: permitir partidas Humano vs. Motor o Motor vs. Motor, configurables vía YAML.
Análisis de la estructura de ficheros
• Top-level:
• Dockerfile, config/, engine_manager.py, main.py, requirements.txt
• frontend/ (React, Vite)
• Dentro de frontend/:
• Código React (src/), index.html, configuración Vite, ESLint, package.json
• Configuración de motores en config/engines.yaml
• Backend:
• main.py: instancia FastAPI, rutas / y /move
• engine_manager.py: EngineInterface, EngineManager, adaptadores RestEngineAdapter y UciEngineAdapter
Componentes principales para el diagrama
A. Usuario y Navegador (Browser)
B. Frontend React (Vite dev server o archivos estáticos servidos por FastAPI)
C. API Server FastAPI (Uvicorn)
D. EngineManager (carga config YAML, delega peticiones)
E. Adaptadores de motor:
1. RestEngineAdapter → Motores REST externos
2. UciEngineAdapter → Motores UCI locales (p. ej. Stockfish)
F. Archivo de configuración YAML (config/engines.yaml)
G. Motores externos:
1. Servicios REST (por ejemplo lichess.org)
2. Proceso local UCI (por ejemplo stockfish)
H. Contenedor Docker (opcionalmente, como envoltorio de todo)
Relaciones e interacciones
• El Usuario mueve una pieza en el UI (React + react-chessboard).
• La jugada se valida localmente con chess.js.
• Frontend envía POST /move al Backend con {engine, fen, depth}.
• FastAPI (main.py) recibe la petición y la pasa a EngineManager.
• EngineManager consulta config/engines.yaml, determina el adaptador: Rest o UCI.
• RestEngineAdapter: construye y ejecuta llamada HTTP al motor REST, extrae mejor movimiento con jsonpath.
• UciEngineAdapter: lanza o comunica con el proceso UCI (stdin/stdout).
• El adaptador devuelve bestmove a EngineManager, que lo envía como respuesta JSON al Frontend.
• Frontend actualiza el tablero.
• En modo Motor vs. Motor, el Frontend repite el ciclo automáticamente cada X segundos.
Patrón y principios arquitectónicos
• Separación clara Frontend / Backend (Single Page App y API REST).
• Adaptador (Adapter Pattern) para motores: RestEngineAdapter y UciEngineAdapter implementan la misma interfaz EngineInterface.
• Configuración declarativa (YAML) para facilidad de extensibilidad sin tocar código.
• Contenerización (Docker) para despliegue reproducible.
• Uso de librerías especializadas: chess.js, react-chessboard, FastAPI, Pydantic, jsonpath, Vite.
Guía práctica para el diagrama
a. Usa contenedores (rectángulos con esquinas redondeadas) para cada componente mayor:
– Cliente (Browser)
– Frontend React
– Backend FastAPI
– EngineManager
– Adaptadores (Rest, UCI)
– Motores externos
– Configuración YAML
– (Opcional) Docker Host
b. Dibuja flechas direccionales para mostrar flujos de datos:
– Cliente → Frontend (interacción UI)
– Frontend → Backend (HTTP GET/POST)
– Backend → EngineManager → Adaptadores → Motores
– Motores → Adaptadores → EngineManager → Backend → Frontend
– Azul para componentes del Frontend
– Verde para Backend y gestión interna
– Naranja para adaptadores
– Rojo para servicios externos / procesos locales
d. Etiqueta cada flecha con la operación o formato de datos (por ejemplo, “POST /move {fen, depth}”, “HTTP GET JSON”, “stdin/stdout UCI”).
Elementos mínimos obligatorios en el diagrama
• Componentes claramente nombrados (p. ej. “RestEngineAdapter”).
• Flechas con dirección y texto explicativo.
• Archivos clave (config/engines.yaml) destacados junto al EngineManager.
• Indicaciones de ciclo para Motor vs. Motor (loop timer).
• Servicio de archivos estáticos para React (ruta /).
Con esta guía, el diagrama reflejará con precisión la arquitectura de la plataforma, resaltando la separación de responsabilidades, los flujos de comunicación y los puntos de extensión para nuevos motores.