change main.py and added json

disease_guide.json

@@ -0,0 +1,119 @@
+{
+  "Apple___Apple_scab": {
+    "disease_name": "Apple Scab",
+    "common_names": ["Apple scab"],
+    "crop": "Apple",
+    "description": "A fungal disease caused by Venturia inaequalis that affects the leaves and fruit of apple trees, resulting in olive-green to black velvety lesions.",
+    "symptoms": [
+      "Dark, scabby lesions on leaves and fruit",
+      "Premature leaf drop"
+    ],
+    "cause": "Fungal",
+    "treatment": [
+      "Apply fungicides like captan or myclobutanil",
+      "Remove infected leaves and fruit"
+    ],
+    "prevention": [
+      "Prune trees for better air circulation",
+      "Plant resistant varieties"
+    ],
+    "image_urls": ["https://yourcdn.com/apple_scab_1.jpg"],
+    "management_tips": "Monitor trees during wet seasons and apply fungicide as needed.",
+    "risk_level": "High",
+    "sprayer_intervals": "Every 7-10 days during wet periods",
+    "localized_tips": "Ensure proper pruning to reduce humidity",
+    "type": "Fungal",
+    "external_resources": [
+      {
+        "title": "Apple Scab Management",
+        "url": "https://example.com/apple-scab"
+      }
+    ]
+  },
+  "Apple___Black_rot": {
+    "disease_name": "Black Rot",
+    "common_names": ["Apple black rot"],
+    "crop": "Apple",
+    "description": "Caused by the fungus Botryosphaeria obtusa, black rot affects the fruit, leaves, and bark of apple trees.",
+    "symptoms": [
+      "Circular brown lesions on fruit",
+      "Purple-bordered leaf spots"
+    ],
+    "cause": "Fungal",
+    "treatment": [
+      "Remove and destroy infected branches and fruit",
+      "Apply fungicides in early spring"
+    ],
+    "prevention": ["Sanitize pruning tools", "Clear fallen debris"],
+    "image_urls": ["https://yourcdn.com/apple_black_rot_1.jpg"],
+    "management_tips": "Clean up mummified fruits and dead wood from the orchard.",
+    "risk_level": "Medium",
+    "sprayer_intervals": "Every 10-14 days",
+    "localized_tips": "Remove mummified fruit and prune affected branches",
+    "type": "Fungal",
+    "external_resources": []
+  },
+  "Apple___Cedar_apple_rust": {
+    "disease_name": "Cedar Apple Rust",
+    "common_names": ["Cedar rust"],
+    "crop": "Apple",
+    "description": "A fungal disease requiring both apple and cedar (juniper) hosts to complete its lifecycle.",
+    "symptoms": ["Bright orange spots on leaves", "Galls on cedar trees"],
+    "cause": "Fungal",
+    "treatment": [
+      "Apply fungicide such as mancozeb",
+      "Remove nearby cedar trees if possible"
+    ],
+    "prevention": [
+      "Use resistant varieties",
+      "Space trees to increase airflow"
+    ],
+    "image_urls": ["https://yourcdn.com/cedar_apple_rust_1.jpg"],
+    "management_tips": "Monitor both apple and cedar hosts for symptoms and apply fungicide preventively.",
+    "risk_level": "Medium",
+    "sprayer_intervals": "Every 7-10 days during infection periods",
+    "localized_tips": "Avoid planting near cedar trees",
+    "type": "Fungal",
+    "external_resources": []
+  },
+  "Apple___healthy": {
+    "disease_name": null,
+    "common_names": [],
+    "crop": "Apple",
+    "description": "Healthy plant — no disease detected.",
+    "symptoms": [],
+    "cause": null,
+    "treatment": [],
+    "prevention": ["Maintain good cultural practices"],
+    "image_urls": ["https://yourcdn.com/apple_healthy_1.jpg"],
+    "management_tips": "Regular inspection and proper irrigation help maintain plant health.",
+    "risk_level": "Low",
+    "sprayer_intervals": "Preventive fungicide once per month",
+    "localized_tips": "Keep foliage dry by watering at the base",
+    "type": "None",
+    "external_resources": []
+  },
+  "Tomato___Late_blight": {
+    "disease_name": "Late Blight",
+    "common_names": ["Tomato late blight"],
+    "crop": "Tomato",
+    "description": "A serious fungal disease caused by Phytophthora infestans, affecting leaves, stems, and fruit.",
+    "symptoms": [
+      "Large, dark brown blotches with green halos on leaves",
+      "Fruits develop firm, dark lesions"
+    ],
+    "cause": "Fungal",
+    "treatment": [
+      "Apply fungicide like chlorothalonil or mancozeb",
+      "Remove infected plants"
+    ],
+    "prevention": ["Use resistant varieties", "Rotate crops annually"],
+    "image_urls": ["https://yourcdn.com/tomato_late_blight.jpg"],
+    "management_tips": "Avoid overhead watering to reduce moisture on leaves.",
+    "risk_level": "High",
+    "sprayer_intervals": "Every 7 days during high humidity",
+    "localized_tips": "Improve drainage and spacing to reduce humidity",
+    "type": "Fungal",
+    "external_resources": []
+  }
+}

main.py

@@ -1,15 +1,20 @@
+import json
 import os
 import logging
-from typing import Optional
+from typing import Dict, Optional, Any, List
 from contextlib import asynccontextmanager
+from rapidfuzz import process, fuzz
+
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
 
 import numpy as np
 import tensorflow as tf
-from fastapi import FastAPI, File, UploadFile, HTTPException, status
+from fastapi import FastAPI, File, Path, Query, UploadFile, HTTPException, status
 from PIL import Image
 import io
 from huggingface_hub import hf_hub_download
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -20,6 +25,8 @@ 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_FILE_SIZE_MB: int = 10
+CONFIDENCE_THRESHOLD: float = 0.5
 
 # Plant disease class names
 CLASS_NAMES = [
@@ -38,36 +45,131 @@ CLASS_NAMES = [
     'Tomato___healthy'
 ]
 
-# Clean class names for better display
-CLEAN_CLASS_NAMES = [name.replace('___', ' - ').replace('_', ' ') for name in CLASS_NAMES]
-
 # HTTP Status Messages
 HTTP_MESSAGES = {
     "MODEL_NOT_LOADED": "Model not loaded. Please check server logs.",
     "INVALID_FILE_TYPE": "File must be an image",
+    "FILE_TOO_LARGE": f"File size exceeds {MAX_FILE_SIZE_MB}MB limit",
     "PREDICTION_FAILED": "Prediction failed: {error}",
     "IMAGE_PROCESSING_FAILED": "Error preprocessing image: {error}",
     "MODEL_LOAD_SUCCESS": "Model loaded successfully",
-    "MODEL_LOAD_FAILED": "Failed to load model"
+    "MODEL_LOAD_FAILED": "Failed to load model",
+    "LOW_CONFIDENCE": "Prediction confidence is low. Please try a clearer image."
 }
 
 # Global model variable
 model: Optional[tf.keras.Model] = None
+disease_guide: Dict[str, Dict[str, Any]] = {}
 
 # Response models
+class DiseaseInfo(BaseModel):
+    disease_name: Optional[str]
+    common_names: List[str] = []
+    crop: str
+    description: str
+    symptoms: List[str] = []
+    cause: Optional[str]
+    treatment: List[str] = []
+    prevention: List[str] = []
+    management_tips: str = ""
+    risk_level: str = "Unknown"
+    sprayer_intervals: str = ""
+    localized_tips: str = ""
+    type: str = "Unknown"
+    external_resources: List[Dict[str, str]] = []
+
 class PredictionResponse(BaseModel):
     success: bool
     predicted_class: str
-    clean_class_name: str
+    clean_class_name: str = Field(description="Human-readable class name")
     confidence: float
-    all_predictions: dict
+    confidence_level: str = Field(description="High/Medium/Low confidence level")
+    all_predictions: Dict[str, float] = Field(description="Top 5 predictions with confidence scores")
+    disease_info: DiseaseInfo
+    recommendations: List[str] = Field(description="Action recommendations based on prediction")
     message: str
 
 class HealthResponse(BaseModel):
     status: str
     model_loaded: bool
+    total_classes: int
+    available_diseases: int
     message: str
 
+class SearchResult(BaseModel):
+    class_name: str
+    disease_info: DiseaseInfo
+    relevance_score: Optional[float] = None
+
+class SearchResponse(BaseModel):
+    results: List[SearchResult]
+    suggestions: List[SearchResult] = []
+    total_results: int
+    message: str = ""
+
+def load_disease_guide() -> Dict[str, Dict[str, Any]]:
+    """Load disease guide from JSON file with error handling"""
+    try:
+        guide_path = "disease_guide.json"
+        if not os.path.exists(guide_path):
+            logger.warning(f"Disease guide file not found at {guide_path}")
+            return {}
+        
+        with open(guide_path, 'r', encoding='utf-8') as f:
+            guide = json.load(f)
+        
+        logger.info(f"Loaded disease guide with {len(guide)} entries")
+        return guide
+    except Exception as e:
+        logger.error(f"Failed to load disease guide: {str(e)}")
+        return {}
+
+def clean_class_name(class_name: str) -> str:
+    """Convert class name to human-readable format"""
+    # Replace underscores with spaces and clean up formatting
+    cleaned = class_name.replace('___', ' - ').replace('_', ' ')
+    # Handle special cases
+    cleaned = cleaned.replace('(including sour)', '(including sour)')
+    cleaned = cleaned.replace('Two-spotted spider mite', 'Two-spotted spider mite')
+    return cleaned.title()
+
+def get_confidence_level(confidence: float) -> str:
+    """Categorize confidence level"""
+    if confidence >= 0.8:
+        return "High"
+    elif confidence >= 0.6:
+        return "Medium"
+    else:
+        return "Low"
+
+def get_recommendations(predicted_class: str, confidence: float, disease_info: Dict[str, Any]) -> List[str]:
+    """Generate actionable recommendations based on prediction"""
+    recommendations = []
+    
+    if confidence < CONFIDENCE_THRESHOLD:
+        recommendations.append("Consider taking a clearer, well-lit photo for better accuracy")
+        recommendations.append("Ensure the leaf fills most of the frame")
+    
+    if disease_info.get("disease_name"):
+        # Disease detected
+        recommendations.extend([
+            f"Immediate action: {disease_info.get('treatment', ['Consult agricultural expert'])[0] if disease_info.get('treatment') else 'Consult agricultural expert'}",
+            "Isolate affected plants to prevent spread",
+            "Monitor other plants for similar symptoms"
+        ])
+        
+        if disease_info.get("risk_level") == "High":
+            recommendations.insert(0, "⚠️ HIGH RISK: Take immediate action to prevent crop loss")
+    else:
+        # Healthy plant
+        recommendations.extend([
+            "Plant appears healthy - continue current care routine",
+            "Monitor regularly for any changes",
+            "Maintain preventive measures"
+        ])
+    
+    return recommendations
+
 def download_model_from_hf() -> str:
     """Download model from Hugging Face Hub"""
     try:
@@ -84,31 +186,51 @@ def download_model_from_hf() -> str:
         raise
 
 def load_model() -> tf.keras.Model:
-    """Load the Keras model from Hugging Face"""
+    """Load the Keras model from Hugging Face with optimization"""
     try:
         model_path = download_model_from_hf()
         loaded_model = tf.keras.models.load_model(model_path)
-        logger.info("Model loaded successfully")
+        
+        # Compile model for inference optimization
+        loaded_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
+        
+        logger.info("Model loaded and compiled successfully")
         return loaded_model
     except Exception as e:
         logger.error(f"Failed to load model: {str(e)}")
         raise
 
+def validate_file_size(file_size: int) -> None:
+    """Validate uploaded file size"""
+    max_size_bytes = MAX_FILE_SIZE_MB * 1024 * 1024
+    if file_size > max_size_bytes:
+        raise HTTPException(
+            status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+            detail=HTTP_MESSAGES["FILE_TOO_LARGE"]
+        )
+
 def preprocess_image(image_bytes: bytes) -> np.ndarray:
-    """Preprocess image for model prediction"""
+    """Preprocess image for model prediction with enhanced error handling"""
     try:
-        # Open image from bytes
+        # Validate file size
+        validate_file_size(len(image_bytes))
+        
+        # Open and validate image
         image = Image.open(io.BytesIO(image_bytes))
         
+        # Validate image format
+        if image.format not in ['JPEG', 'PNG', 'BMP', 'TIFF', 'WEBP']:
+            raise ValueError(f"Unsupported image format: {image.format}")
+        
         # Convert to RGB if needed
         if image.mode != 'RGB':
             image = image.convert('RGB')
         
-        # Resize image
-        image = image.resize(IMAGE_SIZE)
+        # Resize image with high-quality resampling
+        image = image.resize(IMAGE_SIZE, Image.Resampling.LANCZOS)
         
         # Convert to numpy array and normalize
-        img_array = np.array(image) / 255.0
+        img_array = np.array(image, dtype=np.float32) / 255.0
         
         # Add batch dimension
         img_array = np.expand_dims(img_array, axis=0)
@@ -116,11 +238,14 @@ def preprocess_image(image_bytes: bytes) -> np.ndarray:
         return img_array
     except Exception as e:
         logger.error(f"Error preprocessing image: {str(e)}")
-        raise
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=HTTP_MESSAGES["IMAGE_PROCESSING_FAILED"].format(error=str(e))
+        )
 
 def predict_image(image_bytes: bytes) -> PredictionResponse:
-    """Make prediction for the uploaded image"""
-    global model
+    """Make prediction for the uploaded image with enhanced response"""
+    global model, disease_guide
     
     if model is None:
         raise HTTPException(
@@ -137,25 +262,48 @@ def predict_image(image_bytes: bytes) -> PredictionResponse:
         predicted_class_idx = np.argmax(predictions[0])
         confidence = float(predictions[0][predicted_class_idx])
         
-        # Get class names
+        # Get predicted class
         predicted_class = CLASS_NAMES[predicted_class_idx]
-        clean_class_name = CLEAN_CLASS_NAMES[predicted_class_idx]
+        clean_name = clean_class_name(predicted_class)
+        confidence_level = get_confidence_level(confidence)
         
-        # Create all predictions dictionary
+        # Get top 5 predictions
+        top_indices = np.argsort(predictions[0])[-5:][::-1]
         all_predictions = {
-            CLEAN_CLASS_NAMES[i]: float(predictions[0][i]) 
-            for i in range(len(CLASS_NAMES))
+            clean_class_name(CLASS_NAMES[idx]): float(predictions[0][idx])
+            for idx in top_indices
         }
         
+        # Get disease information
+        disease_data = disease_guide.get(predicted_class, {})
+        disease_info = DiseaseInfo(**disease_data) if disease_data else DiseaseInfo(
+            crop="Unknown",
+            description="No information available for this class"
+        )
+        
+        # Generate recommendations
+        recommendations = get_recommendations(predicted_class, confidence, disease_data)
+        
+        # Determine message based on confidence
+        if confidence < CONFIDENCE_THRESHOLD:
+            message = HTTP_MESSAGES["LOW_CONFIDENCE"]
+        else:
+            message = "Prediction completed successfully"
+        
         return PredictionResponse(
             success=True,
             predicted_class=predicted_class,
-            clean_class_name=clean_class_name,
+            clean_class_name=clean_name,
             confidence=confidence,
+            confidence_level=confidence_level,
             all_predictions=all_predictions,
-            message="Image processed successfully"
+            disease_info=disease_info,
+            recommendations=recommendations,
+            message=message
         )
         
+    except HTTPException:
+        raise
     except Exception as e:
         logger.error(f"Prediction failed: {str(e)}")
         raise HTTPException(
@@ -165,6 +313,8 @@ def predict_image(image_bytes: bytes) -> PredictionResponse:
 
 def is_image_file(filename: str) -> bool:
     """Check if file is an image based on extension"""
+    if not filename:
+        return False
     image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.gif', '.tiff', '.webp'}
     return any(filename.lower().endswith(ext) for ext in image_extensions)
 
@@ -172,9 +322,14 @@ def is_image_file(filename: str) -> bool:
 async def lifespan(app: FastAPI):
     """Handle startup and shutdown events"""
     # Startup
-    global model
+    global model, disease_guide
     try:
-        logger.info("Starting up... Loading model")
+        logger.info("Starting up... Loading disease guide and model")
+        
+        # Load disease guide
+        disease_guide = load_disease_guide()
+        
+        # Load model
         model = load_model()
         
         # Pre-warm the model with a dummy prediction
@@ -183,7 +338,7 @@ async def lifespan(app: FastAPI):
         logger.info("Model pre-warmed successfully")
         
     except Exception as e:
-        logger.error(f"Failed to load model during startup: {str(e)}")
+        logger.error(f"Failed to initialize during startup: {str(e)}")
         model = None
     
     yield
@@ -194,9 +349,20 @@ async def lifespan(app: FastAPI):
 # Create FastAPI app
 app = FastAPI(
     title="Plant Disease Prediction API",
-    description="API for predicting plant diseases from a single leaf image using deep learning",
-    version="1.0.0",
-    lifespan=lifespan
+    description="API for predicting plant diseases from leaf images using deep learning",
+    version="2.0.0",
+    lifespan=lifespan,
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure appropriately for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
 )
 
 @app.get("/", response_model=HealthResponse)
@@ -205,6 +371,8 @@ async def root():
     return HealthResponse(
         status="running",
         model_loaded=model is not None,
+        total_classes=len(CLASS_NAMES),
+        available_diseases=len([d for d in disease_guide.values() if d.get("disease_name")]),
         message="Plant Disease Prediction API is running"
     )
 
@@ -214,6 +382,8 @@ async def health_check():
     return HealthResponse(
         status="healthy" if model is not None else "unhealthy",
         model_loaded=model is not None,
+        total_classes=len(CLASS_NAMES),
+        available_diseases=len([d for d in disease_guide.values() if d.get("disease_name")]),
         message=HTTP_MESSAGES["MODEL_LOAD_SUCCESS"] if model is not None else HTTP_MESSAGES["MODEL_NOT_LOADED"]
     )
 
@@ -222,12 +392,18 @@ async def predict_plant_disease(file: UploadFile = File(...)):
     """
     Predict plant disease from uploaded image
     
-    - **file**: Single image file to analyze
+    - **file**: Single image file to analyze (max 10MB)
     
-    Returns prediction with confidence score for the image
+    Returns comprehensive prediction with confidence score, disease information, and recommendations
     """
     
-    # Check if file is an image
+    # Validate file
+    if not file.filename:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="No filename provided"
+        )
+    
     if not is_image_file(file.filename):
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
@@ -251,15 +427,148 @@ async def predict_plant_disease(file: UploadFile = File(...)):
             detail=HTTP_MESSAGES["IMAGE_PROCESSING_FAILED"].format(error=str(e))
         )
 
-@app.get("/classes")
-async def get_classes():
-    """Get all available plant disease classes"""
+@app.get("/diseases", response_model=List[SearchResult])
+async def get_all_plant_diseases(
+    crop: Optional[str] = Query(None, description="Filter by crop name (e.g. Apple, Tomato)"),
+    disease_type: Optional[str] = Query(None, description="Filter by disease type (Fungal, Bacterial, Viral)"),
+    risk_level: Optional[str] = Query(None, description="Filter by risk level (High, Medium, Low)")
+):
+    """
+    Get all plant diseases with optional filtering
+    """
+    diseases = []
+    
+    for class_name, info in disease_guide.items():
+        if not info.get("disease_name"):
+            continue  # Skip healthy entries
+        
+        # Apply filters
+        if crop and info.get("crop", "").lower() != crop.lower():
+            continue
+        if disease_type and info.get("type", "").lower() != disease_type.lower():
+            continue
+        if risk_level and info.get("risk_level", "").lower() != risk_level.lower():
+            continue
+        
+        diseases.append(SearchResult(
+            class_name=class_name,
+            disease_info=DiseaseInfo(**info)
+        ))
+    
+    return diseases
+
+@app.get("/search", response_model=SearchResponse)
+async def search_diseases(
+    query: str = Query(..., min_length=1, description="Search term"),
+    limit: int = Query(10, ge=1, le=50, description="Maximum number of results")
+):
+    """
+    Search plant diseases with fuzzy matching and relevance scoring
+    """
+    query_lower = query.lower()
+    exact_matches = []
+    fuzzy_candidates = []
+    
+    for class_name, info in disease_guide.items():
+        if not info.get("disease_name"):
+            continue
+        
+        # Build searchable text
+        searchable_text = " ".join([
+            class_name,
+            info.get("disease_name", ""),
+            info.get("description", ""),
+            info.get("crop", ""),
+            info.get("type", ""),
+            " ".join(info.get("symptoms", [])),
+            " ".join(info.get("common_names", []))
+        ]).lower()
+        
+        # Check for exact substring matches
+        if query_lower in searchable_text:
+            exact_matches.append(SearchResult(
+                class_name=class_name,
+                disease_info=DiseaseInfo(**info)
+            ))
+        else:
+            fuzzy_candidates.append((class_name, info, searchable_text))
+    
+    # If we have exact matches, return them
+    if exact_matches:
+        return SearchResponse(
+            results=exact_matches[:limit],
+            total_results=len(exact_matches),
+            message=f"Found {len(exact_matches)} exact matches"
+        )
+    
+    # Fuzzy search on candidates
+    search_texts = [text for _, _, text in fuzzy_candidates]
+    fuzzy_matches = process.extract(
+        query, search_texts, scorer=fuzz.token_sort_ratio, limit=limit
+    )
+    
+    suggestions = []
+    for match_text, score, idx in fuzzy_matches:
+        if score > 60:  # Minimum relevance threshold
+            class_name, info, _ = fuzzy_candidates[idx]
+            suggestions.append(SearchResult(
+                class_name=class_name,
+                disease_info=DiseaseInfo(**info),
+                relevance_score=score
+            ))
+    
+    return SearchResponse(
+        results=[],
+        suggestions=suggestions,
+        total_results=len(suggestions),
+        message="No exact matches found. Showing relevant suggestions." if suggestions else "No matches found."
+    )
+
+@app.get("/diseases/{class_name}", response_model=SearchResult)
+async def get_disease_by_class_name(
+    class_name: str = Path(..., description="Exact class name, e.g. Apple___Apple_scab")
+):
+    """
+    Retrieve detailed information for a specific disease class
+    """
+    disease_data = disease_guide.get(class_name)
+    
+    if not disease_data:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Disease with class name '{class_name}' not found."
+        )
+    
+    return SearchResult(
+        class_name=class_name,
+        disease_info=DiseaseInfo(**disease_data)
+    )
+
+@app.get("/stats")
+async def get_api_stats():
+    """Get API statistics and supported classes"""
+    crops = set()
+    disease_types = set()
+    risk_levels = set()
+    
+    for info in disease_guide.values():
+        if info.get("crop"):
+            crops.add(info["crop"])
+        if info.get("type"):
+            disease_types.add(info["type"])
+        if info.get("risk_level"):
+            risk_levels.add(info["risk_level"])
+    
     return {
-        "classes": CLASS_NAMES,
-        "clean_classes": CLEAN_CLASS_NAMES,
-        "total_classes": len(CLASS_NAMES)
+        "total_classes": len(CLASS_NAMES),
+        "diseases_in_guide": len([d for d in disease_guide.values() if d.get("disease_name")]),
+        "healthy_classes": len([d for d in disease_guide.values() if not d.get("disease_name")]),
+        "supported_crops": sorted(list(crops)),
+        "disease_types": sorted(list(disease_types)),
+        "risk_levels": sorted(list(risk_levels)),
+        "model_loaded": model is not None
     }
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    uvicorn.run(app, host="0.0.0.0", port=8000, reload=False)

todo.md

@@ -0,0 +1,43 @@
+## ✅ Completed
+
+- [x] Apple\_\_\_Apple_scab
+- [x] Apple\_\_\_Black_rot
+- [x] Apple\_\_\_Cedar_apple_rust
+- [x] Apple\_\_\_healthy
+- [x] Tomato\_\_\_Late_blight
+
+## ⏳ To Do
+
+- [ ] Blueberry\_\_\_healthy
+- [ ] Cherry\_(including_sour)\_\_\_Powdery_mildew
+- [ ] Cherry\_(including_sour)\_\_\_healthy
+- [ ] Corn\_(maize)\_\_\_Cercospora_leaf_spot Gray_leaf_spot
+- [ ] Corn\_(maize)_\_\_Common_rust_
+- [ ] Corn\_(maize)\_\_\_Northern_Leaf_Blight
+- [ ] Corn\_(maize)\_\_\_healthy
+- [ ] Grape\_\_\_Black_rot
+- [ ] Grape*\_\_Esca*(Black_Measles)
+- [ ] Grape*\_\_Leaf_blight*(Isariopsis_Leaf_Spot)
+- [ ] Grape\_\_\_healthy
+- [ ] Orange*\_\_Haunglongbing*(Citrus_greening)
+- [ ] Peach\_\_\_Bacterial_spot
+- [ ] Peach\_\_\_healthy
+- [ ] Pepper,\_bell\_\_\_Bacterial_spot
+- [ ] Pepper,\_bell\_\_\_healthy
+- [ ] Potato\_\_\_Early_blight
+- [ ] Potato\_\_\_Late_blight
+- [ ] Potato\_\_\_healthy
+- [ ] Raspberry\_\_\_healthy
+- [ ] Soybean\_\_\_healthy
+- [ ] Squash\_\_\_Powdery_mildew
+- [ ] Strawberry\_\_\_Leaf_scorch
+- [ ] Strawberry\_\_\_healthy
+- [ ] Tomato\_\_\_Bacterial_spot
+- [ ] Tomato\_\_\_Early_blight
+- [ ] Tomato\_\_\_Leaf_Mold
+- [ ] Tomato\_\_\_Septoria_leaf_spot
+- [ ] Tomato\_\_\_Spider_mites Two-spotted_spider_mite
+- [ ] Tomato\_\_\_Target_Spot
+- [ ] Tomato\_\_\_Tomato_Yellow_Leaf_Curl_Virus
+- [ ] Tomato\_\_\_Tomato_mosaic_virus
+- [ ] Tomato\_\_\_healthy