Update app.py

app.py

@@ -162,7 +162,7 @@ def enhance_image_with_codeformer(rgb_img, temp_dir=None):
     python_cmd = sys.executable if sys.executable else "python3"
     cmd = (
         f"{python_cmd} {CODEFORMER_PATH} "
-        f"-w 0.4 "
+        f"-w 0.7 "
         f"--input_path {input_path} "
         f"--output_path {temp_dir} "
         f"--bg_upsampler realesrgan "
@@ -182,168 +182,73 @@ def enhance_image_with_codeformer(rgb_img, temp_dir=None):
     enhanced = cv2.imread(final_path)
     return cv2.cvtColor(enhanced, cv2.COLOR_BGR2RGB)
     
-import numpy as np
-from sklearn.metrics.pairwise import cosine_similarity
-
-SIM_THRESHOLD = 0.35   # strict
-MAX_YAW = 35
-MAX_PITCH = 25
-MIN_FACE_AREA = 10000
-
-
-def face_ok(face):
-    yaw, pitch, roll = face.pose
-    x1, y1, x2, y2 = face.bbox
-    area = (x2 - x1) * (y2 - y1)
-
-    return (
-        abs(yaw) <= MAX_YAW and
-        abs(pitch) <= MAX_PITCH and
-        area >= MIN_FACE_AREA
-    )
-
-
-def quality_score(face):
-    yaw, pitch, roll = face.pose
-    x1, y1, x2, y2 = face.bbox
-    area = (x2 - x1) * (y2 - y1)
-    return area - abs(yaw)*200 - abs(pitch)*150
-
-
-def multi_face_swap_industry(src_img, tgt_img):
-    """
-    Industry-grade 2-face swap
-    Returns swapped RGB image or raises error
-    """
-
+def multi_face_swap(src_img, tgt_img):
     src_bgr = cv2.cvtColor(src_img, cv2.COLOR_RGB2BGR)
     tgt_bgr = cv2.cvtColor(tgt_img, cv2.COLOR_RGB2BGR)
 
     src_faces = face_analysis_app.get(src_bgr)
     tgt_faces = face_analysis_app.get(tgt_bgr)
 
-    if len(src_faces) < 1 or len(tgt_faces) < 1:
+    if not src_faces or not tgt_faces:
         raise ValueError("No faces detected")
 
-    if len(src_faces) > 2 or len(tgt_faces) > 2:
-        raise ValueError("More than 2 faces detected (blocked)")
-
-    # ---- Quality filtering ----
-    src_faces = [f for f in src_faces if face_ok(f)]
-    tgt_faces = [f for f in tgt_faces if face_ok(f)]
+    def face_sort_key(face):
+        x1, y1, x2, y2 = face.bbox
+        area = (x2 - x1) * (y2 - y1)
+        cx = (x1 + x2) / 2
+        return (-area, cx)
 
-    if not src_faces or not tgt_faces:
-        raise ValueError("Faces rejected due to pose/quality")
+    # Split by gender
+    src_male = [f for f in src_faces if f.gender == 1]
+    src_female = [f for f in src_faces if f.gender == 0]
 
-    # ---- Sort by quality (best first) ----
-    src_faces = sorted(src_faces, key=quality_score, reverse=True)
-    tgt_faces = sorted(tgt_faces, key=quality_score, reverse=True)
+    tgt_male = [f for f in tgt_faces if f.gender == 1]
+    tgt_female = [f for f in tgt_faces if f.gender == 0]
 
-    # ---- Extract embeddings ----
-    src_embs = np.array([f.normed_embedding for f in src_faces])
-    tgt_embs = np.array([f.normed_embedding for f in tgt_faces])
+    # Sort inside gender groups
+    src_male = sorted(src_male, key=face_sort_key)
+    src_female = sorted(src_female, key=face_sort_key)
 
-    sim = cosine_similarity(src_embs, tgt_embs)
+    tgt_male = sorted(tgt_male, key=face_sort_key)
+    tgt_female = sorted(tgt_female, key=face_sort_key)
 
-    used_tgts = set()
+    # Build final swap pairs
     pairs = []
 
-    for i in range(len(src_faces)):
-        j = np.argmax(sim[i])
-        score = sim[i][j]
+    for s, t in zip(src_male, tgt_male):
+        pairs.append((s, t))
 
-        if score < SIM_THRESHOLD:
-            raise ValueError(f"Low identity similarity ({score:.2f})")
+    for s, t in zip(src_female, tgt_female):
+        pairs.append((s, t))
 
-        if j in used_tgts:
-            continue
+    # Fallback if gender mismatch
+    if not pairs:
+        src_faces = sorted(src_faces, key=face_sort_key)
+        tgt_faces = sorted(tgt_faces, key=face_sort_key)
+        pairs = list(zip(src_faces, tgt_faces))
 
-        pairs.append((src_faces[i], tgt_faces[j], score))
-        used_tgts.add(j)
+    result_img = tgt_bgr.copy()
 
-    if not pairs:
-        raise ValueError("No valid face pairs")
+    for src_face, _ in pairs:
+        # 🔁 re-detect current target faces
+        current_faces = face_analysis_app.get(result_img)
+        current_faces = sorted(current_faces, key=face_sort_key)
 
-    # ---- Swap WITHOUT re-detection ----
-    result = tgt_bgr.copy()
+        # choose best matching gender
+        candidates = [
+            f for f in current_faces if f.gender == src_face.gender
+        ] or current_faces
 
-    for src_face, tgt_face, score in pairs:
-        result = swapper.get(
-            result,
-            tgt_face,
+        target_face = candidates[0]
+
+        result_img = swapper.get(
+            result_img,
+            target_face,
             src_face,
             paste_back=True
         )
 
-    return cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
-    
-# def multi_face_swap(src_img, tgt_img):
-#     src_bgr = cv2.cvtColor(src_img, cv2.COLOR_RGB2BGR)
-#     tgt_bgr = cv2.cvtColor(tgt_img, cv2.COLOR_RGB2BGR)
-
-#     src_faces = face_analysis_app.get(src_bgr)
-#     tgt_faces = face_analysis_app.get(tgt_bgr)
-
-#     if not src_faces or not tgt_faces:
-#         raise ValueError("No faces detected")
-
-#     def face_sort_key(face):
-#         x1, y1, x2, y2 = face.bbox
-#         area = (x2 - x1) * (y2 - y1)
-#         cx = (x1 + x2) / 2
-#         return (-area, cx)
-
-#     # Split by gender
-#     src_male = [f for f in src_faces if f.gender == 1]
-#     src_female = [f for f in src_faces if f.gender == 0]
-
-#     tgt_male = [f for f in tgt_faces if f.gender == 1]
-#     tgt_female = [f for f in tgt_faces if f.gender == 0]
-
-#     # Sort inside gender groups
-#     src_male = sorted(src_male, key=face_sort_key)
-#     src_female = sorted(src_female, key=face_sort_key)
-
-#     tgt_male = sorted(tgt_male, key=face_sort_key)
-#     tgt_female = sorted(tgt_female, key=face_sort_key)
-
-#     # Build final swap pairs
-#     pairs = []
-
-#     for s, t in zip(src_male, tgt_male):
-#         pairs.append((s, t))
-
-#     for s, t in zip(src_female, tgt_female):
-#         pairs.append((s, t))
-
-#     # Fallback if gender mismatch
-#     if not pairs:
-#         src_faces = sorted(src_faces, key=face_sort_key)
-#         tgt_faces = sorted(tgt_faces, key=face_sort_key)
-#         pairs = list(zip(src_faces, tgt_faces))
-
-#     result_img = tgt_bgr.copy()
-
-#     for src_face, _ in pairs:
-#         # 🔁 re-detect current target faces
-#         current_faces = face_analysis_app.get(result_img)
-#         current_faces = sorted(current_faces, key=face_sort_key)
-
-#         # choose best matching gender
-#         candidates = [
-#             f for f in current_faces if f.gender == src_face.gender
-#         ] or current_faces
-
-#         target_face = candidates[0]
-
-#         result_img = swapper.get(
-#             result_img,
-#             target_face,
-#             src_face,
-#             paste_back=True
-#         )
-
-#     return cv2.cvtColor(result_img, cv2.COLOR_BGR2RGB)
+    return cv2.cvtColor(result_img, cv2.COLOR_BGR2RGB)
 
 
 
@@ -366,16 +271,14 @@ def face_swap_and_enhance(src_img, tgt_img, temp_dir=None):
                 return None, None, "❌ Face not detected in one of the images"
 
             swapped_path = os.path.join(temp_dir, f"swapped_{uuid.uuid4().hex[:8]}.jpg")
-            swapped_rgb = multi_face_swap_industry(src_img, tgt_img)
-            swapped_bgr = cv2.cvtColor(swapped_rgb, cv2.COLOR_RGB2BGR)
-
+            swapped_bgr = swapper.get(tgt_bgr, tgt_faces[0], src_faces[0])
             if swapped_bgr is None:
                 return None, None, "❌ Face swap failed"
 
             cv2.imwrite(swapped_path, swapped_bgr)
 
             python_cmd = sys.executable if sys.executable else "python3"
-            cmd = f"{python_cmd} {CODEFORMER_PATH} -w 0.4 --input_path {swapped_path} --output_path {temp_dir} --bg_upsampler realesrgan --face_upsample"
+            cmd = f"{python_cmd} {CODEFORMER_PATH} -w 0.7 --input_path {swapped_path} --output_path {temp_dir} --bg_upsampler realesrgan --face_upsample"
             result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
             if result.returncode != 0:
                 return None, None, f"❌ CodeFormer failed:\n{result.stderr}"
@@ -476,7 +379,7 @@ def build_multi_faceswap_gradio():
 
         def process(src_img, tgt_img):
             try:
-                swapped = multi_face_swap_industry(src_img, tgt_img)
+                swapped = multi_face_swap(src_img, tgt_img)
                 enhanced = enhance_image_with_codeformer(swapped)
                 return enhanced, ""
             except Exception as e:
@@ -896,7 +799,6 @@ fastapi_app = mount_gradio_app(
 if __name__ == "__main__":
     uvicorn.run(fastapi_app, host="0.0.0.0", port=7860)
 
-
 # # --------------------- List Images Endpoint ---------------------
 # import os
 # os.environ["OMP_NUM_THREADS"] = "1"
@@ -907,6 +809,8 @@ if __name__ == "__main__":
 # import threading
 # import subprocess
 # import logging
+# import tempfile
+# import sys
 # from datetime import datetime,timedelta
 
 # import insightface
@@ -917,10 +821,13 @@ if __name__ == "__main__":
 # from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 # from motor.motor_asyncio import AsyncIOMotorClient
 # from bson import ObjectId
-# import requests
+# from bson.errors import InvalidId
+# import httpx
 # import uvicorn
 # import gradio as gr
 # from gradio import mount_gradio_app
+# from PIL import Image
+# import io
 
 # # DigitalOcean Spaces
 # import boto3
@@ -1045,10 +952,208 @@ if __name__ == "__main__":
 # # --------------------- Face Swap Pipeline ---------------------
 # swap_lock = threading.Lock()
 
-# def face_swap_and_enhance(src_img, tgt_img, temp_dir="/tmp/faceswap_work"):
+# def enhance_image_with_codeformer(rgb_img, temp_dir=None):
+#     if temp_dir is None:
+#         temp_dir = os.path.join(tempfile.gettempdir(), f"enhance_{uuid.uuid4().hex[:8]}")
+#     os.makedirs(temp_dir, exist_ok=True)
+
+#     input_path = os.path.join(temp_dir, "input.jpg")
+#     cv2.imwrite(input_path, cv2.cvtColor(rgb_img, cv2.COLOR_RGB2BGR))
+
+#     python_cmd = sys.executable if sys.executable else "python3"
+#     cmd = (
+#         f"{python_cmd} {CODEFORMER_PATH} "
+#         f"-w 0.4 "
+#         f"--input_path {input_path} "
+#         f"--output_path {temp_dir} "
+#         f"--bg_upsampler realesrgan "
+#         f"--face_upsample"
+#     )
+
+#     result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+#     if result.returncode != 0:
+#         raise RuntimeError(result.stderr)
+
+#     final_dir = os.path.join(temp_dir, "final_results")
+#     files = [f for f in os.listdir(final_dir) if f.endswith(".png")]
+#     if not files:
+#         raise RuntimeError("No enhanced output")
+
+#     final_path = os.path.join(final_dir, files[0])
+#     enhanced = cv2.imread(final_path)
+#     return cv2.cvtColor(enhanced, cv2.COLOR_BGR2RGB)
+    
+# import numpy as np
+# from sklearn.metrics.pairwise import cosine_similarity
+
+# SIM_THRESHOLD = 0.35   # strict
+# MAX_YAW = 35
+# MAX_PITCH = 25
+# MIN_FACE_AREA = 10000
+
+
+# def face_ok(face):
+#     yaw, pitch, roll = face.pose
+#     x1, y1, x2, y2 = face.bbox
+#     area = (x2 - x1) * (y2 - y1)
+
+#     return (
+#         abs(yaw) <= MAX_YAW and
+#         abs(pitch) <= MAX_PITCH and
+#         area >= MIN_FACE_AREA
+#     )
+
+
+# def quality_score(face):
+#     yaw, pitch, roll = face.pose
+#     x1, y1, x2, y2 = face.bbox
+#     area = (x2 - x1) * (y2 - y1)
+#     return area - abs(yaw)*200 - abs(pitch)*150
+
+
+# def multi_face_swap_industry(src_img, tgt_img):
+#     """
+#     Industry-grade 2-face swap
+#     Returns swapped RGB image or raises error
+#     """
+
+#     src_bgr = cv2.cvtColor(src_img, cv2.COLOR_RGB2BGR)
+#     tgt_bgr = cv2.cvtColor(tgt_img, cv2.COLOR_RGB2BGR)
+
+#     src_faces = face_analysis_app.get(src_bgr)
+#     tgt_faces = face_analysis_app.get(tgt_bgr)
+
+#     if len(src_faces) < 1 or len(tgt_faces) < 1:
+#         raise ValueError("No faces detected")
+
+#     if len(src_faces) > 2 or len(tgt_faces) > 2:
+#         raise ValueError("More than 2 faces detected (blocked)")
+
+#     # ---- Quality filtering ----
+#     src_faces = [f for f in src_faces if face_ok(f)]
+#     tgt_faces = [f for f in tgt_faces if face_ok(f)]
+
+#     if not src_faces or not tgt_faces:
+#         raise ValueError("Faces rejected due to pose/quality")
+
+#     # ---- Sort by quality (best first) ----
+#     src_faces = sorted(src_faces, key=quality_score, reverse=True)
+#     tgt_faces = sorted(tgt_faces, key=quality_score, reverse=True)
+
+#     # ---- Extract embeddings ----
+#     src_embs = np.array([f.normed_embedding for f in src_faces])
+#     tgt_embs = np.array([f.normed_embedding for f in tgt_faces])
+
+#     sim = cosine_similarity(src_embs, tgt_embs)
+
+#     used_tgts = set()
+#     pairs = []
+
+#     for i in range(len(src_faces)):
+#         j = np.argmax(sim[i])
+#         score = sim[i][j]
+
+#         if score < SIM_THRESHOLD:
+#             raise ValueError(f"Low identity similarity ({score:.2f})")
+
+#         if j in used_tgts:
+#             continue
+
+#         pairs.append((src_faces[i], tgt_faces[j], score))
+#         used_tgts.add(j)
+
+#     if not pairs:
+#         raise ValueError("No valid face pairs")
+
+#     # ---- Swap WITHOUT re-detection ----
+#     result = tgt_bgr.copy()
+
+#     for src_face, tgt_face, score in pairs:
+#         result = swapper.get(
+#             result,
+#             tgt_face,
+#             src_face,
+#             paste_back=True
+#         )
+
+#     return cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
+    
+# # def multi_face_swap(src_img, tgt_img):
+# #     src_bgr = cv2.cvtColor(src_img, cv2.COLOR_RGB2BGR)
+# #     tgt_bgr = cv2.cvtColor(tgt_img, cv2.COLOR_RGB2BGR)
+
+# #     src_faces = face_analysis_app.get(src_bgr)
+# #     tgt_faces = face_analysis_app.get(tgt_bgr)
+
+# #     if not src_faces or not tgt_faces:
+# #         raise ValueError("No faces detected")
+
+# #     def face_sort_key(face):
+# #         x1, y1, x2, y2 = face.bbox
+# #         area = (x2 - x1) * (y2 - y1)
+# #         cx = (x1 + x2) / 2
+# #         return (-area, cx)
+
+# #     # Split by gender
+# #     src_male = [f for f in src_faces if f.gender == 1]
+# #     src_female = [f for f in src_faces if f.gender == 0]
+
+# #     tgt_male = [f for f in tgt_faces if f.gender == 1]
+# #     tgt_female = [f for f in tgt_faces if f.gender == 0]
+
+# #     # Sort inside gender groups
+# #     src_male = sorted(src_male, key=face_sort_key)
+# #     src_female = sorted(src_female, key=face_sort_key)
+
+# #     tgt_male = sorted(tgt_male, key=face_sort_key)
+# #     tgt_female = sorted(tgt_female, key=face_sort_key)
+
+# #     # Build final swap pairs
+# #     pairs = []
+
+# #     for s, t in zip(src_male, tgt_male):
+# #         pairs.append((s, t))
+
+# #     for s, t in zip(src_female, tgt_female):
+# #         pairs.append((s, t))
+
+# #     # Fallback if gender mismatch
+# #     if not pairs:
+# #         src_faces = sorted(src_faces, key=face_sort_key)
+# #         tgt_faces = sorted(tgt_faces, key=face_sort_key)
+# #         pairs = list(zip(src_faces, tgt_faces))
+
+# #     result_img = tgt_bgr.copy()
+
+# #     for src_face, _ in pairs:
+# #         # 🔁 re-detect current target faces
+# #         current_faces = face_analysis_app.get(result_img)
+# #         current_faces = sorted(current_faces, key=face_sort_key)
+
+# #         # choose best matching gender
+# #         candidates = [
+# #             f for f in current_faces if f.gender == src_face.gender
+# #         ] or current_faces
+
+# #         target_face = candidates[0]
+
+# #         result_img = swapper.get(
+# #             result_img,
+# #             target_face,
+# #             src_face,
+# #             paste_back=True
+# #         )
+
+# #     return cv2.cvtColor(result_img, cv2.COLOR_BGR2RGB)
+
+
+
+# def face_swap_and_enhance(src_img, tgt_img, temp_dir=None):
 #     try:
 #         with swap_lock:
 #             # Use a temp dir for intermediate files
+#             if temp_dir is None:
+#                 temp_dir = os.path.join(tempfile.gettempdir(), f"faceswap_work_{uuid.uuid4().hex[:8]}")
 #             if os.path.exists(temp_dir):
 #                 shutil.rmtree(temp_dir)
 #             os.makedirs(temp_dir, exist_ok=True)
@@ -1062,13 +1167,16 @@ if __name__ == "__main__":
 #                 return None, None, "❌ Face not detected in one of the images"
 
 #             swapped_path = os.path.join(temp_dir, f"swapped_{uuid.uuid4().hex[:8]}.jpg")
-#             swapped_bgr = swapper.get(tgt_bgr, tgt_faces[0], src_faces[0])
+#             swapped_rgb = multi_face_swap_industry(src_img, tgt_img)
+#             swapped_bgr = cv2.cvtColor(swapped_rgb, cv2.COLOR_RGB2BGR)
+
 #             if swapped_bgr is None:
 #                 return None, None, "❌ Face swap failed"
 
 #             cv2.imwrite(swapped_path, swapped_bgr)
 
-#             cmd = f"python {CODEFORMER_PATH} -w 0.7 --input_path {swapped_path} --output_path {temp_dir} --bg_upsampler realesrgan --face_upsample"
+#             python_cmd = sys.executable if sys.executable else "python3"
+#             cmd = f"{python_cmd} {CODEFORMER_PATH} -w 0.4 --input_path {swapped_path} --output_path {temp_dir} --bg_upsampler realesrgan --face_upsample"
 #             result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
 #             if result.returncode != 0:
 #                 return None, None, f"❌ CodeFormer failed:\n{result.stderr}"
@@ -1079,31 +1187,59 @@ if __name__ == "__main__":
 #                 return None, None, "❌ No enhanced image found"
 
 #             final_path = os.path.join(final_results_dir, final_files[0])
-#             final_img = cv2.cvtColor(cv2.imread(final_path), cv2.COLOR_BGR2RGB)
+#             final_img_bgr = cv2.imread(final_path)
+#             if final_img_bgr is None:
+#                 return None, None, "❌ Failed to read enhanced image file"
+#             final_img = cv2.cvtColor(final_img_bgr, cv2.COLOR_BGR2RGB)
 
 #             return final_img, final_path, ""
 
 #     except Exception as e:
 #         return None, None, f"❌ Error: {str(e)}"
+        
+# def compress_image(
+#     image_bytes: bytes,
+#     max_size=(1280, 1280),   # max width/height
+#     quality=75               # JPEG quality (60–80 is ideal)
+# ) -> bytes:
+#     """
+#     Compress image by resizing and lowering quality.
+#     Returns compressed image bytes.
+#     """
+#     img = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+
+#     # Resize while maintaining aspect ratio
+#     img.thumbnail(max_size, Image.LANCZOS)
+
+#     output = io.BytesIO()
+#     img.save(
+#         output,
+#         format="JPEG",
+#         quality=quality,
+#         optimize=True,
+#         progressive=True
+#     )
+
+#     return output.getvalue()
 
 # # --------------------- Gradio ---------------------
-# with gr.Blocks() as demo:
-#     gr.Markdown("Face Swap")
+# # with gr.Blocks() as demo:
+# #     gr.Markdown("Face Swap")
 
-#     with gr.Row():
-#         src_input = gr.Image(type="numpy", label="Upload Your Face")
-#         tgt_input = gr.Image(type="numpy", label="Upload Target Image")
+# #     with gr.Row():
+# #         src_input = gr.Image(type="numpy", label="Upload Your Face")
+# #         tgt_input = gr.Image(type="numpy", label="Upload Target Image")
 
-#     btn = gr.Button("Swap Face")
-#     output_img = gr.Image(type="numpy", label="Enhanced Output")
-#     download = gr.File(label="⬇️ Download Enhanced Image")
-#     error_box = gr.Textbox(label="Logs / Errors", interactive=False)
+# #     btn = gr.Button("Swap Face")
+# #     output_img = gr.Image(type="numpy", label="Enhanced Output")
+# #     download = gr.File(label="⬇️ Download Enhanced Image")
+# #     error_box = gr.Textbox(label="Logs / Errors", interactive=False)
 
-#     def process(src, tgt):
-#         img, path, err = face_swap_and_enhance(src, tgt)
-#         return img, path, err
+# #     def process(src, tgt):
+# #         img, path, err = face_swap_and_enhance(src, tgt)
+# #         return img, path, err
 
-#     btn.click(process, [src_input, tgt_input], [output_img, download, error_box])
+# #     btn.click(process, [src_input, tgt_input], [output_img, download, error_box])
 
 # # --------------------- DigitalOcean Spaces Helper ---------------------
 # def get_spaces_client():
@@ -1128,10 +1264,34 @@ if __name__ == "__main__":
 #     obj = client.get_object(Bucket=DO_SPACES_BUCKET, Key=key)
 #     return obj['Body'].read()
 
+# def build_multi_faceswap_gradio():
+#     with gr.Blocks() as demo:
+#         gr.Markdown("## 👩‍❤️‍👨 Multi Face Swap (Couple → Couple)")
+
+#         with gr.Row():
+#             src = gr.Image(type="numpy", label="Source Image (2 Faces)")
+#             tgt = gr.Image(type="numpy", label="Target Image (2 Faces)")
+
+#         out = gr.Image(type="numpy", label="Swapped Result")
+#         error = gr.Textbox(label="Logs", interactive=False)
+
+#         def process(src_img, tgt_img):
+#             try:
+#                 swapped = multi_face_swap_industry(src_img, tgt_img)
+#                 enhanced = enhance_image_with_codeformer(swapped)
+#                 return enhanced, ""
+#             except Exception as e:
+#                 return None, str(e)
+
+#         btn = gr.Button("Swap Faces")
+#         btn.click(process, [src, tgt], [out, error])
+
+#     return demo
+
 # # --------------------- API Endpoints ---------------------
 # @fastapi_app.get("/")
 # def root():
-#     return RedirectResponse("/gradio")
+#     return {"status": "healthy"}
 
 # @fastapi_app.get("/health")
 # async def health():
@@ -1221,12 +1381,19 @@ if __name__ == "__main__":
 #             # ------------------------------------------------------------------#
 #             if user_id:
 #                 try:
-#                     user_oid = ObjectId(user_id.strip())
+#                     user_id_clean = user_id.strip()
+#                     if not user_id_clean:
+#                         raise ValueError("user_id cannot be empty")
+#                     try:
+#                         user_oid = ObjectId(user_id_clean)
+#                     except (InvalidId, ValueError) as e:
+#                         logger.error(f"Invalid user_id format: {user_id_clean}")
+#                         raise ValueError(f"Invalid user_id format: {user_id_clean}")
+                    
 #                     now = datetime.utcnow()
             
 #                     # Normalize dates (UTC midnight)
 #                     today_date = datetime(now.year, now.month, now.day)
-#                     yesterday_date = today_date - timedelta(days=1)
             
 #                     # -------------------------------------------------
 #                     # STEP 1: Ensure root document exists
@@ -1340,6 +1507,29 @@ if __name__ == "__main__":
 #                                 }
 #                             }
 #                         )
+                    
+#                     # -------------------------------------------------
+#                     # STEP 5: Sort subCategories by lastClickedAt (ascending - oldest first)
+#                     # -------------------------------------------------
+#                     user_doc = await media_clicks_col.find_one({"userId": user_oid})
+#                     if user_doc and "subCategories" in user_doc:
+#                         subcategories = user_doc["subCategories"]
+#                         # Sort by lastClickedAt in ascending order (oldest first)
+#                         # Handle missing or None dates by using datetime.min
+#                         subcategories_sorted = sorted(
+#                             subcategories,
+#                             key=lambda x: x.get("lastClickedAt") if x.get("lastClickedAt") is not None else datetime.min
+#                         )
+#                         # Update with sorted array
+#                         await media_clicks_col.update_one(
+#                             {"userId": user_oid},
+#                             {
+#                                 "$set": {
+#                                     "subCategories": subcategories_sorted,
+#                                     "updatedAt": now
+#                                 }
+#                             }
+#                         )
             
 #                     logger.info(
 #                         "[MEDIA_CLICK] user=%s subCategory=%s ai_edit_complete++ daily_tracked",
@@ -1410,7 +1600,10 @@ if __name__ == "__main__":
 # #         # ------------------------------------------------------------------
 # #         # DOWNLOAD TARGET IMAGE
 # #         # ------------------------------------------------------------------
-#         tgt_bytes = requests.get(target_url).content
+#         async with httpx.AsyncClient(timeout=30.0) as client:
+#             response = await client.get(target_url)
+#             response.raise_for_status()
+#             tgt_bytes = response.content
 
 #         src_bgr = cv2.imdecode(np.frombuffer(src_bytes, np.uint8), cv2.IMREAD_COLOR)
 #         tgt_bgr = cv2.imdecode(np.frombuffer(tgt_bytes, np.uint8), cv2.IMREAD_COLOR)
@@ -1433,6 +1626,21 @@ if __name__ == "__main__":
 
 #         result_key = f"faceswap/result/{uuid.uuid4().hex}_enhanced.png"
 #         result_url = upload_to_spaces(result_bytes, result_key)
+#         # -------------------------------------------------
+#         # COMPRESS IMAGE (2–3 MB target)
+#         # -------------------------------------------------
+#         compressed_bytes = compress_image(
+#             image_bytes=result_bytes,
+#             max_size=(1280, 1280),
+#             quality=72
+#         )
+        
+#         compressed_key = f"faceswap/result/{uuid.uuid4().hex}_enhanced_compressed.jpg"
+#         compressed_url = upload_to_spaces(
+#             compressed_bytes,
+#             compressed_key,
+#             content_type="image/jpeg"
+#         )
 #         end_time = datetime.utcnow()
 #         response_time_ms = (end_time - start_time).total_seconds() * 1000
 
@@ -1447,7 +1655,8 @@ if __name__ == "__main__":
 
 #         return {
 #             "result_key": result_key,
-#             "result_url": result_url
+#             "result_url": result_url,
+#             "Compressed_Image_URL": compressed_url
 #         }
         
 #     except Exception as e:
@@ -1477,7 +1686,13 @@ if __name__ == "__main__":
 #         headers={"Content-Disposition": "inline; filename=result.png"}
 #     )
 # # --------------------- Mount Gradio ---------------------
-# fastapi_app = mount_gradio_app(fastapi_app, demo, path="/gradio")
+
+# multi_faceswap_app = build_multi_faceswap_gradio()
+# fastapi_app = mount_gradio_app(
+#     fastapi_app,
+#     multi_faceswap_app,
+#     path="/gradio-multi"
+# )
 
 # if __name__ == "__main__":
 #     uvicorn.run(fastapi_app, host="0.0.0.0", port=7860)