Update main.py

main.py

@@ -70,8 +70,13 @@ app.add_middleware(
 )
 
 # Paths relative to the Docker container
-ENGINE_PATH = os.environ.get("ENGINE_PATH", "/app/engine/deepcastle")
-NNUE_PATH = os.environ.get("NNUE_PATH", "/app/engine/output.nnue")
+DEEPCASTLE_ENGINE_PATH = os.environ.get(
+    "DEEPCASTLE_ENGINE_PATH",
+    os.environ.get("ENGINE_PATH", "/app/engine_bin/deepcastle"),
+)
+STOCKFISH_ENGINE_PATH = os.environ.get("STOCKFISH_ENGINE_PATH", "/usr/games/stockfish")
+NNUE_PATH = os.environ.get("NNUE_PATH", "/app/engine_bin/output.nnue")
+NNUE_SMALL_PATH = os.environ.get("NNUE_SMALL_PATH", "/app/engine_bin/small_output.nnue")
 
 class MoveRequest(BaseModel):
     fen: str
@@ -116,21 +121,92 @@ def home():
 
 @app.get("/health")
 def health():
-    if not os.path.exists(ENGINE_PATH):
-        return {"status": "error", "message": "Engine binary not found"}
-    return {"status": "ok", "engine": "Deepcastle"}
-
-async def get_engine():
-    if not os.path.exists(ENGINE_PATH):
-        raise HTTPException(status_code=500, detail="Engine binary not found")
-    transport, engine = await chess.engine.popen_uci(ENGINE_PATH)
-    if os.path.exists(NNUE_PATH):
+    missing = []
+    if not os.path.exists(DEEPCASTLE_ENGINE_PATH):
+        missing.append("deepcastle")
+    if not os.path.exists(STOCKFISH_ENGINE_PATH):
+        missing.append("stockfish")
+    if missing:
+        return {"status": "error", "message": f"Missing engine binary: {', '.join(missing)}"}
+    return {"status": "ok", "engines": ["deepcastle", "stockfish"]}
+
+# Global engine instances to save memory and improve performance
+_GLOBAL_DEEPCASTLE_ENGINE = None
+_GLOBAL_STOCKFISH_ENGINE = None
+
+async def _get_or_start_engine(engine_path: str, *, role: str, options: Optional[dict] = None):
+    global _GLOBAL_DEEPCASTLE_ENGINE, _GLOBAL_STOCKFISH_ENGINE
+
+    current_engine = _GLOBAL_DEEPCASTLE_ENGINE if role == "deepcastle" else _GLOBAL_STOCKFISH_ENGINE
+    if current_engine is not None:
         try:
-            await engine.configure({"EvalFile": NNUE_PATH})
-            await engine.configure({"Hash": 512, "Threads": 2})
+            if not current_engine.is_terminated():
+                return current_engine
         except Exception:
-            pass
-    return engine
+            if role == "deepcastle":
+                _GLOBAL_DEEPCASTLE_ENGINE = None
+            else:
+                _GLOBAL_STOCKFISH_ENGINE = None
+
+    if not os.path.exists(engine_path):
+        raise HTTPException(status_code=500, detail=f"{role} binary NOT FOUND at {engine_path}")
+
+    print(f"[DEBUG] Attempting to start {role} engine at {engine_path}")
+    try:
+        transport, engine = await chess.engine.popen_uci(engine_path)
+        print(f"[DEBUG] {role} process started. ID: {transport.get_pid()}")
+
+        if options:
+            await engine.configure(options)
+
+        if role == "deepcastle":
+            if os.path.exists(NNUE_PATH):
+                try:
+                    await engine.configure({"EvalFile": NNUE_PATH})
+                    print("[DEBUG] DeepCastle big net loaded successfully.")
+                except Exception as ne:
+                    print(f"[ERROR] DeepCastle big net load failed: {str(ne)}")
+            else:
+                print(f"[WARNING] DeepCastle big net not found at {NNUE_PATH}")
+
+            if os.path.exists(NNUE_SMALL_PATH):
+                try:
+                    await engine.configure({"EvalFileSmall": NNUE_SMALL_PATH})
+                    print("[DEBUG] DeepCastle small net loaded successfully.")
+                except Exception as ne:
+                    print(f"[ERROR] DeepCastle small net load failed: {str(ne)}")
+            else:
+                print(f"[WARNING] DeepCastle small net not found at {NNUE_SMALL_PATH}")
+
+            _GLOBAL_DEEPCASTLE_ENGINE = engine
+        else:
+            _GLOBAL_STOCKFISH_ENGINE = engine
+
+        return engine
+    except Exception as e:
+        print(f"[CRITICAL] {role} failed to start: {str(e)}")
+        # Try to gather more info by running the binary directly briefly
+        import subprocess
+        try:
+            diag = subprocess.run([engine_path, "uci"], capture_output=True, text=True, timeout=2)
+            print(f"[DIAG] {role} output: {diag.stdout} | Error: {diag.stderr}")
+        except Exception as de:
+            print(f"[DIAG] Could not run diagnosis: {str(de)}")
+        raise HTTPException(status_code=500, detail=f"{role} crash: {str(e)}")
+
+async def get_deepcastle_engine():
+    return await _get_or_start_engine(
+        DEEPCASTLE_ENGINE_PATH,
+        role="deepcastle",
+        options={"Hash": 128, "Threads": 1},
+    )
+
+async def get_stockfish_engine():
+    return await _get_or_start_engine(
+        STOCKFISH_ENGINE_PATH,
+        role="stockfish",
+        options={"Hash": 128, "Threads": 1},
+    )
 
 def get_normalized_score(info) -> tuple[float, Optional[int]]:
     """Returns the score from White's perspective in centipawns."""
@@ -140,19 +216,21 @@ def get_normalized_score(info) -> tuple[float, Optional[int]]:
     if raw.is_mate():
         m = raw.mate() or 0
         return (10000.0 if m > 0 else -10000.0), m
-    return raw.score() or 0.0, None
+    return float(raw.score() or 0.0), None
 
 # ─── Engine Inference Route ────────────────────────────────────────────────────
 @app.post("/move", response_model=MoveResponse)
 async def get_move(request: MoveRequest):
-    engine = None
     try:
-        engine = await get_engine()
+        engine = await get_deepcastle_engine()
         board = chess.Board(request.fen)
         limit = chess.engine.Limit(time=request.time, depth=request.depth)
         
+        # Search for best move
         result = await engine.play(board, limit)
-        info = await engine.analyse(board, limit)
+        
+        # Get evaluation separately to avoid blocking
+        info = await engine.analyse(board, chess.engine.Limit(time=0.1, depth=limit.depth or 12))
         
         # From White's perspective in CP -> converted to Pawns for UI
         score_cp, mate_in = get_normalized_score(info)
@@ -194,12 +272,54 @@ async def get_move(request: MoveRequest):
     except Exception as e:
         print(f"Error: {e}")
         raise HTTPException(status_code=500, detail=str(e))
-    finally:
-        if engine:
-            try:
-                await engine.quit()
-            except Exception:
-                pass
+
+@app.post("/analysis-move", response_model=MoveResponse)
+async def get_analysis_move(request: MoveRequest):
+    try:
+        engine = await get_stockfish_engine()
+        board = chess.Board(request.fen)
+        limit = chess.engine.Limit(time=request.time, depth=request.depth)
+
+        result = await engine.play(board, limit)
+        info = await engine.analyse(board, chess.engine.Limit(time=0.1, depth=limit.depth or 12))
+
+        score_cp, mate_in = get_normalized_score(info)
+
+        depth = info.get("depth", 0)
+        nodes = info.get("nodes", 0)
+        nps = info.get("nps", 0)
+
+        pv_board = board.copy()
+        pv_parts = []
+        for m in info.get("pv", [])[:5]:
+            if m in pv_board.legal_moves:
+                try:
+                    pv_parts.append(pv_board.san(m))
+                    pv_board.push(m)
+                except Exception:
+                    break
+            else:
+                break
+        pv = " ".join(pv_parts)
+
+        score_pawns = score_cp / 100.0 if abs(score_cp) < 9900 else (100.0 if score_cp > 0 else -100.0)
+
+        board_fen_only = board.fen().split(" ")[0]
+        opening_name = openings_db.get(board_fen_only)
+
+        return MoveResponse(
+            bestmove=result.move.uci(),
+            score=score_pawns,
+            depth=depth,
+            nodes=nodes,
+            nps=nps,
+            pv=pv,
+            mate_in=mate_in,
+            opening=opening_name
+        )
+    except Exception as e:
+        print(f"Analysis move error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
 
 import math
@@ -347,7 +467,7 @@ def get_move_classification(
 async def analyze_game(request: AnalyzeRequest):
     engine = None
     try:
-        engine = await get_engine()
+        engine = await get_stockfish_engine()
         board = chess.Board(request.start_fen) if request.start_fen else chess.Board()
         limit = chess.engine.Limit(time=request.time_per_move)
         
@@ -483,12 +603,6 @@ async def analyze_game(request: AnalyzeRequest):
     except Exception as e:
         print(f"Analysis Error: {e}")
         raise HTTPException(status_code=500, detail=str(e))
-    finally:
-        if engine:
-            try:
-                await engine.quit()
-            except Exception:
-                pass
 
 
 if __name__ == "__main__":