testing of fix

app.py

@@ -5,6 +5,8 @@ from fastapi.responses import JSONResponse
 import base64
 import json
 import logging
+import os
+import tempfile
 import cv2
 import numpy as np
 import requests
@@ -24,35 +26,48 @@ def log_event(event_type: str, **fields):
     payload = {"event": event_type, **fields}
     logger.error(json.dumps(payload, default=str))
 
-def load_image(source: str):
+def safe_remove(path: str):
+    try:
+        os.remove(path)
+    except OSError:
+        pass
+
+
+def prepare_image_for_deepface(source: str):
     """
-    Load an image from a URL, base64 data URI, or local file path into a numpy array (BGR).
+    Return a filesystem path DeepFace can consume reliably.
+    For URLs / base64 we materialize a temp file and return (path, True).
+    For local paths we return (path, False).
     """
-    if isinstance(source, str):
-        if source.startswith("http://") or source.startswith("https://"):
-            # Download and decode
-            resp = requests.get(source, headers={"User-Agent": "Mozilla/5.0"}, timeout=20)
-            resp.raise_for_status()
-            data = np.frombuffer(resp.content, dtype=np.uint8)
-            img = cv2.imdecode(data, cv2.IMREAD_COLOR)
-            if img is None:
-                raise ValueError(f"Failed to decode image from URL: {source}")
-            return img
-        if source.startswith("data:image"):
-            # data URI: data:image/<type>;base64,<payload>
-            b64_payload = source.split(",", 1)[1] if "," in source else source
-            binary = base64.b64decode(b64_payload)
-            data = np.frombuffer(binary, dtype=np.uint8)
-            img = cv2.imdecode(data, cv2.IMREAD_COLOR)
-            if img is None:
-                raise ValueError("Failed to decode image from base64 data")
-            return img
-        # Fallback: treat as local path
+    if not isinstance(source, str):
+        raise TypeError("Unsupported image source type")
+
+    if source.startswith("http://") or source.startswith("https://"):
+        resp = requests.get(source, headers={"User-Agent": "Mozilla/5.0"}, timeout=20)
+        resp.raise_for_status()
+        binary = resp.content
+    elif source.startswith("data:image"):
+        b64_payload = source.split(",", 1)[1] if "," in source else source
+        binary = base64.b64decode(b64_payload)
+    else:
         img = cv2.imread(source)
         if img is None:
             raise ValueError(f"Failed to load local image: {source}")
-        return img
-    raise TypeError("Unsupported image source type")
+        return source, False
+
+    data = np.frombuffer(binary, dtype=np.uint8)
+    img = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    if img is None:
+        raise ValueError(f"Failed to decode image: {source}")
+
+    tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".jpg")
+    tmp_file_path = tmp_file.name
+    tmp_file.close()
+    wrote = cv2.imwrite(tmp_file_path, img)
+    if not wrote:
+        safe_remove(tmp_file_path)
+        raise ValueError(f"Failed to write temp image: {source}")
+    return tmp_file_path, True
 
 @app.get("/")
 def greet_json():
@@ -66,69 +81,63 @@ def verify(v: Verify):
 
     true_count = 0
     print(selfie)
+    selfie_path = None
+    selfie_is_temp = False
     try:
-        selfie_img = load_image(selfie)
+        selfie_path, selfie_is_temp = prepare_image_for_deepface(selfie)
     except Exception as e:
         print(f"Failed to load selfie image: {e}")
         log_event("load_error", target="selfie", source=selfie, error=str(e))
         return JSONResponse(content={"verified": False, "image": None, "error": "failed_to_load_selfie"})
 
-    for image in gallery:
-        print(image)
-        try:
-            gallery_img = load_image(image)
-        except Exception as e:
-            print(f"Failed to load gallery image {image}: {e}")
-            log_event("load_error", target="gallery", source=image, error=str(e))
-            continue
-        try:
-            selfie_candidate = selfie_img.copy()
-            gallery_candidate = gallery_img.copy()
-            # Use a more robust detector; fall back if detection fails
-            result = DeepFace.verify(
-                img1_path=selfie_candidate,
-                img2_path=gallery_candidate,
-                detector_backend="retinaface"
-            )
-            if result.get("verified", False):
-                true_count += 1
-                if true_count >= 2:
-                    return JSONResponse(content={"verified": True, "image": image})
-        except Exception as e:
-            msg = str(e)
-            print(f"DeepFace verification error for {image}: {msg}")
-            # Retry once when DeepFace specifically fails while processing img1_path.
-            # Re-load selfie to avoid potential in-place mutation side effects.
-            if "img1_path" in msg:
-                try:
-                    selfie_retry = load_image(selfie)
-                    result = DeepFace.verify(
-                        img1_path=selfie_retry,
-                        img2_path=gallery_img.copy(),
-                        detector_backend="retinaface"
-                    )
-                    if result.get("verified", False):
-                        true_count += 1
-                        if true_count >= 2:
-                            return JSONResponse(content={"verified": True, "image": image})
-                    continue
-                except Exception as e_retry:
-                    print(f"DeepFace img1_path retry error for {image}: {e_retry}")
-                    log_event("img1_path_error", gallery_image=image, error=str(e_retry))
-            # Optional fallback without strict detection to avoid generic img2_path errors
-            if "Face could not be detected" in msg or "No face" in msg:
-                log_event("face_not_detected", gallery_image=image, error=msg)
-                try:
-                    result = DeepFace.verify(
-                        img1_path=selfie_img.copy(),
-                        img2_path=gallery_img.copy(),
-                        detector_backend="retinaface",
-                        enforce_detection=False
-                    )
-                    if result.get("verified", False):
-                        true_count += 1
-                        if true_count >= 2:
-                            return JSONResponse(content={"verified": True, "image": image})
-                except Exception as e2:
-                    print(f"DeepFace fallback error for {image}: {e2}")
-    return JSONResponse(content={"verified": False, "image": None})
+    try:
+        for image in gallery:
+            print(image)
+            gallery_path = None
+            gallery_is_temp = False
+            try:
+                gallery_path, gallery_is_temp = prepare_image_for_deepface(image)
+            except Exception as e:
+                print(f"Failed to load gallery image {image}: {e}")
+                log_event("load_error", target="gallery", source=image, error=str(e))
+                continue
+
+            try:
+                result = DeepFace.verify(
+                    img1_path=selfie_path,
+                    img2_path=gallery_path,
+                    detector_backend="retinaface"
+                )
+                if result.get("verified", False):
+                    true_count += 1
+                    if true_count >= 2:
+                        return JSONResponse(content={"verified": True, "image": image})
+            except Exception as e:
+                msg = str(e)
+                print(f"DeepFace verification error for {image}: {msg}")
+                if "img1_path" in msg:
+                    log_event("img1_path_error", gallery_image=image, error=msg)
+                if "Face could not be detected" in msg or "No face" in msg:
+                    log_event("face_not_detected", gallery_image=image, error=msg)
+                # Fallback path on generic processing or face-detection errors.
+                if "img1_path" in msg or "Face could not be detected" in msg or "No face" in msg:
+                    try:
+                        result = DeepFace.verify(
+                            img1_path=selfie_path,
+                            img2_path=gallery_path,
+                            detector_backend="opencv",
+                            enforce_detection=False
+                        )
+                        if result.get("verified", False):
+                            true_count += 1
+                            if true_count >= 2:
+                                return JSONResponse(content={"verified": True, "image": image})
+                    except Exception as e2:
+                        print(f"DeepFace fallback error for {image}: {e2}")
+            finally:
+                if gallery_is_temp and gallery_path:
+                    safe_remove(gallery_path)
+        return JSONResponse(content={"verified": False, "image": None})
+    finally:
+        if selfie_is_temp and selfie_path:
+            safe_remove(selfie_path)