Update main.py

main.py

@@ -9,8 +9,18 @@ import chess.engine
 import asyncio
 import json
 
-app = FastAPI(title="Deepcastle Engine API")
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup: Initialize the engine pool
+    await pool.start()
+    yield
+    # Shutdown: Clean up the engine pool
+    await pool.stop()
+
+app = FastAPI(title="Deepcastle Engine API", lifespan=lifespan)
 from contextlib import asynccontextmanager
+
+# ─── Multiplaying / Challenge Manager ──────────────────────────────────────────
 class ConnectionManager:
     def __init__(self):
         # match_id -> list of websockets
@@ -133,6 +143,8 @@ class EnginePool:
                 await self.engines.put(engine)
                 self.all_engines.append(engine)
                 print(f"  [+] Engine {i+1}/{self.size} ready.")
+                # Give the system some room to breathe between processes
+                await asyncio.sleep(0.5)
             except Exception as e:
                 print(f"  [!] Failed to start engine {i+1}: {e}")
 
@@ -169,15 +181,7 @@ class EnginePool:
             except:
                 pass
 
-pool = EnginePool(size=8)
-
-@app.on_event("startup")
-async def startup_event():
-    await pool.start()
-
-@app.on_event("shutdown")
-async def shutdown_event():
-    await pool.stop()
+pool = EnginePool(size=4)
 
 def get_normalized_score(info) -> tuple[float, Optional[int]]:
     """Returns the score from White's perspective in centipawns."""
@@ -257,6 +261,16 @@ def get_win_percentage_from_cp(cp: int) -> float:
     win_chances = 2.0 / (1.0 + math.exp(MULTIPLIER * cp_ceiled)) - 1.0
     return 50.0 + 50.0 * win_chances
 
+def get_move_accuracy(win_pct_before: float, win_pct_after: float, is_white_move: bool) -> float:
+    """Lichess-style win%-based per-move accuracy (0–100)."""
+    if is_white_move:
+        diff = win_pct_before - win_pct_after
+    else:
+        diff = (100.0 - win_pct_before) - (100.0 - win_pct_after)
+    
+    accuracy = 103.1668 * math.exp(-0.04354 * max(0.0, diff)) - 3.1669
+    return max(0.0, min(100.0, accuracy))
+
 def get_win_percentage(info: dict) -> float:
     score = info.get("score")
     if not score:
@@ -398,8 +412,8 @@ async def analyze_game(request: AnalyzeRequest):
             player_is_white = (request.player_color.lower() == "white")
             fen_history = [board.fen()]
             move_history = []
-            total_cpl = 0.0
-            player_moves_count = 0
+            player_move_accuracies: List[float] = []
+            player_cpls: List[float] = []  # keep for estimated_elo
             current_score, _ = get_normalized_score(infos_before[0])
 
             for i, san_move in enumerate(request.moves):
@@ -467,12 +481,14 @@ async def analyze_game(request: AnalyzeRequest):
                     )
                 
                 move_gain = score_after - score_before if is_white_turn else score_before - score_after
-                cpl = max(0, -move_gain)
-                cpl = min(cpl, 1000.0)
-                
+                cpl = max(0.0, min(1000.0, -move_gain))
+
+                # Lichess-style per-move accuracy using win%
+                move_acc = get_move_accuracy(win_pct_before, win_pct_after, is_white_turn)
+
                 if is_player_turn:
-                    total_cpl += cpl
-                    player_moves_count += 1
+                    player_move_accuracies.append(move_acc)
+                    player_cpls.append(cpl)
                     counts[cls] = counts.get(cls, 0) + 1
                 
                 analysis_results.append(MoveAnalysis(
@@ -488,9 +504,18 @@ async def analyze_game(request: AnalyzeRequest):
                 ))
                 infos_before = infos_after
 
-            avg_cpl = total_cpl / max(1, player_moves_count)
-            accuracy = max(10.0, min(100.0, 100.0 * math.exp(-0.005 * avg_cpl)))
-            estimated_elo = int(max(400, min(3600, 3600 - (avg_cpl * 20))))
+            # NEW — Lichess win%-based accuracy
+            if player_move_accuracies:
+                # Lichess uses harmonic mean blended with arithmetic mean
+                arithmetic_mean = sum(player_move_accuracies) / len(player_move_accuracies)
+                harmonic_mean = len(player_move_accuracies) / sum(1.0 / max(a, 0.1) for a in player_move_accuracies)
+                accuracy = (arithmetic_mean + harmonic_mean) / 2.0
+            else:
+                accuracy = 0.0
+
+            # Elo from avg CPL using exponential decay calibrated to your 3600 engine
+            avg_cpl = sum(player_cpls) / max(1, len(player_cpls))
+            estimated_elo = int(max(400, min(3600, round(3600 * math.exp(-0.01 * avg_cpl)))))
 
             return AnalyzeResponse(
                 accuracy=round(accuracy, 1),
@@ -505,4 +530,5 @@ async def analyze_game(request: AnalyzeRequest):
 
 if __name__ == "__main__":
     import uvicorn
+    # Hugging Face Spaces port is 7860
     uvicorn.run(app, host="0.0.0.0", port=7860)