Update app.py

app.py

@@ -180,7 +180,11 @@ async def analyze(file: UploadFile = File(...)):
             tmp_path = tmp.name
         
         result_json = call_roboflow_api(tmp_path)
-        logger.info(f"🔍 ROBOFLOW FULL RESPONSE: {result_json}")  # ADD THIS
+        
+        # ─── DEBUG: Log what Roboflow returns ────────────────────────────────
+        logger.info(f"🔍 Response Type: {type(result_json)}")
+        logger.info(f"🔍 Response Keys: {result_json.keys() if isinstance(result_json, dict) else 'Not a dict'}")
+        logger.info(f"🔍 Full Response: {result_json}")
         
     except Exception as e:
         logger.error(f"Roboflow workflow error: {e}")
@@ -191,21 +195,73 @@ async def analyze(file: UploadFile = File(...)):
             os.remove(tmp_path)
 
     # ─── Parse detections ────────────────────────────────────────────────────
+    predictions = []
+
     try:
-        if isinstance(result_json, list):
-            output_data = result_json[0].get("outputs", {})
-        else:
-            output_data = result_json.get("outputs", [{}])[0] if isinstance(result_json.get("outputs"), list) else result_json.get("outputs", {})
+        # Handle different response structures
+        if isinstance(result_json, list) and len(result_json) > 0:
+            # Response is a list
+            first_item = result_json[0]
+            logger.info(f"🔍 First item keys: {first_item.keys() if isinstance(first_item, dict) else 'Not dict'}")
+            
+            if "outputs" in first_item:
+                outputs = first_item["outputs"]
+                logger.info(f"🔍 Outputs type: {type(outputs)}")
+                logger.info(f"🔍 Outputs content: {outputs}")
+                
+                # Try to get predictions from outputs
+                if isinstance(outputs, dict):
+                    predictions = outputs.get("predictions", outputs.get("image", {}).get("predictions", []))
+                elif isinstance(outputs, list):
+                    predictions = outputs
+                    
+        elif isinstance(result_json, dict):
+            # Response is a dict
+            logger.info(f"🔍 Dict keys: {list(result_json.keys())}")
+            
+            # Try multiple paths
+            if "outputs" in result_json:
+                outputs = result_json["outputs"]
+                logger.info(f"🔍 Found outputs, type: {type(outputs)}")
+                
+                if isinstance(outputs, list) and len(outputs) > 0:
+                    output_data = outputs[0]
+                elif isinstance(outputs, dict):
+                    output_data = outputs
+                else:
+                    output_data = {}
+                    
+                logger.info(f"🔍 Output data: {output_data}")
+                
+                # Extract predictions
+                if isinstance(output_data, dict):
+                    predictions = output_data.get("predictions", [])
+                    
+            elif "predictions" in result_json:
+                predictions = result_json["predictions"]
+                
+            elif "image" in result_json:
+                predictions = result_json["image"].get("predictions", [])
         
-        predictions = output_data.get("predictions", [])
+        # Handle nested predictions dict
         if isinstance(predictions, dict):
-            predictions = predictions.get("predictions", [])
+            logger.info(f"🔍 Predictions is dict with keys: {predictions.keys()}")
+            if "predictions" in predictions:
+                predictions = predictions["predictions"]
+            elif "image" in predictions:
+                predictions = predictions["image"].get("predictions", [])
+        
+        logger.info(f"🔍 Final predictions type: {type(predictions)}")
+        logger.info(f"🔍 Final predictions length: {len(predictions) if isinstance(predictions, list) else 'Not a list'}")
+        if isinstance(predictions, list) and len(predictions) > 0:
+            logger.info(f"🔍 First prediction sample: {predictions[0]}")
+            
     except Exception as e:
-        logger.warning(f"Response parsing issue: {e}")
-        logger.warning(f"Raw response: {result_json}")
+        logger.error(f"❌ Parsing error: {e}", exc_info=True)
         predictions = []
 
-    if not predictions:
+    if not predictions or (isinstance(predictions, list) and len(predictions) == 0):
+        logger.warning("⚠️ No predictions found after parsing")
         return {
             "status": "success",
             "tooth_count": 0,
@@ -213,6 +269,8 @@ async def analyze(file: UploadFile = File(...)):
             "message": "No teeth detected in image"
         }
 
+    logger.info(f"✅ Found {len(predictions)} teeth detections")
+
     # ─── Process crops ───────────────────────────────────────────────────────
     batch_images = []
     metadata = []
@@ -252,8 +310,10 @@ async def analyze(file: UploadFile = File(...)):
             batch_images.append(final_img)
             metadata.append({"id": i, "box": [x1, y1, x2, y2]})
             
+            logger.info(f"✅ Processed tooth {i}: bbox=[{x1},{y1},{x2},{y2}]")
+            
         except Exception as e:
-            logger.warning(f"Skipping detection {i} due to error: {e}")
+            logger.warning(f"⚠️ Skipping detection {i} due to error: {e}")
             continue
 
     if not batch_images:
@@ -264,13 +324,17 @@ async def analyze(file: UploadFile = File(...)):
             "message": "No valid tooth crops extracted"
         }
 
+    logger.info(f"✅ Prepared {len(batch_images)} tooth images for inference")
+
     # ─── Model inference ─────────────────────────────────────────────────────
     try:
         batch_array = np.array(batch_images)
+        logger.info(f"🔄 Running inference on batch shape: {batch_array.shape}")
         reconstructions = MODEL.predict(batch_array, verbose=0)
         errors = np.mean(np.abs(batch_array - reconstructions), axis=(1, 2, 3))
+        logger.info(f"✅ Inference complete. Scores: {errors}")
     except Exception as e:
-        logger.error(f"Inference error: {e}")
+        logger.error(f"❌ Inference error: {e}")
         raise HTTPException(status_code=500, detail="Model inference failed")
 
     # ─── Format results ──────────────────────────────────────────────────────
@@ -285,6 +349,8 @@ async def analyze(file: UploadFile = File(...)):
             "confidence": "high" if score_val > THRESHOLD * 1.5 else "medium" if score_val > THRESHOLD else "low"
         })
 
+    logger.info(f"🎉 Analysis complete: {len(results)} teeth analyzed")
+    
     return {
         "status": "success",
         "tooth_count": len(results),