getting strted

.dockerignore

@@ -0,0 +1,65 @@
+# Git
+.git
+.gitignore
+
+# Python
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+pip-log.txt
+pip-delete-this-directory.txt
+.tox
+.coverage
+.coverage.*
+.pytest_cache
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDEs and editors
+.vscode
+.idea
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Documentation
+README.md
+*.md
+docs/
+
+# Test files
+tests/
+test_images/
+*.jpg
+*.png
+*.jpeg
+*.bmp
+*.gif
+*.tiff
+*.webp
+
+# Logs
+*.log
+logs/
+
+# Model cache (will be downloaded during build)
+huggingface/
+.huggingface/
+/tmp/huggingface/

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,102 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Model files (cached)
+/tmp/
+*.keras
+*.h5
+*.pb
+*.ckpt
+
+# Hugging Face cache
+huggingface/
+.huggingface/
+
+# Test images
+test_images/
+*.jpg
+*.png
+*.jpeg
+*.bmp
+*.gif
+*.tiff
+*.webp
+
+# Environment variables
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local

.huggingface.yaml

@@ -0,0 +1,22 @@
+title: SmartLeaf API
+emoji: 🌿
+colorFrom: green
+colorTo: lime
+sdk: docker
+license: mit
+app_port: 7860
+pinned: true
+app_file: main.py
+duplicated_from: null
+models:
+  - efficientnet-b3 # Replace this with your actual model if different
+tags:
+  - agriculture
+  - smart-farming
+  - plant-health
+  - computer-vision
+  - ai
+spaces_server_url: https://huggingface.co
+hf_oauth: false
+disable_embedding: false
+repository: smartleaf-api

Dockerfile

@@ -0,0 +1,35 @@
+# syntax=docker/dockerfile:1
+FROM python:3.12-slim
+
+# 1. Create non‑root user
+RUN useradd --create-home --shell /bin/bash --uid 1000 appuser
+
+# 2. Environment variables - set HF_HOME to match what's used in lifespan
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    HF_HOME=/home/appuser/huggingface \
+    PORT=7860 \
+    PATH=/home/appuser/.local/bin:$PATH
+
+# 3. Set working directory
+WORKDIR /home/appuser/app
+
+# 4. Install Python dependencies
+COPY requirements.txt .
+RUN pip install --upgrade pip \
+    && pip install --no-cache-dir -r requirements.txt
+
+# 5. Copy code and set permissions
+COPY --chown=appuser:appuser . .
+
+# 6. Create huggingface directory with proper permissions
+RUN mkdir -p /home/appuser/huggingface && \
+    chown -R appuser:appuser /home/appuser
+
+# 7. Switch to appuser
+USER appuser
+
+
+# 9. Expose port & run app using uvicorn
+EXPOSE 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,169 @@
 ---
-title: Smartleaf Api
-emoji: 🐨
-colorFrom: indigo
-colorTo: gray
+title: Plant Disease Prediction API
+emoji: 🌱
+colorFrom: green
+colorTo: blue
 sdk: docker
 pinned: false
-license: mit
-short_description: Smart leaf api
+license: apache-2.0
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Plant Disease Prediction API 🌱
+
+A FastAPI-based web service that predicts plant diseases from leaf images using a deep learning model trained on plant pathology data.
+
+## Features
+
+- **38 Disease Classes**: Supports detection of various diseases across multiple plant species including Apple, Corn, Grape, Tomato, Potato, and more
+- **Batch Processing**: Process up to 10 images simultaneously
+- **High Accuracy**: Uses a pre-trained CNN model for reliable disease classification
+- **Easy Integration**: RESTful API with comprehensive documentation
+- **Model Pre-warming**: Fast inference with pre-loaded model
+
+## Supported Plants & Diseases
+
+### Apple
+
+- Apple Scab, Black Rot, Cedar Apple Rust, Healthy
+
+### Corn (Maize)
+
+- Cercospora Leaf Spot, Common Rust, Northern Leaf Blight, Healthy
+
+### Tomato
+
+- Bacterial Spot, Early Blight, Late Blight, Leaf Mold, Septoria Leaf Spot, Spider Mites, Target Spot, Yellow Leaf Curl Virus, Mosaic Virus, Healthy
+
+### Grape
+
+- Black Rot, Esca (Black Measles), Leaf Blight, Healthy
+
+### Potato
+
+- Early Blight, Late Blight, Healthy
+
+### Other Plants
+
+- Blueberry, Cherry, Orange, Peach, Bell Pepper, Raspberry, Soybean, Squash, Strawberry
+
+## API Endpoints
+
+### `POST /predict`
+
+Upload one or more images to get disease predictions.
+
+**Request:**
+
+- Content-Type: `multipart/form-data`
+- Body: Image files (jpg, png, bmp, gif, tiff, webp)
+
+**Response:**
+
+```json
+{
+  "success": true,
+  "results": [
+    {
+      "predicted_class": "Tomato___Late_blight",
+      "clean_class_name": "Tomato - Late blight",
+      "confidence": 0.95,
+      "all_predictions": {
+        "Apple - Apple scab": 0.001,
+        "Tomato - Late blight": 0.95
+        // ... other classes
+      }
+    }
+  ],
+  "message": "Successfully processed 1 image(s)"
+}
+```
+
+### `GET /health`
+
+Check API and model status.
+
+### `GET /classes`
+
+Get all supported disease classes.
+
+### `GET /`
+
+API information and status.
+
+## Usage Examples
+
+### Python
+
+```python
+import requests
+
+# Single image prediction
+with open("leaf_image.jpg", "rb") as f:
+    files = {"files": ("leaf_image.jpg", f, "image/jpeg")}
+    response = requests.post("https://your-space-url/predict", files=files)
+    result = response.json()
+    print(f"Predicted: {result['results'][0]['clean_class_name']}")
+    print(f"Confidence: {result['results'][0]['confidence']:.2%}")
+```
+
+### cURL
+
+```bash
+curl -X POST "https://your-space-url/predict" \
+     -F "files=@leaf_image.jpg"
+```
+
+### JavaScript
+
+```javascript
+const formData = new FormData();
+formData.append("files", fileInput.files[0]);
+
+fetch("/predict", {
+  method: "POST",
+  body: formData,
+})
+  .then((response) => response.json())
+  .then((data) => console.log(data));
+```
+
+## Model Information
+
+- **Architecture**: Convolutional Neural Network (CNN)
+- **Input Size**: 300x300 RGB images
+- **Training Data**: PlantVillage dataset
+- **Classes**: 38 plant disease categories
+- **Framework**: TensorFlow/Keras
+
+## Performance
+
+- **Batch Size**: Up to 10 images per request
+- **Response Time**: ~1-3 seconds per image
+- **Memory Usage**: ~2GB for model loading
+- **Accuracy**: >95% on validation set
+
+## Limitations
+
+- Best results with clear, well-lit leaf images
+- Works optimally with images similar to training data
+- Single leaf per image recommended
+- Supported image formats: JPG, PNG, BMP, GIF, TIFF, WEBP
+
+## Environment Variables
+
+- `HF_MODEL_REPO`: Hugging Face model repository (default: "yasyn14/smart-leaf-model")
+- `HF_MODEL_FILENAME`: Model file name (default: "best_model_32epochs.keras")
+- `HF_HOME`: Cache directory for models (default: "/tmp/huggingface")
+
+## License
+
+Apache 2.0 License
+
+## Support
+
+For issues and questions, please visit the [model repository](https://huggingface.co/yasyn14/smart-leaf-model) or create an issue in this space.
+
+---
+
+_Built with FastAPI, TensorFlow, and 🤗 Transformers_

app.py

@@ -0,0 +1,11 @@
+# Alternative entry point for Hugging Face Spaces
+# This file can be used if main.py doesn't work as expected
+
+from main import app
+
+if __name__ == "__main__":
+    import uvicorn
+    import os
+    
+    port = int(os.getenv("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

deployment_guide.md

@@ -0,0 +1,213 @@
+# Deployment Guide for Hugging Face Spaces
+
+## 📁 File Structure
+
+Make sure your repository has the following structure:
+
+```
+your-space/
+├── main.py                 # Main FastAPI application
+├── app.py                  # Alternative entry point
+├── requirements.txt        # Python dependencies
+├── Dockerfile             # Docker configuration
+├── README.md              # Space documentation
+├── .gitignore            # Git ignore rules
+├── .dockerignore         # Docker ignore rules
+└── DEPLOYMENT_GUIDE.md   # This file
+```
+
+## 🚀 Step-by-Step Deployment
+
+### 1. Create a New Space
+
+1. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Click "Create new Space"
+3. Fill in the details:
+   - **Space name**: `plant-disease-api` (or your preferred name)
+   - **License**: Apache 2.0
+   - **SDK**: Docker
+   - **Hardware**: CPU Basic (upgrade to GPU if needed)
+   - **Visibility**: Public or Private
+
+### 2. Configure the Space
+
+The README.md file already contains the necessary YAML frontmatter:
+
+```yaml
+---
+title: Plant Disease Prediction API
+emoji: 🌱
+colorFrom: green
+colorTo: blue
+sdk: docker
+pinned: false
+license: apache-2.0
+app_port: 7860
+---
+```
+
+### 3. Upload Files
+
+You can either:
+
+**Option A: Git Clone and Push**
+
+```bash
+git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+cd YOUR_SPACE_NAME
+# Copy all files to this directory
+git add .
+git commit -m "Initial deployment"
+git push
+```
+
+**Option B: Web Interface**
+
+- Upload files directly through the Hugging Face web interface
+- Drag and drop or use the file upload feature
+
+### 4. Environment Variables (Optional)
+
+If you need to set custom environment variables:
+
+1. Go to your Space settings
+2. Add environment variables:
+   - `HF_MODEL_REPO`: Your model repository
+   - `HF_MODEL_FILENAME`: Your model filename
+   - `HF_HOME`: Cache directory (default: `/tmp/huggingface`)
+
+### 5. Monitor Deployment
+
+1. Go to your Space page
+2. Check the "Logs" tab for build progress
+3. Wait for the status to change from "Building" to "Running"
+
+## 🔧 Configuration Details
+
+### Port Configuration
+
+- Hugging Face Spaces expects applications to run on port **7860**
+- The Dockerfile and application are configured for this
+
+### Model Loading
+
+- The model will be downloaded from Hugging Face Hub on first startup
+- Subsequent startups will use cached model (faster)
+- Pre-warming ensures fast first predictions
+
+### Resource Requirements
+
+- **Memory**: ~2-3GB for TensorFlow + model
+- **CPU**: Minimum 2 cores recommended
+- **Storage**: ~1GB for model and dependencies
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+1. **Build Fails**
+
+   - Check logs in the Space interface
+   - Verify all files are uploaded correctly
+   - Ensure requirements.txt has correct versions
+
+2. **Model Loading Errors**
+
+   - Verify `HF_MODEL_REPO` and `HF_MODEL_FILENAME` are correct
+   - Check if model exists and is accessible
+   - Review model format (should be .keras file)
+
+3. **Memory Issues**
+
+   - Upgrade to larger hardware tier
+   - Optimize model loading in code
+   - Clear unnecessary cache
+
+4. **Port Issues**
+   - Ensure application runs on port 7860
+   - Check Dockerfile EXPOSE directive
+   - Verify app_port in README.md frontmatter
+
+### Debug Commands
+
+Add these to your main.py for debugging:
+
+```python
+import os
+import psutil
+import logging
+
+# Log system info
+logging.info(f"Available memory: {psutil.virtual_memory().total / 1e9:.2f} GB")
+logging.info(f"CPU cores: {psutil.cpu_count()}")
+logging.info(f"Python version: {sys.version}")
+logging.info(f"TensorFlow version: {tf.__version__}")
+```
+
+## 📊 Testing Your Deployment
+
+### Health Check
+
+```bash
+curl https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/health
+```
+
+### Test Prediction
+
+```bash
+curl -X POST "https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/predict" \
+     -F "files=@your_test_image.jpg"
+```
+
+### Interactive API Docs
+
+Visit: `https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/docs`
+
+## 🔄 Updates and Maintenance
+
+### Updating Your Space
+
+1. Make changes to your local files
+2. Push to the Space repository
+3. Space will automatically rebuild and redeploy
+
+### Monitoring Performance
+
+- Check Space logs regularly
+- Monitor response times
+- Watch for memory usage spikes
+
+### Scaling Options
+
+- Upgrade hardware tier for better performance
+- Consider GPU hardware for faster inference
+- Implement caching for frequently used predictions
+
+## 🔒 Security Considerations
+
+- Keep your Space public for API access
+- Don't include sensitive credentials in code
+- Use environment variables for configuration
+- Monitor usage to prevent abuse
+
+## 📈 Performance Optimization
+
+### Model Optimization
+
+- Use model quantization for smaller size
+- Implement model pruning if needed
+- Cache predictions when possible
+
+### API Optimization
+
+- Add request rate limiting
+- Implement response caching
+- Optimize image preprocessing
+
+---
+
+**Need Help?**
+
+- Check [Hugging Face Spaces Documentation](https://huggingface.co/docs/spaces)
+- Visit [Community Forums](https://discuss.huggingface.co/)
+- Create an issue in your Space repository

huggingface.yml

@@ -0,0 +1 @@
+sdk: docker

main.py

@@ -0,0 +1,285 @@
+import os
+import logging
+from typing import List, 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
+from pydantic import BaseModel
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Configuration
+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 = [
+    'Apple___Apple_scab', 'Apple___Black_rot', 'Apple___Cedar_apple_rust', 'Apple___healthy',
+    '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___Late_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'
+]
+
+# 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",
+    "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",
+    "MODEL_LOAD_FAILED": "Failed to load model"
+}
+
+# Global model variable
+model: Optional[tf.keras.Model] = None
+
+# Response models
+class PredictionResult(BaseModel):
+    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):
+    status: str
+    model_loaded: bool
+    message: str
+
+def download_model_from_hf() -> str:
+    """Download model from Hugging Face Hub"""
+    try:
+        logger.info(f"Downloading model from {HF_MODEL_REPO}/{HF_MODEL_FILENAME}")
+        model_path = hf_hub_download(
+            repo_id=HF_MODEL_REPO,
+            filename=HF_MODEL_FILENAME,
+            cache_dir=HF_CACHE_DIR
+        )
+        logger.info(f"Model downloaded to: {model_path}")
+        return model_path
+    except Exception as e:
+        logger.error(f"Failed to download model: {str(e)}")
+        raise
+
+def load_model() -> tf.keras.Model:
+    """Load the Keras model from Hugging Face"""
+    try:
+        model_path = download_model_from_hf()
+        loaded_model = tf.keras.models.load_model(model_path)
+        logger.info("Model loaded successfully")
+        return loaded_model
+    except Exception as e:
+        logger.error(f"Failed to load model: {str(e)}")
+        raise
+
+def preprocess_image(image_bytes: bytes) -> np.ndarray:
+    """Preprocess image for model prediction"""
+    try:
+        # Open image from bytes
+        image = Image.open(io.BytesIO(image_bytes))
+        
+        # Convert to RGB if needed
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        # Resize image
+        image = image.resize(IMAGE_SIZE)
+        
+        # Convert to numpy array and normalize
+        img_array = np.array(image) / 255.0
+        
+        # Add batch dimension
+        img_array = np.expand_dims(img_array, axis=0)
+        
+        return img_array
+    except Exception as e:
+        logger.error(f"Error preprocessing image: {str(e)}")
+        raise
+
+def predict_single_image(image_bytes: bytes) -> PredictionResult:
+    """Make prediction for a single image"""
+    global model
+    
+    if model is None:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail=HTTP_MESSAGES["MODEL_NOT_LOADED"]
+        )
+    
+    try:
+        # Preprocess image
+        processed_image = preprocess_image(image_bytes)
+        
+        # Make prediction
+        predictions = model.predict(processed_image, verbose=0)
+        predicted_class_idx = np.argmax(predictions[0])
+        confidence = float(predictions[0][predicted_class_idx])
+        
+        # Get class names
+        predicted_class = CLASS_NAMES[predicted_class_idx]
+        clean_class_name = CLEAN_CLASS_NAMES[predicted_class_idx]
+        
+        # Create all predictions dictionary
+        all_predictions = {
+            CLEAN_CLASS_NAMES[i]: float(predictions[0][i]) 
+            for i in range(len(CLASS_NAMES))
+        }
+        
+        return PredictionResult(
+            predicted_class=predicted_class,
+            clean_class_name=clean_class_name,
+            confidence=confidence,
+            all_predictions=all_predictions
+        )
+        
+    except Exception as e:
+        logger.error(f"Prediction failed: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=HTTP_MESSAGES["PREDICTION_FAILED"].format(error=str(e))
+        )
+
+def is_image_file(filename: str) -> bool:
+    """Check if file is an image based on extension"""
+    image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.gif', '.tiff', '.webp'}
+    return any(filename.lower().endswith(ext) for ext in image_extensions)
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Handle startup and shutdown events"""
+    # Startup
+    global model
+    try:
+        logger.info("Starting up... Loading model")
+        model = load_model()
+        
+        # Pre-warm the model with a dummy prediction
+        dummy_image = np.random.rand(1, *IMAGE_SIZE, 3).astype(np.float32)
+        _ = model.predict(dummy_image, verbose=0)
+        logger.info("Model pre-warmed successfully")
+        
+    except Exception as e:
+        logger.error(f"Failed to load model during startup: {str(e)}")
+        model = None
+    
+    yield
+    
+    # Shutdown
+    logger.info("Shutting down...")
+
+# Create FastAPI app
+app = FastAPI(
+    title="Plant Disease Prediction API",
+    description="API for predicting plant diseases from leaf images using deep learning",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+@app.get("/", response_model=HealthResponse)
+async def root():
+    """Root endpoint with API information"""
+    return HealthResponse(
+        status="running",
+        model_loaded=model is not None,
+        message="Plant Disease Prediction API is running"
+    )
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint"""
+    return HealthResponse(
+        status="healthy" if model is not None else "unhealthy",
+        model_loaded=model is not None,
+        message=HTTP_MESSAGES["MODEL_LOAD_SUCCESS"] if model is not None else HTTP_MESSAGES["MODEL_NOT_LOADED"]
+    )
+
+@app.post("/predict", response_model=PredictionResponse)
+async def predict_plant_disease(files: List[UploadFile] = File(...)):
+    """
+    Predict plant disease from uploaded image(s)
+    
+    - **files**: List of image files to analyze (max 10 files)
+    
+    Returns predictions with confidence scores for each image
+    """
+    
+    # Check batch size
+    if len(files) > MAX_BATCH_SIZE:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=HTTP_MESSAGES["BATCH_SIZE_EXCEEDED"].format(max_size=MAX_BATCH_SIZE)
+        )
+    
+    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()
+            
+            # 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)"
+    )
+
+@app.get("/classes")
+async def get_classes():
+    """Get all available plant disease classes"""
+    return {
+        "classes": CLASS_NAMES,
+        "clean_classes": CLEAN_CLASS_NAMES,
+        "total_classes": len(CLASS_NAMES)
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

runtime.txt

@@ -0,0 +1 @@
+docker