fix

app.py

@@ -1,202 +1,141 @@
 import os
+import uuid
+import tempfile
 import gradio as gr
 from qdrant_client import QdrantClient
-from qdrant_client.http import models as rest
-from qdrant_client.http.models import Distance, VectorParams
+from qdrant_client.models import VectorParams, Distance, PointStruct
 from sentence_transformers import SentenceTransformer
-from transformers import CLIPProcessor, CLIPModel
 from PIL import Image
-import uuid
+import torch
+import numpy as np
+
+# --------------------------
+# Qdrant Cloud Connection
+# --------------------------
+QDRANT_URL = "https://ff4da494-27b1-413c-ba58-d5ea14932fe1.europe-west3-0.gcp.cloud.qdrant.io"  
+QDRANT_API_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3MiOiJtIn0.98XRKd7ZdDXSfYDl44zbZ_VZ5csnh4tz1JACP62KZds"                    
+COLLECTION_NAME = "lost_and_found"
+
+# CLIP model (text + image embeddings)
+MODEL_NAME = "sentence-transformers/clip-ViT-B-32"
+embedder = SentenceTransformer(MODEL_NAME)
+VECTOR_SIZE = embedder.get_sentence_embedding_dimension()
+
+# Qdrant Client (Cloud)
+qclient = QdrantClient(
+    url=QDRANT_URL,
+    api_key=QDRANT_API_KEY
+)
+
+# Ensure collection exists
+qclient.recreate_collection(
+    collection_name=COLLECTION_NAME,
+    vectors_config=VectorParams(size=VECTOR_SIZE, distance=Distance.COSINE),
+)
+
+# --------------------------
+# Helper Functions
+# --------------------------
+def embed_text(text: str):
+    """Generate embedding for text"""
+    return embedder.encode(text).tolist()
+
+def embed_image(image: Image.Image):
+    """Generate embedding for image"""
+    img_tensor = embedder.encode(image, convert_to_tensor=True)
+    return img_tensor.cpu().detach().numpy().tolist()
+
+# --------------------------
+# Core Functions
+# --------------------------
+def add_item(description, image):
+    """Add a found item to Qdrant"""
+    if not description and image is None:
+        return "⚠️ Please provide description or image."
+
+    vectors = []
+    payload = {"description": description}
+
+    if description:
+        vectors = embed_text(description)
+
+    if image:
+        vectors = embed_image(image)
+        # Save uploaded image
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp:
+            image.save(tmp.name)
+            payload["image_path"] = tmp.name
+
+    point = PointStruct(
+        id=str(uuid.uuid4()),
+        vector=vectors,
+        payload=payload
+    )
+    qclient.upsert(collection_name=COLLECTION_NAME, points=[point])
+
+    return "✅ Item added successfully!"
+
+def search_items(query_text, query_image, max_results, min_score):
+    """Search lost items by text or image"""
+    vectors = None
 
-# ----------------------------
-# Qdrant Setup
-# ----------------------------
-QDRANT_HOST = "localhost"
-QDRANT_PORT = 6333
-COLLECTION = "lost_and_found"
-
-qclient = QdrantClient(QDRANT_HOST, port=QDRANT_PORT)
-
-# Load Models
-text_model = SentenceTransformer("all-MiniLM-L6-v2")
-clip_model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
-clip_processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
-
-# Embedding sizes
-TEXT_VECTOR_SIZE = text_model.get_sentence_embedding_dimension()
-IMAGE_VECTOR_SIZE = clip_model.config.projection_dim
-
-# Create collection if not exists
-try:
-    qclient.get_collection(COLLECTION)
-except Exception:
-    qclient.create_collection(
-        COLLECTION,
-        vectors_config={
-            "text": VectorParams(size=TEXT_VECTOR_SIZE, distance=Distance.COSINE),
-            "image": VectorParams(size=IMAGE_VECTOR_SIZE, distance=Distance.COSINE),
-        },
+    if query_text:
+        vectors = embed_text(query_text)
+
+    elif query_image:
+        vectors = embed_image(query_image)
+
+    else:
+        return ["⚠️ Provide text or image to search."]
+
+    results = qclient.search(
+        collection_name=COLLECTION_NAME,
+        query_vector=vectors,
+        limit=max_results,
+        score_threshold=min_score,
     )
 
-# ----------------------------
-# Encoding Helpers
-# ----------------------------
-def encode_text(text: str):
-    return text_model.encode([text])[0]
-
-def encode_image(image: Image.Image):
-    inputs = clip_processor(images=image, return_tensors="pt")
-    with torch.no_grad():
-        emb = clip_model.get_image_features(**inputs)
-    return emb[0].cpu().numpy()
-
-# ----------------------------
-# Add Found Item
-# ----------------------------
-def add_item(text, image, uploader_name, uploader_phone):
-    try:
-        if not text and image is None:
-            return "❌ Please provide a description or an image."
-
-        text_vector = encode_text(text) if text else None
-        image_vector = encode_image(image) if image is not None else None
+    if not results:
+        return ["No matches found."]
 
-        # Save uploaded image
-        img_path = None
-        if image is not None:
-            os.makedirs("uploaded_images", exist_ok=True)
-            img_id = str(uuid.uuid4()) + ".png"
-            img_path = os.path.join("uploaded_images", img_id)
-            image.save(img_path)
-
-        vectors = {}
-        if text_vector is not None:
-            vectors["text"] = text_vector.tolist()
-        if image_vector is not None:
-            vectors["image"] = image_vector.tolist()
-
-        qclient.upsert(
-            collection_name=COLLECTION,
-            points=[
-                rest.PointStruct(
-                    id=str(uuid.uuid4()),
-                    vector=vectors,
-                    payload={
-                        "text": text,
-                        "image_path": img_path,
-                        "uploader_name": uploader_name or "N/A",
-                        "uploader_phone": uploader_phone or "N/A",
-                    },
-                )
-            ],
-        )
-        return "✅ Item added successfully!"
-    except Exception as e:
-        return f"❌ Error adding item: {e}"
-
-# ----------------------------
-# Search Lost Items
-# ----------------------------
-def search_items(text, image, max_results, min_score):
-    try:
-        vector = None
-        query_text = text.strip() if text else ""
-
-        if isinstance(image, Image.Image):
-            vector = encode_image(image)
-        elif text:
-            vector = encode_text(text)
-
-        results = []
-
-        # 1. Vector search
-        if vector is not None:
-            results = qclient.search(
-                collection_name=COLLECTION,
-                query_vector=vector.tolist(),
-                limit=int(max_results),
-                score_threshold=float(min_score),
-                with_payload=True,
-            )
-
-        # 2. Fallback text search on payload
-        if query_text:
-            keyword_results = qclient.scroll(
-                collection_name=COLLECTION,
-                scroll_filter=rest.Filter(
-                    must=[rest.FieldCondition(
-                        key="text",
-                        match=rest.MatchText(text=query_text)
-                    )]
-                ),
-                limit=100,
-                with_payload=True
-            )[0]
-
-            existing_ids = {r.id for r in results}
-            for km in keyword_results:
-                if km.id not in existing_ids:
-                    km.score = 1.0
-                    results.append(km)
-
-        if not results:
-            return "No matches found.", []
-
-        # Format output
-        text_out, gallery = [], []
-        for r in results[:max_results]:
-            payload = r.payload or {}
-            score = getattr(r, "score", 0)
-            uploader_name = payload.get("uploader_name", "N/A")
-            uploader_phone = payload.get("uploader_phone", "N/A")
-            desc = (
-                f"id:{r.id} | score:{score:.3f} | "
-                f"text:{payload.get('text','')} | "
-                f"finder:{uploader_name} ({uploader_phone})"
-            )
-            text_out.append(desc)
-            img_path = payload.get("image_path")
-            if img_path and os.path.exists(img_path):
-                gallery.append(img_path)
-
-        return "\n".join(text_out), gallery
-    except Exception as e:
-        return f"❌ Error: {e}", []
-
-# ----------------------------
+    outputs = []
+    for r in results:
+        desc = r.payload.get("description", "No description")
+        img = r.payload.get("image_path", None)
+        score = round(r.score, 3)
+        if img:
+            outputs.append((img, f"{desc} (score: {score})"))
+        else:
+            outputs.append((None, f"{desc} (score: {score})"))
+
+    return outputs
+
+# --------------------------
 # Gradio UI
-# ----------------------------
-with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
+# --------------------------
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
     with gr.Tab("➕ Add Found Item"):
-        desc_in = gr.Textbox(label="Description", placeholder="Describe the item...")
-        img_in = gr.Image(label="Upload Image", type="pil")
-        uploader_name = gr.Textbox(label="Finder's Name")
-        uploader_phone = gr.Textbox(label="Finder's Phone")
+        with gr.Row():
+            desc_in = gr.Textbox(label="Item Description")
+            img_in = gr.Image(type="pil", label="Upload Image")
         add_btn = gr.Button("Add Item")
         add_out = gr.Textbox(label="Status")
-        add_btn.click(
-            add_item,
-            inputs=[desc_in, img_in, uploader_name, uploader_phone],
-            outputs=[add_out]
-        )
+        add_btn.click(fn=add_item, inputs=[desc_in, img_in], outputs=add_out)
 
     with gr.Tab("🔍 Search Lost Item"):
-        text_in = gr.Textbox(label="Search by Text (optional)")
-        img_in_search = gr.Image(label="Search by Image (optional)", type="pil")
-        max_res = gr.Slider(1, 20, value=5, step=1, label="Max Results")
-        min_score = gr.Slider(0, 1, value=0.3, step=0.01, label="Min Similarity Score")
+        query_text = gr.Textbox(label="Search by Text (optional)")
+        query_img = gr.Image(type="pil", label="Search by Image (optional)")
+        max_results = gr.Slider(1, 20, step=1, value=5, label="Max Results")
+        min_score = gr.Slider(0.0, 1.0, step=0.01, value=0.3, label="Min Similarity Score")
         search_btn = gr.Button("Search")
-        result_text = gr.Textbox(label="Search Results (Text)")
-        result_gallery = gr.Gallery(label="Search Results (Images)").style(grid=3)
-        search_btn.click(
-            search_items,
-            inputs=[text_in, img_in_search, max_res, min_score],
-            outputs=[result_text, result_gallery]
-        )
+        results_out = gr.Gallery(label="Search Results").style(grid=2, height="auto")
+        search_btn.click(fn=search_items, inputs=[query_text, query_img, max_results, min_score], outputs=results_out)
 
     with gr.Tab("⚙️ Admin"):
-        gr.Markdown("Admin dashboard placeholder...")
+        gr.Markdown("Admin dashboard (future expansion).")
 
+# --------------------------
+# Run App
+# --------------------------
 if __name__ == "__main__":
-    import torch
     demo.launch(server_name="0.0.0.0", server_port=7860)