Update app.py

app.py

@@ -18,18 +18,15 @@ 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_path} ({os.path.getsize(model_path)/(1024*1024):.2f} MB)")
-        
+        logger.info(f"Loading model from {model_path}...")
         sess_options = ort.SessionOptions()
         sess_options.intra_op_num_threads = 2
         sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
-        
         self.session = ort.InferenceSession(model_path, sess_options=sess_options, providers=['CPUExecutionProvider'])
         self.input_name = self.session.get_inputs()[0].name
         self.output_name = self.session.get_outputs()[0].name
         self.nodes = 0
-        logger.info("✅ Engine ready")
+        logger.info("✅ Nexus-Nano engine loaded")
     
     def fen_to_tensor(self, fen: str) -> np.ndarray:
         board = chess.Board(fen)
@@ -54,18 +51,15 @@ class NexusNanoEngine:
             s = 0
             if board.is_capture(m):
                 v, a = board.piece_at(m.to_square), board.piece_at(m.from_square)
-                if v and a:
-                    s = self.PIECE_VALUES.get(v.piece_type, 0) * 10 - self.PIECE_VALUES.get(a.piece_type, 0)
+                if v and a: s = self.PIECE_VALUES.get(v.piece_type, 0) * 10 - self.PIECE_VALUES.get(a.piece_type, 0)
             if m.promotion == chess.QUEEN: s += 90
             scored.append((s, m))
         scored.sort(key=lambda x: x[0], reverse=True)
         return [m for _, m in scored]
     
-    def alpha_beta(self, board, depth, alpha, beta) -> Tuple[float, Optional[chess.Move]]:
-        if board.is_game_over():
-            return (-10000 if board.is_checkmate() else 0), None
-        if depth == 0:
-            return self.evaluate(board), None
+    def alpha_beta(self, board, depth, alpha, beta):
+        if board.is_game_over(): return (-10000 if board.is_checkmate() else 0), None
+        if depth == 0: return self.evaluate(board), None
         moves = list(board.legal_moves)
         if not moves: return 0, None
         moves = self.order_moves(board, moves)
@@ -75,8 +69,7 @@ class NexusNanoEngine:
             score, _ = self.alpha_beta(board, depth - 1, -beta, -alpha)
             score = -score
             board.pop()
-            if score > best_score:
-                best_score, best_move = score, move
+            if score > best_score: best_score, best_move = score, move
             alpha = max(alpha, score)
             if alpha >= beta: break
         return best_score, best_move
@@ -85,16 +78,13 @@ class NexusNanoEngine:
         board = chess.Board(fen)
         self.nodes = 0
         moves = list(board.legal_moves)
-        if len(moves) == 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, 2), 'nodes': 1, 'depth': 0}
+        if not moves: 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, 2), 'nodes': 1, 'depth': 0}
         best_move, best_score, current_depth = moves[0], float('-inf'), 1
         for d in range(1, depth + 1):
             try:
                 score, move = self.alpha_beta(board, d, float('-inf'), float('inf'))
-                if move:
-                    best_move, best_score, current_depth = move, score, d
+                if move: best_move, best_score, current_depth = move, score, d
             except: break
         return {'best_move': best_move.uci(), 'evaluation': round(best_score/100, 2), 'depth': current_depth, 'nodes': self.nodes}
 
@@ -117,55 +107,33 @@ class MoveResponse(BaseModel):
 @app.on_event("startup")
 async def startup():
     global engine
-    logger.info("🚀 Starting Nexus-Nano...")
-    
-    # FIXED: Check both possible paths
-    possible_paths = [
-        "/app/app/models/nexus-nano.onnx",  # When uploaded to app/models/
-        "/app/models/nexus-nano.onnx"        # When uploaded to models/
-    ]
-    
-    model_path = None
-    for path in possible_paths:
-        if os.path.exists(path):
-            model_path = path
-            logger.info(f"✅ Found model at: {path}")
-            break
-    
-    if not model_path:
-        logger.error("❌ Model not found in any expected location")
-        logger.error(f"Checked paths: {possible_paths}")
-        # List all files
-        for root, dirs, files in os.walk("/app"):
-            for file in files:
-                if file.endswith('.onnx'):
-                    logger.error(f"Found .onnx at: {os.path.join(root, file)}")
-        raise FileNotFoundError("Model not found")
-    
+    logger.info("🚀 Starting Nexus-Nano API...")
+    model_path = "/app/models/nexus-nano.onnx"
     try:
         engine = NexusNanoEngine(model_path)
+        logger.info("✅ Engine ready")
     except Exception as e:
-        logger.error(f"❌ Load failed: {e}", exc_info=True)
+        logger.error(f"❌ Failed to load engine: {e}")
         raise
 
 @app.get("/health")
 async def health():
-    return {"status": "healthy" if engine else "unhealthy", "model": "nexus-nano", "version": "1.0.0"}
+    return {"status": "healthy" if engine else "unhealthy", "model_loaded": engine is not None, "version": "1.0.0"}
 
 @app.post("/get-move", response_model=MoveResponse)
 async def get_move(req: MoveRequest):
-    if not engine: raise HTTPException(503, "Not loaded")
+    if not engine: raise HTTPException(503, "Engine not loaded")
     try: chess.Board(req.fen)
     except: raise HTTPException(400, "Invalid FEN")
     start = time.time()
     try:
         result = engine.search(req.fen, req.depth)
         elapsed = int((time.time() - start) * 1000)
-        logger.info(f"✓ {result['best_move']} | {result['evaluation']:+.2f} | {elapsed}ms")
+        logger.info(f"Move: {result['best_move']} | Eval: {result['evaluation']:+.2f} | 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"Error: {e}", exc_info=True)
+        logger.error(f"Error: {e}")
         raise HTTPException(500, str(e))
 
 @app.get("/")