Update app.py

app.py

@@ -1,264 +1,355 @@
 import os
+from contextlib import asynccontextmanager
+
+# ─── 1. MANDATORY BACKEND CONFIG (Must be at the very top) ───────────────────
+os.environ["KERAS_BACKEND"] = "jax"
+os.environ["JAX_PLATFORM_NAME"] = "cpu"
+os.environ["HF_HOME"] = "/tmp/huggingface"
+
 import base64
 import logging
-import traceback
-from flask import Flask, request, jsonify, render_template
-from flask_cors import CORS
-from dotenv import load_dotenv
-from roboflow import Roboflow
-
-# ─── Configuration ───────────────────────────────────────────────────────
-load_dotenv()
+import numpy as np
+import cv2
+import requests
+import tempfile
+from typing import List, Dict, Any, Optional
 
-app = Flask(__name__)
-CORS(app)
+import keras
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import JSONResponse
+from huggingface_hub import hf_hub_download
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+from inference_sdk import InferenceHTTPClient
 
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
-)
+# ─── 2. LOGGING & CONFIG ─────────────────────────────────────────────────────
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# ─── Roboflow Setup ──────────────────────────────────────────────────────
-ROBOFLOW_API_KEY = os.getenv("ROBOFLOW_API_KEY")
-ROBOFLOW_WORKSPACE = os.getenv("ROBOFLOW_WORKSPACE")
-ROBOFLOW_PROJECT = os.getenv("ROBOFLOW_PROJECT")
-ROBOFLOW_VERSION = int(os.getenv("ROBOFLOW_VERSION", 1))
-
-if not all([ROBOFLOW_API_KEY, ROBOFLOW_WORKSPACE, ROBOFLOW_PROJECT]):
-    raise ValueError("Missing required Roboflow environment variables")
+API_KEY = os.getenv("ROBOFLOW_API_KEY")
+WORKSPACE_NAME = "my-workspace-iy9ll"
+WORKFLOW_ID = "find-teeth"
+IMG_SIZE = 256
+THRESHOLD = 0.05
+MODEL_REPO = "sairamv1/TeethCariesDetection_CNNAutoencoder"
+MODEL_FILENAME = "autoencoder.keras"
 
-logger.info(f"🚀 Initializing Roboflow: {ROBOFLOW_WORKSPACE}/{ROBOFLOW_PROJECT}/{ROBOFLOW_VERSION}")
+MODEL = None
+roboflow_client = None
 
-try:
-    rf = Roboflow(api_key=ROBOFLOW_API_KEY)
-    project = rf.workspace(ROBOFLOW_WORKSPACE).project(ROBOFLOW_PROJECT)
-    model = project.version(ROBOFLOW_VERSION).model
-    logger.info("✅ Roboflow model loaded successfully")
-except Exception as e:
-    logger.error(f"❌ Failed to initialize Roboflow: {e}")
-    raise
+# ─── 3. RETRY-ENABLED MODEL DOWNLOAD ─────────────────────────────────────────
+@retry(
+    stop=stop_after_attempt(3),
+    wait=wait_exponential(multiplier=1, min=2, max=10),
+    retry=retry_if_exception_type((requests.RequestException, OSError))
+)
+def download_model() -> str:
+    """Download model from HuggingFace Hub with retry logic."""
+    logger.info(f"🚀 Downloading model from {MODEL_REPO}...")
+    local_path = hf_hub_download(
+        repo_id=MODEL_REPO,
+        filename=MODEL_FILENAME,
+        cache_dir="/tmp/huggingface"
+    )
+    logger.info(f"✅ Model downloaded to {local_path}")
+    return local_path
 
-# ─── Helper Functions ────────────────────────────────────────────────────
+def init_roboflow_client():
+    """Initialize Roboflow client if API key is available."""
+    global roboflow_client
+    if API_KEY:
+        try:
+            roboflow_client = InferenceHTTPClient(
+                api_url="https://serverless.roboflow.com",
+                api_key=API_KEY
+            )
+            logger.info("✅ Roboflow client initialized")
+        except Exception as e:
+            logger.error(f"❌ Roboflow client initialization failed: {e}")
+            roboflow_client = None
+    else:
+        logger.warning("⚠️ ROBOFLOW_API_KEY not set")
 
-def decode_base64_image(base64_string):
-    """Decode base64 image string to bytes."""
+# ─── 4. LIFESPAN EVENT HANDLER ───────────────────────────────────────────────
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Manage model loading at startup and cleanup at shutdown."""
+    global MODEL
     try:
-        # Remove data URL prefix if present
-        if ',' in base64_string:
-            base64_string = base64_string.split(',')[1]
+        local_model_path = download_model()
+        logger.info("🔄 Loading Keras model with JAX backend...")
+        MODEL = keras.saving.load_model(local_model_path)
+        logger.info(f"✅ Model loaded successfully! Input shape: {MODEL.input_shape}")
         
-        image_data = base64.b64decode(base64_string)
-        logger.info(f"✅ Decoded image: {len(image_data)} bytes")
-        return image_data
+        # Initialize Roboflow client
+        init_roboflow_client()
     except Exception as e:
-        logger.error(f"❌ Base64 decode error: {e}")
-        raise ValueError(f"Invalid base64 image data: {str(e)}")
-
-def save_temp_image(image_data, filename="temp_image.jpg"):
-    """Save image data to temporary file."""
-    try:
-        temp_path = os.path.join("/tmp", filename)
-        with open(temp_path, "wb") as f:
-            f.write(image_data)
-        logger.info(f"✅ Saved temp image: {temp_path}")
-        return temp_path
-    except Exception as e:
-        logger.error(f"❌ Failed to save temp image: {e}")
-        raise
-
-def cleanup_temp_file(filepath):
-    """Remove temporary file."""
-    try:
-        if os.path.exists(filepath):
-            os.remove(filepath)
-            logger.info(f"🗑️ Cleaned up: {filepath}")
-    except Exception as e:
-        logger.warning(f"⚠️ Failed to cleanup {filepath}: {e}")
+        logger.error(f"❌ Startup failed: {e}")
+        MODEL = None
+    
+    yield
+    logger.info("🛑 Shutting down...")
 
-# ─── API Routes ──────────────────────────────────────────────────────────
+app = FastAPI(
+    title="Teeth Caries Detection API",
+    description="Dental anomaly detection using CNN Autoencoder",
+    version="1.0.0",
+    lifespan=lifespan
+)
 
-@app.route('/')
-def index():
-    """Serve the main HTML page."""
-    return render_template('index.html')
+# ─── 5. ROBOFLOW API CALL ────────────────────────────────────────────────────
+def call_roboflow_api(image_path: str) -> Dict:
+    """Call Roboflow workflow using inference SDK."""
+    if not roboflow_client:
+        raise Exception("Roboflow client not initialized")
+    
+    result = roboflow_client.run_workflow(
+        workspace_name=WORKSPACE_NAME,
+        workflow_id=WORKFLOW_ID,
+        images={"image": image_path},
+        use_cache=False
+    )
+    return result
 
-@app.route('/health', methods=['GET'])
-def health_check():
+# ─── 6. ROUTES ───────────────────────────────────────────────────────────────
+@app.get("/")
+async def root():
     """Health check endpoint."""
-    return jsonify({
+    return {
+        "status": "active",
+        "model_ready": MODEL is not None,
+        "backend": os.environ.get("KERAS_BACKEND"),
+        "api_configured": API_KEY is not None,
+        "roboflow_ready": roboflow_client is not None
+    }
+
+@app.get("/health")
+async def health():
+    """Detailed health check."""
+    if MODEL is None:
+        return JSONResponse(
+            status_code=503,
+            content={"status": "unhealthy", "reason": "Model not loaded"}
+        )
+    return {
         "status": "healthy",
-        "model": f"{ROBOFLOW_WORKSPACE}/{ROBOFLOW_PROJECT}/{ROBOFLOW_VERSION}"
-    })
+        "model_input_shape": str(MODEL.input_shape),
+        "roboflow_status": "ready" if roboflow_client else "not configured"
+    }
 
-@app.route('/detect', methods=['POST'])
-def detect_teeth():
+@app.post("/analyze")
+async def analyze(file: UploadFile = File(...)):
     """
-    Main detection endpoint.
-    Expects JSON with 'image' field containing base64-encoded image.
+    Analyze dental image for caries detection.
+    
+    Returns anomaly scores for each detected tooth.
     """
-    temp_path = None
+    if MODEL is None:
+        raise HTTPException(status_code=503, detail="Model not initialized. Please retry later.")
     
+    if not roboflow_client:
+        raise HTTPException(status_code=500, detail="ROBOFLOW_API_KEY not configured")
+
+    # ─── Read and validate image ─────────────────────────────────────────────
     try:
-        # ─── Validate request ────────────────────────────────────────────
-        data = request.get_json()
+        contents = await file.read()
+        if len(contents) == 0:
+            raise HTTPException(status_code=400, detail="Empty file uploaded")
         
-        if not data or 'image' not in data:
-            logger.error("❌ No image data in request")
-            return jsonify({
-                "status": "error",
-                "message": "No image data provided"
-            }), 400
+        nparr = np.frombuffer(contents, np.uint8)
+        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
         
-        logger.info("📥 Received detection request")
+        if img is None or img.size == 0:
+            raise HTTPException(status_code=400, detail="Invalid image format or corrupted file")
         
-        # ─── Decode and save image ───────────────────────────────────────
-        image_data = decode_base64_image(data['image'])
-        temp_path = save_temp_image(image_data)
+        img_h, img_w = img.shape[:2]
+        if img_h < 50 or img_w < 50:
+            raise HTTPException(status_code=400, detail="Image too small (min 50x50 pixels)")
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Image decode error: {e}")
+        raise HTTPException(status_code=400, detail=f"Image processing failed: {str(e)}")
+
+    # ─── Call Roboflow detection ─────────────────────────────────────────────
+    tmp_path = None
+    try:
+        # Save to temp file for inference_sdk
+        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp:
+            tmp.write(contents)
+            tmp_path = tmp.name
         
-        # ─── Run inference ───────────────────────────────────────────────
-        logger.info("🔍 Running Roboflow inference...")
-        result = model.predict(temp_path, confidence=40, overlap=30)
+        result_json = call_roboflow_api(tmp_path)
         
-        # Get JSON response
-        result_json = result.json()
+        # ─── 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}")
         
-        # ─── Parse detections ────────────────────────────────────────────
-        predictions = []
-        
-        try:
-            # 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 type: {type(first_item)}")
-                logger.info(f"🔍 First item keys: {first_item.keys() if isinstance(first_item, dict) else 'Not dict'}")
-                
-                # FIXED: Check for "predictions" directly first!
-                if isinstance(first_item, dict):
-                    if "predictions" in first_item:
-                        predictions = first_item["predictions"]
-                        logger.info(f"✅ Found predictions directly in first_item")
-                    elif "outputs" in first_item:
-                        outputs = first_item["outputs"]
-                        logger.info(f"🔍 Found outputs: {type(outputs)}")
-                        if isinstance(outputs, dict):
-                            predictions = outputs.get("predictions", [])
-                            
-            elif isinstance(result_json, dict):
-                # Response is a dict
-                logger.info(f"🔍 Dict keys: {list(result_json.keys())}")
-                
-                # Try "predictions" first
-                if "predictions" in result_json:
-                    predictions = result_json["predictions"]
-                elif "outputs" in result_json:
-                    outputs = result_json["outputs"]
-                    if isinstance(outputs, list) and len(outputs) > 0:
-                        output_data = outputs[0]
-                    elif isinstance(outputs, dict):
-                        output_data = outputs
-                    else:
-                        output_data = {}
-                    predictions = output_data.get("predictions", [])
+    except Exception as e:
+        logger.error(f"Roboflow workflow error: {e}")
+        raise HTTPException(status_code=502, detail=f"Detection service failed: {str(e)}")
+    finally:
+        # Clean up temp file
+        if tmp_path and os.path.exists(tmp_path):
+            os.remove(tmp_path)
+
+        # ─── Parse detections ────────────────────────────────────────────────────
+    predictions = []
+    
+    try:
+        # 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 type: {type(first_item)}")
+            logger.info(f"🔍 First item keys: {first_item.keys() if isinstance(first_item, dict) else 'Not dict'}")
             
-            # Handle case where predictions might be a dict
-            if isinstance(predictions, dict) and "predictions" in predictions:
-                predictions = predictions["predictions"]
+            # FIXED: Check for "predictions" directly first!
+            if isinstance(first_item, dict):
+                if "predictions" in first_item:
+                    predictions = first_item["predictions"]
+                    logger.info(f"✅ Found predictions directly in first_item")
+                elif "outputs" in first_item:
+                    outputs = first_item["outputs"]
+                    logger.info(f"🔍 Found outputs: {type(outputs)}")
+                    if isinstance(outputs, dict):
+                        predictions = outputs.get("predictions", [])
+                        
+        elif isinstance(result_json, dict):
+            # Response is a dict
+            logger.info(f"🔍 Dict keys: {list(result_json.keys())}")
             
-            logger.info(f"🔍 Final predictions type: {type(predictions)}")
-            logger.info(f"🔍 Final predictions count: {len(predictions) if isinstance(predictions, list) else 0}")
-            if isinstance(predictions, list) and len(predictions) > 0:
-                logger.info(f"🔍 First prediction keys: {predictions[0].keys()}")
-                
-        except Exception as e:
-            logger.error(f"❌ Parsing error: {e}", exc_info=True)
-            predictions = []
-        
-        if not predictions or (isinstance(predictions, list) and len(predictions) == 0):
-            logger.warning("⚠️ No predictions found after parsing")
-            return jsonify({
-                "status": "success",
-                "tooth_count": 0,
-                "results": [],
-                "message": "No teeth detected in image"
-            })
-        
-        logger.info(f"✅ Found {len(predictions)} teeth detections")
+            # Try "predictions" first
+            if "predictions" in result_json:
+                predictions = result_json["predictions"]
+            elif "outputs" in result_json:
+                outputs = result_json["outputs"]
+                if isinstance(outputs, list) and len(outputs) > 0:
+                    output_data = outputs[0]
+                elif isinstance(outputs, dict):
+                    output_data = outputs
+                else:
+                    output_data = {}
+                predictions = output_data.get("predictions", [])
         
-        # ─── Process detections ──────────────────────────────────────────
-        teeth_data = []
+        # Handle case where predictions might be a dict
+        if isinstance(predictions, dict) and "predictions" in predictions:
+            predictions = predictions["predictions"]
         
-        for idx, pred in enumerate(predictions):
-            try:
-                detection = {
-                    "tooth_id": idx + 1,
-                    "class": pred.get("class", "tooth"),
-                    "confidence": round(pred.get("confidence", 0) * 100, 2),
-                    "bounding_box": {
-                        "x": pred.get("x", 0),
-                        "y": pred.get("y", 0),
-                        "width": pred.get("width", 0),
-                        "height": pred.get("height", 0)
-                    }
-                }
-                
-                # Add detection ID if available
-                if "detection_id" in pred:
-                    detection["detection_id"] = pred["detection_id"]
-                
-                teeth_data.append(detection)
-                logger.info(f"🦷 Tooth {idx + 1}: {detection['class']} ({detection['confidence']}%)")
-                
-            except Exception as e:
-                logger.error(f"❌ Error processing detection {idx}: {e}")
+        logger.info(f"🔍 Final predictions type: {type(predictions)}")
+        logger.info(f"🔍 Final predictions count: {len(predictions) if isinstance(predictions, list) else 0}")
+        if isinstance(predictions, list) and len(predictions) > 0:
+            logger.info(f"🔍 First prediction keys: {predictions[0].keys()}")
+            
+    except Exception as e:
+        logger.error(f"❌ Parsing error: {e}", exc_info=True)
+        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,
+            "results": [],
+            "message": "No teeth detected in image"
+        }
+    
+    logger.info(f"✅ Found {len(predictions)} teeth detections")
+
+
+    # ─── Process crops ───────────────────────────────────────────────────────
+    batch_images = []
+    metadata = []
+
+    for i, det in enumerate(predictions[:12]):
+        try:
+            xc, yc, w, h = det["x"], det["y"], det["width"], det["height"]
+            x1 = max(0, int(xc - w/2))
+            y1 = max(0, int(yc - h/2))
+            x2 = min(img_w, int(xc + w/2))
+            y2 = min(img_h, int(yc + h/2))
+            
+            if x2 <= x1 or y2 <= y1:
                 continue
-        
-        # ─── Prepare response ────────────────────────────────────────────
-        response = {
+            
+            crop = img[y1:y2, x1:x2]
+            if crop.size == 0:
+                continue
+
+            # Preprocessing pipeline
+            gray = cv2.cvtColor(crop, cv2.COLOR_BGR2GRAY)
+            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+            gray = clahe.apply(gray)
+            
+            # Aspect-ratio preserving resize with padding
+            h_c, w_c = gray.shape
+            scale = IMG_SIZE / max(h_c, w_c)
+            nw, nh = int(w_c * scale), int(h_c * scale)
+            resized = cv2.resize(gray, (nw, nh), interpolation=cv2.INTER_AREA)
+            
+            canvas = np.zeros((IMG_SIZE, IMG_SIZE), dtype=np.uint8)
+            y_offset = (IMG_SIZE - nh) // 2
+            x_offset = (IMG_SIZE - nw) // 2
+            canvas[y_offset:y_offset + nh, x_offset:x_offset + nw] = resized
+            
+            final_img = (canvas.astype(np.float32) / 255.0)[..., np.newaxis]
+            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}")
+            continue
+
+    if not batch_images:
+        return {
             "status": "success",
-            "tooth_count": len(teeth_data),
-            "results": teeth_data,
-            "model_info": {
-                "workspace": ROBOFLOW_WORKSPACE,
-                "project": ROBOFLOW_PROJECT,
-                "version": ROBOFLOW_VERSION
-            }
+            "tooth_count": 0,
+            "results": [],
+            "message": "No valid tooth crops extracted"
         }
-        
-        logger.info(f"✅ Detection complete: {len(teeth_data)} teeth found")
-        return jsonify(response)
-        
-    except ValueError as ve:
-        logger.error(f"❌ Validation error: {ve}")
-        return jsonify({
-            "status": "error",
-            "message": str(ve)
-        }), 400
-        
+
+    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"❌ Unexpected error: {e}")
-        logger.error(traceback.format_exc())
-        return jsonify({
-            "status": "error",
-            "message": f"Internal server error: {str(e)}"
-        }), 500
-        
-    finally:
-        # Cleanup temp file
-        if temp_path:
-            cleanup_temp_file(temp_path)
+        logger.error(f"❌ Inference error: {e}")
+        raise HTTPException(status_code=500, detail="Model inference failed")
 
-# ─── Main ────────────────────────────────────────────────────────────────
+    # ─── Format results ──────────────────────────────────────────────────────
+    results = []
+    for idx, score in enumerate(errors):
+        score_val = float(score)
+        results.append({
+            "tooth_index": metadata[idx]["id"],
+            "anomaly_score": round(score_val, 4),
+            "is_caries_detected": score_val > THRESHOLD,
+            "bounding_box": metadata[idx]["box"],
+            "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),
+        "detection_threshold": THRESHOLD,
+        "results": results
+    }
 
-if __name__ == '__main__':
-    port = int(os.getenv('PORT', 5000))
-    logger.info(f"🚀 Starting server on port {port}")
-    app.run(
-        host='0.0.0.0',
-        port=port,
-        debug=os.getenv('FLASK_DEBUG', 'False').lower() == 'true'
+# ─── 7. ERROR HANDLER ────────────────────────────────────────────────────────
+@app.exception_handler(Exception)
+async def global_exception_handler(request, exc):
+    logger.error(f"Unhandled exception: {exc}", exc_info=True)
+    return JSONResponse(
+        status_code=500,
+        content={"detail": "Internal server error occurred"}
     )