Update app.py

app.py

@@ -1,6 +1,7 @@
 """
-Nexus-Nano Inference API (Fixed)
-Ultra-lightweight single-file engine with proper error handling
+Nexus-Nano Inference API - Path Fixed
+Model: /app/models/nexus-nano.onnx
+Ultra-lightweight single-file engine
 """
 
 from fastapi import FastAPI, HTTPException
@@ -12,7 +13,6 @@ import chess
 import time
 import logging
 import os
-from pathlib import Path
 from typing import Optional, Tuple
 
 logging.basicConfig(
@@ -21,7 +21,7 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# ==================== NANO ENGINE (Single File) ====================
+# ==================== NANO ENGINE ====================
 
 class NexusNanoEngine:
     """Ultra-lightweight chess engine"""
@@ -35,8 +35,8 @@ class NexusNanoEngine:
         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")
+        logger.info(f"📦 Loading model: {model_path}")
+        logger.info(f"💾 Size: {os.path.getsize(model_path)/(1024*1024):.2f} MB")
         
         sess_options = ort.SessionOptions()
         sess_options.intra_op_num_threads = 2
@@ -52,7 +52,7 @@ class NexusNanoEngine:
         self.output_name = self.session.get_outputs()[0].name
         self.nodes = 0
         
-        logger.info("✅ Nexus-Nano engine loaded")
+        logger.info("✅ Engine ready!")
     
     def fen_to_tensor(self, fen: str) -> np.ndarray:
         board = chess.Board(fen)
@@ -78,7 +78,6 @@ class NexusNanoEngine:
         return -score if board.turn == chess.BLACK else score
     
     def order_moves(self, board: chess.Board, moves):
-        """Simple MVV-LVA ordering"""
         scored = []
         for m in moves:
             s = 0
@@ -139,16 +138,19 @@ class NexusNanoEngine:
         
         moves = list(board.legal_moves)
         if len(moves) == 0:
-            return {'best_move': '0000', 'evaluation': 0.0, 'nodes': 0}
+            return {'best_move': '0000', 'evaluation': 0.0, 'nodes': 0, 'depth': 0}
+        
         if len(moves) == 1:
             return {
                 'best_move': moves[0].uci(),
                 'evaluation': round(self.evaluate(board) / 100.0, 2),
-                'nodes': 1
+                'nodes': 1,
+                'depth': 0
             }
         
         best_move = moves[0]
         best_score = float('-inf')
+        current_depth = 1
         
         for d in range(1, depth + 1):
             try:
@@ -156,13 +158,14 @@ class NexusNanoEngine:
                 if move:
                     best_move = move
                     best_score = score
+                    current_depth = d
             except:
                 break
         
         return {
             'best_move': best_move.uci(),
             'evaluation': round(best_score / 100.0, 2),
-            'depth': d,
+            'depth': current_depth,
             'nodes': self.nodes
         }
 
@@ -170,7 +173,7 @@ class NexusNanoEngine:
 # ==================== FASTAPI APP ====================
 
 app = FastAPI(
-    title="Nexus-Nano API",
+    title="Nexus-Nano Inference API",
     description="Ultra-lightweight chess engine",
     version="1.0.0"
 )
@@ -204,25 +207,32 @@ async def startup():
     global engine
     logger.info("🚀 Starting Nexus-Nano API...")
     
-    model_path = "/app/models/nexus_nano.onnx"
+    # FIXED: Correct path with hyphen
+    model_path = "/app/models/nexus-nano.onnx"
+    
+    logger.info(f"🔍 Looking for: {model_path}")
     
-    # Debug: Check models directory
     if os.path.exists("/app/models"):
-        logger.info(f"📂 Files in /app/models/:")
+        logger.info("📂 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)")
+            if os.path.isfile(full_path):
+                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")
+        logger.error("❌ /app/models/ not found!")
+        raise FileNotFoundError("/app/models/ directory missing")
+    
+    if not os.path.exists(model_path):
+        logger.error(f"❌ Model not found: {model_path}")
+        logger.error("💡 Available:", os.listdir("/app/models"))
+        raise FileNotFoundError(f"Missing: {model_path}")
     
-    # Load engine
     try:
         engine = NexusNanoEngine(model_path)
-        logger.info("✅ Engine ready")
+        logger.info("🎉 Nexus-Nano ready!")
     except Exception as e:
-        logger.error(f"❌ Failed to load: {e}", exc_info=True)
+        logger.error(f"❌ Load failed: {e}", exc_info=True)
         raise
 
 
@@ -232,19 +242,20 @@ async def health():
         "status": "healthy" if engine else "unhealthy",
         "model": "nexus-nano",
         "version": "1.0.0",
-        "model_loaded": engine is not None
+        "model_loaded": engine is not None,
+        "model_path": "/app/models/nexus-nano.onnx"
     }
 
 
 @app.post("/get-move", response_model=MoveResponse)
 async def get_move(req: MoveRequest):
     if not engine:
-        raise HTTPException(503, "Engine not loaded")
+        raise HTTPException(status_code=503, detail="Engine not loaded")
     
     try:
         chess.Board(req.fen)
     except:
-        raise HTTPException(400, "Invalid FEN")
+        raise HTTPException(status_code=400, detail="Invalid FEN")
     
     start = time.time()
     
@@ -253,8 +264,9 @@ async def get_move(req: MoveRequest):
         elapsed = int((time.time() - start) * 1000)
         
         logger.info(
-            f"Move: {result['best_move']} | "
+            f"✓ Move: {result['best_move']} | "
             f"Eval: {result['evaluation']:+.2f} | "
+            f"Depth: {result['depth']} | "
             f"Nodes: {result['nodes']} | "
             f"Time: {elapsed}ms"
         )
@@ -266,22 +278,35 @@ async def get_move(req: MoveRequest):
             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))
+        logger.error(f"❌ Search error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
 
 
 @app.get("/")
 async def root():
     return {
-        "name": "Nexus-Nano API",
+        "name": "Nexus-Nano Inference API",
         "version": "1.0.0",
         "model": "2.8M parameters",
-        "speed": "Lightning-fast (0.2-0.5s)",
-        "status": "healthy" if engine else "loading"
+        "architecture": "Compact ResNet",
+        "speed": "0.2-0.5s per move @ depth 3",
+        "status": "online" if engine else "starting",
+        "endpoints": {
+            "POST /get-move": "Get best move",
+            "GET /health": "Health check",
+            "GET /docs": "API docs"
+        }
     }
 
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=7860,
+        log_level="info",
+        access_log=True
+    )