Update app.py

app.py

@@ -6,16 +6,17 @@ from fastapi import FastAPI
 from pydantic import BaseModel
 import insightface
 import gradio as gr
+import uvicorn
 from fastapi.middleware.cors import CORSMiddleware
 
-# ---------- Load Face Detector + Recognition Model ----------
+# -------------------- Load Face Recognition Model --------------------
 model = insightface.app.FaceAnalysis(name="buffalo_l")
 model.prepare(ctx_id=0, det_size=(640, 640))
 
-# ---------- FastAPI App ----------
+# -------------------- FASTAPI APP --------------------
 app = FastAPI()
 
-# Add CORS for FlutterFlow
+# Allow all CORS (FlutterFlow)
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -24,71 +25,60 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# ---------- API Request Schema ----------
+# -------------------- Request Schema --------------------
 class CompareRequest(BaseModel):
-    image1: str | None = None     # base64
-    image2: str | None = None     # base64
-    image1_url: str | None = None # URL
-    image2_url: str | None = None # URL
+    image1: str | None = None
+    image2: str | None = None
+    image1_url: str | None = None
+    image2_url: str | None = None
 
-# ---------- Helper: Convert base64 to CV2 image ----------
+# -------------------- Helpers --------------------
 def b64_to_img(b64_string):
     try:
         img_data = base64.b64decode(b64_string)
-        np_arr = np.frombuffer(img_data, np.uint8)
-        img = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
-        return img
+        arr = np.frombuffer(img_data, np.uint8)
+        return cv2.imdecode(arr, cv2.IMREAD_COLOR)
     except:
         return None
 
-# ---------- Helper: Convert URL to CV2 image ----------
 def url_to_img(url):
     try:
-        resp = requests.get(url, timeout=10)
-        np_arr = np.frombuffer(resp.content, np.uint8)
-        img = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
-        return img
+        r = requests.get(url, timeout=5)
+        arr = np.frombuffer(r.content, np.uint8)
+        return cv2.imdecode(arr, cv2.IMREAD_COLOR)
     except:
         return None
 
-# ---------- Helper: Extract face embedding ----------
+def load_any(x):
+    if x.startswith("http://") or x.startswith("https://"):
+        return url_to_img(x)
+    return b64_to_img(x)
+
 def get_embedding(img):
     faces = model.get(img)
-    if len(faces) == 0:
+    if not faces:
         return None
     return faces[0].embedding
 
-# ---------- POST /compare API ----------
+# -------------------- /compare API --------------------
 @app.post("/compare")
 async def compare_faces(req: CompareRequest):
 
-    # Load image 1
-    if req.image1:
-        img1 = b64_to_img(req.image1)
-    elif req.image1_url:
-        img1 = url_to_img(req.image1_url)
-    else:
-        return {"error": "Image1 missing"}
-
-    # Load image 2
-    if req.image2:
-        img2 = b64_to_img(req.image2)
-    elif req.image2_url:
-        img2 = url_to_img(req.image2_url)
-    else:
-        return {"error": "Image2 missing"}
+    img1 = load_any(req.image1 or req.image1_url or "")
+    img2 = load_any(req.image2 or req.image2_url or "")
 
     if img1 is None or img2 is None:
-        return {"error": "Invalid image data"}
+        return {"error": "Invalid image1/image2 or URLs"}
 
     emb1 = get_embedding(img1)
     emb2 = get_embedding(img2)
 
     if emb1 is None or emb2 is None:
-        return {"error": "Face not detected"}
+        return {"error": "No face detected in one or both images."}
 
     similarity = float(
-        np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
+        np.dot(emb1, emb2) /
+        (np.linalg.norm(emb1) * np.linalg.norm(emb2))
     )
 
     return {
@@ -96,43 +86,42 @@ async def compare_faces(req: CompareRequest):
         "match": similarity > 0.55
     }
 
-# ---------- GRADIO UI ----------
-def gradio_ui(image1_input, image2_input):
-
-    def load_any(x):
-        if x.startswith("http://") or x.startswith("https://"):
-            return url_to_img(x)
-        else:
-            return b64_to_img(x)
-
-    img1 = load_any(image1_input)
-    img2 = load_any(image2_input)
+# -------------------- GRADIO UI --------------------
+def gradio_ui(img1_text, img2_text):
+    img1 = load_any(img1_text)
+    img2 = load_any(img2_text)
 
     if img1 is None or img2 is None:
-        return "Invalid image input"
+        return "Invalid base64 or URL."
 
     emb1 = get_embedding(img1)
     emb2 = get_embedding(img2)
 
     if emb1 is None or emb2 is None:
-        return "Face not detected"
+        return "Face not detected."
 
-    similarity = float(
-        np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
+    similarity = np.dot(emb1, emb2) / (
+        np.linalg.norm(emb1) * np.linalg.norm(emb2)
     )
-    matched = similarity > 0.55
 
-    return f"Similarity: {similarity:.3f} | Match: {matched}"
+    return f"Similarity: {similarity:.3f} | Match: {similarity > 0.55}"
 
-# Build a Gradio Blocks app (needed for mount_gradio_app)
-with gr.Blocks() as demo:
-    gr.Markdown("# Face Comparison API (Text Input)")
-    img1 = gr.Textbox(label="Image 1 (URL or base64)")
-    img2 = gr.Textbox(label="Image 2 (URL or base64)")
-    out = gr.Textbox(label="Result")
-    btn = gr.Button("Compare")
-
-    btn.click(fn=gradio_ui, inputs=[img1, img2], outputs=out)
+gradio_ui_app = gr.Interface(
+    fn=gradio_ui,
+    inputs=[
+        gr.Textbox(label="Image 1 (base64 or URL)"),
+        gr.Textbox(label="Image 2 (base64 or URL)")
+    ],
+    outputs="text",
+    title="Face Match API (Text Input)"
+)
 
-# Mount Gradio UI at "/"
-app = gr.mount_gradio_app(app, demo, path="/")
+# IMPORTANT: Launching Gradio inside FastAPI server
+# HuggingFace will call "app" automatically
+@app.get("/")
+async def serve_gradio():
+    return gradio_ui_app.launch(
+        inline=True,  # IMPORTANT: embed inside FastAPI
+        share=False,
+        prevent_thread_lock=True
+    )