changed to single image sending

main.py

@@ -1,12 +1,11 @@
 import os
 import logging
-from typing import List, Optional
+from typing import Optional
 from contextlib import asynccontextmanager
 
 import numpy as np
 import tensorflow as tf
 from fastapi import FastAPI, File, UploadFile, HTTPException, status
-from fastapi.responses import JSONResponse
 from PIL import Image
 import io
 from huggingface_hub import hf_hub_download
@@ -21,7 +20,6 @@ HF_MODEL_REPO: str = os.getenv("HF_MODEL_REPO", "yasyn14/smart-leaf-model")
 HF_MODEL_FILENAME: str = os.getenv("HF_MODEL_FILENAME", "best_model_32epochs.keras")
 HF_CACHE_DIR: str = os.getenv("HF_HOME", "/home/appuser/huggingface")
 IMAGE_SIZE: tuple = (300, 300)
-MAX_BATCH_SIZE: int = 10
 
 # Plant disease class names
 CLASS_NAMES = [
@@ -47,7 +45,6 @@ CLEAN_CLASS_NAMES = [name.replace('___', ' - ').replace('_', ' ') for name in CL
 HTTP_MESSAGES = {
     "MODEL_NOT_LOADED": "Model not loaded. Please check server logs.",
     "INVALID_FILE_TYPE": "File must be an image",
-    "BATCH_SIZE_EXCEEDED": "Maximum {max_size} images allowed per batch",
     "PREDICTION_FAILED": "Prediction failed: {error}",
     "IMAGE_PROCESSING_FAILED": "Error preprocessing image: {error}",
     "MODEL_LOAD_SUCCESS": "Model loaded successfully",
@@ -58,15 +55,12 @@ HTTP_MESSAGES = {
 model: Optional[tf.keras.Model] = None
 
 # Response models
-class PredictionResult(BaseModel):
+class PredictionResponse(BaseModel):
+    success: bool
     predicted_class: str
     clean_class_name: str
     confidence: float
     all_predictions: dict
-
-class PredictionResponse(BaseModel):
-    success: bool
-    results: List[PredictionResult]
     message: str
 
 class HealthResponse(BaseModel):
@@ -124,8 +118,8 @@ def preprocess_image(image_bytes: bytes) -> np.ndarray:
         logger.error(f"Error preprocessing image: {str(e)}")
         raise
 
-def predict_single_image(image_bytes: bytes) -> PredictionResult:
-    """Make prediction for a single image"""
+def predict_image(image_bytes: bytes) -> PredictionResponse:
+    """Make prediction for the uploaded image"""
     global model
     
     if model is None:
@@ -153,11 +147,13 @@ def predict_single_image(image_bytes: bytes) -> PredictionResult:
             for i in range(len(CLASS_NAMES))
         }
         
-        return PredictionResult(
+        return PredictionResponse(
+            success=True,
             predicted_class=predicted_class,
             clean_class_name=clean_class_name,
             confidence=confidence,
-            all_predictions=all_predictions
+            all_predictions=all_predictions,
+            message="Image processed successfully"
         )
         
     except Exception as e:
@@ -198,7 +194,7 @@ async def lifespan(app: FastAPI):
 # Create FastAPI app
 app = FastAPI(
     title="Plant Disease Prediction API",
-    description="API for predicting plant diseases from leaf images using deep learning",
+    description="API for predicting plant diseases from a single leaf image using deep learning",
     version="1.0.0",
     lifespan=lifespan
 )
@@ -222,54 +218,38 @@ async def health_check():
     )
 
 @app.post("/predict", response_model=PredictionResponse)
-async def predict_plant_disease(files: List[UploadFile] = File(...)):
+async def predict_plant_disease(file: UploadFile = File(...)):
     """
-    Predict plant disease from uploaded image(s)
+    Predict plant disease from uploaded image
     
-    - **files**: List of image files to analyze (max 10 files)
+    - **file**: Single image file to analyze
     
-    Returns predictions with confidence scores for each image
+    Returns prediction with confidence score for the image
     """
     
-    # Check batch size
-    if len(files) > MAX_BATCH_SIZE:
+    # Check if file is an image
+    if not is_image_file(file.filename):
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
-            detail=HTTP_MESSAGES["BATCH_SIZE_EXCEEDED"].format(max_size=MAX_BATCH_SIZE)
+            detail=f"{HTTP_MESSAGES['INVALID_FILE_TYPE']}: {file.filename}"
         )
     
-    results = []
-    
-    for file in files:
-        # Check if file is an image
-        if not is_image_file(file.filename):
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"{HTTP_MESSAGES['INVALID_FILE_TYPE']}: {file.filename}"
-            )
+    try:
+        # Read file content
+        image_bytes = await file.read()
         
-        try:
-            # Read file content
-            image_bytes = await file.read()
-            
-            # Make prediction
-            result = predict_single_image(image_bytes)
-            results.append(result)
-            
-        except HTTPException:
-            raise
-        except Exception as e:
-            logger.error(f"Error processing file {file.filename}: {str(e)}")
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail=HTTP_MESSAGES["IMAGE_PROCESSING_FAILED"].format(error=str(e))
-            )
-    
-    return PredictionResponse(
-        success=True,
-        results=results,
-        message=f"Successfully processed {len(results)} image(s)"
-    )
+        # Make prediction
+        result = predict_image(image_bytes)
+        return result
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error processing file {file.filename}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=HTTP_MESSAGES["IMAGE_PROCESSING_FAILED"].format(error=str(e))
+        )
 
 @app.get("/classes")
 async def get_classes():