Update server.py

server.py

@@ -2,12 +2,12 @@ import os
 import shutil
 import zipfile
 import logging
+import urllib.parse
 from fastapi import FastAPI, File, UploadFile, Form, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from huggingface_hub import snapshot_download
 
-# Configure Logging to see errors in HF Logs clearly
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
@@ -31,88 +31,84 @@ def setup_environment():
         os.makedirs(IMAGE_DIR)
 
     try:
-        logger.info(f"Starting sync from {DATASET_REPO}...")
+        logger.info(f"Syncing from {DATASET_REPO}...")
         snapshot_download(repo_id=DATASET_REPO, repo_type="dataset", token=token, local_dir=".")
 
         zip_name = "orbiitt_db.zip"
         if os.path.exists(zip_name):
-            logger.info("Extracting database and images...")
             with zipfile.ZipFile(zip_name, 'r') as z:
                 z.extractall("temp_extract")
             
-            # Recursive scan for DB and Images
             for root, _, files in os.walk("temp_extract"):
                 for f in files:
                     src = os.path.join(root, f)
                     
-                    # Identify the Database (Look for specific name OR any .db)
-                    if f in ["orbiitt_db", "orbiitt_db.db", "orbiitt.db"] or (f.endswith(".db") and "analytics" not in f):
+                    # 1. DATABASE FIX: Force rename to 'orbiitt.db'
+                    if f in ["orbiitt_db", "orbiitt_db.db", "orbiitt.db"] or f.endswith(".db"):
                         if not os.path.exists(DB_TARGET):
                             shutil.move(src, f"./{DB_TARGET}")
-                            logger.info(f"Database identified and moved: {f} -> {DB_TARGET}")
+                            logger.info(f"DB Found: {f}")
                     
-                    # Identify and move Images
+                    # 2. IMAGE FIX: Remove spaces and %20 from filenames
                     elif f.lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
-                        dest = os.path.join(IMAGE_DIR, f)
-                        if not os.path.exists(dest):
-                            shutil.move(src, dest)
+                        # Unquote removes %20, replace(' ', '_') removes spaces
+                        clean_name = urllib.parse.unquote(f).replace(" ", "_")
+                        dest = os.path.join(IMAGE_DIR, clean_name)
+                        shutil.move(src, dest)
             
             shutil.rmtree("temp_extract")
         
-        logger.info(f"Setup Finished. Images: {len(os.listdir(IMAGE_DIR))}")
+        # Cleanup: Rename any files left in root that should be DB
+        if os.path.exists("orbiitt_db") and not os.path.exists(DB_TARGET):
+            shutil.move("orbiitt_db", DB_TARGET)
+
     except Exception as e:
-        logger.error(f"Setup failed: {str(e)}")
+        logger.error(f"Setup Error: {e}")
 
 setup_environment()
 
-# Serving static files
-if os.path.exists(IMAGE_DIR):
-    app.mount("/Productimages", StaticFiles(directory=IMAGE_DIR), name="Productimages")
+app.mount("/Productimages", StaticFiles(directory=IMAGE_DIR), name="Productimages")
 
-# Engine Logic
 engine = None
 try:
     from orbiitt_engine import OrbiittEngine
     if os.path.exists(DB_TARGET):
         engine = OrbiittEngine()
-        logger.info("Search Engine Initialized.")
+        logger.info("ENGINE ONLINE")
 except Exception as e:
-    logger.error(f"Engine Load Error: {e}")
+    logger.error(f"ENGINE ERROR: {e}")
 
 @app.get("/")
-def health_check():
-    """Diagnostic endpoint to verify server state."""
-    files_in_root = os.listdir(".")
+def health():
     imgs = os.listdir(IMAGE_DIR) if os.path.exists(IMAGE_DIR) else []
     return {
-        "status": "active",
-        "database_found": os.path.exists(DB_TARGET),
-        "engine_loaded": engine is not None,
-        "total_images": len(imgs),
-        "sample_image": imgs[0] if imgs else None,
-        "root_files": files_in_root
+        "engine": engine is not None,
+        "db": os.path.exists(DB_TARGET),
+        "img_count": len(imgs),
+        "first_img": imgs[0] if imgs else None
     }
 
 @app.post("/search")
 async def search(text: str = Form(None), weight: float = Form(0.5), file: UploadFile = File(None)):
-    if not engine:
-        raise HTTPException(status_code=503, detail="Search engine not ready.")
-    
+    if not engine: raise HTTPException(503, detail="Engine Offline")
     t_path = None
     try:
         if file:
-            t_path = f"search_tmp_{file.filename}"
-            with open(t_path, "wb") as buffer:
-                buffer.write(await file.read())
+            t_path = f"tmp_{file.filename}"
+            with open(t_path, "wb") as b: b.write(await file.read())
         
         results = engine.search(text_query=text, image_file=t_path, text_weight=weight)
+        
+        # 3. FIX RESULT PATHS: Ensure the frontend gets the "Clean" names
+        for r in results:
+            if 'url' in r:
+                r['url'] = r['url'].replace(" ", "_")
+                
         return {"results": results}
     except Exception as e:
-        logger.error(f"Search error: {e}")
         return {"results": [], "error": str(e)}
     finally:
-        if t_path and os.path.exists(t_path):
-            os.remove(t_path)
+        if t_path and os.path.exists(t_path): os.remove(t_path)
 
 if __name__ == "__main__":
     import uvicorn