Update main.py

main.py

@@ -17,6 +17,7 @@ import cloudinary.uploader
 import cloudinary.api
 from pinecone import Pinecone, ServerlessSpec
 
+# ── Deferred imports ─────────────────────────────────────────────
 ai = None
 p = inflect.engine()
 
@@ -26,10 +27,9 @@ _inference_sem: asyncio.Semaphore
 _pinecone_pool = OrderedDict()
 _POOL_MAX = 64
 
-IDX_FACES = "enterprise-faces"
+IDX_FACES   = "enterprise-faces"
 IDX_OBJECTS = "enterprise-objects"
 
-# ── Pinecone pool (keyed by api_key — safe, each key = one account) ──
 def _get_pinecone(api_key: str) -> Pinecone:
     if api_key not in _pinecone_pool:
         if len(_pinecone_pool) >= _POOL_MAX:
@@ -38,52 +38,38 @@ def _get_pinecone(api_key: str) -> Pinecone:
     _pinecone_pool.move_to_end(api_key)
     return _pinecone_pool[api_key]
 
-# ── Cloudinary: NO global config, NO pool.
-# Credentials are injected per-call via keyword args.
-# This is the ONLY correct pattern when multiple users share one server process.
+# Cloudinary helpers — credentials injected per-call, never globally configured.
+# This is the ONLY safe pattern when multiple users share one server process.
 def _cld_upload(tmp_path: str, folder: str, creds: dict):
     return cloudinary.uploader.upload(
-        tmp_path,
-        folder=folder,
-        api_key=creds["api_key"],
-        api_secret=creds["api_secret"],
-        cloud_name=creds["cloud_name"],
+        tmp_path, folder=folder,
+        api_key=creds["api_key"], api_secret=creds["api_secret"], cloud_name=creds["cloud_name"],
     )
 
 def _cld_ping(creds: dict):
     return cloudinary.api.ping(
-        api_key=creds["api_key"],
-        api_secret=creds["api_secret"],
-        cloud_name=creds["cloud_name"],
+        api_key=creds["api_key"], api_secret=creds["api_secret"], cloud_name=creds["cloud_name"],
     )
 
 def _cld_root_folders(creds: dict):
     return cloudinary.api.root_folders(
-        api_key=creds["api_key"],
-        api_secret=creds["api_secret"],
-        cloud_name=creds["cloud_name"],
+        api_key=creds["api_key"], api_secret=creds["api_secret"], cloud_name=creds["cloud_name"],
     )
 
-# ─────────────────────────────────────────────────────────────────
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     global ai, _inference_sem
     from src.models import AIModelManager
-    print("Loading AI models...")
+    
+    print("⏳ Loading AI models …")
     loop = asyncio.get_event_loop()
     ai = await loop.run_in_executor(None, AIModelManager)
     _inference_sem = asyncio.Semaphore(MAX_CONCURRENT_INFERENCES)
-    print("Ready!")
+    print("✅ Ready!")
     yield
 
 app = FastAPI(lifespan=lifespan)
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
 os.makedirs("temp_uploads", exist_ok=True)
 
 def standardize_category_name(name: str) -> str:
@@ -98,80 +84,60 @@ def get_cloudinary_creds(env_url: str) -> dict:
     if not env_url:
         return {}
     parsed = urlparse(env_url)
-    return {
-        "api_key":    parsed.username,
-        "api_secret": parsed.password,
-        "cloud_name": parsed.hostname,
-    }
-
-def require_cloudinary_creds(creds: dict):
-    if not creds.get("cloud_name") or not creds.get("api_key") or not creds.get("api_secret"):
-        raise HTTPException(400, "Invalid or missing Cloudinary Environment URL.")
-
+    return {"api_key": parsed.username, "api_secret": parsed.password, "cloud_name": parsed.hostname}
 
 # ══════════════════════════════════════════════════════════════════
-# 1. VERIFY KEYS
+# 1. VERIFY KEYS & AUTO-BUILD INDEXES
 # ══════════════════════════════════════════════════════════════════
 @app.post("/api/verify-keys")
 async def verify_keys(pinecone_key: str = Form(""), cloudinary_url: str = Form("")):
     if cloudinary_url:
-        creds = get_cloudinary_creds(cloudinary_url)
-        require_cloudinary_creds(creds)
         try:
+            creds = get_cloudinary_creds(cloudinary_url)
+            if not creds.get("cloud_name"): raise ValueError("bad url")
             await asyncio.to_thread(_cld_ping, creds)
+        except HTTPException: raise
         except Exception:
-            raise HTTPException(400, "Cloudinary ping failed. Check your Environment URL.")
-
+            raise HTTPException(400, "Invalid Cloudinary Environment URL.")
     if pinecone_key:
         try:
             pc = _get_pinecone(pinecone_key)
             existing = {idx.name for idx in await asyncio.to_thread(pc.list_indexes)}
             tasks = []
             if IDX_OBJECTS not in existing:
-                tasks.append(asyncio.to_thread(
-                    pc.create_index, name=IDX_OBJECTS, dimension=1536, metric="cosine",
-                    spec=ServerlessSpec(cloud="aws", region="us-east-1")
-                ))
+                tasks.append(asyncio.to_thread(pc.create_index, name=IDX_OBJECTS, dimension=1536, metric="cosine", spec=ServerlessSpec(cloud="aws", region="us-east-1")))
             if IDX_FACES not in existing:
-                tasks.append(asyncio.to_thread(
-                    pc.create_index, name=IDX_FACES, dimension=512, metric="cosine",
-                    spec=ServerlessSpec(cloud="aws", region="us-east-1")
-                ))
+                tasks.append(asyncio.to_thread(pc.create_index, name=IDX_FACES, dimension=512, metric="cosine", spec=ServerlessSpec(cloud="aws", region="us-east-1")))
             if tasks:
                 await asyncio.gather(*tasks)
-        except HTTPException:
-            raise
         except Exception as e:
             raise HTTPException(400, f"Pinecone Error: {e}")
-
     return {"message": "Keys verified and indexes ready!"}
 
 
 # ══════════════════════════════════════════════════════════════════
-# 2. UPLOAD
+# 2. UPLOAD 
 # ══════════════════════════════════════════════════════════════════
 @app.post("/api/upload")
-async def upload_new_images(
-    files: List[UploadFile] = File(...),
-    folder_name: str = Form(...),
-    detect_faces: bool = Form(True),
-    user_pinecone_key: str = Form(""),
-    user_cloudinary_url: str = Form(""),
-):
-    actual_pc_key  = user_pinecone_key  or os.getenv("DEFAULT_PINECONE_KEY", "")
-    actual_cld_url = user_cloudinary_url or os.getenv("DEFAULT_CLOUDINARY_URL", "")
+async def upload_new_images(files: List[UploadFile] = File(...), folder_name: str = Form(...), detect_faces: bool = Form(True), user_pinecone_key: str = Form(""), user_cloudinary_url: str = Form("")):
+    # Frontend always sends the correct keys (guest keys = hardcoded in App.jsx,
+    # PRO keys = from Supabase). Backend never falls back to env vars here.
+    actual_pc_key  = (user_pinecone_key  or "").strip()
+    actual_cld_url = (user_cloudinary_url or "").strip()
 
     if not actual_pc_key or not actual_cld_url:
-        raise HTTPException(400, "API Keys are missing.")
+        raise HTTPException(400, "API keys missing. Configure them in Settings or check the app.")
 
-    creds = get_cloudinary_creds(actual_cld_url)
-    require_cloudinary_creds(creds)
-
-    folder       = standardize_category_name(folder_name)
-    pc           = _get_pinecone(actual_pc_key)
-    idx_obj      = pc.Index(IDX_OBJECTS)
-    idx_face     = pc.Index(IDX_FACES)
+    folder = standardize_category_name(folder_name)
     uploaded_urls = []
+    
+    creds = get_cloudinary_creds(actual_cld_url)
+    if not creds.get("cloud_name"):
+        raise HTTPException(400, "Invalid Cloudinary URL format.")
+        
+    pc       = _get_pinecone(actual_pc_key)
+    idx_obj  = pc.Index(IDX_OBJECTS)
+    idx_face = pc.Index(IDX_FACES)
 
     for file in files:
         tmp_path = f"temp_uploads/{uuid.uuid4().hex}_{sanitize_filename(file.filename)}"
@@ -179,54 +145,40 @@ async def upload_new_images(
             with open(tmp_path, "wb") as buf:
                 shutil.copyfileobj(file.file, buf)
 
-            # Upload using THIS request's credentials only
-            res       = await asyncio.to_thread(_cld_upload, tmp_path, folder, creds)
+            res = await asyncio.to_thread(_cld_upload, tmp_path, folder, creds)
             image_url = res["secure_url"]
             uploaded_urls.append(image_url)
 
             async with _inference_sem:
                 vectors = await ai.process_image_async(tmp_path, is_query=False, detect_faces=detect_faces)
 
-            face_ups, obj_ups = [], []
+            face_upserts, object_upserts = [], []
             for v in vectors:
                 vec_list = v["vector"].tolist() if hasattr(v["vector"], "tolist") else v["vector"]
-                record = {
-                    "id": str(uuid.uuid4()),
-                    "values": vec_list,
-                    "metadata": {"url": image_url, "folder": folder},
-                }
-                (face_ups if v["type"] == "face" else obj_ups).append(record)
-
-            tasks = []
-            if face_ups:  tasks.append(asyncio.to_thread(idx_face.upsert, vectors=face_ups))
-            if obj_ups:   tasks.append(asyncio.to_thread(idx_obj.upsert,  vectors=obj_ups))
-            if tasks:     await asyncio.gather(*tasks)
+                record = {"id": str(uuid.uuid4()), "values": vec_list, "metadata": {"url": image_url, "folder": folder}}
+                (face_upserts if v["type"] == "face" else object_upserts).append(record)
 
-        except HTTPException:
-            raise
+            upsert_tasks = []
+            if face_upserts: upsert_tasks.append(asyncio.to_thread(idx_face.upsert, vectors=face_upserts))
+            if object_upserts: upsert_tasks.append(asyncio.to_thread(idx_obj.upsert, vectors=object_upserts))
+            if upsert_tasks: await asyncio.gather(*upsert_tasks)
         except Exception as e:
-            print(f"Upload error: {e}")
+            print(f"❌ Upload error: {e}")
             raise HTTPException(500, f"Upload processing failed: {str(e)}")
         finally:
-            if os.path.exists(tmp_path):
-                os.remove(tmp_path)
-
+            if os.path.exists(tmp_path): os.remove(tmp_path)
+            
     return {"message": "Done!", "urls": uploaded_urls}
 
 
 # ══════════════════════════════════════════════════════════════════
-# 3. SEARCH
+# 3. SEARCH 
 # ══════════════════════════════════════════════════════════════════
 @app.post("/api/search")
-async def search_database(
-    file: UploadFile = File(...),
-    detect_faces: bool = Form(True),
-    user_pinecone_key: str = Form(""),
-    user_cloudinary_url: str = Form(""),
-):
-    actual_pc_key = user_pinecone_key or os.getenv("DEFAULT_PINECONE_KEY", "")
+async def search_database(file: UploadFile = File(...), detect_faces: bool = Form(True), user_pinecone_key: str = Form(""), user_cloudinary_url: str = Form("")):
+    actual_pc_key = (user_pinecone_key or "").strip()
     if not actual_pc_key:
-        raise HTTPException(400, "Pinecone Key is missing.")
+        raise HTTPException(400, "Pinecone key missing.")
 
     tmp_path = f"temp_uploads/query_{uuid.uuid4().hex}_{sanitize_filename(file.filename)}"
     try:
@@ -236,31 +188,28 @@ async def search_database(
         async with _inference_sem:
             vectors = await ai.process_image_async(tmp_path, is_query=True, detect_faces=detect_faces)
 
-        pc       = _get_pinecone(actual_pc_key)
-        idx_obj  = pc.Index(IDX_OBJECTS)
+        pc = _get_pinecone(actual_pc_key)
+        idx_obj = pc.Index(IDX_OBJECTS)
         idx_face = pc.Index(IDX_FACES)
 
         async def _query_one(vec_dict: dict):
-            vec_list   = vec_dict["vector"].tolist() if hasattr(vec_dict["vector"], "tolist") else vec_dict["vector"]
+            vec_list = vec_dict["vector"].tolist() if hasattr(vec_dict["vector"], "tolist") else vec_dict["vector"]
             target_idx = idx_face if vec_dict["type"] == "face" else idx_obj
+            
             try:
                 res = await asyncio.to_thread(target_idx.query, vector=vec_list, top_k=10, include_metadata=True)
             except Exception as e:
                 if "404" in str(e):
-                    raise HTTPException(404, "Pinecone index not found. Go to Settings → Verify & Save to build indexes.")
-                raise
+                    raise HTTPException(404, f"Pinecone Index not found. Please log in and click 'Verify Keys' in Settings to build the indexes.")
+                raise e
+                
             out = []
             for match in res.get("matches", []):
-                caption = ("👤 Verified Identity" if vec_dict["type"] == "face"
-                           else match["metadata"].get("folder", "🎯 Object Match"))
-                out.append({
-                    "url":     match["metadata"].get("url", ""),
-                    "score":   match["score"],
-                    "caption": caption,
-                })
+                caption = "👤 Verified Identity" if vec_dict["type"] == "face" else match["metadata"].get("folder", "🎯 Object Match")
+                out.append({"url": match["metadata"].get("url", ""), "score": match["score"], "caption": caption})
             return out
 
-        nested      = await asyncio.gather(*[_query_one(v) for v in vectors])
+        nested = await asyncio.gather(*[_query_one(v) for v in vectors])
         all_results = [r for sub in nested for r in sub]
 
         seen = {}
@@ -270,15 +219,13 @@ async def search_database(
                 seen[url] = r
 
         return {"results": sorted(seen.values(), key=lambda x: x["score"], reverse=True)[:10]}
-
     except HTTPException:
         raise
     except Exception as e:
-        print(f"Search error: {e}")
+        print(f"❌ Search error: {e}")
         raise HTTPException(500, str(e))
     finally:
-        if os.path.exists(tmp_path):
-            os.remove(tmp_path)
+        if os.path.exists(tmp_path): os.remove(tmp_path)
 
 
 # ══════════════════════════════════════════════════════════════════
@@ -286,19 +233,15 @@ async def search_database(
 # ═════════��════════════════════════════════════════════════════════
 @app.post("/api/categories")
 async def get_categories(user_cloudinary_url: str = Form("")):
-    # Priority:
-    #   1. Logged-in user sends their own URL → use it, fetch THEIR folders
-    #   2. Guest (no URL sent) → use DEFAULT_CLOUDINARY_URL (server owner's demo cloud)
-    #   3. No URL anywhere → return empty list, never error
-    actual_cld_url = user_cloudinary_url.strip() or os.getenv("DEFAULT_CLOUDINARY_URL", "")
+    actual_cld_url = (user_cloudinary_url or "").strip()
     if not actual_cld_url:
         return {"categories": []}
-
-    creds = get_cloudinary_creds(actual_cld_url)
-    if not creds.get("cloud_name") or not creds.get("api_key"):
-        return {"categories": []}
-
+        
     try:
+        creds = get_cloudinary_creds(actual_cld_url)
+        if not creds.get("cloud_name"):
+            return {"categories": []}
+            
         result = await asyncio.to_thread(_cld_root_folders, creds)
         return {"categories": [f["name"] for f in result.get("folders", [])]}
     except Exception as e:
@@ -306,9 +249,6 @@ async def get_categories(user_cloudinary_url: str = Form("")):
         return {"categories": []}
 
 
-# ══════════════════════════════════════════════════════════════════
-# 5. HEALTH
-# ══════════════════════════════════════════════════════════════════
 @app.get("/api/health")
 async def health():
-    return {"status": "ok", "device": getattr(ai, "device", "loading")}
+    return {"status": "ok"}