Update app.py

app.py

@@ -6,7 +6,7 @@ import base64
 import logging
 import uuid
 import time
-from typing import List, Dict, Any, Tuple
+from typing import List, Dict, Any, Tuple, Optional
 
 from flask import Flask, request, jsonify
 from flask_cors import CORS
@@ -36,7 +36,7 @@ GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "")
 if not GEMINI_API_KEY:
     log.warning("GEMINI_API_KEY not set — gemini calls will fail (but fallback still works).")
 
-client = genai.Client(api_key=GEMINI_API_KEY)
+client = genai.Client(api_key=GEMINI_API_KEY) if GEMINI_API_KEY else None
 
 # Firebase config (read service account JSON from env)
 FIREBASE_ADMIN_JSON = os.getenv("FIREBASE_ADMIN_JSON", "").strip()
@@ -60,18 +60,14 @@ def init_firebase_admin_if_needed():
         return None
     if not FIREBASE_ADMIN_AVAILABLE:
         raise RuntimeError("firebase-admin not installed (pip install firebase-admin)")
-
     try:
         sa_obj = json.loads(FIREBASE_ADMIN_JSON)
     except Exception as e:
         log.exception("Failed parsing FIREBASE_ADMIN_JSON: %s", e)
         raise
-
-    # determine bucket
     bucket_name = FIREBASE_STORAGE_BUCKET or (sa_obj.get("project_id") and f"{sa_obj.get('project_id')}.appspot.com")
     if not bucket_name:
         raise RuntimeError("Could not determine storage bucket. Set FIREBASE_STORAGE_BUCKET or include project_id in service account JSON.")
-
     try:
         cred = fb_credentials.Certificate(sa_obj)
         _firebase_app = firebase_admin.initialize_app(cred, {"storageBucket": bucket_name})
@@ -83,7 +79,7 @@ def init_firebase_admin_if_needed():
 
 def upload_b64_to_firebase(base64_str: str, path: str, content_type="image/jpeg", metadata: dict = None) -> str:
     """
-    Upload base64 string to Firebase Storage at `path` (e.g. detected/uid/item.jpg).
+    Upload base64 string to Firebase Storage at `path`.
     Optionally attach metadata dict (custom metadata).
     Returns a public URL when possible, otherwise returns gs://<bucket>/<path>.
     """
@@ -103,11 +99,10 @@ def upload_b64_to_firebase(base64_str: str, path: str, content_type="image/jpeg"
         bucket = fb_storage.bucket()
         blob = bucket.blob(path)
         blob.upload_from_string(data, content_type=content_type)
-        # attach metadata if provided
+        # attach metadata if provided (values must be strings)
         if metadata:
             try:
-                # google-cloud-storage uses blob.metadata (dict)
-                blob.metadata = metadata
+                blob.metadata = {k: (json.dumps(v) if not isinstance(v, str) else v) for k, v in metadata.items()}
                 blob.patch()
             except Exception as me:
                 log.warning("Failed to patch metadata for %s: %s", path, me)
@@ -132,7 +127,6 @@ def read_image_bytes(file_storage) -> Tuple[np.ndarray, int, int, bytes]:
     try:
         img = ImageOps.exif_transpose(img)
     except Exception:
-        # ignore if EXIF not present or transpose fails
         pass
     img = img.convert("RGB")
     w, h = img.size
@@ -146,7 +140,6 @@ def crop_and_b64(bgr_img: np.ndarray, x: int, y: int, w: int, h: int, max_side=5
     crop = bgr_img[y:y2, x:x2]
     if crop.size == 0:
         return ""
-    # resize if too large
     max_dim = max(crop.shape[0], crop.shape[1])
     if max_dim > max_side:
         scale = max_side / max_dim
@@ -185,7 +178,6 @@ def fallback_contour_crops(bgr_img, max_items=8) -> List[Dict[str, Any]]:
             "thumbnail_b64": b64,
             "source": "fallback"
         })
-    # if still none, split into grid
     if not items:
         h_half, w_half = h_img//2, w_img//2
         rects = [
@@ -205,6 +197,75 @@ def fallback_contour_crops(bgr_img, max_items=8) -> List[Dict[str, Any]]:
                 })
     return items
 
+# ---------- AI analysis helper ----------
+def analyze_crop_with_gemini(jpeg_b64: str) -> Dict[str, Any]:
+    """
+    Run Gemini on the cropped image bytes to extract:
+      type (one-word category like 'shoe', 'jacket', 'dress'),
+      summary (single-line description),
+      brand (string or empty),
+      tags (array of short descriptors)
+    Returns dict, falls back to empty/defaults on error or missing key.
+    """
+    if not client:
+        return {"type": "unknown", "summary": "", "brand": "", "tags": []}
+    try:
+        # prepare prompt
+        prompt = (
+            "You are an assistant that identifies clothing item characteristics from an image. "
+            "Return only a JSON object with keys: type (single word like 'shoe','top','jacket'), "
+            "summary (a single short sentence, one line), brand (brand name if visible else empty string), "
+            "tags (an array of short single-word tags describing visible attributes, e.g. ['striped','leather','white']). "
+            "Keep values short and concise."
+        )
+
+        contents = [
+            types.Content(role="user", parts=[types.Part.from_text(text=prompt)])
+        ]
+
+        # attach the image bytes
+        image_bytes = base64.b64decode(jpeg_b64)
+        contents.append(types.Content(role="user", parts=[types.Part.from_bytes(data=image_bytes, mime_type="image/jpeg")]))
+
+        schema = {
+            "type": "object",
+            "properties": {
+                "type": {"type": "string"},
+                "summary": {"type": "string"},
+                "brand": {"type": "string"},
+                "tags": {"type": "array", "items": {"type": "string"}}
+            },
+            "required": ["type", "summary"]
+        }
+        cfg = types.GenerateContentConfig(response_mime_type="application/json", response_schema=schema)
+
+        # call model (use the same model family you used before)
+        resp = client.models.generate_content(model="gemini-2.5-flash-lite", contents=contents, config=cfg)
+        text = resp.text or ""
+        parsed = {}
+        try:
+            parsed = json.loads(text)
+            # coerce expected shapes
+            parsed["type"] = str(parsed.get("type", "")).strip()
+            parsed["summary"] = str(parsed.get("summary", "")).strip()
+            parsed["brand"] = str(parsed.get("brand", "")).strip()
+            tags = parsed.get("tags", [])
+            if not isinstance(tags, list):
+                tags = []
+            parsed["tags"] = [str(t).strip() for t in tags if str(t).strip()]
+        except Exception as e:
+            log.warning("Failed parsing Gemini analysis JSON: %s — raw: %s", e, (text[:300] if text else ""))
+            parsed = {"type": "unknown", "summary": "", "brand": "", "tags": []}
+        return {
+            "type": parsed.get("type", "unknown") or "unknown",
+            "summary": parsed.get("summary", "") or "",
+            "brand": parsed.get("brand", "") or "",
+            "tags": parsed.get("tags", []) or []
+        }
+    except Exception as e:
+        log.exception("analyze_crop_with_gemini failure: %s", e)
+        return {"type": "unknown", "summary": "", "brand": "", "tags": []}
+
 # ---------- Main / processing ----------
 @app.route("/process", methods=["POST"])
 def process_image():
@@ -212,7 +273,6 @@ def process_image():
         return jsonify({"error": "missing photo"}), 400
     file = request.files["photo"]
 
-    # optional uid from form fields (client can supply for grouping)
     uid = (request.form.get("uid") or request.args.get("uid") or "anon").strip() or "anon"
 
     try:
@@ -221,10 +281,9 @@ def process_image():
         log.error("invalid image: %s", e)
         return jsonify({"error": "invalid image"}), 400
 
-    # generate a per-request session id used to mark temporary uploads
     session_id = str(uuid.uuid4())
 
-    # Build a prompt instructing Gemini to detect garments and return normalized bbox list
+    # Detection prompt (same as before)
     user_prompt = (
         "You are an assistant that extracts clothing detections from a single image. "
         "Return a JSON object with a single key 'items' which is an array. Each item must have: "
@@ -271,13 +330,13 @@ def process_image():
         cfg = types.GenerateContentConfig(response_mime_type="application/json", response_schema=schema)
 
         log.info("Calling Gemini model for detection (gemini-2.5-flash-lite)...")
-        model_resp = client.models.generate_content(model="gemini-2.5-flash-lite", contents=contents, config=cfg)
-        raw_text = model_resp.text or ""
+        model_resp = client.models.generate_content(model="gemini-2.5-flash-lite", contents=contents, config=cfg) if client else None
+        raw_text = (model_resp.text or "") if model_resp else ""
         log.info("Gemini raw response length: %d", len(raw_text))
 
         parsed = None
         try:
-            parsed = json.loads(raw_text)
+            parsed = json.loads(raw_text) if raw_text else None
         except Exception as e:
             log.warning("Could not parse Gemini JSON: %s", e)
             parsed = None
@@ -315,39 +374,59 @@ def process_image():
             log.info("Gemini returned no items or parse failed — using fallback contour crops.")
             items_out = fallback_contour_crops(bgr_img, max_items=8)
 
-        # === AUTO-UPLOAD all detection thumbnails to Firebase Storage (temporary, marked by session_id) ===
+        # Perform AI analysis per crop (if possible) and auto-upload to firebase with metadata (tmp + session)
         if FIREBASE_ADMIN_JSON and FIREBASE_ADMIN_AVAILABLE:
+            try:
+                init_firebase_admin_if_needed()
+                bucket = fb_storage.bucket()
+            except Exception as e:
+                log.exception("Firebase admin init for upload failed: %s", e)
+                bucket = None
+
             safe_uid = "".join(ch for ch in uid if ch.isalnum() or ch in ("-", "_")) or "anon"
             for itm in items_out:
                 b64 = itm.get("thumbnail_b64")
                 if not b64:
                     continue
+                # analyze
+                try:
+                    analysis = analyze_crop_with_gemini(b64) if client else {"type":"unknown","summary":"","brand":"","tags":[]}
+                except Exception as ae:
+                    log.warning("analysis failed: %s", ae)
+                    analysis = {"type":"unknown","summary":"","brand":"","tags":[]}
+
+                itm["analysis"] = analysis
+
                 item_id = itm.get("id") or str(uuid.uuid4())
                 path = f"detected/{safe_uid}/{item_id}.jpg"
                 try:
-                    meta = {
+                    metadata = {
                         "tmp": "true",
                         "session_id": session_id,
                         "uploaded_by": safe_uid,
-                        "uploaded_at": str(int(time.time()))
+                        "uploaded_at": str(int(time.time())),
+                        # store AI fields as JSON strings for later inspection
+                        "ai_type": analysis.get("type",""),
+                        "ai_brand": analysis.get("brand",""),
+                        "ai_summary": analysis.get("summary",""),
+                        "ai_tags": json.dumps(analysis.get("tags", [])),
                     }
-                    url = upload_b64_to_firebase(b64, path, content_type="image/jpeg", metadata=meta)
+                    url = upload_b64_to_firebase(b64, path, content_type="image/jpeg", metadata=metadata)
                     itm["thumbnail_url"] = url
-                    # remove raw base64 to keep response small
+                    itm["thumbnail_path"] = path
                     itm.pop("thumbnail_b64", None)
-                    # add session marker to response item
                     itm["_session_id"] = session_id
                     log.debug("Auto-uploaded thumbnail for %s -> %s (session=%s)", item_id, url, session_id)
                 except Exception as up_e:
                     log.warning("Auto-upload failed for %s: %s", item_id, up_e)
-                    # leave thumbnail_b64 for client fallback display
+                    # keep thumbnail_b64 and analysis for client fallback
         else:
             if not FIREBASE_ADMIN_JSON:
                 log.info("FIREBASE_ADMIN_JSON not set; skipping server-side thumbnail upload.")
             else:
                 log.info("Firebase admin SDK not available; skipping server-side thumbnail upload.")
 
-        return jsonify({"ok": True, "items": items_out, "session_id": session_id, "debug": {"raw_model_text": raw_text[:1600]}}), 200
+        return jsonify({"ok": True, "items": items_out, "session_id": session_id, "debug": {"raw_model_text": (raw_text or "")[:1600]}}), 200
 
     except Exception as ex:
         log.exception("Processing error: %s", ex)
@@ -406,18 +485,15 @@ def finalize_detections():
         blobs = list(bucket.list_blobs(prefix=prefix))
         for blob in blobs:
             try:
-                name = blob.name  # e.g. "detected/<safe_uid>/<itemid>.jpg"
+                name = blob.name
                 fname = name.split("/")[-1]
-                # only accept files of form <id>.<ext>
                 if "." not in fname:
-                    # skip unexpected filenames
                     continue
                 item_id = fname.rsplit(".", 1)[0]
 
                 md = blob.metadata or {}
-                # only consider temporary files that match this session id
+                # only consider temporary files matching this session id
                 if str(md.get("session_id", "")) != session_id or str(md.get("tmp", "")).lower() not in ("true", "1", "yes"):
-                    # skip (not part of this session / not temporary)
                     continue
 
                 if item_id in keep_ids:
@@ -427,9 +503,28 @@ def finalize_detections():
                         url = blob.public_url
                     except Exception:
                         url = f"gs://{bucket.name}/{name}"
-                    kept.append({"id": item_id, "thumbnail_url": url})
+
+                    # extract AI metadata (if present)
+                    ai_type = md.get("ai_type") or ""
+                    ai_brand = md.get("ai_brand") or ""
+                    ai_summary = md.get("ai_summary") or ""
+                    ai_tags_raw = md.get("ai_tags") or "[]"
+                    try:
+                        ai_tags = json.loads(ai_tags_raw) if isinstance(ai_tags_raw, str) else ai_tags_raw
+                    except Exception:
+                        ai_tags = []
+                    kept.append({
+                        "id": item_id,
+                        "thumbnail_url": url,
+                        "thumbnail_path": name,
+                        "analysis": {
+                          "type": ai_type,
+                          "brand": ai_brand,
+                          "summary": ai_summary,
+                          "tags": ai_tags
+                        }
+                    })
                 else:
-                    # delete unkept (safe: only temporary and session-matching files)
                     try:
                         blob.delete()
                         deleted.append(item_id)
@@ -442,6 +537,57 @@ def finalize_detections():
         log.exception("finalize_detections error: %s", e)
         return jsonify({"error": "internal", "detail": str(e)}), 500
 
+# ---------- Clear session: delete all temporary files for a session ----------
+@app.route("/clear_session", methods=["POST"])
+def clear_session():
+    """
+    Body JSON: { "session_id": "<id>", "uid": "<optional uid>" }
+    Deletes all detected/<uid>/* blobs where metadata.session_id == session_id and metadata.tmp == "true".
+    """
+    try:
+        body = request.get_json(force=True)
+    except Exception:
+        return jsonify({"error": "invalid json"}), 400
+
+    session_id = (body.get("session_id") or request.args.get("session_id") or "").strip()
+    uid = (body.get("uid") or request.args.get("uid") or "anon").strip() or "anon"
+
+    if not session_id:
+        return jsonify({"error": "session_id required"}), 400
+
+    if not FIREBASE_ADMIN_JSON or not FIREBASE_ADMIN_AVAILABLE:
+        return jsonify({"error": "firebase admin not configured"}), 500
+
+    try:
+        init_firebase_admin_if_needed()
+        bucket = fb_storage.bucket()
+    except Exception as e:
+        log.exception("Firebase init error in clear_session: %s", e)
+        return jsonify({"error": "firebase admin init failed", "detail": str(e)}), 500
+
+    safe_uid = "".join(ch for ch in uid if ch.isalnum() or ch in ("-", "_")) or "anon"
+    prefix = f"detected/{safe_uid}/"
+
+    deleted = []
+    errors = []
+    try:
+        blobs = list(bucket.list_blobs(prefix=prefix))
+        for blob in blobs:
+            try:
+                md = blob.metadata or {}
+                if str(md.get("session_id", "")) == session_id and str(md.get("tmp", "")).lower() in ("true", "1", "yes"):
+                    try:
+                        blob.delete()
+                        deleted.append(blob.name.split("/")[-1].rsplit(".", 1)[0])
+                    except Exception as de:
+                        errors.append({"blob": blob.name, "error": str(de)})
+            except Exception as e:
+                errors.append({"blob": getattr(blob, "name", None), "error": str(e)})
+        return jsonify({"ok": True, "deleted": deleted, "errors": errors}), 200
+    except Exception as e:
+        log.exception("clear_session error: %s", e)
+        return jsonify({"error": "internal", "detail": str(e)}), 500
+
 if __name__ == "__main__":
     port = int(os.getenv("PORT", 7860))
     log.info("Starting server on 0.0.0.0:%d", port)