model dir changed

app.py

@@ -1,18 +1,26 @@
 # --- IMPORTS ---
 import os
+import sys
+from pathlib import Path
+
 from fastapi import FastAPI, Request
 from fastapi.responses import HTMLResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
-import uvicorn 
-import sys # <-- Add this import
-from pathlib import Path # <-- Add this import
+import uvicorn
+
+# NEW, CRITICAL IMPORT for running behind a proxy
+from uvicorn.middleware.proxy_headers import ProxyHeadersMiddleware
 
+# --- ADD THIS BLOCK TO FIX 'ModuleNotFoundError' ---
+# This adds the 'src' directory to the Python path
+# so it can find the cnnClassifier package in the Docker container.
 sys.path.append(str(Path(__file__).parent / "src"))
+# ----------------------------------------------------
 
-# Your existing ML components
+# Now we can import your custom ML components
 from cnnClassifier.utils.common import decodeImage
 from cnnClassifier.pipeline.prediction import PredictionPipeline
 
@@ -26,8 +34,14 @@ app = FastAPI(
     description="An API to predict whether a chest CT scan shows signs of adenocarcinoma cancer."
 )
 
+# --- ADD PROXY MIDDLEWARE (FIXES HTTPS/MIXED CONTENT ERROR) ---
+# This middleware is essential for running behind a reverse proxy like Hugging Face Spaces.
+# It tells the app to trust the 'x-forwarded-proto' header from the proxy.
+app.add_middleware(ProxyHeadersMiddleware, trusted_hosts="*")
+# ------------------------------------------------------------
+
 # --- MIDDLEWARE (for CORS) ---
-# This is the FastAPI equivalent of Flask-CORS
+# This should come AFTER the ProxyHeadersMiddleware
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -37,39 +51,25 @@ app.add_middleware(
 )
 
 # --- MOUNT STATIC FILES AND TEMPLATES ---
-# This is how FastAPI serves your CSS, JS, and HTML files
 app.mount("/static", StaticFiles(directory="static"), name="static")
 templates = Jinja2Templates(directory="templates")
 
-
 # --- LOAD THE PREDICTION PIPELINE ON STARTUP ---
-# This ensures the model is loaded only once when the application starts.
 classifier = PredictionPipeline(filename="inputImage.jpg")
 
-
 # --- DEFINE THE REQUEST BODY STRUCTURE ---
-# Pydantic model for automatic validation of the incoming JSON
 class ImagePayload(BaseModel):
     image: str
 
-
 # --- API ENDPOINTS ---
-
 @app.get("/", response_class=HTMLResponse)
 async def home(request: Request):
-    """
-    Renders the main user interface (index.html).
-    """
+    """Renders the main user interface (index.html)."""
     return templates.TemplateResponse("index.html", {"request": request})
 
-
 @app.post("/train")
 async def trainRoute():
-    """
-    Triggers the DVC pipeline to retrain the model.
-    NOTE: This is a blocking operation and not recommended for a real-world, high-traffic production server.
-    It's suitable for this project's demonstration purposes.
-    """
+    """Triggers the DVC pipeline to retrain the model."""
     os.system("dvc repro")
     return {"message": "Training done successfully!"}
 
@@ -77,26 +77,31 @@ async def trainRoute():
 @app.post("/predict")
 async def predictRoute(payload: ImagePayload):
     """
-    Accepts a base64 encoded image, saves it, runs prediction, and returns the result.
+    Accepts a base64 encoded image, saves it to a temporary location,
+    runs prediction, and returns the result.
     """
-    # 1. Decode the image and save it
-    decodeImage(payload.image, "inputImage.jpg")
-
-    # 2. Run the prediction pipeline
+    # --- THIS IS THE FIX ---
+    # Define a writable filename inside the /tmp directory.
+    temp_image_path = "/tmp/inputImage.jpg"
+    
+    # 1. Decode the image and save it to the temporary path
+    decodeImage(payload.image, temp_image_path)
+
+    # 2. Update the classifier's filename to the new temporary path and predict
+    classifier.filename = temp_image_path
     prediction_value = classifier.predict()
+    # ----------------------
 
     # 3. Translate the numeric prediction into a human-readable string
-    # Based on your confirmed class indices: {'adenocarcinoma': 0, 'normal': 1}
     if prediction_value == 1:
         prediction_text = "Normal"
-    else:  # The value was 0
+    else:
         prediction_text = "Cancer"
 
-    # 4. Return the result. FastAPI handles the JSON conversion.
+    # 4. Return the result
     return [{"prediction": prediction_text}]
 
-
 # --- RUN THE APP ---
-# This block is for local development. Gunicorn/Uvicorn will run the app in production.
 if __name__ == "__main__":
+    # Note: Hugging Face uses port 7860 by default for its apps
     uvicorn.run(app, host="0.0.0.0", port=7860)

src/cnnClassifier/pipeline/prediction.py

@@ -5,32 +5,40 @@ import os
 
 class PredictionPipeline:
     def __init__(self, filename):
+        """
+        Initializes the prediction pipeline.
+
+        This is where we load the model ONCE when the application starts.
+        This is much more efficient than loading it for every prediction.
+        """
         self.filename = filename
+        
+        # --- THIS IS THE FIX ---
+        # The Dockerfile places the model in a 'model' directory.
+        # This is the correct path inside the container.
+        model_path = os.path.join("model", "best_model.h5")
+        self.model = tf.keras.models.load_model(model_path)
+        # ----------------------
 
     def predict(self):
-        # --- FIX #1: LOAD THE CORRECT MODEL ---
-        # Load the BEST model produced by your DVC pipeline.
-        model_path = os.path.join("artifacts", "training", "best_model.h5")
-        model = tf.keras.models.load_model(model_path)
-
-        # --- Load and preprocess the image ---
+        """
+        Performs the prediction on the image file.
+        It uses the model that was already loaded in the constructor.
+        """
+        # Load and preprocess the image
         imagename = self.filename
         test_image = image.load_img(imagename, target_size=(224, 224))
         test_image_array = image.img_to_array(test_image)
         
-        # --- FIX #2: THE CRITICAL RESCALING STEP ---
         # Scale the pixel values to be between 0 and 1, just like the training data.
         scaled_image_array = test_image_array / 255.0
         
         # Add the batch dimension
         input_data = np.expand_dims(scaled_image_array, axis=0)
 
-        # --- Make the prediction on the CORRECTLY preprocessed image ---
-        result_index = np.argmax(model.predict(input_data), axis=1)[0]
-        print(f"Model predicted index: {result_index}")
+        # Make the prediction using the pre-loaded model
+        prediction_probs = self.model.predict(input_data)
+        result_index = np.argmax(prediction_probs, axis=1)
 
-        # --- FIX #3: RETURN THE CORRECT JSON STRUCTURE ---
-        # The logic for translation should be in app.py to keep this pipeline clean,
-        # but for now, we will just return the raw index.
-        # app.py will handle translating 0/1 to "Cancer"/"Normal".
+        # Return the raw index (e.g., [0] or [1])
         return result_index