with comments

app.py

@@ -1,11 +1,12 @@
 # app.py
-# Adapted to follow the logic from the provided Django api/views.py
+# Adapted to follow the logic from the provided Django api/views.py with added logging
 import os
 import cv2
 import tempfile
 import numpy as np
 import uvicorn
 import base64
+import io
 from PIL import Image
 from inference_sdk import InferenceHTTPClient
 from fastapi import FastAPI, File, UploadFile
@@ -57,7 +58,6 @@ def detect_eyes_roboflow(image_path):
     h, w = raw_image.shape[:2]
     scale = min(1.0, MAX_INFER_DIM / max(h, w))
     
-    # Use a temporary file for inference if resizing is needed
     if scale < 1.0:
         small_image = cv2.resize(raw_image, (int(w*scale), int(h*scale)))
         with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp:
@@ -69,17 +69,14 @@ def detect_eyes_roboflow(image_path):
     try:
         resp = CLIENT_EYES.infer(infer_path, model_id="eye-detection-kso3d/3")
     finally:
-        # Clean up temp file if one was created
         if scale < 1.0 and os.path.exists(infer_path):
             os.remove(infer_path)
 
     crops = []
     for p in resp.get("predictions", []):
-        # Scale coordinates back to original image dimensions
         cx, cy = p["x"] / scale, p["y"] / scale
         bw, bh = p["width"] / scale, p["height"] / scale
         
-        # Crop from the original raw image
         x1 = int(cx - bw / 2)
         y1 = int(cy - bh / 2)
         x2 = int(cx + bw / 2)
@@ -105,7 +102,6 @@ def get_largest_iris_prediction(eye_crop):
 
 def run_leukocoria_prediction(iris_crop):
     """Runs the loaded TensorFlow model on an iris crop."""
-    # The logic from views.py is now directly in the TF model call
     enh = enhance_image_unsharp_mask(iris_crop)
     enh_rs = cv2.resize(enh, ENHANCED_SIZE)
     
@@ -127,38 +123,47 @@ app = FastAPI()
 
 @app.post("/detect/")
 async def full_detection_pipeline(image: UploadFile = File(...)):
+    print("\n--- 1. Starting full detection pipeline. ---")
     with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp:
         tmp.write(await image.read())
         temp_image_path = tmp.name
 
     try:
-        # Step 1: Face Check
+        print("--- 2. Checking for faces... ---")
         if not detect_faces_roboflow(temp_image_path):
+            print("--- 2a. No face detected. Aborting. ---")
             return JSONResponse(status_code=200, content={"warnings": ["No face detected."]})
+        print("--- 2b. Face found. Proceeding. ---")
 
-        # Step 2: Eye Detection
+        print("--- 3. Detecting eyes... ---")
         raw_image, eye_crops = detect_eyes_roboflow(temp_image_path)
         if raw_image is None:
             return JSONResponse(status_code=400, content={"error": "Could not read uploaded image."})
-
+        
+        print(f"--- 4. Found {len(eye_crops)} eyes. ---")
         if len(eye_crops) != 2:
             return JSONResponse(status_code=200, content={
                 "analyzed_image": to_base64(raw_image),
                 "warnings": ["Exactly two eyes not detected."]
             })
 
-        # Step 3: Process Eyes with NEW Labeling Logic
+        initial_coords = [e['coords'] for e in eye_crops]
+        print(f"--- 5. Initial eye coordinates: {initial_coords} ---")
+
         sorted_eyes = sorted(eye_crops, key=lambda e: e["coords"][0])
+        sorted_coords = [e['coords'] for e in sorted_eyes]
+        print(f"--- 6. Sorted eye coordinates: {sorted_coords} ---")
+
         images_b64 = {}
         flags = {}
         
-        # This new loop labels the left-most eye as "left" and right-most as "right"
         for side, eye_info in zip(("left", "right"), sorted_eyes):
+            print(f"--- 7. Processing side: '{side}' ---")
             eye_img = eye_info["image"]
             
-            # Iris detection and Leukocoria prediction
             pred = get_largest_iris_prediction(eye_img)
             if pred:
+                print(f"--- 8. Iris found for '{side}' eye. Running leukocoria prediction... ---")
                 cx, cy, w, h = pred["x"], pred["y"], pred["width"], pred["height"]
                 x1, y1 = int(cx - w / 2), int(cy - h / 2)
                 x2, y2 = int(cx + w / 2), int(cy + h / 2)
@@ -166,13 +171,15 @@ async def full_detection_pipeline(image: UploadFile = File(...)):
                 iris_crop = eye_img[y1:y2, x1:x2]
                 
                 has_leuko, confidence = run_leukocoria_prediction(iris_crop)
+                print(f"--- 9. Prediction for '{side}' eye: Has Leukocoria={has_leuko}, Confidence={confidence:.4f} ---")
                 flags[side] = has_leuko
             else:
+                print(f"--- 8a. No iris found for '{side}' eye. ---")
                 flags[side] = None
 
             images_b64[side] = to_base64(eye_img)
-
-        # Step 4: Prepare and return the final response
+        
+        print(f"--- 10. Final generated flags: {flags} ---")
         return JSONResponse(status_code=200, content={
             "analyzed_image": to_base64(raw_image),
             "two_eyes": images_b64,