446 lines
15 KiB
Python
446 lines
15 KiB
Python
"""
|
|
routes/lab.py
|
|
=============
|
|
Batch simulation & lab management endpoints:
|
|
POST /api/lab/start
|
|
POST /api/lab/start-deepseek
|
|
GET /api/lab/status
|
|
GET /api/lab/result
|
|
GET /api/lab/decks
|
|
GET /api/lab/history
|
|
GET /api/lab/profiles
|
|
GET /api/lab/profiles/{name}
|
|
GET /api/lab/analytics/{deck_name}
|
|
GET /api/lab/trends/{deck_name}
|
|
GET /api/lab/log
|
|
GET /api/lab/debug-log
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import glob
|
|
import json
|
|
import os
|
|
import re
|
|
import threading
|
|
import uuid
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
from typing import Optional
|
|
|
|
from fastapi import APIRouter, HTTPException, BackgroundTasks, Request as FastAPIRequest
|
|
from fastapi.responses import JSONResponse
|
|
|
|
from routes.shared import (
|
|
CFG,
|
|
active_batches,
|
|
BatchState,
|
|
StartRequest,
|
|
StartResponse,
|
|
StatusResponse,
|
|
AI_PROFILES,
|
|
PRECON_DIR,
|
|
PRECON_INDEX,
|
|
build_java_command,
|
|
run_batch_subprocess,
|
|
_run_deepseek_batch_thread,
|
|
parse_dck_file,
|
|
_get_db_conn,
|
|
_load_deck_cards_by_name,
|
|
_ml_logging_enabled,
|
|
log,
|
|
log_batch,
|
|
)
|
|
|
|
router = APIRouter(tags=["lab"])
|
|
|
|
|
|
@router.post("/api/lab/start", response_model=StartResponse)
|
|
async def start_batch(req: StartRequest, background_tasks: BackgroundTasks):
|
|
"""Start a new batch simulation run."""
|
|
if len(req.decks) < 2 or len(req.decks) > 4:
|
|
raise HTTPException(400, "2-4 decks required")
|
|
if not all(req.decks):
|
|
raise HTTPException(400, f"All {len(req.decks)} deck slots must be filled")
|
|
if req.numGames < 1 or req.numGames > 10000:
|
|
raise HTTPException(400, "numGames must be 1-10000")
|
|
if req.threads < 1 or req.threads > 16:
|
|
raise HTTPException(400, "threads must be 1-16")
|
|
|
|
if not os.path.exists(CFG.forge_jar):
|
|
raise HTTPException(500, f"Forge JAR not found: {CFG.forge_jar}")
|
|
if not os.path.isdir(CFG.forge_dir):
|
|
raise HTTPException(500, f"Forge dir not found: {CFG.forge_dir}")
|
|
|
|
batch_id = str(uuid.uuid4())[:12]
|
|
state = BatchState(batch_id, req.numGames, req.threads)
|
|
active_batches[batch_id] = state
|
|
|
|
os.makedirs(CFG.results_dir, exist_ok=True)
|
|
output_path = os.path.join(CFG.results_dir, f"batch-{batch_id}.json")
|
|
state.result_path = output_path
|
|
|
|
background_tasks.add_task(
|
|
run_batch_subprocess,
|
|
state,
|
|
req.decks,
|
|
req.numGames,
|
|
req.threads,
|
|
req.seed,
|
|
req.clock,
|
|
output_path,
|
|
req.useLearnedPolicy,
|
|
req.policyStyle,
|
|
req.policyGreedy,
|
|
req.aiSimplified,
|
|
req.aiThinkTimeMs,
|
|
req.maxQueueDepth,
|
|
)
|
|
|
|
policy_msg = ""
|
|
if req.useLearnedPolicy:
|
|
policy_msg = f" [Learned Policy: {req.policyStyle}]"
|
|
return StartResponse(
|
|
batchId=batch_id,
|
|
status="started",
|
|
message=f"Running {req.numGames} games with {req.threads} threads{policy_msg}",
|
|
)
|
|
|
|
|
|
@router.get("/api/lab/status", response_model=StatusResponse)
|
|
async def get_status(batchId: Optional[str] = None):
|
|
# If no batchId given, find the most recent active (or last) batch
|
|
state = None
|
|
if batchId:
|
|
state = active_batches.get(batchId)
|
|
else:
|
|
# Return the most recently active batch, or any batch
|
|
for s in active_batches.values():
|
|
if s.running:
|
|
state = s
|
|
break
|
|
if state is None and active_batches:
|
|
state = list(active_batches.values())[-1]
|
|
if not state:
|
|
return StatusResponse(
|
|
batchId="", running=False, completed=0, total=0,
|
|
threads=0, elapsedMs=0, error=None, simsPerSec=0.0,
|
|
run_id="", games_completed=0, total_games=0, current_decks=[],
|
|
)
|
|
elapsed = int((datetime.now() - state.start_time).total_seconds() * 1000)
|
|
deck_names = getattr(state, 'deck_names', []) if hasattr(state, 'deck_names') else []
|
|
return StatusResponse(
|
|
batchId=state.batch_id,
|
|
running=state.running,
|
|
completed=state.completed_games,
|
|
total=state.total_games,
|
|
threads=state.threads,
|
|
elapsedMs=elapsed if state.running else state.elapsed_ms,
|
|
error=state.error,
|
|
simsPerSec=state.sims_per_sec,
|
|
# React SPA fields
|
|
run_id=state.batch_id,
|
|
games_completed=state.completed_games,
|
|
total_games=state.total_games,
|
|
current_decks=deck_names,
|
|
)
|
|
|
|
|
|
@router.get("/api/lab/result")
|
|
async def get_result(batchId: Optional[str] = None):
|
|
state = None
|
|
if batchId:
|
|
state = active_batches.get(batchId)
|
|
else:
|
|
# Find most recent completed batch
|
|
for s in reversed(list(active_batches.values())):
|
|
if not s.running and s.result_path:
|
|
state = s
|
|
break
|
|
if not state:
|
|
raise HTTPException(404, "No batch result available")
|
|
if state.running:
|
|
raise HTTPException(409, "Batch still running")
|
|
if state.error:
|
|
raise HTTPException(500, state.error)
|
|
if not state.result_path or not os.path.exists(state.result_path):
|
|
raise HTTPException(500, "Result file not found")
|
|
with open(state.result_path, "r", encoding="utf-8") as f:
|
|
data = json.load(f)
|
|
return JSONResponse(content=data)
|
|
|
|
|
|
@router.get("/api/lab/decks")
|
|
async def list_decks():
|
|
decks = []
|
|
seen_names = set()
|
|
|
|
# 1. Forge .dck files from decks directory
|
|
decks_dir = CFG.forge_decks_dir
|
|
if decks_dir and os.path.isdir(decks_dir):
|
|
for f in sorted(Path(decks_dir).glob("*.dck")):
|
|
deck_name = f.stem
|
|
decks.append({"name": deck_name, "filename": f.name, "source": "forge"})
|
|
seen_names.add(deck_name.lower())
|
|
|
|
# 2. Decks from the Deck Builder database
|
|
try:
|
|
conn = _get_db_conn()
|
|
rows = conn.execute(
|
|
"SELECT id, name, commander_name FROM decks ORDER BY id DESC"
|
|
).fetchall()
|
|
for row in rows:
|
|
db_name = row["name"]
|
|
if db_name.lower() not in seen_names:
|
|
decks.append({
|
|
"name": db_name,
|
|
"filename": "",
|
|
"source": "deckbuilder",
|
|
"deck_id": row["id"],
|
|
"commander": row["commander_name"] or "",
|
|
})
|
|
seen_names.add(db_name.lower())
|
|
except Exception as e:
|
|
log.warning(f" WARNING: Failed to load DB decks for /api/lab/decks: {e}")
|
|
|
|
return {"decks": decks}
|
|
|
|
|
|
@router.get("/api/lab/history")
|
|
async def list_history():
|
|
results_dir = Path(CFG.results_dir)
|
|
if not results_dir.exists():
|
|
return {"results": []}
|
|
results = []
|
|
for f in sorted(results_dir.glob("batch-*.json"), reverse=True):
|
|
try:
|
|
with open(f, "r", encoding="utf-8") as fh:
|
|
data = json.load(fh)
|
|
meta = data.get("metadata", {})
|
|
decks = data.get("decks", [])
|
|
results.append({
|
|
"filename": f.name,
|
|
"batchId": meta.get("batchId", ""),
|
|
"timestamp": meta.get("timestamp", ""),
|
|
"totalGames": meta.get("completedGames", 0),
|
|
"threads": meta.get("threads", 1),
|
|
"elapsedMs": meta.get("elapsedMs", 0),
|
|
"decks": [{"name": d.get("deckName", ""), "source": d.get("source", "")} for d in decks],
|
|
})
|
|
except Exception:
|
|
continue
|
|
return {"results": results[:50]}
|
|
|
|
|
|
# ════════════════════════════════════════════════════════════
|
|
# AI Profiles
|
|
# ════════════════════════════════════════════════════════════
|
|
|
|
AI_PROFILES = {
|
|
"default": {
|
|
"name": "default",
|
|
"description": "Balanced \u2014 Forge's default AI behavior",
|
|
"aggression": 0.5, "cardAdvantage": 0.5, "removalPriority": 0.5,
|
|
"boardPresence": 0.5, "comboPriority": 0.3, "patience": 0.5,
|
|
},
|
|
"aggro": {
|
|
"name": "aggro",
|
|
"description": "Aggressive \u2014 attacks early, prioritizes damage",
|
|
"aggression": 0.9, "cardAdvantage": 0.3, "removalPriority": 0.3,
|
|
"boardPresence": 0.8, "comboPriority": 0.1, "patience": 0.1,
|
|
},
|
|
"control": {
|
|
"name": "control",
|
|
"description": "Control \u2014 defensive, removal-heavy, card advantage",
|
|
"aggression": 0.2, "cardAdvantage": 0.9, "removalPriority": 0.9,
|
|
"boardPresence": 0.3, "comboPriority": 0.4, "patience": 0.9,
|
|
},
|
|
"combo": {
|
|
"name": "combo",
|
|
"description": "Combo \u2014 ramps, digs for pieces, assembles combos",
|
|
"aggression": 0.2, "cardAdvantage": 0.8, "removalPriority": 0.4,
|
|
"boardPresence": 0.3, "comboPriority": 0.95, "patience": 0.7,
|
|
},
|
|
"midrange": {
|
|
"name": "midrange",
|
|
"description": "Midrange \u2014 flexible, strong board presence, value-oriented",
|
|
"aggression": 0.5, "cardAdvantage": 0.6, "removalPriority": 0.6,
|
|
"boardPresence": 0.7, "comboPriority": 0.3, "patience": 0.5,
|
|
},
|
|
}
|
|
|
|
@router.get("/api/lab/profiles")
|
|
async def list_profiles():
|
|
return {"profiles": list(AI_PROFILES.values())}
|
|
|
|
@router.get("/api/lab/profiles/{name}")
|
|
async def get_profile(name: str):
|
|
profile = AI_PROFILES.get(name.lower())
|
|
if not profile:
|
|
raise HTTPException(404, f"Profile '{name}' not found. Available: {list(AI_PROFILES.keys())}")
|
|
return profile
|
|
|
|
|
|
@router.get("/api/lab/analytics/{deck_name}")
|
|
async def analyze_deck(deck_name: str):
|
|
decks_dir = CFG.forge_decks_dir
|
|
if not decks_dir or not os.path.isdir(decks_dir):
|
|
raise HTTPException(500, f"Decks directory not found: {decks_dir}")
|
|
deck_path = os.path.join(decks_dir, deck_name + ".dck")
|
|
if not os.path.exists(deck_path):
|
|
for f in os.listdir(decks_dir):
|
|
if f.lower() == deck_name.lower() + ".dck":
|
|
deck_path = os.path.join(decks_dir, f)
|
|
break
|
|
else:
|
|
raise HTTPException(404, f"Deck not found: {deck_name}")
|
|
try:
|
|
analysis = parse_dck_file(deck_path)
|
|
return analysis
|
|
except Exception as e:
|
|
raise HTTPException(500, f"Analysis failed: {str(e)}")
|
|
|
|
|
|
def parse_dck_file(deck_path: str) -> dict:
|
|
cards = []
|
|
commander = None
|
|
section = "Main"
|
|
deck_name = Path(deck_path).stem
|
|
with open(deck_path, "r", encoding="utf-8") as f:
|
|
for line in f:
|
|
line = line.strip()
|
|
if not line or line.startswith("//"):
|
|
continue
|
|
if line.startswith("[") and line.endswith("]"):
|
|
section = line[1:-1]
|
|
continue
|
|
if line.startswith("Name="):
|
|
deck_name = line[5:].strip()
|
|
continue
|
|
m = re.match(r"^(\d+)\s+(.+?)(?:\|(.+))?$", line)
|
|
if m:
|
|
qty = int(m.group(1))
|
|
name = m.group(2).strip()
|
|
set_code = m.group(3).strip() if m.group(3) else ""
|
|
cards.append({
|
|
"quantity": qty, "name": name, "set": set_code,
|
|
"section": section,
|
|
"is_commander": 1 if section == "Commander" else 0,
|
|
})
|
|
if section == "Commander":
|
|
commander = name
|
|
total = sum(c["quantity"] for c in cards)
|
|
return {
|
|
"deckName": deck_name,
|
|
"commanderName": commander,
|
|
"totalCards": total,
|
|
"cardCount": len(cards),
|
|
"cards": cards[:200],
|
|
}
|
|
|
|
|
|
@router.get("/api/lab/trends/{deck_name}")
|
|
async def get_deck_trends(deck_name: str):
|
|
results_dir = Path(CFG.results_dir)
|
|
if not results_dir.exists():
|
|
return {"deckName": deck_name, "history": []}
|
|
history = []
|
|
for f in sorted(results_dir.glob("batch-*.json")):
|
|
try:
|
|
with open(f, "r", encoding="utf-8") as fh:
|
|
data = json.load(fh)
|
|
summary = data.get("summary", {})
|
|
meta = data.get("metadata", {})
|
|
per_deck = summary.get("perDeck", [])
|
|
for ds in per_deck:
|
|
if ds.get("deckName", "").lower() == deck_name.lower():
|
|
history.append({
|
|
"batchId": meta.get("batchId"),
|
|
"timestamp": meta.get("timestamp"),
|
|
"winRate": ds.get("winRate", 0),
|
|
"wins": ds.get("wins", 0),
|
|
"losses": ds.get("losses", 0),
|
|
"draws": ds.get("draws", 0),
|
|
"totalGames": meta.get("completedGames", 0),
|
|
})
|
|
break
|
|
except Exception:
|
|
continue
|
|
return {"deckName": deck_name, "history": history}
|
|
|
|
|
|
@router.get("/api/lab/log")
|
|
async def get_log(batchId: str):
|
|
state = active_batches.get(batchId)
|
|
if not state:
|
|
raise HTTPException(404, f"Batch {batchId} not found")
|
|
return {"lines": state.log_lines[-200:]}
|
|
|
|
|
|
@router.get("/api/lab/debug-log")
|
|
async def get_debug_log():
|
|
"""Return the raw Forge subprocess debug log for diagnosing simulation issues."""
|
|
# Check multiple possible locations for the debug log
|
|
candidates = []
|
|
if CFG.forge_dir:
|
|
candidates.append(Path(CFG.forge_dir).parent / "forge-sim-debug.log")
|
|
candidates.append(Path(CFG.forge_dir) / "forge-sim-debug.log")
|
|
candidates.append(Path("forge-sim-debug.log"))
|
|
|
|
for log_path in candidates:
|
|
if log_path.exists():
|
|
text = log_path.read_text(encoding="utf-8", errors="replace")
|
|
# Return last 50KB to avoid huge responses
|
|
if len(text) > 50000:
|
|
text = "... (truncated) ...\n" + text[-50000:]
|
|
return {"path": str(log_path), "content": text}
|
|
|
|
return {"path": None, "content": "No debug log found. Run a simulation first."}
|
|
|
|
|
|
|
|
@router.post('/api/lab/start-deepseek')
|
|
async def start_batch_deepseek(request: FastAPIRequest, background_tasks: BackgroundTasks):
|
|
"""Start a batch simulation using the Python sim engine + DeepSeek LLM opponent."""
|
|
body = await request.json()
|
|
decks = body.get('decks', [])
|
|
num_games = body.get('numGames', 30)
|
|
# Note: threads not applicable for Python sim (single-threaded LLM calls)
|
|
|
|
if not decks or len(decks) < 1:
|
|
raise HTTPException(400, 'At least 1 deck required')
|
|
if num_games < 1 or num_games > 500:
|
|
raise HTTPException(400, 'numGames must be 1-500')
|
|
|
|
# Filter empty deck slots
|
|
decks = [d for d in decks if d]
|
|
if not decks:
|
|
raise HTTPException(400, 'No valid decks provided')
|
|
|
|
batch_id = str(uuid.uuid4())[:12]
|
|
state = BatchState(batch_id, num_games, 1)
|
|
active_batches[batch_id] = state
|
|
|
|
os.makedirs(CFG.results_dir, exist_ok=True)
|
|
output_path = os.path.join(CFG.results_dir, f'batch-{batch_id}.json')
|
|
state.result_path = output_path
|
|
|
|
# Use threading instead of BackgroundTasks to avoid async issues with DB
|
|
t = threading.Thread(
|
|
target=_run_deepseek_batch_thread,
|
|
args=(state, decks, num_games, output_path),
|
|
daemon=True,
|
|
)
|
|
t.start()
|
|
|
|
return JSONResponse({
|
|
'batchId': batch_id,
|
|
'status': 'started',
|
|
'message': f'Running {num_games} games across {len(decks)} decks with DeepSeek AI',
|
|
'engine': 'deepseek',
|
|
})
|
|
|
|
|
|
# Global ML logging toggle (can be enabled via API)
|
|
_ml_logging_enabled = False
|
|
|