Update app.py

app.py

@@ -6,17 +6,21 @@ from fastapi import FastAPI
 from pydantic import BaseModel
 import insightface
 import gradio as gr
-import uvicorn
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
 
-# -------------------- Load Face Recognition Model --------------------
+# -------------------------------------------
+# Load Face Model
+# -------------------------------------------
 model = insightface.app.FaceAnalysis(name="buffalo_l")
 model.prepare(ctx_id=0, det_size=(640, 640))
 
-# -------------------- FASTAPI APP --------------------
+# -------------------------------------------
+# FastAPI app
+# -------------------------------------------
 app = FastAPI()
 
-# Allow all CORS (FlutterFlow)
+# CORS for FlutterFlow
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -25,74 +29,99 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# -------------------- Request Schema --------------------
+
+# -------------------------------------------
+# Request Schema
+# -------------------------------------------
 class CompareRequest(BaseModel):
     image1: str | None = None
     image2: str | None = None
     image1_url: str | None = None
     image2_url: str | None = None
 
-# -------------------- Helpers --------------------
+
+# -------------------------------------------
+# Helper Functions
+# -------------------------------------------
 def b64_to_img(b64_string):
     try:
         img_data = base64.b64decode(b64_string)
-        arr = np.frombuffer(img_data, np.uint8)
-        return cv2.imdecode(arr, cv2.IMREAD_COLOR)
+        np_arr = np.frombuffer(img_data, np.uint8)
+        img = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
+        return img
     except:
         return None
 
+
 def url_to_img(url):
     try:
-        r = requests.get(url, timeout=5)
-        arr = np.frombuffer(r.content, np.uint8)
-        return cv2.imdecode(arr, cv2.IMREAD_COLOR)
+        resp = requests.get(url, timeout=5)
+        np_arr = np.frombuffer(resp.content, np.uint8)
+        img = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
+        return img
     except:
         return None
 
-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 not faces:
+    if len(faces) == 0:
         return None
     return faces[0].embedding
 
-# -------------------- /compare API --------------------
+
+# -------------------------------------------
+# API Endpoint
+# -------------------------------------------
 @app.post("/compare")
 async def compare_faces(req: CompareRequest):
 
-    img1 = load_any(req.image1 or req.image1_url or "")
-    img2 = load_any(req.image2 or req.image2_url or "")
+    # Load image 1
+    if req.image1:
+        img1 = b64_to_img(req.image1)
+    elif req.image1_url:
+        img1 = url_to_img(req.image1_url)
+    else:
+        img1 = None
+
+    # Load image 2
+    if req.image2:
+        img2 = b64_to_img(req.image2)
+    elif req.image2_url:
+        img2 = url_to_img(req.image2_url)
+    else:
+        img2 = None
 
     if img1 is None or img2 is None:
-        return {"error": "Invalid image1/image2 or URLs"}
+        return {"error": "Invalid image data or URL"}
 
     emb1 = get_embedding(img1)
     emb2 = get_embedding(img2)
 
     if emb1 is None or emb2 is None:
-        return {"error": "No face detected in one or both images."}
+        return {"error": "No face detected"}
 
-    similarity = float(
-        np.dot(emb1, emb2) /
-        (np.linalg.norm(emb1) * np.linalg.norm(emb2))
-    )
+    similarity = float(np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2)))
+    matched = similarity > 0.55
 
-    return {
-        "similarity": similarity,
-        "match": similarity > 0.55
-    }
+    return {"similarity": similarity, "match": matched}
 
-# -------------------- GRADIO UI --------------------
+
+# -------------------------------------------
+# Gradio UI (embedded inside FastAPI)
+# -------------------------------------------
 def gradio_ui(img1_text, img2_text):
+
+    def load_any(s):
+        if s.startswith("http"):
+            return url_to_img(s)
+        return b64_to_img(s)
+
     img1 = load_any(img1_text)
     img2 = load_any(img2_text)
 
     if img1 is None or img2 is None:
-        return "Invalid base64 or URL."
+        return "Invalid image or URL"
 
     emb1 = get_embedding(img1)
     emb2 = get_embedding(img2)
@@ -100,28 +129,20 @@ def gradio_ui(img1_text, img2_text):
     if emb1 is None or emb2 is None:
         return "Face not detected."
 
-    similarity = np.dot(emb1, emb2) / (
-        np.linalg.norm(emb1) * np.linalg.norm(emb2)
-    )
+    similarity = float(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}"
 
-gradio_ui_app = gr.Interface(
+ui = gr.Interface(
     fn=gradio_ui,
     inputs=[
         gr.Textbox(label="Image 1 (base64 or URL)"),
-        gr.Textbox(label="Image 2 (base64 or URL)")
+        gr.Textbox(label="Image 2 (base64 or URL)"),
     ],
     outputs="text",
-    title="Face Match API (Text Input)"
+    title="Face Match API",
 )
 
-# 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
-    )
+app = gr.mount_gradio_app(app, ui, path="/")