Update app.py

app.py

@@ -1,7 +1,6 @@
 """
-Nexus-Nano Inference API
-Ultra-lightweight single-file engine
-No modular architecture - pure speed optimization
+Nexus-Nano Inference API (Fixed)
+Ultra-lightweight single-file engine with proper error handling
 """
 
 from fastapi import FastAPI, HTTPException
@@ -12,19 +11,20 @@ import numpy as np
 import chess
 import time
 import logging
+import os
 from pathlib import Path
 from typing import Optional, Tuple
 
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
 logger = logging.getLogger(__name__)
 
 # ==================== NANO ENGINE (Single File) ====================
 
 class NexusNanoEngine:
-    """
-    Ultra-lightweight chess engine
-    Pure alpha-beta, no cache, minimal overhead
-    """
+    """Ultra-lightweight chess engine"""
     
     PIECE_VALUES = {
         chess.PAWN: 1, chess.KNIGHT: 3, chess.BISHOP: 3,
@@ -32,6 +32,12 @@ class NexusNanoEngine:
     }
     
     def __init__(self, model_path: str):
+        if not os.path.exists(model_path):
+            raise FileNotFoundError(f"Model not found: {model_path}")
+        
+        logger.info(f"Loading model from {model_path}...")
+        logger.info(f"Model size: {os.path.getsize(model_path)/(1024*1024):.2f} MB")
+        
         sess_options = ort.SessionOptions()
         sess_options.intra_op_num_threads = 2
         sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
@@ -46,7 +52,7 @@ class NexusNanoEngine:
         self.output_name = self.session.get_outputs()[0].name
         self.nodes = 0
         
-        logger.info("✅ Nexus-Nano loaded")
+        logger.info("✅ Nexus-Nano engine loaded")
     
     def fen_to_tensor(self, fen: str) -> np.ndarray:
         board = chess.Board(fen)
@@ -196,23 +202,44 @@ class MoveResponse(BaseModel):
 @app.on_event("startup")
 async def startup():
     global engine
-    logger.info("🚀 Starting Nexus-Nano...")
+    logger.info("🚀 Starting Nexus-Nano API...")
+    
+    model_path = "/app/models/nexus_nano.onnx"
+    
+    # Debug: Check models directory
+    if os.path.exists("/app/models"):
+        logger.info(f"📂 Files in /app/models/:")
+        for f in os.listdir("/app/models"):
+            full_path = os.path.join("/app/models", f)
+            size = os.path.getsize(full_path) / (1024*1024)
+            logger.info(f"   - {f} ({size:.2f} MB)")
+    else:
+        logger.error("❌ /app/models/ directory not found!")
+        raise FileNotFoundError("/app/models/ not found")
+    
+    # Load engine
     try:
-        engine = NexusNanoEngine("/app/models/nexus_nano.onnx")
+        engine = NexusNanoEngine(model_path)
+        logger.info("✅ Engine ready")
     except Exception as e:
-        logger.error(f"❌ Failed: {e}")
+        logger.error(f"❌ Failed to load: {e}", exc_info=True)
         raise
 
 
 @app.get("/health")
 async def health():
-    return {"status": "healthy", "model": "nexus-nano", "version": "1.0.0"}
+    return {
+        "status": "healthy" if engine else "unhealthy",
+        "model": "nexus-nano",
+        "version": "1.0.0",
+        "model_loaded": engine is not None
+    }
 
 
 @app.post("/get-move", response_model=MoveResponse)
 async def get_move(req: MoveRequest):
     if not engine:
-        raise HTTPException(503, "Not loaded")
+        raise HTTPException(503, "Engine not loaded")
     
     try:
         chess.Board(req.fen)
@@ -220,23 +247,28 @@ async def get_move(req: MoveRequest):
         raise HTTPException(400, "Invalid FEN")
     
     start = time.time()
-    result = engine.search(req.fen, req.depth)
-    elapsed = int((time.time() - start) * 1000)
-    
-    logger.info(
-        f"Move: {result['best_move']} | "
-        f"Eval: {result['evaluation']:+.2f} | "
-        f"Nodes: {result['nodes']} | "
-        f"Time: {elapsed}ms"
-    )
     
-    return MoveResponse(
-        best_move=result['best_move'],
-        evaluation=result['evaluation'],
-        depth_searched=result['depth'],
-        nodes_evaluated=result['nodes'],
-        time_taken=elapsed
-    )
+    try:
+        result = engine.search(req.fen, req.depth)
+        elapsed = int((time.time() - start) * 1000)
+        
+        logger.info(
+            f"Move: {result['best_move']} | "
+            f"Eval: {result['evaluation']:+.2f} | "
+            f"Nodes: {result['nodes']} | "
+            f"Time: {elapsed}ms"
+        )
+        
+        return MoveResponse(
+            best_move=result['best_move'],
+            evaluation=result['evaluation'],
+            depth_searched=result['depth'],
+            nodes_evaluated=result['nodes'],
+            time_taken=elapsed
+        )
+    except Exception as e:
+        logger.error(f"Search error: {e}", exc_info=True)
+        raise HTTPException(500, str(e))
 
 
 @app.get("/")
@@ -245,10 +277,11 @@ async def root():
         "name": "Nexus-Nano API",
         "version": "1.0.0",
         "model": "2.8M parameters",
-        "speed": "Lightning-fast"
+        "speed": "Lightning-fast (0.2-0.5s)",
+        "status": "healthy" if engine else "loading"
     }
 
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")