Update app.py

app.py

@@ -5,7 +5,7 @@ import json
 import base64
 import logging
 import uuid
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Tuple
 
 from flask import Flask, request, jsonify
 from flask_cors import CORS
@@ -17,6 +17,17 @@ import cv2
 from google import genai
 from google.genai import types
 
+# Firebase Admin (in-memory JSON init)
+try:
+    import firebase_admin
+    from firebase_admin import credentials as fb_credentials, storage as fb_storage
+    FIREBASE_ADMIN_AVAILABLE = True
+except Exception:
+    firebase_admin = None
+    fb_credentials = None
+    fb_storage = None
+    FIREBASE_ADMIN_AVAILABLE = False
+
 logging.basicConfig(level=logging.INFO)
 log = logging.getLogger("wardrobe-server")
 
@@ -24,20 +35,91 @@ GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "")
 if not GEMINI_API_KEY:
     log.warning("GEMINI_API_KEY not set — gemini calls will fail.")
 
+# Firebase config (read service account JSON from env)
+FIREBASE_ADMIN_JSON = os.getenv("FIREBASE_ADMIN_JSON", "").strip()
+FIREBASE_STORAGE_BUCKET = os.getenv("FIREBASE_STORAGE_BUCKET", "").strip()  # optional override
+
+if FIREBASE_ADMIN_JSON and not FIREBASE_ADMIN_AVAILABLE:
+    log.warning("FIREBASE_ADMIN_JSON provided but firebase-admin SDK is not installed. Install firebase-admin.")
+
 client = genai.Client(api_key=GEMINI_API_KEY)
 
 app = Flask(__name__)
 CORS(app)
 
-# Helper: read uploaded image bytes -> BGR numpy
-def read_image_bytes(file_storage) -> (np.ndarray, int, int, bytes):
+# ---------- Firebase init helpers ----------
+_firebase_app = None
+
+def init_firebase_admin_if_needed():
+    global _firebase_app
+    if _firebase_app is not None:
+        return _firebase_app
+    if not FIREBASE_ADMIN_JSON:
+        log.info("No FIREBASE_ADMIN_JSON env var set; skipping Firebase admin init.")
+        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})
+        log.info("Initialized firebase admin with bucket: %s", bucket_name)
+        return _firebase_app
+    except Exception as e:
+        log.exception("Failed to initialize firebase admin: %s", e)
+        raise
+
+def upload_b64_to_firebase(base64_str: str, path: str, content_type="image/jpeg") -> str:
+    """
+    Upload base64 string to Firebase Storage at `path` (e.g. detected/uid/item.jpg).
+    Returns a public URL when possible, otherwise returns gs://<bucket>/<path>.
+    """
+    if not FIREBASE_ADMIN_JSON:
+        raise RuntimeError("FIREBASE_ADMIN_JSON not set")
+    init_firebase_admin_if_needed()
+    if not FIREBASE_ADMIN_AVAILABLE:
+        raise RuntimeError("firebase-admin not available")
+
+    # decode base64 (strip data:... prefix if present)
+    raw = base64_str
+    if raw.startswith("data:"):
+        raw = raw.split(",", 1)[1]
+    raw = raw.replace("\n", "").replace("\r", "")
+    data = base64.b64decode(raw)
+
+    try:
+        bucket = fb_storage.bucket()  # uses default bucket from app options
+        blob = bucket.blob(path)
+        blob.upload_from_string(data, content_type=content_type)
+        try:
+            blob.make_public()
+            return blob.public_url
+        except Exception as e:
+            log.warning("Could not make blob public: %s", e)
+            return f"gs://{bucket.name}/{path}"
+    except Exception as e:
+        log.exception("Firebase upload error for path %s: %s", path, e)
+        raise
+
+# ---------- Image helpers (unchanged) ----------
+def read_image_bytes(file_storage) -> Tuple[np.ndarray, int, int, bytes]:
     data = file_storage.read()
     img = Image.open(io.BytesIO(data)).convert("RGB")
     w, h = img.size
     arr = np.array(img)[:, :, ::-1]  # RGB -> BGR
     return arr, w, h, data
 
-# Helper: crop bgr image by pixel rect and return base64 jpeg
 def crop_and_b64(bgr_img: np.ndarray, x: int, y: int, w: int, h: int, max_side=512) -> str:
     h_img, w_img = bgr_img.shape[:2]
     x = max(0, int(x)); y = max(0, int(y))
@@ -53,7 +135,6 @@ def crop_and_b64(bgr_img: np.ndarray, x: int, y: int, w: int, h: int, max_side=5
     _, jpeg = cv2.imencode(".jpg", crop, [int(cv2.IMWRITE_JPEG_QUALITY), 82])
     return base64.b64encode(jpeg.tobytes()).decode("ascii")
 
-# Fallback: simple contour detection cropping
 def fallback_contour_crops(bgr_img, max_items=8) -> List[Dict[str, Any]]:
     gray = cv2.cvtColor(bgr_img, cv2.COLOR_BGR2GRAY)
     blur = cv2.GaussianBlur(gray, (7,7), 0)
@@ -105,12 +186,16 @@ def fallback_contour_crops(bgr_img, max_items=8) -> List[Dict[str, Any]]:
                 })
     return items
 
-# Main route: process image using Gemini for detection -> crop thumbnails with OpenCV
+# ---------- Main / processing ----------
 @app.route("/process", methods=["POST"])
 def process_image():
     if "photo" not in request.files:
         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:
         bgr_img, img_w, img_h, raw_bytes = read_image_bytes(file)
     except Exception as e:
@@ -127,15 +212,12 @@ def process_image():
         "Output ONLY valid JSON. If you cannot detect any clothing confidently, return {\"items\":[]}."
     )
 
-    # Prepare request contents: prompt text + image bytes
     try:
         contents = [
             types.Content(role="user", parts=[types.Part.from_text(text=user_prompt)])
         ]
-        # include image bytes as a user part (like other examples)
         contents.append(types.Content(role="user", parts=[types.Part.from_bytes(data=raw_bytes, mime_type="image/jpeg")]))
 
-        # Force JSON response schema: top-level object with items array
         schema = {
             "type": "object",
             "properties": {
@@ -166,13 +248,11 @@ def process_image():
 
         cfg = types.GenerateContentConfig(response_mime_type="application/json", response_schema=schema)
 
-        # Call Gemini model
         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 ""
         log.info("Gemini raw response length: %d", len(raw_text))
 
-        # Try parse JSON
         parsed = None
         try:
             parsed = json.loads(raw_text)
@@ -186,17 +266,14 @@ def process_image():
                 try:
                     label = str(it.get("label","unknown"))[:48]
                     bbox = it.get("bbox",{})
-                    # bbox in normalized coords -> to pixels
                     nx = float(bbox.get("x",0))
                     ny = float(bbox.get("y",0))
                     nw = float(bbox.get("w",0))
                     nh = float(bbox.get("h",0))
-                    # clamp 0..1
                     nx = max(0.0, min(1.0, nx)); ny = max(0.0,min(1.0,ny))
                     nw = max(0.0, min(1.0, nw)); nh = max(0.0, min(1.0, nh))
                     px = int(nx * img_w); py = int(ny * img_h)
                     pw = int(nw * img_w); ph = int(nh * img_h)
-                    # guard tiny
                     if pw <= 8 or ph <= 8:
                         continue
                     b64 = crop_and_b64(bgr_img, px, py, pw, ph)
@@ -213,17 +290,53 @@ def process_image():
                 except Exception as e:
                     log.warning("skipping item due to error: %s", e)
         else:
-            # Fallback to contour heuristic
             log.info("Gemini returned no items or parse failed — using fallback contour crops.")
             items_out = fallback_contour_crops(bgr_img, max_items=8)
 
+        # Try uploading thumbnails to Firebase Storage (if configured)
+        if FIREBASE_ADMIN_JSON and FIREBASE_ADMIN_AVAILABLE:
+            for itm in items_out:
+                b64 = itm.get("thumbnail_b64")
+                if not b64:
+                    continue
+                item_id = itm.get("id") or str(uuid.uuid4())
+                safe_uid = "".join(ch for ch in uid if ch.isalnum() or ch in ("-", "_")) or "anon"
+                path = f"detected/{safe_uid}/{item_id}.jpg"
+                try:
+                    url = upload_b64_to_firebase(b64, path, content_type="image/jpeg")
+                    itm["thumbnail_url"] = url
+                    # remove raw base64 to keep response small
+                    itm.pop("thumbnail_b64", None)
+                    log.debug("Uploaded thumbnail for %s -> %s", item_id, url)
+                except Exception as up_e:
+                    log.warning("Failed to upload thumbnail for %s: %s", item_id, up_e)
+                    # keep thumbnail_b64 as 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, "debug": {"raw_model_text": raw_text[:1600]}}), 200
 
     except Exception as ex:
         log.exception("Processing error: %s", ex)
-        # final fallback: contour crops
         try:
             items_out = fallback_contour_crops(bgr_img, max_items=8)
+            if FIREBASE_ADMIN_JSON and FIREBASE_ADMIN_AVAILABLE:
+                for itm in items_out:
+                    b64 = itm.get("thumbnail_b64")
+                    if not b64:
+                        continue
+                    item_id = itm.get("id") or str(uuid.uuid4())
+                    safe_uid = "".join(ch for ch in uid if ch.isalnum() or ch in ("-", "_")) or "anon"
+                    path = f"detected/{safe_uid}/{item_id}.jpg"
+                    try:
+                        url = upload_b64_to_firebase(b64, path, content_type="image/jpeg")
+                        itm["thumbnail_url"] = url
+                        itm.pop("thumbnail_b64", None)
+                    except Exception as up_e:
+                        log.warning("Failed to upload fallback thumbnail for %s: %s", item_id, up_e)
             return jsonify({"ok": True, "items": items_out, "debug": {"error": str(ex)}}), 200
         except Exception as e2:
             log.exception("Fallback also failed: %s", e2)