Update app.py

app.py

@@ -1,6 +1,6 @@
 """
-Nexus-Core Inference API (Fixed)
-Fast and efficient chess engine with proper error handling
+Nexus-Core Inference API - Path Fixed
+Model: /app/models/nexus-core.onnx
 """
 
 from fastapi import FastAPI, HTTPException
@@ -62,36 +62,39 @@ async def startup_event():
     global engine
     logger.info("🚀 Starting Nexus-Core API...")
     
-    # Check model file
-    model_path = "/app/models/nexus_core.onnx"
+    # FIXED: Correct model path with hyphen
+    model_path = "/app/models/nexus-core.onnx"
+    
+    # Debug logging
+    logger.info(f"Looking for model at: {model_path}")
     
-    # Debug: List files in 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 does not exist!")
         raise FileNotFoundError("/app/models/ not found")
     
-    # Check if model exists
     if not os.path.exists(model_path):
-        logger.error(f"❌ Model not found at {model_path}")
-        logger.error("Available files:", os.listdir("/app/models") if os.path.exists("/app/models") else "No models dir")
-        raise FileNotFoundError(f"Model file not found: {model_path}")
+        logger.error(f"❌ Model not found at: {model_path}")
+        logger.error("💡 Available files:", os.listdir("/app/models"))
+        raise FileNotFoundError(f"Model file missing: {model_path}")
     
-    logger.info(f"✅ Model found: {model_path} ({os.path.getsize(model_path)/(1024*1024):.2f} MB)")
+    logger.info(f"✅ Model found: {os.path.getsize(model_path)/(1024*1024):.2f} MB")
     
     try:
         engine = NexusCoreEngine(
             model_path=model_path,
             num_threads=2
         )
-        logger.info("✅ Nexus-Core engine loaded successfully")
+        logger.info("✅ Nexus-Core engine loaded successfully!")
+        
     except Exception as e:
-        logger.error(f"❌ Failed to load engine: {e}", exc_info=True)
+        logger.error(f"❌ Engine load failed: {e}", exc_info=True)
         raise
 
 
@@ -101,29 +104,29 @@ async def health_check():
         "status": "healthy" if engine else "unhealthy",
         "model_loaded": engine is not None,
         "version": "2.0.0",
-        "model_path": "/app/models/nexus_core.onnx" if engine else None
+        "model_path": "/app/models/nexus-core.onnx"
     }
 
 
 @app.post("/get-move", response_model=MoveResponse)
 async def get_move(request: MoveRequest):
     if not engine:
-        raise HTTPException(503, "Engine not loaded")
+        raise HTTPException(status_code=503, detail="Engine not loaded")
     
     if not engine.validate_fen(request.fen):
-        raise HTTPException(400, "Invalid FEN")
+        raise HTTPException(status_code=400, detail="Invalid FEN string")
     
     start = time.time()
     
     try:
         result = engine.get_best_move(
-            request.fen,
-            request.depth,
-            request.time_limit
+            fen=request.fen,
+            depth=request.depth,
+            time_limit=request.time_limit
         )
         
         logger.info(
-            f"Move: {result['best_move']} | "
+            f"✓ Move: {result['best_move']} | "
             f"Eval: {result['evaluation']:+.2f} | "
             f"Depth: {result['depth_searched']} | "
             f"Nodes: {result['nodes_evaluated']} | "
@@ -131,28 +134,35 @@ async def get_move(request: MoveRequest):
         )
         
         return MoveResponse(**result)
-    
+        
     except Exception as e:
-        logger.error(f"Error during search: {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-Core API",
+        "name": "Nexus-Core Inference API",
         "version": "2.0.0",
         "model": "13M parameters",
-        "speed": "Ultra-fast (0.5-1s per move)",
-        "status": "healthy" if engine else "loading",
+        "architecture": "ResNet CNN",
+        "speed": "0.5-1s per move @ depth 4",
+        "status": "online" if engine else "starting",
         "endpoints": {
-            "POST /get-move": "Get best move",
-            "GET /health": "Health check",
-            "GET /docs": "API documentation"
+            "POST /get-move": "Get best chess move",
+            "GET /health": "API health check",
+            "GET /docs": "Interactive API documentation"
         }
     }
 
 
 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
+    )