Update main.py

main.py

@@ -17,7 +17,6 @@ import cloudinary.uploader
 import cloudinary.api
 from pinecone import Pinecone, ServerlessSpec
 
-# ── Deferred imports ─────────────────────────────────────────────
 ai = None
 p = inflect.engine()
 
@@ -25,12 +24,12 @@ MAX_CONCURRENT_INFERENCES = int(os.getenv("MAX_CONCURRENT_INFERENCES", "6"))
 _inference_sem: asyncio.Semaphore
 
 _pinecone_pool = OrderedDict()
-_cloudinary_pool = {}
 _POOL_MAX = 64
 
 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:
@@ -39,31 +38,52 @@ def _get_pinecone(api_key: str) -> Pinecone:
     _pinecone_pool.move_to_end(api_key)
     return _pinecone_pool[api_key]
 
-def _configure_cloudinary(creds: dict):
-    key = creds.get("cloud_name")
-    if not key: return
-    if key not in _cloudinary_pool:
-        cloudinary.config(
-            cloud_name=creds["cloud_name"], 
-            api_key=creds["api_key"], 
-            api_secret=creds["api_secret"]
-        )
-        _cloudinary_pool[key] = True
-
+# ── 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.
+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"],
+    )
+
+def _cld_ping(creds: dict):
+    return cloudinary.api.ping(
+        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"],
+    )
+
+# ─────────────────────────────────────────────────────────────────
 @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:
@@ -78,99 +98,135 @@ 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}
+    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.")
+
 
 # ══════════════════════════════════════════════════════════════════
-# 1. VERIFY KEYS & AUTO-BUILD INDEXES
+# 1. VERIFY KEYS
 # ══════════════════════════════════════════════════════════════════
 @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:
-            _configure_cloudinary(get_cloudinary_creds(cloudinary_url))
-            await asyncio.to_thread(cloudinary.api.ping)
+            await asyncio.to_thread(_cld_ping, creds)
         except Exception:
-            raise HTTPException(400, "Invalid Cloudinary Environment URL.")
+            raise HTTPException(400, "Cloudinary ping failed. Check your 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("")):
-    # DEFENSIVE FIX: The 'or ""' ensures it never becomes None, preventing 500 crashes
-    actual_pc_key = user_pinecone_key or os.getenv("DEFAULT_PINECONE_KEY", "")
+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", "")
-    
+
     if not actual_pc_key or not actual_cld_url:
-        raise HTTPException(400, "API Keys are missing. If you are a guest, the server is missing its DEFAULT_ secrets in Hugging Face.")
+        raise HTTPException(400, "API Keys are missing.")
 
-    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.")
-        
-    _configure_cloudinary(creds)
-    pc = _get_pinecone(actual_pc_key)
-    idx_obj = pc.Index(IDX_OBJECTS)
-    idx_face = pc.Index(IDX_FACES)
+    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)
+    uploaded_urls = []
 
     for file in files:
         tmp_path = f"temp_uploads/{uuid.uuid4().hex}_{sanitize_filename(file.filename)}"
         try:
             with open(tmp_path, "wb") as buf:
                 shutil.copyfileobj(file.file, buf)
-                
-            res = await asyncio.to_thread(cloudinary.uploader.upload, tmp_path, folder=folder)
+
+            # Upload using THIS request's credentials only
+            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_upserts, object_upserts = [], []
+            face_ups, obj_ups = [], []
             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_upserts if v["type"] == "face" else object_upserts).append(record)
+                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)
 
-            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)
+            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)
+
+        except HTTPException:
+            raise
         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("")):
+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", "")
     if not actual_pc_key:
-        raise HTTPException(400, "Pinecone Key is missing. If you are a guest, the server is missing its DEFAULT_PINECONE_KEY in Hugging Face.")
+        raise HTTPException(400, "Pinecone Key is missing.")
 
     tmp_path = f"temp_uploads/query_{uuid.uuid4().hex}_{sanitize_filename(file.filename)}"
     try:
@@ -180,28 +236,31 @@ async def search_database(file: UploadFile = File(...), detect_faces: bool = For
         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, f"Pinecone Index not found. Please log in and click 'Verify Keys' in Settings to build the indexes.")
-                raise e
-                
+                    raise HTTPException(404, "Pinecone index not found. Go to Settings → Verify & Save to build indexes.")
+                raise
             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 = {}
@@ -211,13 +270,15 @@ async def search_database(file: UploadFile = File(...), detect_faces: bool = For
                 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)
 
 
 # ══════════════════════════════════════════════════════════════════
@@ -228,20 +289,23 @@ async def get_categories(user_cloudinary_url: str = Form("")):
     actual_cld_url = user_cloudinary_url or os.getenv("DEFAULT_CLOUDINARY_URL", "")
     if not actual_cld_url:
         return {"categories": []}
-        
+
+    creds = get_cloudinary_creds(actual_cld_url)
+    if not creds.get("cloud_name"):
+        return {"categories": []}
+
     try:
-        creds = get_cloudinary_creds(actual_cld_url)
-        if not creds.get("cloud_name"):
-            return {"categories": []}
-            
-        _configure_cloudinary(creds)
-        result = await asyncio.to_thread(cloudinary.api.root_folders)
+        # Uses THIS request's credentials — never touches another user's cloud
+        result = await asyncio.to_thread(_cld_root_folders, creds)
         return {"categories": [f["name"] for f in result.get("folders", [])]}
     except Exception as e:
         print(f"Category fetch error: {e}")
         return {"categories": []}
 
 
+# ══════════════════════════════════════════════════════════════════
+# 5. HEALTH
+# ══════════════════════════════════════════════════════════════════
 @app.get("/api/health")
 async def health():
-    return {"status": "ok"}
+    return {"status": "ok", "device": getattr(ai, "device", "loading")}