version 3

Dockerfile

@@ -1,30 +1,45 @@
+# -------------------------
+# Base image
+# -------------------------
 FROM python:3.10-slim
 
+# -------------------------
 # Set working directory
+# -------------------------
 WORKDIR /app
 
-# Set environment variables
+# -------------------------
+# Environment variables
+# -------------------------
 ENV PYTHONDONTWRITEBYTECODE=1
 ENV PYTHONUNBUFFERED=1
 ENV HF_HOME=/tmp/hf_cache
 
+# -------------------------
 # Install system dependencies
+# -------------------------
 RUN apt-get update && apt-get install -y --no-install-recommends \
     gcc \
     libc-dev \
     && rm -rf /var/lib/apt/lists/*
 
-# Copy requirements first for better caching
+# -------------------------
+# Copy requirements and install
+# -------------------------
 COPY requirements.txt .
-
-# Install Python dependencies
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy all files from the root directory
+# -------------------------
+# Copy application code
+# -------------------------
 COPY . .
 
-# Expose HF Spaces port
+# -------------------------
+# Expose Hugging Face port
+# -------------------------
 EXPOSE 7860
 
-# Command to run the application
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--timeout-keep-alive", "120"]
+# -------------------------
+# Command to run FastAPI
+# -------------------------
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--timeout-keep-alive", "120"]

app.py

@@ -1,17 +1,18 @@
 from fastapi import FastAPI, HTTPException, Request, Response
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html
 from pydantic import BaseModel
 import pandas as pd
 import joblib
 import requests
-from datetime import timedelta
-from math import sin, cos, radians, pi
-import logging
 import gc
 import os
+import logging
+from math import sin, cos, radians, pi
 from contextlib import asynccontextmanager
 
 # -------------------------
-# Logger setup
+# Logger
 # -------------------------
 logging.basicConfig(
     level=logging.INFO,
@@ -19,7 +20,7 @@ logging.basicConfig(
 )
 
 # -------------------------
-# Global variables for lazy loading (memory optimization)
+# Global models
 # -------------------------
 _occurrence_model = None
 _occurrence_scaler = None
@@ -27,7 +28,7 @@ _severity_model = None
 _severity_scaler = None
 
 # -------------------------
-# NASA POWER setup
+# Feature setup
 # -------------------------
 API_BASE = "https://power.larc.nasa.gov/api/temporal/daily/point"
 PARAMS = "PRECTOT,T2M,T2M_MAX,T2M_MIN,ALLSKY_SFC_SW_DWN,RH2M,WS2M"
@@ -39,47 +40,26 @@ FEATURE_ORDER = [
 ]
 
 # -------------------------
-# Memory management
+# Utility functions
 # -------------------------
 def cleanup_memory():
-    """Force garbage collection to free up memory"""
     gc.collect()
 
 def safe_model_load(filename: str):
-    """Load model from the same directory as this script with comprehensive error handling"""
     try:
-        # Get the directory of the current script (main.py)
         script_dir = os.path.dirname(os.path.abspath(__file__))
-        model_path = os.path.join(script_dir, filename)
-        logging.info(f"🔄 Attempting to load {filename} from {model_path}...")
-
-        # Check file exists and has content
-        if not os.path.exists(model_path):
-            raise FileNotFoundError(f"File not found: {model_path}")
-
-        file_size = os.path.getsize(model_path)
-        if file_size == 0:
-            raise ValueError(f"File is empty: {model_path}")
-
-        logging.info(f"📊 File size: {file_size / (1024 * 1024):.1f} MB")
-
-        # Load the model
-        model = joblib.load(model_path)
-        logging.info(f"✅ Successfully loaded {filename}")
-        return model
-
+        path = os.path.join(script_dir, filename)
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"{filename} not found")
+        return joblib.load(path)
     except Exception as e:
-        logging.error(f"❌ Failed to load {filename}: {str(e)}")
-        logging.error(f"❌ Error type: {type(e).__name__}")
-        raise HTTPException(status_code=500, detail=f"Model loading failed: {filename} - {str(e)}")
+        logging.error(f"Failed to load {filename}: {e}")
+        raise HTTPException(status_code=500, detail=f"Model loading failed: {filename}")
 
-# -------------------------
-# Lazy loading functions
-# -------------------------
 def get_occurrence_model_and_scaler():
     global _occurrence_model, _occurrence_scaler
     if _occurrence_model is None or _occurrence_scaler is None:
-        logging.info("Loading occurrence model and scaler...")
+        logging.info("Loading occurrence model/scaler...")
         _occurrence_model = safe_model_load("drought_occurrence_model.joblib")
         _occurrence_scaler = safe_model_load("drought_occurrence_scaler.joblib")
         cleanup_memory()
@@ -88,49 +68,55 @@ def get_occurrence_model_and_scaler():
 def get_severity_model_and_scaler():
     global _severity_model, _severity_scaler
     if _severity_model is None or _severity_scaler is None:
-        logging.info("Loading severity model and scaler...")
+        logging.info("Loading severity model/scaler...")
         _severity_model = safe_model_load("drought_severity_model.joblib")
         _severity_scaler = safe_model_load("drought_severity_scaler.joblib")
         cleanup_memory()
     return _severity_model, _severity_scaler
 
 # -------------------------
-# Lifespan event handler
+# Lifespan
 # -------------------------
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    # Startup
-    logging.info("🚀 Drought API starting - models will load on first request")
+    logging.info("🚀 Drought API starting (models load on first request)")
     cleanup_memory()
     yield
-    # Shutdown
-    logging.info("🛑 Drought API shutting down")
+    logging.info("🛑 Shutting down API")
     global _occurrence_model, _occurrence_scaler, _severity_model, _severity_scaler
     _occurrence_model = _occurrence_scaler = _severity_model = _severity_scaler = None
     cleanup_memory()
 
 # -------------------------
-# Request schema
-# -------------------------
-class PredictionRequest(BaseModel):
-    lat: float
-    lon: float
-    time: str  # YYYY-MM-DD
-
-# -------------------------
-# FastAPI app with lifespan
+# FastAPI instance
 # -------------------------
 app = FastAPI(
     title="🌍 Drought Prediction API",
     version="2.4",
     description="Memory-optimized drought prediction API",
-    lifespan=lifespan,
-    docs_url="/docs",  # Explicitly enable
-    redoc_url="/redoc"  # Alternative docs
+    lifespan=lifespan
+)
+
+# -------------------------
+# CORS middleware for website
+# -------------------------
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # replace with website URL in production
+    allow_methods=["*"],
+    allow_headers=["*"]
 )
 
 # -------------------------
-# NASA fetcher (memory optimized)
+# Request model
+# -------------------------
+class PredictionRequest(BaseModel):
+    lat: float
+    lon: float
+    time: str  # YYYY-MM-DD
+
+# -------------------------
+# NASA feature fetcher
 # -------------------------
 def fetch_features(lat, lon, time_str: str) -> dict:
     end = pd.to_datetime(time_str)
@@ -146,198 +132,96 @@ def fetch_features(lat, lon, time_str: str) -> dict:
     }
     try:
         response = requests.get(API_BASE, params=params, timeout=30)
-        if response.status_code != 200:
-            logging.error(f"NASA API error {response.status_code}")
-            raise HTTPException(status_code=502, detail="NASA API error")
+        response.raise_for_status()
         data = response.json().get("properties", {}).get("parameter", {})
-        if not data:
-            raise HTTPException(status_code=502, detail="No data from NASA API")
         features = {}
-        for p, values in data.items():
-            vals = [v for v in values.values() if v is not None]
-            if vals:
-                if p == "PRECTOT":
-                    features["PRECTOTCORR"] = sum(vals)
-                else:
-                    features[p] = sum(vals) / len(vals)
-        # Clear response from memory
-        del data, response, vals
-        cleanup_memory()
-        # Derived features
+        for p, vals in data.items():
+            values = [v for v in vals.values() if v is not None]
+            if values:
+                features["PRECTOTCORR" if p=="PRECTOT" else p] = sum(values)/len(values) if p!="PRECTOT" else sum(values)
         features.update({
             "lat_sin": sin(radians(lat)),
             "lat_cos": cos(radians(lat)),
             "lon_sin": sin(radians(lon)),
             "lon_cos": cos(radians(lon)),
-            "month_sin": sin(2 * pi * end.month / 12),
-            "month_cos": cos(2 * pi * end.month / 12)
+            "month_sin": sin(2*pi*end.month/12),
+            "month_cos": cos(2*pi*end.month/12)
         })
         missing = [f for f in FEATURE_ORDER if f not in features]
         if missing:
             raise HTTPException(status_code=500, detail=f"Missing features: {missing}")
+        cleanup_memory()
         return features
-    except HTTPException:
-        raise
     except Exception as e:
-        logging.error(f"NASA API fetch error: {e}")
+        logging.error(f"NASA fetch error: {e}")
         raise HTTPException(status_code=502, detail="NASA API request failed")
 
 # -------------------------
-# Prediction endpoint (memory optimized with detailed debugging)
+# Prediction endpoint
 # -------------------------
 @app.post("/predict")
 async def predict(req: PredictionRequest):
     try:
-        logging.info(f"🔄 Starting prediction for lat={req.lat}, lon={req.lon}, time={req.time}")
-        # Validate input
-        try:
-            pd.to_datetime(req.time)
-        except Exception as e:
-            logging.error(f"Invalid time format: {req.time}")
-            raise HTTPException(status_code=400, detail=f"Invalid time format: {req.time}. Use YYYY-MM-DD")
-        # Get features
-        logging.info("📡 Fetching NASA data...")
         features = fetch_features(req.lat, req.lon, req.time)
-        logging.info(f"✅ Features fetched: {len(features)} features")
-        X = pd.DataFrame([[features[col] for col in FEATURE_ORDER]], columns=FEATURE_ORDER)
-        logging.info(f"📊 DataFrame created: {X.shape}")
-        # Occurrence prediction
-        logging.info("🔮 Loading occurrence model...")
-        try:
-            occ_model, occ_scaler = get_occurrence_model_and_scaler()
-            logging.info("✅ Occurrence model loaded")
-        except Exception as e:
-            logging.error(f"❌ Failed to load occurrence model: {e}")
-            raise HTTPException(status_code=500, detail=f"Failed to load occurrence model: {str(e)}")
-        try:
-            X_occ = occ_scaler.transform(X)
-            occurrence_pred = int(occ_model.predict(X_occ)[0])
-            occurrence_proba = occ_model.predict_proba(X_occ)[0].tolist()
-            logging.info(f"✅ Occurrence prediction: {occurrence_pred}")
-        except Exception as e:
-            logging.error(f"❌ Occurrence prediction failed: {e}")
-            raise HTTPException(status_code=500, detail=f"Occurrence prediction failed: {str(e)}")
-        del X_occ  # Free memory
-        cleanup_memory()
-        # Severity prediction
-        logging.info("🔮 Loading severity model...")
-        try:
-            sev_model, sev_scaler = get_severity_model_and_scaler()
-            logging.info("✅ Severity model loaded")
-        except Exception as e:
-            logging.error(f"❌ Failed to load severity model: {e}")
-            raise HTTPException(status_code=500, detail=f"Failed to load severity model: {str(e)}")
-        try:
-            X_sev = sev_scaler.transform(X)
-            severity_pred = int(sev_model.predict(X_sev)[0])
-            severity_proba = sev_model.predict_proba(X_sev)[0].tolist()
-            logging.info(f"✅ Severity prediction: {severity_pred}")
-        except Exception as e:
-            logging.error(f"❌ Severity prediction failed: {e}")
-            raise HTTPException(status_code=500, detail=f"Severity prediction failed: {str(e)}")
-        del X_sev  # Free memory
-        cleanup_memory()
+        X = pd.DataFrame([[features[f] for f in FEATURE_ORDER]], columns=FEATURE_ORDER)
+        occ_model, occ_scaler = get_occurrence_model_and_scaler()
+        sev_model, sev_scaler = get_severity_model_and_scaler()
+        X_occ = occ_scaler.transform(X)
+        X_sev = sev_scaler.transform(X)
+        occurrence_pred = int(occ_model.predict(X_occ)[0])
+        occurrence_proba = occ_model.predict_proba(X_occ)[0].tolist()
+        severity_pred = int(sev_model.predict(X_sev)[0])
+        severity_proba = sev_model.predict_proba(X_sev)[0].tolist()
         result = {
             "input": {"lat": req.lat, "lon": req.lon, "time": req.time},
-            "occurrence": {
-                "prediction": occurrence_pred,
-                "probabilities": occurrence_proba
-            },
-            "severity": {
-                "prediction": severity_pred,
-                "probabilities": severity_proba
-            },
-            "features_used": {k: round(v, 4) for k, v in zip(FEATURE_ORDER, X.iloc[0].tolist())}
+            "occurrence": {"prediction": occurrence_pred, "probabilities": occurrence_proba},
+            "severity": {"prediction": severity_pred, "probabilities": severity_proba},
+            "features_used": {k: round(v,4) for k,v in zip(FEATURE_ORDER, X.iloc[0].tolist())}
         }
-        # Final cleanup
-        del X, features
         cleanup_memory()
-        logging.info(f"✅ Prediction complete: Occurrence={occurrence_pred}, Severity={severity_pred}")
         return result
-    except HTTPException as http_err:
-        logging.error(f"HTTP Error: {http_err.detail}")
-        cleanup_memory()
-        raise http_err
+    except HTTPException as e:
+        raise e
     except Exception as e:
-        logging.error(f"❌ Unexpected prediction error: {str(e)}")
-        logging.error(f"❌ Error type: {type(e).__name__}")
-        import traceback
-        logging.error(f"❌ Traceback: {traceback.format_exc()}")
-        cleanup_memory()
-        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")
+        logging.error(f"Prediction error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
 # -------------------------
-# Debug endpoint to test individual components
+# Health check
+# -------------------------
+@app.api_route("/health", methods=["GET", "HEAD"])
+async def health_check(request: Request):
+    if request.method == "HEAD":
+        return Response(status_code=200)
+    return {"status": "healthy", "api_version": "2.4"}
+
+# -------------------------
+# Debug endpoint
 # -------------------------
 @app.get("/debug")
 async def debug_info():
-    """Debug endpoint to check system status"""
-    try:
-        debug_data = {
-            "python_version": f"{os.sys.version_info.major}.{os.sys.version_info.minor}.{os.sys.version_info.micro}",
-            "feature_order": FEATURE_ORDER,
-            "api_base": API_BASE,
-            "models_loaded": {
-                "occurrence_model": _occurrence_model is not None,
-                "occurrence_scaler": _occurrence_scaler is not None,
-                "severity_model": _severity_model is not None,
-                "severity_scaler": _severity_scaler is not None
-            }
-        }
-        # Test NASA API with a simple request
-        try:
-            test_response = requests.get("https://power.larc.nasa.gov", timeout=10)
-            debug_data["nasa_api_accessible"] = test_response.status_code == 200
-        except:
-            debug_data["nasa_api_accessible"] = False
-        # Test local model files
-        try:
-            script_dir = os.path.dirname(os.path.abspath(__file__))
-            model_files = [
-                "drought_occurrence_model.joblib",
-                "drought_occurrence_scaler.joblib",
-                "drought_severity_model.joblib",
-                "drought_severity_scaler.joblib"
-            ]
-            debug_data["model_files_exist"] = {
-                f: os.path.exists(os.path.join(script_dir, f)) for f in model_files
-            }
-        except Exception as e:
-            debug_data["model_files_error"] = str(e)
-        return debug_data
-    except Exception as e:
-        return {"debug_error": str(e)}
+    return {
+        "models_loaded": {
+            "occurrence_model": _occurrence_model is not None,
+            "occurrence_scaler": _occurrence_scaler is not None,
+            "severity_model": _severity_model is not None,
+            "severity_scaler": _severity_scaler is not None
+        },
+        "feature_order": FEATURE_ORDER
+    }
 
 # -------------------------
-# Test prediction with sample data
+# Test endpoint
 # -------------------------
 @app.get("/test")
 async def test_prediction():
-    """Test endpoint with hardcoded values"""
     try:
-        test_request = PredictionRequest(
-            lat=40.7128,  # New York
-            lon=-74.0060,
-            time="2024-08-15"
-        )
-        result = await predict(test_request)
+        test_req = PredictionRequest(lat=40.7128, lon=-74.0060, time="2024-08-15")
+        result = await predict(test_req)
         return {"test_status": "success", "result": result}
     except Exception as e:
         return {"test_status": "failed", "error": str(e)}
 
-# -------------------------
-# Health check (lightweight)
-# -------------------------
-@app.api_route("/health", methods=["GET", "HEAD"])
-async def health_check(request: Request):
-    if request.method == "HEAD":
-        return Response(status_code=200)
-    return {
-        "status": "healthy",
-        "api_version": "2.4",
-        "python_version": f"{os.sys.version_info.major}.{os.sys.version_info.minor}"
-    }
-
 # -------------------------
 # Root endpoint
 # -------------------------
@@ -349,6 +233,20 @@ async def root():
         "endpoints": {
             "predict": "/predict",
             "health": "/health",
-            "docs": "/docs"
+            "debug": "/debug",
+            "test": "/test",
+            "docs": "/docs",
+            "redoc": "/redoc"
         }
-    }
+    }
+
+# -------------------------
+# Swagger UI and Redoc
+# -------------------------
+@app.get("/docs", include_in_schema=False)
+async def custom_swagger_ui():
+    return get_swagger_ui_html(openapi_url="/openapi.json", title="API Docs")
+
+@app.get("/redoc", include_in_schema=False)
+async def custom_redoc():
+    return get_redoc_html(openapi_url="/openapi.json", title="ReDoc")