Update main.py

main.py

@@ -8,7 +8,7 @@ import chess
 import chess.engine
 import asyncio
 
-app = FastAPI(title="Deepcastle v7 Engine API")
+app = FastAPI(title="Deepcastle Engine API")
 
 app.add_middleware(
     CORSMiddleware,
@@ -22,7 +22,7 @@ NNUE_PATH = os.environ.get("NNUE_PATH", "/app/engine/output.nnue")
 
 class MoveRequest(BaseModel):
     fen: str
-    time: float = 1.0
+    time: float = 1.0  
     depth: Optional[int] = None
 
 class MoveResponse(BaseModel):
@@ -34,15 +34,15 @@ class MoveResponse(BaseModel):
     pv: str
 
 class AnalyzeRequest(BaseModel):
-    moves: List[str]
-    time_per_move: float = 0.1
+    moves: List[str]             
+    time_per_move: float = 0.1   
     player_color: str = "white"
 
 class MoveAnalysis(BaseModel):
     move_num: int
     san: str
     fen: str
-    classification: str
+    classification: str          
     cpl: float
     score_before: float
     score_after: float
@@ -53,6 +53,16 @@ class AnalyzeResponse(BaseModel):
     moves: List[MoveAnalysis]
     counts: Dict[str, int]
 
+@app.get("/")
+def home():
+    return {"status": "online", "engine": "Deepcastle Hybrid Neural", "platform": "Hugging Face Spaces"}
+
+@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")
@@ -65,7 +75,7 @@ async def get_engine():
             pass
     return engine
 
-def get_normalized_score(info):
+def get_normalized_score(info, turn_color=chess.WHITE):
     if "score" not in info:
         return 0.0
     raw = info["score"].white()
@@ -73,13 +83,13 @@ def get_normalized_score(info):
         return 10000.0 if (raw.mate() or 0) > 0 else -10000.0
     return raw.score() or 0.0
 
-@app.post("/move")
+@app.post("/move", response_model=MoveResponse)
 async def get_move(request: MoveRequest):
     engine = None
     try:
         engine = await get_engine()
         board = chess.Board(request.fen)
-        limit = chess.engine.Limit(time=request.time)
+        limit = chess.engine.Limit(time=request.time, depth=request.depth)
         result = await engine.play(board, limit)
         info = await engine.analyse(board, limit)
         score_cp = get_normalized_score(info)
@@ -88,7 +98,7 @@ async def get_move(request: MoveRequest):
     finally:
         if engine: await engine.quit()
 
-@app.post("/analyze-game")
+@app.post("/analyze-game", response_model=AnalyzeResponse)
 async def analyze_game(request: AnalyzeRequest):
     engine = None
     try:
@@ -98,14 +108,17 @@ async def analyze_game(request: AnalyzeRequest):
         analysis_results, total_cpl, player_moves_count = [], 0, 0
         counts = {"Brilliant": 0, "Great": 0, "Best": 0, "Excellent": 0, "Good": 0, "Inaccuracy": 0, "Mistake": 0, "Blunder": 0}
         
-        info_start = await engine.analyse(board, limit)
-        current_score = get_normalized_score(info_start)
+        info_before = await engine.analyse(board, limit)
+        current_score = get_normalized_score(info_before)
         player_is_white = (request.player_color.lower() == "white")
 
         for i, san_move in enumerate(request.moves):
-            is_player_turn = board.turn == chess.WHITE if player_is_white else board.turn == chess.BLACK
+            is_player_turn = board.turn == (chess.WHITE if player_is_white else chess.BLACK)
             score_before = current_score
-            board.push_san(san_move)
+            try:
+                board.push_san(san_move)
+            except Exception: break
+            
             info_after = await engine.analyse(board, limit)
             current_score = get_normalized_score(info_after)