app.py using a manual FastAPI endpoint

app.py

@@ -1,14 +1,19 @@
-# Final app.py using FastAPI wrapper
+# The Final app.py using a manual FastAPI endpoint
 
 from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
 import gradio as gr
 import tensorflow as tf
 from huggingface_hub import hf_hub_download
 import numpy as np
 from PIL import Image
 import os
+import base64
+import io
 
-# --- 1. Load the Model ---
+# --- 1. Load the Model (Stays the same) ---
+model = None
 try:
     model_path = hf_hub_download(
         repo_id="skibi11/leukolook-eye-detector", 
@@ -18,9 +23,9 @@ try:
     print("--- MODEL LOADED SUCCESSFULLY! ---")
 except Exception as e:
     print(f"--- ERROR LOADING MODEL: {e} ---")
-    raise RuntimeError(f"Failed to load model: {e}")
+    model = None # Ensure model is None if loading fails
 
-# --- 2. Pre-processing & Prediction Logic (remains the same) ---
+# --- 2. Prediction Logic (Stays the same) ---
 def preprocess_image(img_pil):
     img = img_pil.resize((224, 224))
     img_array = np.array(img)
@@ -30,32 +35,37 @@ def preprocess_image(img_pil):
     img_array = np.expand_dims(img_array, axis=0)
     return img_array
 
-def predict(image_from_gradio):
-    if not isinstance(image_from_gradio, np.ndarray):
-        return {"error": "Invalid input type. Expected an image."}
-    try:
-        pil_image = Image.fromarray(image_from_gradio)
-        processed_image = preprocess_image(pil_image)
-        prediction = model.predict(processed_image)
-        labels = [f"Class_{i}" for i in range(prediction.shape[1])]
-        confidences = {label: float(score) for label, score in zip(labels, prediction[0])}
-        return confidences
-    except Exception as e:
-        return {"error": f"Error during prediction: {e}"}
+def run_prediction(pil_image):
+    if model is None:
+        return {"error": "Model is not loaded on the server."}
 
-# --- 3. Create the Gradio Interface (without launching) ---
-gradio_interface = gr.Interface(
-    fn=predict,
-    inputs=gr.Image(type="numpy"),
-    outputs=gr.JSON(),
-    api_name="predict"
-)
+    processed_image = preprocess_image(pil_image)
+    prediction = model.predict(processed_image)
+    labels = [f"Class_{i}" for i in range(prediction.shape[1])]
+    confidences = {label: float(score) for label, score in zip(labels, prediction[0])}
+    return confidences
 
-# --- 4. Create the FastAPI app and mount the Gradio app to it ---
+# --- 3. Create the FastAPI app ---
 app = FastAPI()
-app = gr.mount_gradio_app(app, gradio_interface, path="/")
 
-# --- 5. To run the server ---
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+# --- 4. Define the input data structure for our new endpoint ---
+class PredictionRequest(BaseModel):
+    data: list[str]
+
+# --- 5. Create our own reliable API endpoint ---
+@app.post("/api/predict/")
+async def handle_prediction(request: PredictionRequest):
+    try:
+        # Get the Base64 string from the JSON payload
+        base64_string = request.data[0].split(',', 1)[1]
+        image_bytes = base64.b64decode(base64_string)
+        pil_image = Image.open(io.BytesIO(image_bytes))
+
+        # Run the prediction
+        result_dict = run_prediction(pil_image)
+
+        # Return the result in the same format Gradio does
+        return JSONResponse(content={"data": [result_dict]})
+
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"error": str(e)})