My 6 can be your 9

.dockerignore

@@ -0,0 +1,47 @@
+# ── Do NOT include in Docker image ──
+
+# Mobile app (not needed by backend)
+app_main/
+
+# Frontend (not needed by backend)
+geo-sight-forge/
+
+# Large local raster files (served from GCS in production)
+ALLrasterFiles/
+
+# Temp files
+temp/
+
+# Secrets
+**/.env
+**/.env.*
+!**/.env.example
+
+# Python bytecode
+**/__pycache__/
+**/*.py[cod]
+**/*.pyo
+
+# Logs
+**/*.log
+
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode/
+.idea/
+
+# Git
+.git/
+.gitignore
+.gitattributes
+
+# Test files (keep build small)
+server/test_*.py
+server/test_*.json
+
+# Render-specific (not needed for HF)
+server/render.yaml
+server/Procfile

.gitattributes

@@ -0,0 +1,11 @@
+*.tif filter=lfs diff=lfs merge=lfs -text
+*.keras filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.db filter=lfs diff=lfs merge=lfs -text
+*.lockb filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+backend/models/

.github/workflows/deploy-hf.yml

@@ -0,0 +1,21 @@
+name: Deploy to HuggingFace Spaces
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          lfs: false
+
+      - name: Push to HuggingFace Spaces
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          git remote add hf https://projectgaia:${HF_TOKEN}@huggingface.co/spaces/shrishtiai/ShrishtiAI-backend
+          git push hf main:main --force

.gitignore

@@ -0,0 +1,106 @@
+ALLrasterFiles/
+.idea/
+temp
+node_modules/
+dist/
+
+# ============================================
+# Root .gitignore for GEO VISION Dashboard
+# ============================================
+
+# ── Git internals ──
+.git_backup/
+
+# ── Credentials & Secrets ──
+*.pem
+*.key
+.env
+.env.*
+!.env.example
+
+# Google service account keys
+geovision-final*.json
+**/geovision-final*.json
+
+# Google OAuth client secrets & tokens
+**/client_secret*.json
+**/geovision_drive_token.json
+client_secret*.json
+
+# ── Python ──
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg-info/
+dist/
+build/
+*.egg
+.eggs/
+*.whl
+venv/
+.venv/
+env/
+
+# ── Node.js ──
+node_modules/
+.npm
+.yarn/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# ── Build outputs ──
+dist/
+dist-ssr/
+*.local
+.output/
+.vercel/
+
+# ── IDE / Editor ──
+.vscode/*
+!.vscode/extensions.json
+!.vscode/settings.json
+.idea/
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+*.swp
+*~
+
+# ── OS files ──
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# ── Logs ──
+*.log
+logs/
+geovision.log
+
+# ── Misc ──
+*.bak
+*.tmp
+*.temp
+.cache/
+coverage/
+.nyc_output/
+
+server/proj_data/
+
+gee_key_for_hf.txt
+
+.vscode/
+server/models/*
+!server/models/*.py
+server/models/__pycache__/
+server/models/geovision/
+server/models/hazardguard/
+server/models/weatherwise/
+
+# Local large data artifacts
+HWSD2/
+final_lookup_tables/

Dockerfile

@@ -0,0 +1,45 @@
+# ============================================================
+# GeoVision Backend — Hugging Face Spaces (Docker)
+# Port: 7860 (required by HF Spaces)
+# ============================================================
+
+FROM python:3.11-slim
+
+# System libs needed by rasterio / pyproj pip wheels
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libexpat1 \
+    libgomp1 \
+    curl \
+    git \
+    git-lfs \
+    && git lfs install \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# ── 1. Install Python deps (cached layer — only rebuilds when requirements change) ──
+COPY server/requirements.txt ./requirements.txt
+RUN pip install --no-cache-dir --upgrade pip \
+ && pip install --no-cache-dir -r requirements.txt
+
+# ── 2. Copy backend source (no model files) ──
+COPY server/ .
+
+# Make entrypoint executable
+RUN chmod +x entrypoint.sh
+
+# ── 3. Non-sensitive runtime defaults (secrets injected via HF Space env vars) ──
+ENV FLASK_ENV=production \
+    FLASK_DEBUG=False \
+    FLASK_HOST=0.0.0.0 \
+    FLASK_PORT=7860 \
+    LOG_LEVEL=INFO \
+    PYTHONUNBUFFERED=1 \
+    # Disable TF GPU detection noise
+    TF_CPP_MIN_LOG_LEVEL=3 \
+    CUDA_VISIBLE_DEVICES=""
+
+EXPOSE 7860
+
+# Entrypoint downloads models at startup (needs HF_TOKEN secret), then starts gunicorn
+CMD ["./entrypoint.sh"]

README.md

@@ -0,0 +1,38 @@
+---
+title: GeoVision Backend
+emoji: 🌍
+colorFrom: green
+colorTo: blue
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# GeoVision Backend
+
+Flask REST API backend for the GeoVision disaster risk prediction platform.
+
+## Endpoints
+
+- `GET /health` — service health check
+- `GET /info` — API info & all route listing
+- `POST /api/chat/message` — Gemini AI assistant
+- `POST /api/hazardguard/predict` — disaster risk prediction
+- `POST /api/weatherwise/forecast` — LSTM weather forecasting
+- `POST /api/geovision/predict` — full fusion model prediction
+- `POST /api/satellite/point` — GEE satellite imagery
+- `GET /api/weather/data` — NASA POWER weather data
+
+## Environment Variables
+
+Set these in **Space Settings → Variables**:
+
+| Variable | Description |
+|---|---|
+| `GEMINI_API_KEY` | Google Gemini API key |
+| `GEE_PROJECT_ID` | GCP project ID for Earth Engine |
+| `GEE_SERVICE_ACCOUNT_KEY` | GEE service account JSON (single-line) |
+| `SUPABASE_URL` | Supabase project URL |
+| `SUPABASE_SERVICE_ROLE_KEY` | Supabase service role key |
+| `ALLOWED_ORIGINS` | Comma-separated CORS origins (your frontend URL) |
+| `GCS_BUCKET_BASE_URL` | GCS public bucket URL for raster COG files |

server/.env.example

@@ -0,0 +1,53 @@
+# ============================================
+# GEO VISION Backend — Environment Variables
+# ============================================
+# Copy this file to .env and fill in your values
+
+# ── Google Earth Engine ──
+GEE_PROJECT_ID=your-gcp-project-id
+GEE_SERVICE_ACCOUNT_KEY=/path/to/your-service-account-key.json
+
+# ── Google Gemini AI ──
+GEMINI_API_KEY=your-gemini-api-key
+
+# ── Flask ──
+FLASK_ENV=production
+FLASK_DEBUG=False
+FLASK_HOST=0.0.0.0
+FLASK_PORT=5000
+
+# ── Application ──
+APP_NAME=Geo Vision Backend
+APP_VERSION=1.0.0
+APP_USER=GeoVision
+
+# ── CORS (comma-separated origins) ──
+ALLOWED_ORIGINS=https://your-frontend-domain.vercel.app
+
+# ── Logging ──
+LOG_LEVEL=INFO
+LOG_FILE=geovision.log
+
+# ── GCS Bucket (public COG raster data) ──
+GCS_BUCKET_BASE_URL=https://storage.googleapis.com/satellite-cog-data-for-shrishti
+GCS_BUCKET=satellite-cog-data-for-shrishti
+GCS_TEMP_PREFIX=temp
+
+# ── Raster Data (COG files from GCS bucket) ──
+RASTER_SOIL_PATH=https://storage.googleapis.com/satellite-cog-data-for-shrishti/soil_type.tif
+RASTER_ELEVATION_PATH=https://storage.googleapis.com/satellite-cog-data-for-shrishti/elevation.tif
+RASTER_POPULATION_PATH=https://storage.googleapis.com/satellite-cog-data-for-shrishti/population_density.tif
+RASTER_LANDCOVER_PATH=https://storage.googleapis.com/satellite-cog-data-for-shrishti/land_cover.tif
+RASTER_NDVI_PATH=https://storage.googleapis.com/satellite-cog-data-for-shrishti/ndvi.tif
+RASTER_PRECIP_PATH=https://storage.googleapis.com/satellite-cog-data-for-shrishti/annual_precip.tif
+RASTER_TEMP_PATH=https://storage.googleapis.com/satellite-cog-data-for-shrishti/mean_annual_temp.tif
+RASTER_WIND_PATH=https://storage.googleapis.com/satellite-cog-data-for-shrishti/wind_speed.tif
+RASTER_IMPERVIOUS_PATH=https://storage.googleapis.com/satellite-cog-data-for-shrishti/impervious_surface.tif
+
+# ── Supabase ──
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_SERVICE_ROLE_KEY=your-supabase-service-role-key
+
+# ── Soil Database (optional, for HWSD2 lookup) ──
+HWSD2_SMU_PATH=/path/to/HWSD2_SMU.xlsx
+HWSD2_WRB4_PATH=/path/to/D_WRB4.xlsx

server/.gitignore

@@ -0,0 +1,43 @@
+# ============================================
+# Backend .gitignore
+# ============================================
+
+# ── Credentials & Secrets ──
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+geovision-final*.json
+client_secret*.json
+geovision_drive_token.json
+
+# ── Python ──
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg-info/
+*.egg
+.eggs/
+*.whl
+venv/
+.venv/
+
+# ── Large data (served from GCS now) ──
+final_lookup_tables/
+
+# ── Logs ──
+*.log
+geovision.log
+
+# ── ML model debug/temp files ──
+models/hazardguard/debug_logs/
+
+# ── OS / IDE ──
+.DS_Store
+Thumbs.db
+.vscode/
+.idea/
+*.swp
+*~

server/Procfile

@@ -0,0 +1 @@
+web: gunicorn main:app --bind 0.0.0.0:$PORT --timeout 120 --workers 2 --threads 4

server/README.md

@@ -0,0 +1,290 @@
+# GEO VISION Backend
+
+Professional Flask backend with MVC architecture for satellite data analysis and disaster monitoring.
+
+## 🏗️ Architecture
+
+```
+backend/
+├── main.py                 # Main application entry point
+├── requirements.txt        # Python dependencies
+├── .env                   # Environment configuration
+├── config/                # Configuration management
+│   └── __init__.py        # Config classes and validation
+├── services/              # External integrations
+│   ├── __init__.py
+│   ├── gee_service.py     # Google Earth Engine service
+│   └── ai_service.py      # Gemini AI service
+├── controllers/           # Business logic layer
+│   ├── __init__.py
+│   ├── chat_controller.py # Chat operations
+│   └── satellite_controller.py # Satellite data operations
+├── views/                 # API routes and endpoints
+│   ├── __init__.py
+│   ├── chat_routes.py     # Chat API endpoints
+│   └── satellite_routes.py # Satellite API endpoints
+├── models/                # Data models and schemas
+│   └── __init__.py        # Data classes and models
+└── utils/                 # Utility functions
+    └── __init__.py        # Common utilities and helpers
+```
+
+## 🚀 Quick Start
+
+### 1. Install Dependencies
+
+```bash
+cd backend
+pip install -r requirements.txt
+```
+
+### 2. Configure Environment
+
+Copy and edit the `.env` file with your credentials:
+
+```bash
+# Google Earth Engine
+GEE_PROJECT_ID=your-gee-project-id
+
+# Gemini AI
+GEMINI_API_KEY=your-gemini-api-key
+
+# Flask Configuration
+FLASK_ENV=development
+FLASK_DEBUG=True
+FLASK_HOST=127.0.0.1
+FLASK_PORT=5000
+
+# Application
+APP_NAME=GEO VISION Backend
+APP_VERSION=1.0.0
+APP_USER=MEWTROS
+
+# CORS
+ALLOWED_ORIGINS=http://localhost:3000
+
+# Logging
+LOG_LEVEL=INFO
+LOG_FILE=geovision.log
+```
+
+### 3. Run the Server
+
+```bash
+python main.py
+```
+
+The server will start at `http://127.0.0.1:5000`
+
+## 📡 API Endpoints
+
+### System Endpoints
+
+- `GET /` - Welcome message and endpoint overview
+- `GET /health` - Health check for all services
+- `GET /info` - Application information and API documentation
+
+### Chat API (`/api/chat/`)
+
+- `POST /message` - Send chat message with optional context
+- `POST /analyze` - Analyze location for disaster indicators
+- `GET /disaster/<type>` - Get disaster-specific information
+- `GET /health` - Chat service health check
+
+### Satellite API (`/api/satellite/`)
+
+- `GET|POST /point` - Get satellite data for specific coordinates
+- `POST /region` - Get satellite data for a region (polygon)
+- `GET|POST /availability` - Check data availability for a location
+- `GET /status` - Satellite service status
+- `GET /collections` - List available satellite collections
+
+## 💬 Chat API Usage
+
+### Send Message
+
+```bash
+curl -X POST http://localhost:5000/api/chat/message \
+  -H "Content-Type: application/json" \
+  -d '{
+    "message": "What can you tell me about flood detection using satellites?",
+    "context": {
+      "location": {
+        "latitude": 12.34,
+        "longitude": 56.78
+      }
+    }
+  }'
+```
+
+### Analyze Location
+
+```bash
+curl -X POST http://localhost:5000/api/chat/analyze \
+  -H "Content-Type: application/json" \
+  -d '{
+    "latitude": 12.34,
+    "longitude": 56.78,
+    "days_back": 30,
+    "query": "Check for flood indicators"
+  }'
+```
+
+## 🛰️ Satellite API Usage
+
+### Get Point Data
+
+```bash
+# GET version
+curl "http://localhost:5000/api/satellite/point?latitude=12.34&longitude=56.78&start_date=2024-01-01&end_date=2024-01-31"
+
+# POST version
+curl -X POST http://localhost:5000/api/satellite/point \
+  -H "Content-Type: application/json" \
+  -d '{
+    "latitude": 12.34,
+    "longitude": 56.78,
+    "start_date": "2024-01-01",
+    "end_date": "2024-01-31",
+    "cloud_filter": 20
+  }'
+```
+
+### Get Region Data
+
+```bash
+curl -X POST http://localhost:5000/api/satellite/region \
+  -H "Content-Type: application/json" \
+  -d '{
+    "bounds": [
+      [-122.5, 37.7],
+      [-122.4, 37.8],
+      [-122.3, 37.7]
+    ],
+    "start_date": "2024-01-01",
+    "end_date": "2024-01-31",
+    "scale": 10
+  }'
+```
+
+### Check Availability
+
+```bash
+curl "http://localhost:5000/api/satellite/availability?latitude=12.34&longitude=56.78&days_back=30"
+```
+
+## 🔧 Configuration
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `GEE_PROJECT_ID` | Google Earth Engine project ID | Required |
+| `GEMINI_API_KEY` | Gemini AI API key | Required |
+| `FLASK_ENV` | Flask environment | `development` |
+| `FLASK_DEBUG` | Enable debug mode | `True` |
+| `FLASK_HOST` | Server host | `127.0.0.1` |
+| `FLASK_PORT` | Server port | `5000` |
+| `ALLOWED_ORIGINS` | CORS allowed origins | `http://localhost:3000` |
+| `LOG_LEVEL` | Logging level | `INFO` |
+
+### Satellite Collections
+
+Supported satellite collections:
+- `COPERNICUS/S2_SR` - Sentinel-2 Level-2A (default)
+- `COPERNICUS/S2` - Sentinel-2 Level-1C
+- `LANDSAT/LC08/C02/T1_L2` - Landsat 8 Collection 2
+
+## 🏥 Health Monitoring
+
+Check service health:
+
+```bash
+curl http://localhost:5000/health
+```
+
+Response:
+```json
+{
+  "status": "healthy",
+  "services": {
+    "gee": "healthy",
+    "ai": "healthy"
+  },
+  "version": "1.0.0",
+  "environment": "development"
+}
+```
+
+## 🔍 Error Handling
+
+All endpoints return standardized error responses:
+
+```json
+{
+  "error": "Error description",
+  "status": "error",
+  "timestamp": "2024-01-15T10:30:00",
+  "details": {
+    "additional": "context"
+  }
+}
+```
+
+## 🚀 Production Deployment
+
+### Using Gunicorn
+
+```bash
+gunicorn -w 4 -b 0.0.0.0:5000 main:create_app()
+```
+
+### Using Waitress (Windows)
+
+```bash
+waitress-serve --host=0.0.0.0 --port=5000 main:create_app()
+```
+
+## 📝 Logging
+
+Logs are configured based on `LOG_LEVEL` and optionally written to `LOG_FILE`. 
+
+Available log levels: `DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`
+
+## 🔐 Security Notes
+
+- Never commit `.env` files to version control
+- Use environment-specific configuration for production
+- Consider API rate limiting for production deployments
+- Implement authentication for production use
+
+## 📚 Development
+
+### Adding New Endpoints
+
+1. Create/modify controller in `controllers/`
+2. Add routes in `views/`
+3. Register blueprint in `main.py`
+4. Update this documentation
+
+### Adding New Services
+
+1. Create service class in `services/`
+2. Initialize in `main.py` `initialize_services()`
+3. Inject into controllers as needed
+
+## 🤝 Integration
+
+This backend is designed to work with:
+- Next.js frontend dashboard
+- React/TypeScript components
+- RESTful API clients
+- Satellite data analysis tools
+
+## 📞 Support
+
+For issues or questions:
+- Check the logs for detailed error information
+- Verify environment configuration
+- Ensure Google Earth Engine authentication
+- Confirm Gemini AI API key validity

server/config/__init__.py

@@ -0,0 +1,82 @@
+"""
+Configuration management for GEO VISION Backend
+Loads environment variables and provides configuration settings
+"""
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+class Config:
+    """Base configuration class"""
+    
+    # Google Earth Engine
+    GEE_PROJECT_ID = os.getenv('GEE_PROJECT_ID', 'geovision-final')
+    GEE_SERVICE_ACCOUNT_KEY = os.getenv('GEE_SERVICE_ACCOUNT_KEY', '')
+    
+    # Gemini AI
+    GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
+    
+    # Flask
+    FLASK_ENV = os.getenv('FLASK_ENV', 'development')
+    FLASK_DEBUG = os.getenv('FLASK_DEBUG', 'True').lower() == 'true'
+    FLASK_HOST = os.getenv('FLASK_HOST', '127.0.0.1')
+    FLASK_PORT = int(os.getenv('FLASK_PORT', 5000))
+    
+    # Application
+    APP_NAME = os.getenv('APP_NAME', 'Geo Vision Backend')
+    APP_VERSION = os.getenv('APP_VERSION', '1.0.0')
+    APP_USER = os.getenv('APP_USER', 'ShrishtiAI')
+    
+    # CORS
+    ALLOWED_ORIGINS = os.getenv('ALLOWED_ORIGINS', 'http://localhost:3000').split(',')
+    
+    # Supabase
+    SUPABASE_URL = os.getenv('SUPABASE_URL', '')
+    SUPABASE_SERVICE_ROLE_KEY = os.getenv('SUPABASE_SERVICE_ROLE_KEY', '')
+
+    # Logging
+    LOG_LEVEL = os.getenv('LOG_LEVEL', 'INFO')
+    LOG_FILE = os.getenv('LOG_FILE', 'geovision.log')
+    
+    @classmethod
+    def validate(cls):
+        """Validate required configuration"""
+        errors = []
+        
+        if not cls.GEE_PROJECT_ID:
+            errors.append("GEE_PROJECT_ID is required")
+            
+        if not cls.GEMINI_API_KEY:
+            errors.append("GEMINI_API_KEY is required")
+            
+        return errors
+
+class DevelopmentConfig(Config):
+    """Development configuration"""
+    DEBUG = True
+    TESTING = False
+
+class ProductionConfig(Config):
+    """Production configuration"""
+    DEBUG = False
+    TESTING = False
+
+class TestingConfig(Config):
+    """Testing configuration"""
+    DEBUG = True
+    TESTING = True
+
+# Configuration mapping
+config = {
+    'development': DevelopmentConfig,
+    'production': ProductionConfig,
+    'testing': TestingConfig,
+    'default': DevelopmentConfig
+}
+
+def get_config():
+    """Get configuration based on environment"""
+    env = os.getenv('FLASK_ENV', 'development')
+    return config.get(env, config['default'])

server/config/raster_config.py

@@ -0,0 +1,376 @@
+"""
+Raster Data Configuration for HazardGuard System
+Configuration loader for raster data paths and settings
+
+Updated to use COG-optimized raster files from final_lookup_tables/
+All 9 raster datasets are Cloud Optimized GeoTIFF (ZSTD compressed, 256x256 tiles)
+"""
+
+import os
+import logging
+from typing import Dict, Optional, Any
+from dotenv import load_dotenv
+
+logger = logging.getLogger(__name__)
+
+# Base directory of the backend (where main.py lives)
+BACKEND_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+# ---------- Google Cloud Storage bucket (public, COG-optimised) ----------
+GCS_BUCKET_BASE_URL = os.getenv(
+    'GCS_BUCKET_BASE_URL',
+    'https://storage.googleapis.com/satellite-cog-data-for-shrishti'
+)
+
+# Local fallback (kept for offline / dev use)
+LOCAL_LOOKUP_DIR = os.path.join(os.path.dirname(BACKEND_DIR), 'final_lookup_tables')
+
+# Mapping from config key -> COG filename
+DEFAULT_COG_FILES = {
+    'soil': 'soil_type.tif',
+    'elevation': 'elevation.tif',
+    'population': 'population_density.tif',
+    'landcover': 'land_cover.tif',
+    'ndvi': 'ndvi.tif',
+    'precip': 'annual_precip.tif',
+    'temp': 'mean_annual_temp.tif',
+    'wind': 'wind_speed.tif',
+    'impervious': 'impervious_surface.tif',
+}
+
+
+def _is_url(path: str) -> bool:
+    """Check if a path is an HTTP(S) URL."""
+    return path.startswith('http://') or path.startswith('https://')
+
+
+def _path_exists(path: str) -> bool:
+    """Check existence — works for both local paths and URLs.
+    For URLs we do a lightweight HEAD request (COG files are public).
+    """
+    if _is_url(path):
+        try:
+            import requests
+            resp = requests.head(path, timeout=5, allow_redirects=True)
+            return resp.status_code == 200
+        except Exception:
+            return False
+    return os.path.exists(path)
+
+
+def _resolve_raster_path(env_value: str) -> str:
+    """Resolve a raster path from an env value.
+    
+    URLs (http/https) are returned as-is.
+    If the value is an absolute path, return as-is.
+    If relative, resolve relative to BACKEND_DIR.
+    """
+    if not env_value:
+        return ''
+    env_value = env_value.strip()
+    # URLs must not be touched by os.path helpers
+    if _is_url(env_value):
+        return env_value
+    if os.path.isabs(env_value):
+        return os.path.normpath(env_value)
+    return os.path.normpath(os.path.join(BACKEND_DIR, env_value))
+
+
+class RasterDataConfig:
+    """Configuration manager for raster data sources"""
+    
+    def __init__(self, env_path: Optional[str] = None):
+        """Initialize raster data configuration"""
+        self.env_path = env_path or '.env'
+        self.config = {}
+        
+        # Load environment variables
+        self.load_config()
+    
+    def load_config(self) -> None:
+        """Load configuration from environment variables"""
+        try:
+            # Load .env file if it exists
+            if os.path.exists(self.env_path):
+                load_dotenv(self.env_path)
+                logger.info(f"Loaded environment variables from {self.env_path}")
+            else:
+                logger.warning(f"Environment file not found: {self.env_path}")
+            
+            # Build default raster paths — prefer GCS bucket, fall back to local
+            default_paths = {}
+            for key, filename in DEFAULT_COG_FILES.items():
+                gcs_url = f"{GCS_BUCKET_BASE_URL}/{filename}"
+                local_path = os.path.join(LOCAL_LOOKUP_DIR, filename)
+                if os.path.exists(local_path):
+                    # Keep local as a fast fallback (no network latency)
+                    # but GCS is the primary source for deployment
+                    default_paths[key] = gcs_url
+                    logger.debug(f"{key}: Using GCS URL {gcs_url} (local copy exists)")
+                else:
+                    default_paths[key] = gcs_url
+                    logger.debug(f"{key}: Using GCS URL {gcs_url}")
+            
+            # Environment variables override defaults; resolve relative paths
+            env_key_map = {
+                'soil': 'RASTER_SOIL_PATH',
+                'elevation': 'RASTER_ELEVATION_PATH',
+                'population': 'RASTER_POPULATION_PATH',
+                'landcover': 'RASTER_LANDCOVER_PATH',
+                'ndvi': 'RASTER_NDVI_PATH',
+                'precip': 'RASTER_PRECIP_PATH',
+                'temp': 'RASTER_TEMP_PATH',
+                'wind': 'RASTER_WIND_PATH',
+                'impervious': 'RASTER_IMPERVIOUS_PATH',
+            }
+            
+            raster_paths = {}
+            for key, env_var in env_key_map.items():
+                env_val = os.getenv(env_var, '')
+                if env_val:
+                    resolved = _resolve_raster_path(env_val)
+                    raster_paths[key] = resolved
+                else:
+                    raster_paths[key] = default_paths.get(key, '')
+            
+            self.config = {
+                'raster_paths': raster_paths,
+                'hwsd2_smu_path': _resolve_raster_path(os.getenv('HWSD2_SMU_PATH', '')),
+                'hwsd2_wrb4_path': _resolve_raster_path(os.getenv('HWSD2_WRB4_PATH', '')),
+                'batch_size': int(os.getenv('RASTER_BATCH_SIZE', '100')),
+                'enable_logging': os.getenv('RASTER_ENABLE_LOGGING', 'true').lower() == 'true',
+                'log_level': os.getenv('RASTER_LOG_LEVEL', 'INFO').upper(),
+                'cache_enabled': os.getenv('RASTER_CACHE_ENABLED', 'false').lower() == 'true',
+                'cache_timeout': int(os.getenv('RASTER_CACHE_TIMEOUT', '3600'))
+            }
+            
+            # Filter out empty paths
+            self.config['raster_paths'] = {
+                k: v for k, v in self.config['raster_paths'].items() 
+                if v and v.strip()
+            }
+            
+            gcs_count = sum(1 for v in self.config['raster_paths'].values() if _is_url(v))
+            local_count = len(self.config['raster_paths']) - gcs_count
+            logger.info(f"Loaded configuration for {len(self.config['raster_paths'])} raster sources "
+                        f"({gcs_count} GCS, {local_count} local)")
+            
+        except Exception as e:
+            logger.error(f"Error loading raster configuration: {e}")
+            self.config = self.get_default_config()
+    
+    def get_config(self) -> Dict[str, Any]:
+        """Get complete configuration dictionary"""
+        return self.config.copy()
+    
+    def get_raster_paths(self) -> Dict[str, str]:
+        """Get raster file paths"""
+        return self.config.get('raster_paths', {})
+    
+    def get_soil_database_paths(self) -> Dict[str, str]:
+        """Get soil database file paths"""
+        return {
+            'hwsd2_smu_path': self.config.get('hwsd2_smu_path', ''),
+            'hwsd2_wrb4_path': self.config.get('hwsd2_wrb4_path', '')
+        }
+    
+    def validate_configuration(self) -> Dict[str, Any]:
+        """Validate configuration and file paths"""
+        validation_results = {
+            'valid': True,
+            'errors': [],
+            'warnings': [],
+            'raster_files': {},
+            'database_files': {}
+        }
+        
+        try:
+            # Validate raster files (supports both local paths and HTTPS URLs)
+            for data_type, file_path in self.config.get('raster_paths', {}).items():
+                file_status = {
+                    'path': file_path,
+                    'exists': False,
+                    'readable': False,
+                    'size_mb': 0,
+                    'is_remote': _is_url(file_path),
+                    'error': None
+                }
+                
+                if not file_path:
+                    file_status['error'] = 'Path not configured'
+                    validation_results['warnings'].append(f"{data_type}: Path not configured")
+                elif not _path_exists(file_path):
+                    file_status['error'] = 'File does not exist'
+                    validation_results['errors'].append(f"{data_type}: File does not exist - {file_path}")
+                    validation_results['valid'] = False
+                else:
+                    file_status['exists'] = True
+                    try:
+                        if not _is_url(file_path):
+                            file_status['size_mb'] = round(os.path.getsize(file_path) / (1024 * 1024), 2)
+                        
+                        # Try to open with rasterio (works with both local + HTTPS COGs)
+                        import rasterio
+                        with rasterio.open(file_path) as src:
+                            file_status['readable'] = True
+                            file_status['crs'] = str(src.crs)
+                            file_status['shape'] = src.shape
+                    except ImportError:
+                        validation_results['warnings'].append("rasterio not installed - cannot validate raster files")
+                    except Exception as e:
+                        file_status['error'] = f"Cannot read file: {str(e)}"
+                        validation_results['errors'].append(f"{data_type}: Cannot read file - {str(e)}")
+                
+                validation_results['raster_files'][data_type] = file_status
+            
+            # Validate soil database files
+            for db_name, file_path in self.get_soil_database_paths().items():
+                file_status = {
+                    'path': file_path,
+                    'exists': False,
+                    'readable': False,
+                    'size_mb': 0,
+                    'error': None
+                }
+                
+                if not file_path:
+                    file_status['error'] = 'Path not configured'
+                    validation_results['warnings'].append(f"{db_name}: Path not configured")
+                elif not os.path.exists(file_path):
+                    file_status['error'] = 'File does not exist'
+                    validation_results['errors'].append(f"{db_name}: File does not exist - {file_path}")
+                    validation_results['valid'] = False
+                else:
+                    file_status['exists'] = True
+                    try:
+                        file_status['size_mb'] = round(os.path.getsize(file_path) / (1024 * 1024), 2)
+                        
+                        # Try to open with pandas
+                        import pandas as pd
+                        if file_path.endswith('.xlsx'):
+                            df = pd.read_excel(file_path)
+                            file_status['readable'] = True
+                            file_status['rows'] = len(df)
+                            file_status['columns'] = list(df.columns)
+                        else:
+                            file_status['error'] = 'Unsupported file format'
+                    except ImportError:
+                        validation_results['warnings'].append("pandas not installed - cannot validate Excel files")
+                    except Exception as e:
+                        file_status['error'] = f"Cannot read file: {str(e)}"
+                        validation_results['errors'].append(f"{db_name}: Cannot read file - {str(e)}")
+                
+                validation_results['database_files'][db_name] = file_status
+            
+            # Summary
+            validation_results['summary'] = {
+                'total_raster_files': len(self.config.get('raster_paths', {})),
+                'available_raster_files': sum(1 for f in validation_results['raster_files'].values() if f['exists']),
+                'readable_raster_files': sum(1 for f in validation_results['raster_files'].values() if f['readable']),
+                'total_database_files': len(self.get_soil_database_paths()),
+                'available_database_files': sum(1 for f in validation_results['database_files'].values() if f['exists']),
+                'readable_database_files': sum(1 for f in validation_results['database_files'].values() if f['readable'])
+            }
+            
+        except Exception as e:
+            validation_results['valid'] = False
+            validation_results['errors'].append(f"Validation error: {str(e)}")
+            logger.error(f"Error validating raster configuration: {e}")
+        
+        return validation_results
+    
+    def get_default_config(self) -> Dict[str, Any]:
+        """Get default configuration when loading fails"""
+        return {
+            'raster_paths': {},
+            'hwsd2_smu_path': '',
+            'hwsd2_wrb4_path': '',
+            'batch_size': 100,
+            'enable_logging': True,
+            'log_level': 'INFO',
+            'cache_enabled': False,
+            'cache_timeout': 3600
+        }
+    
+    def get_feature_availability(self) -> Dict[str, bool]:
+        """Get availability status for each feature"""
+        feature_mapping = {
+            'soil_type': 'soil',
+            'elevation_m': 'elevation',
+            'pop_density_persqkm': 'population',
+            'land_cover_class': 'landcover',
+            'ndvi': 'ndvi',
+            'annual_precip_mm': 'precip',
+            'annual_mean_temp_c': 'temp',
+            'mean_wind_speed_ms': 'wind',
+            'impervious_surface_pct': 'impervious'
+        }
+        
+        raster_paths = self.get_raster_paths()
+        availability = {}
+        
+        for feature_name, path_key in feature_mapping.items():
+            path = raster_paths.get(path_key, '')
+            # For remote URLs, assume available if configured
+            availability[feature_name] = bool(path and (_is_url(path) or os.path.exists(path)))
+        
+        return availability
+    
+    def reload_config(self) -> bool:
+        """Reload configuration from environment file"""
+        try:
+            self.load_config()
+            logger.info("Configuration reloaded successfully")
+            return True
+        except Exception as e:
+            logger.error(f"Error reloading configuration: {e}")
+            return False
+    
+    def update_config(self, updates: Dict[str, Any]) -> bool:
+        """Update configuration programmatically"""
+        try:
+            # Deep update
+            for key, value in updates.items():
+                if key in self.config:
+                    if isinstance(self.config[key], dict) and isinstance(value, dict):
+                        self.config[key].update(value)
+                    else:
+                        self.config[key] = value
+                else:
+                    self.config[key] = value
+            
+            logger.info("Configuration updated successfully")
+            return True
+        except Exception as e:
+            logger.error(f"Error updating configuration: {e}")
+            return False
+    
+    def get_config_summary(self) -> Dict[str, Any]:
+        """Get configuration summary for API responses"""
+        return {
+            'raster_sources_configured': len(self.config.get('raster_paths', {})),
+            'soil_databases_configured': bool(
+                self.config.get('hwsd2_smu_path') and 
+                self.config.get('hwsd2_wrb4_path')
+            ),
+            'batch_size': self.config.get('batch_size', 100),
+            'cache_enabled': self.config.get('cache_enabled', False),
+            'logging_enabled': self.config.get('enable_logging', True),
+            'available_features': list(self.get_feature_availability().keys())
+        }
+
+# Global configuration instance
+raster_config = RasterDataConfig()
+
+def get_raster_config() -> RasterDataConfig:
+    """Get global raster configuration instance"""
+    return raster_config
+
+def reload_raster_config() -> bool:
+    """Reload global raster configuration"""
+    global raster_config
+    return raster_config.reload_config()
+
+def validate_raster_config() -> Dict[str, Any]:
+    """Validate global raster configuration"""
+    return raster_config.validate_configuration()

server/controllers/__init__.py

@@ -0,0 +1,8 @@
+"""
+Controllers Package
+Business logic layer for handling requests and coordinating services
+"""
+from .chat_controller import ChatController
+from .satellite_controller import SatelliteController
+
+__all__ = ['ChatController', 'SatelliteController']

server/controllers/auth_controller.py

@@ -0,0 +1,167 @@
+"""
+Auth Controller
+Handles authentication, profile, and activity-log operations.
+Sits between routes and the AuthService.
+"""
+import logging
+from typing import Dict, Any
+from services.auth_service import AuthService
+from models.auth_model import (
+    LoginRequest, SignUpRequest, ProfileUpdate, ActivityLogEntry
+)
+from utils import create_error_response, create_success_response
+
+logger = logging.getLogger(__name__)
+
+
+class AuthController:
+    """Controller for all auth-related endpoints"""
+
+    def __init__(self, auth_service: AuthService):
+        self.auth_service = auth_service
+
+    # ── Auth ────────────────────────────────────────────────────────────
+
+    def login(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        req = LoginRequest(
+            email=data.get("email", ""),
+            password=data.get("password", ""),
+        )
+        errors = req.validate()
+        if errors:
+            return create_error_response("Validation failed", {"errors": errors})
+
+        ok, result = self.auth_service.sign_in(req.email, req.password)
+        if not ok:
+            return create_error_response(result.get("error", "Login failed"))
+
+        # Log the login activity
+        self.auth_service.log_activity(
+            user_id=result["user"]["id"],
+            activity_type="login",
+            description=f"User logged in: {req.email}",
+            device_info=data.get("device_info"),
+        )
+
+        return create_success_response(result, "Login successful")
+
+    def signup(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        req = SignUpRequest(
+            email=data.get("email", ""),
+            password=data.get("password", ""),
+            full_name=data.get("full_name", ""),
+            organization=data.get("organization"),
+            purpose=data.get("purpose"),
+        )
+        errors = req.validate()
+        if errors:
+            return create_error_response("Validation failed", {"errors": errors})
+
+        ok, result = self.auth_service.sign_up(
+            email=req.email,
+            password=req.password,
+            full_name=req.full_name,
+            organization=req.organization,
+            purpose=req.purpose,
+        )
+        if not ok:
+            return create_error_response(result.get("error", "Signup failed"))
+
+        # Log the signup activity
+        self.auth_service.log_activity(
+            user_id=result["user"]["id"],
+            activity_type="signup",
+            description=f"New user registered: {req.email}",
+            device_info=data.get("device_info"),
+        )
+
+        return create_success_response(result, "Account created successfully")
+
+    def logout(self, access_token: str, user_id: str) -> Dict[str, Any]:
+        self.auth_service.sign_out(access_token)
+        self.auth_service.log_activity(
+            user_id=user_id,
+            activity_type="logout",
+            description="User logged out",
+        )
+        return create_success_response(None, "Logged out")
+
+    def get_me(self, access_token: str) -> Dict[str, Any]:
+        """Verify token and return current user info."""
+        ok, user = self.auth_service.verify_token(access_token)
+        if not ok or not user:
+            return create_error_response("Invalid or expired token")
+        return create_success_response({"user": user})
+
+    def refresh(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        refresh_token = data.get("refresh_token", "")
+        if not refresh_token:
+            return create_error_response("refresh_token is required")
+        ok, result = self.auth_service.refresh_session(refresh_token)
+        if not ok:
+            return create_error_response(result.get("error", "Refresh failed"))
+        return create_success_response(result, "Session refreshed")
+
+    def resend_verification(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        email = data.get("email", "").strip()
+        if not email:
+            return create_error_response("Email is required")
+        ok, err = self.auth_service.resend_verification_email(email)
+        if not ok:
+            return create_error_response(err or "Failed to resend verification email")
+        return create_success_response(None, "Verification email sent")
+
+    # ── Profile ─────────────────────────────────────────────────────────
+
+    def get_profile(self, user_id: str) -> Dict[str, Any]:
+        profile = self.auth_service.get_profile(user_id)
+        if not profile:
+            return create_error_response("Profile not found")
+        return create_success_response({"profile": profile})
+
+    def update_profile(self, user_id: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        update = ProfileUpdate(
+            full_name=data.get("full_name"),
+            organization=data.get("organization"),
+            purpose=data.get("purpose"),
+        )
+        fields = update.to_dict()
+        if not fields:
+            return create_error_response("No fields to update")
+
+        ok, err = self.auth_service.update_profile(user_id, fields)
+        if not ok:
+            return create_error_response(err or "Update failed")
+
+        self.auth_service.log_activity(
+            user_id=user_id,
+            activity_type="profile_update",
+            description="Profile info updated",
+        )
+        return create_success_response(None, "Profile updated")
+
+    # ── Activity Logs ───────────────────────────────────────────────────
+
+    def log_activity(self, user_id: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        entry = ActivityLogEntry(
+            activity_type=data.get("activity_type", ""),
+            description=data.get("description"),
+            metadata=data.get("metadata"),
+            device_info=data.get("device_info"),
+        )
+        errors = entry.validate()
+        if errors:
+            return create_error_response("Validation failed", {"errors": errors})
+
+        self.auth_service.log_activity(
+            user_id=user_id,
+            activity_type=entry.activity_type,
+            description=entry.description,
+            metadata=entry.metadata,
+            device_info=entry.device_info,
+        )
+        return create_success_response(None, "Activity logged")
+
+    def get_activity_logs(self, user_id: str, limit: int = 50) -> Dict[str, Any]:
+        logs = self.auth_service.get_activity_logs(user_id, limit)
+        return create_success_response({"logs": logs, "count": len(logs)})

server/controllers/chat_controller.py

@@ -0,0 +1,206 @@
+"""
+Chat Controller
+Handles chat-related business logic and service coordination
+"""
+import logging
+from typing import Dict, Any, Optional
+from flask import request
+from services.ai_service import AIService
+from services.gee_service import GEEService
+
+class ChatController:
+    """Controller for chat operations"""
+    
+    def __init__(self, ai_service: AIService, gee_service: GEEService):
+        self.ai_service = ai_service
+        self.gee_service = gee_service
+        self.logger = logging.getLogger(__name__)
+    
+    def handle_chat_message(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Process incoming chat message and generate response
+        
+        Args:
+            data: Request data containing message and optional context
+            
+        Returns:
+            Response dictionary
+        """
+        try:
+            # Extract message from request data
+            message = data.get('message', '').strip()
+            if not message:
+                return {
+                    'error': 'Message is required',
+                    'status': 'error'
+                }
+            
+            # Extract optional context
+            context = data.get('context', {})
+            
+            # Check if satellite data is requested
+            location = context.get('location')
+            if location and isinstance(location, dict):
+                lat = location.get('latitude')
+                lon = location.get('longitude')
+                
+                if lat is not None and lon is not None:
+                    # Add satellite data to context
+                    context = self._enrich_context_with_satellite_data(context, lat, lon)
+            
+            # Generate AI response
+            response = self.ai_service.generate_response(message, context)
+            
+            if response['status'] == 'success':
+                return {
+                    'response': response['message'],
+                    'status': 'success',
+                    'metadata': {
+                        'model': response.get('model'),
+                        'attempt': response.get('attempt'),
+                        'context_enriched': bool(context)
+                    }
+                }
+            else:
+                return {
+                    'error': response.get('message', 'Failed to generate response'),
+                    'status': 'error'
+                }
+        
+        except Exception as e:
+            self.logger.error(f"Chat message processing error: {str(e)}")
+            return {
+                'error': f'Internal server error: {str(e)}',
+                'status': 'error'
+            }
+    
+    def _enrich_context_with_satellite_data(self, context: Dict[str, Any], lat: float, lon: float) -> Dict[str, Any]:
+        """
+        Enrich context with satellite data if GEE is available
+        
+        Args:
+            context: Current context
+            lat: Latitude
+            lon: Longitude
+            
+        Returns:
+            Enriched context
+        """
+        try:
+            if self.gee_service.initialized:
+                # Get recent satellite data (last 30 days)
+                from datetime import datetime, timedelta
+                
+                end_date = datetime.now()
+                start_date = end_date - timedelta(days=30)
+                
+                satellite_data = self.gee_service.get_satellite_data(
+                    latitude=lat,
+                    longitude=lon,
+                    start_date=start_date.strftime('%Y-%m-%d'),
+                    end_date=end_date.strftime('%Y-%m-%d')
+                )
+                
+                context['satellite_data'] = satellite_data
+                
+        except Exception as e:
+            self.logger.warning(f"Failed to enrich context with satellite data: {str(e)}")
+        
+        return context
+    
+    def analyze_location(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Analyze a specific location for disaster indicators
+        
+        Args:
+            data: Request data containing location and analysis parameters
+            
+        Returns:
+            Analysis results
+        """
+        try:
+            # Extract location data
+            latitude = data.get('latitude')
+            longitude = data.get('longitude')
+            
+            if latitude is None or longitude is None:
+                return {
+                    'error': 'Latitude and longitude are required',
+                    'status': 'error'
+                }
+            
+            # Get satellite data
+            from datetime import datetime, timedelta
+            
+            end_date = datetime.now()
+            start_date = end_date - timedelta(days=data.get('days_back', 30))
+            
+            satellite_data = self.gee_service.get_satellite_data(
+                latitude=latitude,
+                longitude=longitude,
+                start_date=start_date.strftime('%Y-%m-%d'),
+                end_date=end_date.strftime('%Y-%m-%d'),
+                cloud_filter=data.get('cloud_filter', 20)
+            )
+            
+            # Get AI analysis
+            user_query = data.get('query', 'Analyze this location for potential disaster indicators')
+            analysis = self.ai_service.analyze_satellite_data(satellite_data, user_query)
+            
+            return {
+                'status': 'success',
+                'location': {
+                    'latitude': latitude,
+                    'longitude': longitude
+                },
+                'satellite_data': satellite_data,
+                'analysis': analysis,
+                'parameters': {
+                    'days_back': data.get('days_back', 30),
+                    'cloud_filter': data.get('cloud_filter', 20)
+                }
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Location analysis error: {str(e)}")
+            return {
+                'error': f'Analysis failed: {str(e)}',
+                'status': 'error'
+            }
+    
+    def get_disaster_info(self, disaster_type: str, location_data: Dict[str, Any] = None) -> Dict[str, Any]:
+        """
+        Get information about a specific disaster type
+        
+        Args:
+            disaster_type: Type of disaster
+            location_data: Optional location context
+            
+        Returns:
+            Disaster information
+        """
+        try:
+            # Validate disaster type
+            valid_disasters = ['flood', 'drought', 'storm', 'landslide', 'wildfire', 'earthquake']
+            if disaster_type.lower() not in valid_disasters:
+                return {
+                    'error': f'Invalid disaster type. Valid types: {", ".join(valid_disasters)}',
+                    'status': 'error'
+                }
+            
+            # Get AI insights
+            insights = self.ai_service.get_disaster_insights(disaster_type, location_data)
+            
+            return {
+                'status': 'success',
+                'disaster_type': disaster_type,
+                'insights': insights,
+                'location_specific': bool(location_data)
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Disaster info error: {str(e)}")
+            return {
+                'error': f'Failed to get disaster information: {str(e)}',
+                'status': 'error'
+            }

server/controllers/feature_engineering_controller.py

@@ -0,0 +1,366 @@
+"""
+Feature Engineering Controller
+Handles feature engineering operations and coordinates between service and API
+"""
+import logging
+from typing import Dict, Any, List, Optional
+from services.feature_engineering_service import FeatureEngineeringService
+from models.feature_engineering_model import WeatherFeatureModel
+from utils import create_error_response, create_success_response
+
+class FeatureEngineeringController:
+    """Controller for weather feature engineering operations"""
+    
+    def __init__(self, feature_service: FeatureEngineeringService):
+        self.feature_service = feature_service
+        self.logger = logging.getLogger(__name__)
+    
+    def process_features(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Process weather data to compute engineered features
+        
+        Args:
+            data: Request data containing weather_data and optional parameters
+            
+        Returns:
+            Feature engineering response
+        """
+        try:
+            # Validate required parameters
+            if 'weather_data' not in data or not data['weather_data']:
+                return create_error_response(
+                    "Missing required parameter: 'weather_data'",
+                    {"required_fields": ["weather_data"]}
+                )
+            
+            weather_data = data['weather_data']
+            event_duration = data.get('event_duration', 1.0)
+            include_metadata = data.get('include_metadata', True)
+            
+            # Validate event duration
+            try:
+                event_duration = float(event_duration) if event_duration else 1.0
+                if event_duration <= 0:
+                    event_duration = 1.0
+            except (ValueError, TypeError):
+                return create_error_response(
+                    "Invalid event_duration: must be a positive number",
+                    {"event_duration": event_duration}
+                )
+            
+            self.logger.info(f"Processing features for weather data with {len(weather_data)} fields, "
+                           f"event_duration: {event_duration} days")
+            
+            # Process features
+            success, result = self.feature_service.process_weather_features(
+                weather_data, event_duration, include_metadata
+            )
+            
+            if success:
+                return create_success_response(result)
+            else:
+                return create_error_response(
+                    "Failed to process engineered features",
+                    result
+                )
+                
+        except Exception as e:
+            self.logger.error(f"Feature processing error: {str(e)}")
+            return create_error_response(
+                f"Failed to process features: {str(e)}"
+            )
+    
+    def process_batch_features(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Process multiple weather datasets for feature engineering
+        
+        Args:
+            data: Request data containing batch of weather datasets
+            
+        Returns:
+            Batch feature engineering response
+        """
+        try:
+            # Validate batch request
+            if 'batch_data' not in data or not isinstance(data['batch_data'], list):
+                return create_error_response(
+                    "Invalid batch request: 'batch_data' array required"
+                )
+            
+            batch_data = data['batch_data']
+            include_metadata = data.get('include_metadata', True)
+            
+            if len(batch_data) > 100:  # Limit batch size
+                return create_error_response(
+                    "Batch size too large: maximum 100 items allowed",
+                    {"max_allowed": 100, "requested": len(batch_data)}
+                )
+            
+            self.logger.info(f"Processing batch feature engineering for {len(batch_data)} datasets")
+            
+            # Process batch
+            success, result = self.feature_service.process_batch_features(
+                batch_data, include_metadata
+            )
+            
+            if success:
+                return create_success_response(result)
+            else:
+                return create_error_response(
+                    "Failed to process batch features",
+                    result
+                )
+                
+        except Exception as e:
+            self.logger.error(f"Batch feature processing error: {str(e)}")
+            return create_error_response(
+                f"Failed to process batch features: {str(e)}"
+            )
+    
+    def create_feature_dataframe(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Create DataFrame with weather data and engineered features
+        
+        Args:
+            data: Request data containing weather_data, disaster_date, and days_before
+            
+        Returns:
+            DataFrame creation response
+        """
+        try:
+            # Validate required parameters
+            required_fields = ['weather_data', 'disaster_date', 'days_before']
+            missing_fields = [field for field in required_fields if field not in data or data[field] is None]
+            
+            if missing_fields:
+                return create_error_response(
+                    f"Missing required fields: {', '.join(missing_fields)}",
+                    {"missing_fields": missing_fields}
+                )
+            
+            weather_data = data['weather_data']
+            disaster_date = str(data['disaster_date'])
+            event_duration = data.get('event_duration', 1.0)
+            
+            try:
+                days_before = int(data['days_before'])
+                event_duration = float(event_duration)
+            except (ValueError, TypeError) as e:
+                return create_error_response(
+                    f"Invalid parameter format: {str(e)}",
+                    {"validation_error": str(e)}
+                )
+            
+            self.logger.info(f"Creating feature DataFrame for {disaster_date}, "
+                           f"{days_before} days, duration: {event_duration}")
+            
+            # Process features first
+            success, feature_result = self.feature_service.process_weather_features(
+                weather_data, event_duration, include_metadata=True
+            )
+            
+            if not success:
+                return create_error_response(
+                    "Failed to process features for DataFrame",
+                    feature_result
+                )
+            
+            # Create DataFrame
+            try:
+                df = self.feature_service.create_feature_dataframe(
+                    weather_data,
+                    feature_result['engineered_features'],
+                    disaster_date,
+                    days_before
+                )
+                
+                # Convert DataFrame to dict for JSON response
+                dataframe_data = {
+                    'dates': df['date'].tolist(),
+                    'weather_data': {
+                        col: df[col].tolist()
+                        for col in df.columns 
+                        if col in WeatherFeatureModel.WEATHER_FIELDS
+                    },
+                    'engineered_features': {
+                        col: df[col].tolist()
+                        for col in df.columns
+                        if col in WeatherFeatureModel.ENGINEERED_FEATURES
+                    }
+                }
+                
+                return create_success_response({
+                    'dataframe': dataframe_data,
+                    'shape': df.shape,
+                    'columns': list(df.columns),
+                    'metadata': feature_result.get('metadata', {}),
+                    'validation': feature_result.get('validation', {})
+                })
+                
+            except Exception as e:
+                return create_error_response(
+                    f"Failed to create DataFrame: {str(e)}"
+                )
+                
+        except Exception as e:
+            self.logger.error(f"DataFrame creation error: {str(e)}")
+            return create_error_response(
+                f"Failed to create feature DataFrame: {str(e)}"
+            )
+    
+    def get_feature_info(self) -> Dict[str, Any]:
+        """Get information about available engineered features"""
+        try:
+            feature_info = self.feature_service.get_feature_info()
+            
+            return create_success_response({
+                'feature_info': feature_info,
+                'service_status': self.feature_service.get_service_status()
+            })
+            
+        except Exception as e:
+            self.logger.error(f"Feature info error: {str(e)}")
+            return create_error_response(
+                f"Failed to get feature info: {str(e)}"
+            )
+    
+    def validate_weather_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Validate weather data for feature engineering
+        
+        Args:
+            data: Request data containing weather_data
+            
+        Returns:
+            Validation response
+        """
+        try:
+            if 'weather_data' not in data or not data['weather_data']:
+                return create_error_response(
+                    "Missing required parameter: 'weather_data'",
+                    {"required_fields": ["weather_data"]}
+                )
+            
+            weather_data = data['weather_data']
+            
+            # Validate data
+            is_valid, validation = self.feature_service.validate_input_data(weather_data)
+            
+            validation_result = {
+                'validation': validation,
+                'is_valid': is_valid,
+                'ready_for_processing': is_valid
+            }
+            
+            if is_valid:
+                return create_success_response(validation_result)
+            else:
+                return create_error_response(
+                    "Weather data validation failed",
+                    validation_result
+                )
+                
+        except Exception as e:
+            self.logger.error(f"Validation error: {str(e)}")
+            return create_error_response(
+                f"Failed to validate weather data: {str(e)}"
+            )
+    
+    def process_and_export(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Process features and export in specified format
+        
+        Args:
+            data: Request data with weather_data, disaster_date, days_before, and export options
+            
+        Returns:
+            Export response
+        """
+        try:
+            # Validate required parameters
+            required_fields = ['weather_data', 'disaster_date', 'days_before']
+            missing_fields = [field for field in required_fields if field not in data or data[field] is None]
+            
+            if missing_fields:
+                return create_error_response(
+                    f"Missing required fields: {', '.join(missing_fields)}",
+                    {"missing_fields": missing_fields}
+                )
+            
+            weather_data = data['weather_data']
+            disaster_date = str(data['disaster_date'])
+            event_duration = data.get('event_duration', 1.0)
+            export_format = data.get('export_format', 'dict').lower()
+            
+            try:
+                days_before = int(data['days_before'])
+                event_duration = float(event_duration)
+            except (ValueError, TypeError) as e:
+                return create_error_response(
+                    f"Invalid parameter format: {str(e)}",
+                    {"validation_error": str(e)}
+                )
+            
+            # Validate export format
+            valid_formats = ['dict', 'dataframe', 'json']
+            if export_format not in valid_formats:
+                return create_error_response(
+                    f"Invalid export format: {export_format}",
+                    {"valid_formats": valid_formats}
+                )
+            
+            self.logger.info(f"Processing and exporting features in '{export_format}' format")
+            
+            # Process and export
+            success, result = self.feature_service.process_and_export(
+                weather_data, disaster_date, days_before, event_duration, export_format
+            )
+            
+            if success:
+                # Handle DataFrame special case for JSON response
+                if export_format == 'dataframe' and 'export' in result:
+                    export_data = result['export']
+                    if 'dataframe' in export_data:
+                        # Convert DataFrame to dict for JSON serialization
+                        df = export_data['dataframe']
+                        export_data['dataframe_dict'] = df.to_dict(orient='list')
+                        # Remove actual DataFrame object for JSON response
+                        del export_data['dataframe']
+                
+                return create_success_response(result)
+            else:
+                return create_error_response(
+                    "Failed to process and export features",
+                    result
+                )
+                
+        except Exception as e:
+            self.logger.error(f"Process and export error: {str(e)}")
+            return create_error_response(
+                f"Failed to process and export: {str(e)}"
+            )
+    
+    def get_service_status(self) -> Dict[str, Any]:
+        """Get feature engineering service status and health"""
+        try:
+            service_status = self.feature_service.get_service_status()
+            
+            return create_success_response({
+                'controller': 'Feature Engineering Controller',
+                'service': service_status,
+                'health': 'healthy' if service_status.get('initialized') else 'unhealthy',
+                'available_operations': [
+                    'process_features',
+                    'process_batch_features', 
+                    'create_feature_dataframe',
+                    'validate_weather_data',
+                    'process_and_export',
+                    'get_feature_info'
+                ]
+            })
+            
+        except Exception as e:
+            self.logger.error(f"Service status error: {str(e)}")
+            return create_error_response(
+                f"Failed to get service status: {str(e)}"
+            )

server/controllers/geovision_fusion_controller.py

@@ -0,0 +1,170 @@
+"""
+GeoVision Fusion Prediction Controller
+API request coordination and response formatting for GeoVision fusion predictions
+"""
+
+import logging
+from typing import Dict, Optional, Any, Tuple
+from datetime import datetime
+
+from services.geovision_fusion_service import GeoVisionFusionService
+
+logger = logging.getLogger(__name__)
+
+
+class GeoVisionFusionController:
+    """Controller for GeoVision fusion prediction API operations."""
+
+    def __init__(self, service: Optional[GeoVisionFusionService] = None):
+        """Initialize the controller with a service instance."""
+        self.service = service or GeoVisionFusionService()
+        self.controller_stats = {
+            'total_requests': 0,
+            'successful_requests': 0,
+            'failed_requests': 0
+        }
+        logger.info("[GEOVISION_CTRL] Controller initialized")
+
+    def initialize_controller(self) -> Dict[str, Any]:
+        """Initialize by setting up the service."""
+        try:
+            success, message = self.service.initialize_service()
+            return self._create_response(
+                success=success,
+                message=message if success else "Controller initialization failed",
+                data={'service_status': 'ready' if success else 'failed'},
+                error=None if success else message
+            )
+        except Exception as e:
+            return self._create_response(
+                success=False,
+                message="Controller initialization error",
+                error=str(e)
+            )
+
+    def predict_fusion(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Primary endpoint: run GeoVision fusion prediction for a location.
+
+        Expected request_data:
+            latitude: float     (-90 to 90)
+            longitude: float    (-180 to 180)
+        """
+        self.controller_stats['total_requests'] += 1
+
+        try:
+            # Reject if TF models are still warming up in the background thread
+            if not self.service.service_stats.get('models_loaded'):
+                return self._create_response(
+                    success=False,
+                    message="Service is warming up, please retry in a moment",
+                    error="models_not_ready"
+                )
+
+            # Validate required fields
+            is_valid, msg, parsed = self._validate_request(request_data)
+            if not is_valid:
+                return self._create_response(
+                    success=False,
+                    message="Validation failed",
+                    error=msg,
+                    data={
+                        'required_fields': ['latitude', 'longitude']
+                    }
+                )
+
+            latitude, longitude = parsed
+
+            # Call service (no reference_date — service auto-selects most recent)
+            result = self.service.predict_for_location(latitude, longitude)
+
+            if result.get('success'):
+                self.controller_stats['successful_requests'] += 1
+                return self._create_response(
+                    success=True,
+                    message="GeoVision fusion prediction completed",
+                    data={
+                        'location': result['location'],
+                        'prediction': result['prediction'],
+                        'intermediate': result.get('intermediate', {}),
+                        'metadata': result.get('metadata', {}),
+                        'data_collection_summary': {
+                            'weather_data': result['data_collection']['weather']['success'],
+                            'feature_engineering': result['data_collection']['features']['success'],
+                            'raster_data': result['data_collection']['raster']['success'],
+                        }
+                    },
+                    processing_info={
+                        'processing_time_seconds': result['processing_time_seconds'],
+                        'disaster_prediction': result['prediction']['disaster_prediction'],
+                        'weather_prediction': result['prediction']['weather_prediction'],
+                        'models_used': result.get('intermediate', {}).get('models_used', [])
+                    }
+                )
+            else:
+                self.controller_stats['failed_requests'] += 1
+                return self._create_response(
+                    success=False,
+                    message="Fusion prediction failed",
+                    error=result.get('error', 'Unknown error'),
+                    data={
+                        'location': result.get('location'),
+                        'data_collection': result.get('data_collection')
+                    }
+                )
+
+        except Exception as e:
+            self.controller_stats['failed_requests'] += 1
+            logger.error(f"[GEOVISION_CTRL] Error: {e}")
+            return self._create_response(
+                success=False,
+                message="Fusion prediction error",
+                error=str(e)
+            )
+
+    def get_service_status(self) -> Dict[str, Any]:
+        """Return service health and model status."""
+        status = self.service.get_service_status()
+        return self._create_response(
+            success=True,
+            message="GeoVision service status",
+            data=status
+        )
+
+    # ────────────────────────────────────────────────────────
+    # PRIVATE HELPERS
+    # ────────────────────────────────────────────────────────
+    def _validate_request(self, data: Dict[str, Any]) -> Tuple[bool, str, Optional[Tuple]]:
+        """Validate prediction request."""
+        if 'latitude' not in data:
+            return False, "Missing required field: 'latitude'", None
+        if 'longitude' not in data:
+            return False, "Missing required field: 'longitude'", None
+        try:
+            lat = float(data['latitude'])
+            lon = float(data['longitude'])
+        except (ValueError, TypeError):
+            return False, "latitude/longitude must be numeric", None
+        if not (-90 <= lat <= 90):
+            return False, f"Invalid latitude {lat}", None
+        if not (-180 <= lon <= 180):
+            return False, f"Invalid longitude {lon}", None
+
+        return True, "OK", (lat, lon)
+
+    def _create_response(self, success: bool = True, message: str = '',
+                         data: Any = None, error: str = None,
+                         processing_info: Optional[Dict] = None) -> Dict[str, Any]:
+        """Build standardized response."""
+        response = {
+            'success': success,
+            'message': message,
+            'data': data,
+            'timestamp': datetime.now().isoformat(),
+            'service': 'geovision_fusion'
+        }
+        if error:
+            response['error'] = error
+        if processing_info:
+            response['processing_info'] = processing_info
+        return response

server/controllers/hazardguard_prediction_controller.py

@@ -0,0 +1,541 @@
+"""
+HazardGuard Disaster Prediction Controller
+API request coordination and response formatting for disaster predictions
+"""
+
+import logging
+import json
+from typing import Dict, List, Optional, Any, Tuple
+from datetime import datetime
+
+from services.hazardguard_prediction_service import HazardGuardPredictionService
+
+logger = logging.getLogger(__name__)
+
+class HazardGuardPredictionController:
+    """Controller for HazardGuard disaster prediction API operations"""
+    
+    def __init__(self, service: Optional[HazardGuardPredictionService] = None):
+        """Initialize the HazardGuard prediction controller"""
+        self.service = service or HazardGuardPredictionService()
+        
+        # Standard response templates
+        self.success_template = {
+            'success': True,
+            'message': 'Operation completed successfully',
+            'data': {},
+            'timestamp': None,
+            'processing_info': {}
+        }
+        
+        self.error_template = {
+            'success': False,
+            'error': 'Unknown error',
+            'message': 'Operation failed',
+            'data': None,
+            'timestamp': None
+        }
+        
+        logger.info("HazardGuard prediction controller initialized")
+    
+    def initialize_controller(self) -> Dict[str, Any]:
+        """
+        Initialize the controller by setting up the service
+        
+        Returns:
+            Initialization response
+        """
+        try:
+            success, message = self.service.initialize_service()
+            
+            if success:
+                return self._create_response(
+                    success=True,
+                    message="HazardGuard controller initialized successfully",
+                    data={
+                        'service_status': 'ready',
+                        'initialization_message': message
+                    }
+                )
+            else:
+                return self._create_response(
+                    success=False,
+                    message="Controller initialization failed",
+                    error=message
+                )
+                
+        except Exception as e:
+            logger.error(f"Controller initialization error: {e}")
+            return self._create_response(
+                success=False,
+                message="Controller initialization error",
+                error=f"Controller error: {str(e)}"
+            )
+    
+    def _create_response(self, success: bool = True, message: str = '', 
+                        data: Any = None, error: str = '', 
+                        processing_info: Optional[Dict] = None) -> Dict[str, Any]:
+        """
+        Create standardized API response
+        
+        Args:
+            success: Whether the operation was successful
+            message: Success or error message
+            data: Response data
+            error: Error message (for failed operations)
+            processing_info: Additional processing information
+        
+        Returns:
+            Standardized response dictionary
+        """
+        if success:
+            response = self.success_template.copy()
+            response['message'] = message or 'Operation completed successfully'
+            response['data'] = data
+            response['processing_info'] = processing_info or {}
+        else:
+            response = self.error_template.copy()
+            response['error'] = error or 'Unknown error'
+            response['message'] = message or 'Operation failed'
+            response['data'] = data
+        
+        response['timestamp'] = datetime.now().isoformat()
+        return response
+    
+    def validate_prediction_request(self, request_data: Dict[str, Any]) -> Tuple[bool, str, Optional[Tuple[float, float, Optional[str]]]]:
+        """
+        Validate prediction request data
+        
+        Args:
+            request_data: Request dictionary containing location data
+        
+        Returns:
+            Tuple of (is_valid, message, (latitude, longitude, reference_date))
+        """
+        try:
+            # Check for required fields
+            if 'latitude' not in request_data:
+                return False, "Missing required field: 'latitude'", None
+            
+            if 'longitude' not in request_data:
+                return False, "Missing required field: 'longitude'", None
+            
+            # Extract and validate coordinates
+            try:
+                latitude = float(request_data['latitude'])
+                longitude = float(request_data['longitude'])
+            except (ValueError, TypeError):
+                return False, "Latitude and longitude must be numeric values", None
+            
+            # Validate coordinate ranges
+            if not (-90 <= latitude <= 90):
+                return False, f"Invalid latitude {latitude} (must be -90 to 90)", None
+            
+            if not (-180 <= longitude <= 180):
+                return False, f"Invalid longitude {longitude} (must be -180 to 180)", None
+            
+            # Optional reference date validation
+            reference_date = request_data.get('reference_date')
+            if reference_date:
+                try:
+                    # Validate date format
+                    datetime.strptime(reference_date, '%Y-%m-%d')
+                except ValueError:
+                    return False, "Invalid reference_date format. Use YYYY-MM-DD.", None
+            
+            return True, f"Request validation successful: ({latitude}, {longitude})", (latitude, longitude, reference_date)
+            
+        except Exception as e:
+            logger.error(f"Request validation error: {e}")
+            return False, f"Validation error: {str(e)}", None
+    
+    def predict_disaster_risk(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Primary endpoint: Predict disaster risk for a location
+        
+        Args:
+            request_data: Request dictionary with latitude, longitude, and optional reference_date
+        
+        Returns:
+            Disaster prediction response
+        """
+        try:
+            # Validate request
+            is_valid, validation_message, parsed_data = self.validate_prediction_request(request_data)
+            
+            if not is_valid:
+                return self._create_response(
+                    success=False,
+                    message="Request validation failed",
+                    error=validation_message,
+                    data={
+                        'required_fields': ['latitude', 'longitude'],
+                        'optional_fields': ['reference_date (YYYY-MM-DD)'],
+                        'coordinate_ranges': 'latitude: -90 to 90, longitude: -180 to 180'
+                    }
+                )
+            
+            latitude, longitude, reference_date = parsed_data
+            
+            logger.info(f"Processing disaster prediction for ({latitude}, {longitude})")
+            
+            # Make prediction using service
+            prediction_result = self.service.predict_disaster_for_location(
+                latitude=latitude,
+                longitude=longitude,
+                reference_date=reference_date
+            )
+            
+            if prediction_result['success']:
+                response_data = {
+                    'location': prediction_result['location'],
+                    'prediction': prediction_result['prediction'],
+                    'data_collection_summary': {
+                        'weather_data': prediction_result['data_collection']['weather']['success'],
+                        'feature_engineering': prediction_result['data_collection']['features']['success'],
+                        'raster_data': prediction_result['data_collection']['raster']['success']
+                    },
+                    'processing_details': prediction_result['processing_info']
+                }
+                
+                # Add disaster types if available
+                if prediction_result.get('disaster_types'):
+                    response_data['disaster_types'] = prediction_result['disaster_types']
+                
+                return self._create_response(
+                    success=True,
+                    message="Disaster prediction completed successfully",
+                    data=response_data,
+                    processing_info={
+                        'total_processing_time_seconds': prediction_result['processing_info']['total_processing_time_seconds'],
+                        'prediction_class': prediction_result['prediction']['prediction'],
+                        'disaster_probability': prediction_result['prediction']['probability']['disaster'],
+                        'confidence': prediction_result['prediction']['confidence']
+                    }
+                )
+            else:
+                return self._create_response(
+                    success=False,
+                    message="Disaster prediction failed",
+                    error=prediction_result.get('error', 'Unknown prediction error'),
+                    data={
+                        'location': prediction_result.get('location'),
+                        'data_collection': prediction_result.get('data_collection'),
+                        'processing_time_seconds': prediction_result.get('processing_time_seconds', 0)
+                    }
+                )
+            
+        except Exception as e:
+            logger.error(f"Controller prediction error: {e}")
+            return self._create_response(
+                success=False,
+                message="Disaster prediction error",
+                error=f"Controller error: {str(e)}"
+            )
+    
+    def predict_batch_locations(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Batch prediction endpoint: Predict disaster risk for multiple locations
+        
+        Args:
+            request_data: Request dictionary with 'locations' array
+        
+        Returns:
+            Batch prediction response
+        """
+        try:
+            # Validate batch request
+            locations = request_data.get('locations', [])
+            
+            if not locations or not isinstance(locations, list):
+                return self._create_response(
+                    success=False,
+                    message="Batch prediction validation failed",
+                    error="'locations' field must be a non-empty array",
+                    data={
+                        'required_format': {
+                            'locations': [
+                                {'latitude': float, 'longitude': float, 'reference_date': 'YYYY-MM-DD (optional)'},
+                                {'latitude': float, 'longitude': float}
+                            ]
+                        }
+                    }
+                )
+            
+            if len(locations) > 50:  # Limit batch size
+                return self._create_response(
+                    success=False,
+                    message="Batch size limit exceeded",
+                    error="Maximum 50 locations per batch request"
+                )
+            
+            logger.info(f"Processing batch prediction for {len(locations)} locations")
+            
+            results = []
+            successful_predictions = 0
+            failed_predictions = 0
+            
+            for i, location_data in enumerate(locations):
+                try:
+                    # Validate individual location
+                    is_valid, validation_message, parsed_data = self.validate_prediction_request(location_data)
+                    
+                    if not is_valid:
+                        results.append({
+                            'location_index': i + 1,
+                            'success': False,
+                            'error': validation_message,
+                            'location_data': location_data
+                        })
+                        failed_predictions += 1
+                        continue
+                    
+                    latitude, longitude, reference_date = parsed_data
+                    
+                    # Make prediction
+                    prediction_result = self.service.predict_disaster_for_location(
+                        latitude=latitude,
+                        longitude=longitude,
+                        reference_date=reference_date
+                    )
+                    
+                    if prediction_result['success']:
+                        batch_entry = {
+                            'location_index': i + 1,
+                            'success': True,
+                            'location': prediction_result['location'],
+                            'prediction': prediction_result['prediction'],
+                            'processing_time_seconds': prediction_result['processing_info']['total_processing_time_seconds']
+                        }
+                        # Include disaster type classification if available
+                        if prediction_result.get('disaster_types'):
+                            batch_entry['disaster_types'] = prediction_result['disaster_types']
+                        results.append(batch_entry)
+                        successful_predictions += 1
+                    else:
+                        results.append({
+                            'location_index': i + 1,
+                            'success': False,
+                            'error': prediction_result.get('error', 'Prediction failed'),
+                            'location': prediction_result.get('location'),
+                            'processing_time_seconds': prediction_result.get('processing_time_seconds', 0)
+                        })
+                        failed_predictions += 1
+                        
+                except Exception as e:
+                    results.append({
+                        'location_index': i + 1,
+                        'success': False,
+                        'error': f"Location processing error: {str(e)}",
+                        'location_data': location_data
+                    })
+                    failed_predictions += 1
+            
+            # Calculate success rate
+            total_locations = len(locations)
+            success_rate = (successful_predictions / total_locations * 100) if total_locations > 0 else 0
+            
+            return self._create_response(
+                success=successful_predictions > 0,
+                message=f"Batch prediction completed: {successful_predictions}/{total_locations} successful",
+                data={
+                    'results': results,
+                    'summary': {
+                        'total_locations': total_locations,
+                        'successful_predictions': successful_predictions,
+                        'failed_predictions': failed_predictions,
+                        'success_rate_percent': success_rate
+                    }
+                },
+                processing_info={
+                    'batch_size': total_locations,
+                    'processing_mode': 'sequential'
+                }
+            )
+            
+        except Exception as e:
+            logger.error(f"Controller batch prediction error: {e}")
+            return self._create_response(
+                success=False,
+                message="Batch prediction error",
+                error=f"Controller error: {str(e)}"
+            )
+    
+    def get_prediction_capabilities(self) -> Dict[str, Any]:
+        """
+        Get information about HazardGuard prediction capabilities
+        
+        Returns:
+            Capabilities information response
+        """
+        try:
+            # Get service status to include model info
+            service_status = self.service.get_service_status()
+            
+            capabilities = {
+                'prediction_type': 'Binary Classification (DISASTER vs NORMAL)',
+                'supported_disaster_types': ['Flood', 'Storm', 'Landslide', 'Drought'],
+                'forecasting_horizon': '1 day ahead',
+                'geographic_coverage': 'Global (latitude: -90 to 90, longitude: -180 to 180)',
+                'data_sources': {
+                    'weather_data': 'NASA POWER API (17 variables, 60-day sequences)',
+                    'engineered_features': 'Weather-derived features (19 variables)',
+                    'raster_data': 'Geographic/Environmental data (9 variables)',
+                    'total_features': '~300 features after statistical expansion'
+                },
+                'model_details': {
+                    'algorithm': 'XGBoost Binary Classifier',
+                    'feature_selection': 'SelectKBest with f_classif',
+                    'preprocessing': 'StandardScaler normalization',
+                    'validation': '5-fold GroupKFold cross-validation'
+                },
+                'input_requirements': {
+                    'required_fields': ['latitude', 'longitude'],
+                    'optional_fields': ['reference_date (YYYY-MM-DD)'],
+                    'coordinate_ranges': {
+                        'latitude': {'min': -90, 'max': 90},
+                        'longitude': {'min': -180, 'max': 180}
+                    }
+                },
+                'output_format': {
+                    'prediction': 'DISASTER or NORMAL',
+                    'probabilities': {
+                        'disaster': 'float (0.0 to 1.0)',
+                        'normal': 'float (0.0 to 1.0)'
+                    },
+                    'confidence': 'float (difference between class probabilities)',
+                    'processing_metadata': 'timing, feature counts, etc.'
+                },
+                'batch_processing': {
+                    'supported': True,
+                    'max_locations_per_request': 50
+                },
+                'service_status': service_status
+            }
+            
+            return self._create_response(
+                success=True,
+                message="HazardGuard capabilities retrieved successfully",
+                data=capabilities
+            )
+            
+        except Exception as e:
+            logger.error(f"Controller capabilities error: {e}")
+            return self._create_response(
+                success=False,
+                message="Capabilities retrieval error",
+                error=f"Controller error: {str(e)}"
+            )
+    
+    def get_service_health(self) -> Dict[str, Any]:
+        """
+        Get HazardGuard service health and performance statistics
+        
+        Returns:
+            Service health response
+        """
+        try:
+            service_status = self.service.get_service_status()
+            
+            if service_status.get('service_status') in ['ready', 'healthy']:
+                return self._create_response(
+                    success=True,
+                    message="HazardGuard service is healthy",
+                    data=service_status
+                )
+            else:
+                return self._create_response(
+                    success=False,
+                    message="HazardGuard service health issues detected",
+                    error=service_status.get('error', 'Service not ready'),
+                    data=service_status
+                )
+            
+        except Exception as e:
+            logger.error(f"Controller health check error: {e}")
+            return self._create_response(
+                success=False,
+                message="Health check error",
+                error=f"Controller error: {str(e)}"
+            )
+    
+    def reset_service_statistics(self) -> Dict[str, Any]:
+        """
+        Reset HazardGuard service statistics
+        
+        Returns:
+            Statistics reset response
+        """
+        try:
+            reset_result = self.service.reset_statistics()
+            
+            if reset_result['status'] == 'success':
+                return self._create_response(
+                    success=True,
+                    message="HazardGuard statistics reset successfully",
+                    data=reset_result
+                )
+            else:
+                return self._create_response(
+                    success=False,
+                    message="Statistics reset failed",
+                    error=reset_result['message']
+                )
+            
+        except Exception as e:
+            logger.error(f"Controller statistics reset error: {e}")
+            return self._create_response(
+                success=False,
+                message="Statistics reset error",
+                error=f"Controller error: {str(e)}"
+            )
+    
+    def validate_coordinates_only(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Validate coordinates without making prediction (for testing/validation)
+        
+        Args:
+            request_data: Request dictionary containing coordinates
+        
+        Returns:
+            Coordinate validation response
+        """
+        try:
+            is_valid, validation_message, parsed_data = self.validate_prediction_request(request_data)
+            
+            if is_valid:
+                latitude, longitude, reference_date = parsed_data
+                
+                return self._create_response(
+                    success=True,
+                    message="Coordinate validation successful",
+                    data={
+                        'coordinates': {
+                            'latitude': latitude,
+                            'longitude': longitude,
+                            'reference_date': reference_date
+                        },
+                        'validation_message': validation_message
+                    }
+                )
+            else:
+                return self._create_response(
+                    success=False,
+                    message="Coordinate validation failed",
+                    error=validation_message,
+                    data={
+                        'required_format': {
+                            'latitude': 'float (-90 to 90)',
+                            'longitude': 'float (-180 to 180)',
+                            'reference_date': 'string (YYYY-MM-DD, optional)'
+                        }
+                    }
+                )
+            
+        except Exception as e:
+            logger.error(f"Controller coordinate validation error: {e}")
+            return self._create_response(
+                success=False,
+                message="Coordinate validation error",
+                error=f"Controller error: {str(e)}"
+            )

server/controllers/post_disaster_feature_engineering_controller.py

@@ -0,0 +1,474 @@
+"""
+Post-Disaster Feature Engineering Controller for HazardGuard System
+API request coordination and response formatting
+"""
+
+import logging
+import json
+from typing import Dict, List, Optional, Any, Tuple
+from datetime import datetime
+
+from services.post_disaster_feature_engineering_service import PostDisasterFeatureEngineeringService
+
+logger = logging.getLogger(__name__)
+
+class PostDisasterFeatureEngineeringController:
+    """Controller for post-disaster feature engineering API operations"""
+    
+    def __init__(self):
+        """Initialize the post-disaster feature engineering controller"""
+        self.service = PostDisasterFeatureEngineeringService()
+        
+        # Standard response templates
+        self.success_template = {
+            'success': True,
+            'message': 'Operation completed successfully',
+            'data': {},
+            'timestamp': None,
+            'processing_info': {}
+        }
+        
+        self.error_template = {
+            'success': False,
+            'error': 'Unknown error',
+            'message': 'Operation failed',
+            'data': None,
+            'timestamp': None
+        }
+        
+        logger.info("PostDisasterFeatureEngineeringController initialized")
+    
+    def _create_response(self, success: bool = True, message: str = '', 
+                        data: Any = None, error: str = '', 
+                        processing_info: Optional[Dict] = None) -> Dict[str, Any]:
+        """
+        Create standardized API response
+        
+        Args:
+            success: Whether the operation was successful
+            message: Success or error message
+            data: Response data
+            error: Error message (for failed operations)
+            processing_info: Additional processing information
+        
+        Returns:
+            Standardized response dictionary
+        """
+        if success:
+            response = self.success_template.copy()
+            response['message'] = message or 'Operation completed successfully'
+            response['data'] = data
+            response['processing_info'] = processing_info or {}
+        else:
+            response = self.error_template.copy()
+            response['error'] = error or 'Unknown error'
+            response['message'] = message or 'Operation failed'
+            response['data'] = data
+        
+        response['timestamp'] = datetime.now().isoformat()
+        return response
+    
+    def validate_coordinates(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Validate coordinates from request data
+        
+        Args:
+            request_data: Request dictionary containing 'coordinates' key
+        
+        Returns:
+            Validation response
+        """
+        try:
+            coordinates = request_data.get('coordinates')
+            
+            if not coordinates:
+                return self._create_response(
+                    success=False,
+                    message="Coordinates validation failed",
+                    error="No coordinates provided in request",
+                    data={'required_format': '[[lat1, lon1], [lat2, lon2], ...]'}
+                )
+            
+            # Use service validation
+            is_valid, validation_message, parsed_coordinates = self.service.validate_coordinates(coordinates)
+            
+            if not is_valid:
+                return self._create_response(
+                    success=False,
+                    message="Coordinates validation failed",
+                    error=validation_message,
+                    data={'required_format': '[[lat1, lon1], [lat2, lon2], ...]'}
+                )
+            
+            return self._create_response(
+                success=True,
+                message="Coordinates validation successful",
+                data={
+                    'coordinates': parsed_coordinates,
+                    'count': len(parsed_coordinates),
+                    'validation_message': validation_message
+                },
+                processing_info={
+                    'coordinates_count': len(parsed_coordinates)
+                }
+            )
+            
+        except Exception as e:
+            logger.error(f"Controller coordinates validation error: {e}")
+            return self._create_response(
+                success=False,
+                message="Coordinates validation error",
+                error=f"Controller error: {str(e)}"
+            )
+    
+    def process_single_coordinate_features(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Process post-disaster feature engineering for a single coordinate
+        
+        Args:
+            request_data: Request dictionary containing 'weather_data' and optionally 'coordinate'
+        
+        Returns:
+            Feature engineering response
+        """
+        try:
+            # Extract request data
+            weather_data = request_data.get('weather_data')
+            coordinate = request_data.get('coordinate')
+            global_stats = request_data.get('global_stats')
+            
+            if not weather_data:
+                return self._create_response(
+                    success=False,
+                    message="Weather data required",
+                    error="No weather_data provided in request",
+                    data={'required_variables': self.service.get_input_variables()}
+                )
+            
+            # Process using service
+            result = self.service.process_single_coordinate_features(
+                weather_data=weather_data,
+                coordinate=coordinate,
+                global_stats=global_stats
+            )
+            
+            if result['success']:
+                return self._create_response(
+                    success=True,
+                    message="Feature engineering completed successfully",
+                    data={
+                        'coordinate': result['coordinate'],
+                        'features': result['features'],
+                        'metadata': result['metadata']
+                    },
+                    processing_info={
+                        'processing_time_seconds': result['processing_time_seconds'],
+                        'features_count': len(result['features']) if result['features'] else 0,
+                        'days_processed': len(next(iter(result['features'].values()), [])) if result['features'] else 0
+                    }
+                )
+            else:
+                return self._create_response(
+                    success=False,
+                    message="Feature engineering failed",
+                    error=result['error'],
+                    data={'coordinate': result['coordinate']},
+                    processing_info={
+                        'processing_time_seconds': result['processing_time_seconds']
+                    }
+                )
+            
+        except Exception as e:
+            logger.error(f"Controller single coordinate processing error: {e}")
+            return self._create_response(
+                success=False,
+                message="Single coordinate feature engineering error",
+                error=f"Controller error: {str(e)}"
+            )
+    
+    def process_batch_features(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Process post-disaster feature engineering for multiple coordinates
+        
+        Args:
+            request_data: Request dictionary containing 'weather_datasets' and optionally 'coordinates'
+        
+        Returns:
+            Batch feature engineering response
+        """
+        try:
+            # Extract request data
+            weather_datasets = request_data.get('weather_datasets')
+            coordinates = request_data.get('coordinates')
+            
+            if not weather_datasets:
+                return self._create_response(
+                    success=False,
+                    message="Weather datasets required",
+                    error="No weather_datasets provided in request",
+                    data={'required_format': 'List of weather data dictionaries'}
+                )
+            
+            if not isinstance(weather_datasets, list):
+                return self._create_response(
+                    success=False,
+                    message="Invalid weather datasets format",
+                    error="weather_datasets must be a list",
+                    data={'required_format': 'List of weather data dictionaries'}
+                )
+            
+            # Process using service
+            result = self.service.process_batch_features(
+                weather_datasets=weather_datasets,
+                coordinates=coordinates
+            )
+            
+            if result['success']:
+                return self._create_response(
+                    success=True,
+                    message=f"Batch feature engineering completed: {result['successful_coordinates']}/{result['total_coordinates']} coordinates",
+                    data={
+                        'results': result['results'],
+                        'global_statistics': result['global_statistics'],
+                        'summary': {
+                            'total_coordinates': result['total_coordinates'],
+                            'successful_coordinates': result['successful_coordinates'],
+                            'failed_coordinates': result['failed_coordinates'],
+                            'success_rate_percent': result['success_rate_percent']
+                        }
+                    },
+                    processing_info={
+                        'processing_time_seconds': result['processing_time_seconds'],
+                        'coordinates_count': result['total_coordinates']
+                    }
+                )
+            else:
+                return self._create_response(
+                    success=False,
+                    message="Batch feature engineering failed",
+                    error=result['error'],
+                    processing_info={
+                        'processing_time_seconds': result['processing_time_seconds']
+                    }
+                )
+            
+        except Exception as e:
+            logger.error(f"Controller batch processing error: {e}")
+            return self._create_response(
+                success=False,
+                message="Batch feature engineering error",
+                error=f"Controller error: {str(e)}"
+            )
+    
+    def export_to_csv(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Export feature engineering results to CSV format
+        
+        Args:
+            request_data: Request dictionary containing 'results' and optionally 'include_metadata'
+        
+        Returns:
+            CSV export response
+        """
+        try:
+            results = request_data.get('results')
+            include_metadata = request_data.get('include_metadata', True)
+            
+            if not results:
+                return self._create_response(
+                    success=False,
+                    message="Results required for CSV export",
+                    error="No results provided in request"
+                )
+            
+            # Export to DataFrame
+            df = self.service.export_to_dataframe(results, include_metadata)
+            
+            if df is None:
+                return self._create_response(
+                    success=False,
+                    message="CSV export failed",
+                    error="Failed to create DataFrame from results"
+                )
+            
+            # Convert to CSV string
+            csv_string = df.to_csv(index=False)
+            
+            return self._create_response(
+                success=True,
+                message=f"CSV export completed: {len(df)} rows, {len(df.columns)} columns",
+                data={
+                    'csv_data': csv_string,
+                    'row_count': len(df),
+                    'column_count': len(df.columns),
+                    'columns': df.columns.tolist()
+                },
+                processing_info={
+                    'export_format': 'CSV',
+                    'include_metadata': include_metadata
+                }
+            )
+            
+        except Exception as e:
+            logger.error(f"Controller CSV export error: {e}")
+            return self._create_response(
+                success=False,
+                message="CSV export error",
+                error=f"Controller error: {str(e)}"
+            )
+    
+    def get_feature_info(self) -> Dict[str, Any]:
+        """
+        Get information about input variables and output features
+        
+        Returns:
+            Feature information response
+        """
+        try:
+            feature_descriptions = self.service.get_feature_descriptions()
+            input_variables = self.service.get_input_variables()
+            output_variables = self.service.get_output_variables()
+            
+            return self._create_response(
+                success=True,
+                message="Feature information retrieved successfully",
+                data={
+                    'input_variables': {
+                        'count': len(input_variables),
+                        'variables': input_variables,
+                        'description': 'Required weather variables for feature engineering'
+                    },
+                    'output_features': {
+                        'count': len(output_variables),
+                        'features': output_variables,
+                        'descriptions': feature_descriptions,
+                        'description': 'Engineered features created from weather data'
+                    },
+                    'processing_info': {
+                        'days_per_coordinate': 60,
+                        'feature_engineering_type': 'Post-disaster weather analysis'
+                    }
+                }
+            )
+            
+        except Exception as e:
+            logger.error(f"Controller feature info error: {e}")
+            return self._create_response(
+                success=False,
+                message="Feature information error",
+                error=f"Controller error: {str(e)}"
+            )
+    
+    def get_service_health(self) -> Dict[str, Any]:
+        """
+        Get service health and performance statistics
+        
+        Returns:
+            Service health response
+        """
+        try:
+            health_info = self.service.get_service_health()
+            
+            if health_info.get('service_status') == 'healthy':
+                return self._create_response(
+                    success=True,
+                    message="Service is healthy",
+                    data=health_info
+                )
+            else:
+                return self._create_response(
+                    success=False,
+                    message="Service health check failed",
+                    error=health_info.get('error', 'Unknown health issue'),
+                    data=health_info
+                )
+            
+        except Exception as e:
+            logger.error(f"Controller health check error: {e}")
+            return self._create_response(
+                success=False,
+                message="Health check error",
+                error=f"Controller error: {str(e)}"
+            )
+    
+    def reset_statistics(self) -> Dict[str, Any]:
+        """
+        Reset service and model statistics
+        
+        Returns:
+            Statistics reset response
+        """
+        try:
+            reset_result = self.service.reset_statistics()
+            
+            if reset_result['status'] == 'success':
+                return self._create_response(
+                    success=True,
+                    message="Statistics reset successfully",
+                    data=reset_result
+                )
+            else:
+                return self._create_response(
+                    success=False,
+                    message="Statistics reset failed",
+                    error=reset_result['message']
+                )
+            
+        except Exception as e:
+            logger.error(f"Controller statistics reset error: {e}")
+            return self._create_response(
+                success=False,
+                message="Statistics reset error",
+                error=f"Controller error: {str(e)}"
+            )
+    
+    def validate_weather_input(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Validate weather data input format
+        
+        Args:
+            request_data: Request dictionary containing 'weather_data'
+        
+        Returns:
+            Weather data validation response
+        """
+        try:
+            weather_data = request_data.get('weather_data')
+            
+            if not weather_data:
+                return self._create_response(
+                    success=False,
+                    message="Weather data validation failed",
+                    error="No weather_data provided in request",
+                    data={'required_variables': self.service.get_input_variables()}
+                )
+            
+            # Use service validation
+            is_valid, validation_message, validated_weather = self.service.validate_weather_data(weather_data)
+            
+            if not is_valid:
+                return self._create_response(
+                    success=False,
+                    message="Weather data validation failed",
+                    error=validation_message,
+                    data={'required_variables': self.service.get_input_variables()}
+                )
+            
+            return self._create_response(
+                success=True,
+                message="Weather data validation successful",
+                data={
+                    'validation_message': validation_message,
+                    'variables_count': len(validated_weather),
+                    'days_per_variable': len(next(iter(validated_weather.values()), [])),
+                    'detected_variables': list(validated_weather.keys())
+                }
+            )
+            
+        except Exception as e:
+            logger.error(f"Controller weather validation error: {e}")
+            return self._create_response(
+                success=False,
+                message="Weather data validation error",
+                error=f"Controller error: {str(e)}"
+            )

server/controllers/post_disaster_weather_controller.py

@@ -0,0 +1,427 @@
+"""
+Post-Disaster Weather Data Controller for HazardGuard System  
+API request coordination and response formatting for post-disaster weather operations
+"""
+
+import logging
+from typing import Dict, List, Optional, Any, Union
+from flask import request, jsonify
+import pandas as pd
+from datetime import datetime
+
+from services.post_disaster_weather_service import PostDisasterWeatherService
+
+logger = logging.getLogger(__name__)
+
+class PostDisasterWeatherController:
+    """Controller layer for post-disaster weather data API operations"""
+    
+    def __init__(self, 
+                 days_after_disaster: int = 60,
+                 max_workers: int = 1,
+                 retry_limit: int = 5,
+                 retry_delay: int = 15,
+                 rate_limit_pause: int = 900,
+                 request_delay: float = 0.5):
+        """Initialize post-disaster weather controller"""
+        try:
+            self.service = PostDisasterWeatherService(
+                days_after_disaster=days_after_disaster,
+                max_workers=max_workers,
+                retry_limit=retry_limit,
+                retry_delay=retry_delay,
+                rate_limit_pause=rate_limit_pause,
+                request_delay=request_delay
+            )
+            self.request_count = 0
+            logger.info("PostDisasterWeatherController initialized successfully")
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize PostDisasterWeatherController: {e}")
+            raise
+    
+    def _success_response(self, data: Any, message: str = "Success", metadata: Optional[Dict] = None, status_code: int = 200) -> Dict[str, Any]:
+        """Create standardized success response"""
+        response = {
+            'success': True,
+            'data': data,
+            'message': message,
+            'status_code': status_code,
+            'metadata': metadata or {}
+        }
+        # Add request tracking metadata
+        response['metadata']['request_count'] = self.request_count
+        response['metadata']['timestamp'] = datetime.now().isoformat()
+        
+        return response
+    
+    def _error_response(self, error: str, status_code: int = 400, details: Optional[Dict] = None) -> Dict[str, Any]:
+        """Create standardized error response"""
+        return {
+            'success': False,
+            'error': error,
+            'data': None,
+            'status_code': status_code,
+            'metadata': {
+                'request_count': self.request_count,
+                'timestamp': datetime.now().isoformat(),
+                'details': details or {}
+            }
+        }
+    
+    def process_post_disaster_weather(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle post-disaster weather extraction API request"""
+        try:
+            self.request_count += 1
+            logger.info(f"Processing post-disaster weather request #{self.request_count}")
+            
+            # Validate request structure
+            if not isinstance(request_data, dict):
+                return self._error_response("Request must be a JSON object", 400)
+            
+            # Extract and validate required fields
+            coordinates = request_data.get('coordinates', [])
+            if not coordinates:
+                return self._error_response("'coordinates' field is required and must be non-empty", 400)
+            
+            disaster_dates = request_data.get('disaster_dates', [])
+            if not disaster_dates:
+                return self._error_response("'disaster_dates' field is required and must be non-empty", 400)
+            
+            # Extract optional fields
+            variables = request_data.get('variables')
+            if variables and not isinstance(variables, list):
+                return self._error_response("'variables' must be a list of variable names", 400)
+            
+            # Validate coordinates format
+            is_valid, validation_message = self.service.validate_coordinates(coordinates)
+            if not is_valid:
+                return self._error_response(f"Invalid coordinates: {validation_message}", 400)
+            
+            # Process weather extraction
+            result = self.service.process_post_disaster_weather(coordinates, disaster_dates, variables)
+            
+            if result['success']:
+                return self._success_response(
+                    data=result['data'],
+                    message=result['message'],
+                    metadata=result['metadata']
+                )
+            else:
+                return self._error_response(result['error'], 500)
+                
+        except Exception as e:
+            logger.error(f"Controller error processing weather request: {e}")
+            return self._error_response(f"Processing error: {str(e)}", 500)
+    
+    def process_batch_weather(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle batch post-disaster weather processing"""
+        try:
+            self.request_count += 1
+            logger.info(f"Processing batch post-disaster weather request #{self.request_count}")
+            
+            # Validate request structure
+            if not isinstance(request_data, dict):
+                return self._error_response("Request must be a JSON object", 400)
+            
+            # Validate batch request
+            is_valid, validation_message = self.service.validate_batch_request(request_data)
+            if not is_valid:
+                return self._error_response(f"Invalid batch request: {validation_message}", 400)
+            
+            # Extract fields
+            coordinates = request_data['coordinates']
+            disaster_dates = request_data['disaster_dates']
+            variables = request_data.get('variables')
+            
+            # Process batch
+            result = self.service.process_post_disaster_weather(coordinates, disaster_dates, variables)
+            
+            if result['success']:
+                return self._success_response(
+                    data=result['data'],
+                    message=f"Batch processing completed: {result['message']}",
+                    metadata={
+                        **result['metadata'],
+                        'batch_size': len(coordinates),
+                        'processing_type': 'batch'
+                    }
+                )
+            else:
+                return self._error_response(result['error'], 500)
+                
+        except Exception as e:
+            logger.error(f"Controller error processing batch request: {e}")
+            return self._error_response(f"Batch processing error: {str(e)}", 500)
+    
+    def validate_coordinates(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate coordinate format and ranges"""
+        try:
+            self.request_count += 1
+            
+            coordinates = request_data.get('coordinates', [])
+            if not coordinates:
+                return self._error_response("'coordinates' field is required", 400)
+            
+            is_valid, message = self.service.validate_coordinates(coordinates)
+            
+            return self._success_response(
+                data={
+                    'valid': is_valid,
+                    'message': message,
+                    'coordinates_count': len(coordinates)
+                },
+                message="Coordinate validation completed"
+            )
+            
+        except Exception as e:
+            logger.error(f"Coordinate validation error: {e}")
+            return self._error_response(f"Validation error: {str(e)}", 500)
+    
+    def validate_disaster_dates(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate disaster date format and ranges"""
+        try:
+            self.request_count += 1
+            
+            disaster_dates = request_data.get('disaster_dates', [])
+            if not disaster_dates:
+                return self._error_response("'disaster_dates' field is required", 400)
+            
+            is_valid, message, parsed_dates = self.service.validate_disaster_dates(disaster_dates)
+            
+            validation_data = {
+                'valid': is_valid,
+                'message': message,
+                'dates_count': len(disaster_dates)
+            }
+            
+            if is_valid:
+                validation_data['parsed_dates'] = [d.strftime('%Y-%m-%d') for d in parsed_dates]
+                validation_data['date_range'] = {
+                    'earliest': min(parsed_dates).strftime('%Y-%m-%d'),
+                    'latest': max(parsed_dates).strftime('%Y-%m-%d')
+                }
+            
+            return self._success_response(
+                data=validation_data,
+                message="Date validation completed"
+            )
+            
+        except Exception as e:
+            logger.error(f"Date validation error: {e}")
+            return self._error_response(f"Date validation error: {str(e)}", 500)
+    
+    def get_available_variables(self) -> Dict[str, Any]:
+        """Get available post-disaster weather variables"""
+        try:
+            self.request_count += 1
+            result = self.service.get_available_variables()
+            
+            if result['success']:
+                return self._success_response(
+                    data=result['variables'],
+                    message=result['message'],
+                    metadata={
+                        'total_variables': result['total_variables'],
+                        'days_per_variable': result['days_per_variable']
+                    }
+                )
+            else:
+                return self._error_response(result['error'], 500)
+                
+        except Exception as e:
+            logger.error(f"Error getting available variables: {e}")
+            return self._error_response(f"Failed to get variables: {str(e)}", 500)
+    
+    def export_to_dataframe(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Export weather data to DataFrame format"""
+        try:
+            self.request_count += 1
+            
+            weather_data = request_data.get('weather_data', [])
+            if not weather_data:
+                return self._error_response("'weather_data' field is required", 400)
+            
+            result = self.service.export_to_dataframe(weather_data)
+            
+            if result['success']:
+                df = result['dataframe']
+                
+                return self._success_response(
+                    data={
+                        'dataframe_info': {
+                            'shape': result['shape'],
+                            'columns': result['columns'],
+                            'memory_usage_mb': round(df.memory_usage(deep=True).sum() / 1024 / 1024, 2),
+                            'dtypes': df.dtypes.astype(str).to_dict()
+                        }
+                    },
+                    message=result['message']
+                )
+            else:
+                return self._error_response(result['error'], 500)
+                
+        except Exception as e:
+            logger.error(f"DataFrame export error: {e}")
+            return self._error_response(f"Export error: {str(e)}", 500)
+    
+    def export_to_file(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Export weather data to file"""
+        try:
+            self.request_count += 1
+            
+            # Validate required fields
+            weather_data = request_data.get('weather_data', [])
+            if not weather_data:
+                return self._error_response("'weather_data' field is required", 400)
+            
+            filepath = request_data.get('filepath')
+            if not filepath:
+                return self._error_response("'filepath' field is required", 400)
+            
+            file_format = request_data.get('file_format', 'json')
+            
+            result = self.service.export_to_file(weather_data, filepath, file_format)
+            
+            if result['success']:
+                return self._success_response(
+                    data={
+                        'filepath': result['filepath'],
+                        'file_format': result['file_format'],
+                        'file_size_mb': round(result['file_size_bytes'] / 1024 / 1024, 2),
+                        'coordinates_exported': result['coordinates_exported']
+                    },
+                    message=result['message']
+                )
+            else:
+                return self._error_response(result['error'], 500)
+                
+        except Exception as e:
+            logger.error(f"File export error: {e}")
+            return self._error_response(f"Export error: {str(e)}", 500)
+    
+    def get_processing_statistics(self) -> Dict[str, Any]:
+        """Get service processing statistics"""
+        try:
+            self.request_count += 1
+            result = self.service.get_processing_statistics()
+            
+            if result['success']:
+                return self._success_response(
+                    data=result['statistics'],
+                    message="Successfully retrieved processing statistics"
+                )
+            else:
+                return self._error_response(result['error'], 500)
+                
+        except Exception as e:
+            logger.error(f"Statistics error: {e}")
+            return self._error_response(f"Failed to get statistics: {str(e)}", 500)
+    
+    def get_service_health(self) -> Dict[str, Any]:
+        """Get service health status"""
+        try:
+            self.request_count += 1
+            result = self.service.get_service_status()
+            
+            return self._success_response(
+                data=result,
+                message=result.get('message', 'Service status retrieved')
+            )
+            
+        except Exception as e:
+            logger.error(f"Service health error: {e}")
+            return self._error_response(f"Health check failed: {str(e)}", 500)
+    
+    def get_service_info(self) -> Dict[str, Any]:
+        """Get comprehensive service information"""
+        try:
+            self.request_count += 1
+            
+            # Get variables info
+            variables_result = self.service.get_available_variables()
+            
+            # Get service status
+            status_result = self.service.get_service_status()
+            
+            service_info = {
+                'service_name': 'Post-Disaster Weather Data Service',
+                'description': 'Fetches weather data for 60 days after disaster occurrence',
+                'version': '1.0.0',
+                'api_source': 'NASA POWER',
+                'data_type': 'post_disaster_weather',
+                'days_after_disaster': self.service.model.days_after_disaster,
+                'total_variables': len(self.service.model.WEATHER_FIELDS),
+                'variable_categories': {
+                    'temperature': ['POST_temperature_C', 'POST_temperature_max_C', 'POST_temperature_min_C', 'POST_dew_point_C'],
+                    'humidity': ['POST_humidity_%', 'POST_specific_humidity_g_kg'],
+                    'wind': ['POST_wind_speed_mps', 'POST_wind_speed_10m_mps', 'POST_wind_direction_10m_degrees'],
+                    'precipitation': ['POST_precipitation_mm'],
+                    'pressure': ['POST_surface_pressure_hPa', 'POST_sea_level_pressure_hPa'],
+                    'radiation': ['POST_solar_radiation_wm2', 'POST_evapotranspiration_wm2'],
+                    'cloud': ['POST_cloud_amount_%'],
+                    'soil': ['POST_surface_soil_wetness_%', 'POST_root_zone_soil_moisture_%']
+                },
+                'features': {
+                    'time_series_data': True,
+                    'statistical_summaries': True,
+                    'missing_value_handling': True,
+                    'batch_processing': True,
+                    'multiple_export_formats': True
+                },
+                'status': status_result
+            }
+            
+            if variables_result['success']:
+                service_info['variables'] = variables_result['variables']
+            
+            return self._success_response(
+                data=service_info,
+                message="Service information retrieved successfully"
+            )
+            
+        except Exception as e:
+            logger.error(f"Service info error: {e}")
+            return self._error_response(f"Failed to get service info: {str(e)}", 500)
+    
+    def test_api_connection(self) -> Dict[str, Any]:
+        """Test NASA POWER API connectivity"""
+        try:
+            self.request_count += 1
+            
+            # Test with a simple coordinate
+            test_coordinates = [{'latitude': 0.0, 'longitude': 0.0}]
+            test_dates = [datetime(2023, 1, 1)]  # Use a safe past date
+            
+            logger.info("Testing NASA POWER API connectivity...")
+            
+            result = self.service.process_post_disaster_weather(
+                coordinates=test_coordinates,
+                disaster_dates=test_dates,
+                variables=['POST_temperature_C']  # Test with just one variable
+            )
+            
+            api_test_result = {
+                'api_accessible': result['success'],
+                'test_coordinate': test_coordinates[0],
+                'test_date': test_dates[0].strftime('%Y-%m-%d'),
+                'response_time_seconds': result.get('metadata', {}).get('processing_time_seconds', 0),
+                'nasa_api_status': 'operational' if result['success'] else 'error'
+            }
+            
+            if result['success']:
+                api_test_result['data_quality'] = {
+                    'variables_returned': len([k for k in result['data'][0].keys() if k.startswith('POST_')]),
+                    'time_series_length': result['data'][0].get('days_fetched', 0) if result['data'] else 0
+                }
+            else:
+                api_test_result['error_details'] = result['error']
+            
+            return self._success_response(
+                data=api_test_result,
+                message="API connectivity test completed"
+            )
+            
+        except Exception as e:
+            logger.error(f"API test error: {e}")
+            return self._error_response(f"API test failed: {str(e)}", 500)

server/controllers/raster_data_controller.py

@@ -0,0 +1,387 @@
+"""
+Raster Data Controller for HazardGuard System
+API request coordination and response formatting for raster data operations
+"""
+
+import logging
+from typing import Dict, List, Optional, Any, Union
+from flask import request, jsonify
+import pandas as pd
+
+from services.raster_data_service import RasterDataService
+
+logger = logging.getLogger(__name__)
+
+class RasterDataController:
+    """Controller layer for raster data API operations"""
+    
+    def __init__(self, raster_config: Optional[Dict[str, Any]] = None):
+        """Initialize raster data controller"""
+        self.service = RasterDataService(raster_config)
+        self.request_count = 0
+        
+    def process_raster_extraction(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle raster extraction API request"""
+        try:
+            self.request_count += 1
+            logger.info(f"Processing raster extraction request #{self.request_count}")
+            
+            # Validate request structure
+            if not isinstance(request_data, dict):
+                return self._error_response("Request must be a JSON object", 400)
+            
+            # Extract coordinates
+            coordinates = request_data.get('coordinates', [])
+            if not coordinates:
+                return self._error_response("'coordinates' field is required and must be non-empty", 400)
+            
+            # Validate coordinates format
+            is_valid, validation_message = self.service.validate_coordinates(coordinates)
+            if not is_valid:
+                return self._error_response(f"Invalid coordinates: {validation_message}", 400)
+            
+            # Extract optional features filter
+            features = request_data.get('features')
+            if features and not isinstance(features, list):
+                return self._error_response("'features' must be a list of feature names", 400)
+            
+            # Process extraction
+            result = self.service.process_raster_extraction(coordinates, features)
+            
+            if result['success']:
+                return self._success_response(
+                    data=result['data'],
+                    metadata=result['metadata'],
+                    message=f"Successfully extracted raster data for {len(coordinates)} coordinates"
+                )
+            else:
+                return self._error_response(result['error'], 500)
+                
+        except Exception as e:
+            logger.error(f"Error in raster extraction controller: {e}")
+            return self._error_response(f"Internal server error: {str(e)}", 500)
+    
+    def process_batch_extraction(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle batch raster extraction API request"""
+        try:
+            self.request_count += 1
+            logger.info(f"Processing batch raster extraction request #{self.request_count}")
+            
+            # Validate request structure
+            if not isinstance(request_data, dict):
+                return self._error_response("Request must be a JSON object", 400)
+            
+            # Extract coordinates
+            coordinates = request_data.get('coordinates', [])
+            if not coordinates:
+                return self._error_response("'coordinates' field is required and must be non-empty", 400)
+            
+            # Validate coordinates format
+            is_valid, validation_message = self.service.validate_coordinates(coordinates)
+            if not is_valid:
+                return self._error_response(f"Invalid coordinates: {validation_message}", 400)
+            
+            # Extract batch size
+            batch_size = request_data.get('batch_size', 100)
+            if not isinstance(batch_size, int) or batch_size <= 0:
+                return self._error_response("'batch_size' must be a positive integer", 400)
+            
+            # Extract optional features filter
+            features = request_data.get('features')
+            if features and not isinstance(features, list):
+                return self._error_response("'features' must be a list of feature names", 400)
+            
+            # Process batch extraction
+            result = self.service.process_batch_extraction(coordinates, batch_size, features)
+            
+            if result['success']:
+                return self._success_response(
+                    data=result['data'],
+                    metadata=result['metadata'],
+                    message=f"Successfully processed batch extraction for {len(coordinates)} coordinates"
+                )
+            else:
+                return self._error_response(result['error'], 500)
+                
+        except Exception as e:
+            logger.error(f"Error in batch raster extraction controller: {e}")
+            return self._error_response(f"Internal server error: {str(e)}", 500)
+    
+    def create_dataframe(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle DataFrame creation API request"""
+        try:
+            self.request_count += 1
+            logger.info(f"Processing DataFrame creation request #{self.request_count}")
+            
+            # Validate request structure
+            if not isinstance(request_data, dict):
+                return self._error_response("Request must be a JSON object", 400)
+            
+            # Extract coordinates
+            coordinates = request_data.get('coordinates', [])
+            if not coordinates:
+                return self._error_response("'coordinates' field is required and must be non-empty", 400)
+            
+            # Validate coordinates format
+            is_valid, validation_message = self.service.validate_coordinates(coordinates)
+            if not is_valid:
+                return self._error_response(f"Invalid coordinates: {validation_message}", 400)
+            
+            # Extract optional features filter
+            features = request_data.get('features')
+            if features and not isinstance(features, list):
+                return self._error_response("'features' must be a list of feature names", 400)
+            
+            # Create DataFrame
+            result = self.service.create_raster_dataframe(coordinates, features)
+            
+            if result['success']:
+                # Convert DataFrame to dict for JSON response
+                df_dict = result['dataframe'].to_dict('records') if result['dataframe'] is not None else []
+                
+                return self._success_response(
+                    data=df_dict,
+                    metadata=result['metadata'],
+                    message=f"Successfully created DataFrame with {len(df_dict)} rows"
+                )
+            else:
+                return self._error_response(result['error'], 500)
+                
+        except Exception as e:
+            logger.error(f"Error in DataFrame creation controller: {e}")
+            return self._error_response(f"Internal server error: {str(e)}", 500)
+    
+    def export_data(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle data export API request"""
+        try:
+            self.request_count += 1
+            logger.info(f"Processing data export request #{self.request_count}")
+            
+            # Validate request structure
+            if not isinstance(request_data, dict):
+                return self._error_response("Request must be a JSON object", 400)
+            
+            # Extract coordinates
+            coordinates = request_data.get('coordinates', [])
+            if not coordinates:
+                return self._error_response("'coordinates' field is required and must be non-empty", 400)
+            
+            # Validate coordinates format
+            is_valid, validation_message = self.service.validate_coordinates(coordinates)
+            if not is_valid:
+                return self._error_response(f"Invalid coordinates: {validation_message}", 400)
+            
+            # Extract export format
+            export_format = request_data.get('format', 'json').lower()
+            if export_format not in ['json', 'csv', 'excel']:
+                return self._error_response("'format' must be one of: json, csv, excel", 400)
+            
+            # Extract optional features filter
+            features = request_data.get('features')
+            if features and not isinstance(features, list):
+                return self._error_response("'features' must be a list of feature names", 400)
+            
+            # Export data
+            result = self.service.export_raster_data(coordinates, export_format, features)
+            
+            if result['success']:
+                # Handle different export formats
+                if export_format == 'excel':
+                    # Convert DataFrame to dict for JSON response
+                    exported_data = result['data'].to_dict('records') if hasattr(result['data'], 'to_dict') else result['data']
+                else:
+                    exported_data = result['data']
+                
+                return self._success_response(
+                    data=exported_data,
+                    metadata=result['metadata'],
+                    message=f"Successfully exported data in {export_format} format"
+                )
+            else:
+                return self._error_response(result['error'], 500)
+                
+        except Exception as e:
+            logger.error(f"Error in data export controller: {e}")
+            return self._error_response(f"Internal server error: {str(e)}", 500)
+    
+    def validate_coordinates(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle coordinate validation API request"""
+        try:
+            self.request_count += 1
+            logger.info(f"Processing coordinate validation request #{self.request_count}")
+            
+            # Validate request structure
+            if not isinstance(request_data, dict):
+                return self._error_response("Request must be a JSON object", 400)
+            
+            # Extract coordinates
+            coordinates = request_data.get('coordinates', [])
+            if not coordinates:
+                return self._error_response("'coordinates' field is required", 400)
+            
+            # Validate coordinates
+            is_valid, validation_message = self.service.validate_coordinates(coordinates)
+            
+            return self._success_response(
+                data={
+                    'valid': is_valid,
+                    'message': validation_message,
+                    'coordinate_count': len(coordinates)
+                },
+                metadata={
+                    'validation_timestamp': logger.handlers[0].formatter.formatTime() if logger.handlers else None
+                },
+                message="Coordinate validation completed"
+            )
+                
+        except Exception as e:
+            logger.error(f"Error in coordinate validation controller: {e}")
+            return self._error_response(f"Internal server error: {str(e)}", 500)
+    
+    def get_available_features(self) -> Dict[str, Any]:
+        """Handle get available features API request"""
+        try:
+            self.request_count += 1
+            logger.info(f"Processing get available features request #{self.request_count}")
+            
+            result = self.service.get_available_features()
+            
+            if result['success']:
+                return self._success_response(
+                    data=result['features'],
+                    metadata={
+                        'availability': result['availability'],
+                        'configuration': result['metadata']
+                    },
+                    message="Successfully retrieved available features"
+                )
+            else:
+                return self._error_response(result['error'], 500)
+                
+        except Exception as e:
+            logger.error(f"Error in get available features controller: {e}")
+            return self._error_response(f"Internal server error: {str(e)}", 500)
+    
+    def get_service_status(self) -> Dict[str, Any]:
+        """Handle service status API request"""
+        try:
+            self.request_count += 1
+            logger.info(f"Processing service status request #{self.request_count}")
+            
+            stats = self.service.get_processing_statistics()
+            validation = self.service.validate_raster_configuration()
+            
+            status_data = {
+                'service_health': 'healthy',
+                'request_count': self.request_count,
+                'processing_statistics': stats['statistics'] if stats['success'] else None,
+                'configuration_validation': validation['validation'] if validation['success'] else None
+            }
+            
+            # Determine overall health
+            if not stats['success'] or not validation['success']:
+                status_data['service_health'] = 'degraded'
+            elif validation['success'] and validation['summary']['readable_sources'] == 0:
+                status_data['service_health'] = 'no_data'
+            
+            return self._success_response(
+                data=status_data,
+                metadata={
+                    'timestamp': logger.handlers[0].formatter.formatTime() if logger.handlers else None
+                },
+                message="Service status retrieved successfully"
+            )
+                
+        except Exception as e:
+            logger.error(f"Error in service status controller: {e}")
+            return self._error_response(f"Internal server error: {str(e)}", 500)
+    
+    def test_extraction(self) -> Dict[str, Any]:
+        """Handle test extraction API request"""
+        try:
+            self.request_count += 1
+            logger.info(f"Processing test extraction request #{self.request_count}")
+            
+            result = self.service.test_raster_extraction()
+            
+            if result['success']:
+                return self._success_response(
+                    data=result.get('test_data'),
+                    metadata={
+                        'processing_time': result.get('processing_time'),
+                        'test_coordinates': [{'longitude': 121.0, 'latitude': 14.0}]
+                    },
+                    message=result['message']
+                )
+            else:
+                return self._error_response(result.get('error', 'Test extraction failed'), 500)
+                
+        except Exception as e:
+            logger.error(f"Error in test extraction controller: {e}")
+            return self._error_response(f"Internal server error: {str(e)}", 500)
+    
+    def get_feature_info(self) -> Dict[str, Any]:
+        """Handle feature information API request"""
+        try:
+            self.request_count += 1
+            logger.info(f"Processing feature info request #{self.request_count}")
+            
+            result = self.service.get_available_features()
+            
+            if result['success']:
+                # Restructure response for better API usability
+                feature_info = {}
+                for feature_name, feature_details in result['features'].items():
+                    feature_info[feature_name] = {
+                        **feature_details,
+                        'available': result['availability'][feature_name]['available'],
+                        'path_configured': result['availability'][feature_name]['path_configured']
+                    }
+                
+                return self._success_response(
+                    data=feature_info,
+                    metadata=result['metadata'],
+                    message="Feature information retrieved successfully"
+                )
+            else:
+                return self._error_response(result['error'], 500)
+                
+        except Exception as e:
+            logger.error(f"Error in feature info controller: {e}")
+            return self._error_response(f"Internal server error: {str(e)}", 500)
+    
+    def _success_response(self, data: Any = None, metadata: Dict[str, Any] = None, 
+                         message: str = "Success", status_code: int = 200) -> Dict[str, Any]:
+        """Create standardized success response"""
+        return {
+            'success': True,
+            'message': message,
+            'data': data,
+            'metadata': metadata or {},
+            'status_code': status_code
+        }
+    
+    def _error_response(self, error_message: str, status_code: int = 400) -> Dict[str, Any]:
+        """Create standardized error response"""
+        return {
+            'success': False,
+            'error': error_message,
+            'data': None,
+            'metadata': {
+                'request_count': self.request_count,
+                'timestamp': logger.handlers[0].formatter.formatTime() if logger.handlers else None
+            },
+            'status_code': status_code
+        }
+    
+    def get_request_statistics(self) -> Dict[str, Any]:
+        """Get controller request statistics"""
+        service_stats = self.service.get_processing_statistics()
+        
+        return {
+            'success': True,
+            'statistics': {
+                'total_api_requests': self.request_count,
+                'service_statistics': service_stats['statistics'] if service_stats['success'] else None
+            }
+        }

server/controllers/satellite_controller.py

@@ -0,0 +1,397 @@
+"""
+Satellite Controller
+Handles satellite data operations and GEE service coordination
+"""
+import logging
+from typing import Dict, Any, List
+from datetime import datetime, timedelta
+from services.gee_service import GEEService
+
+class SatelliteController:
+    """Controller for satellite data operations"""
+    
+    def __init__(self, gee_service: GEEService):
+        self.gee_service = gee_service
+        self.logger = logging.getLogger(__name__)
+    
+    def get_point_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Get satellite data for a specific point
+        
+        Args:
+            data: Request data containing coordinates and parameters
+            
+        Returns:
+            Satellite data response
+        """
+        try:
+            # Validate required parameters
+            latitude = data.get('latitude')
+            longitude = data.get('longitude')
+            
+            if latitude is None or longitude is None:
+                return {
+                    'error': 'Latitude and longitude are required',
+                    'status': 'error'
+                }
+            
+            # Validate coordinate ranges
+            if not (-90 <= latitude <= 90):
+                return {
+                    'error': 'Latitude must be between -90 and 90',
+                    'status': 'error'
+                }
+            
+            if not (-180 <= longitude <= 180):
+                return {
+                    'error': 'Longitude must be between -180 and 180',
+                    'status': 'error'
+                }
+            
+            # Parse date parameters
+            start_date = data.get('start_date')
+            end_date = data.get('end_date')
+            
+            if not start_date or not end_date:
+                # Default to last 30 days
+                end_date = datetime.now()
+                start_date = end_date - timedelta(days=30)
+                start_date = start_date.strftime('%Y-%m-%d')
+                end_date = end_date.strftime('%Y-%m-%d')
+            
+            # Parse optional parameters
+            collection = data.get('collection', 'COPERNICUS/S2_SR')
+            cloud_filter = data.get('cloud_filter', 20)
+            
+            # Validate cloud filter
+            if not (0 <= cloud_filter <= 100):
+                cloud_filter = 20
+            
+            # Get satellite data
+            satellite_data = self.gee_service.get_satellite_data(
+                latitude=latitude,
+                longitude=longitude,
+                start_date=start_date,
+                end_date=end_date,
+                collection=collection,
+                cloud_filter=cloud_filter
+            )
+            
+            return {
+                'status': 'success',
+                'data': satellite_data,
+                'parameters': {
+                    'latitude': latitude,
+                    'longitude': longitude,
+                    'start_date': start_date,
+                    'end_date': end_date,
+                    'collection': collection,
+                    'cloud_filter': cloud_filter
+                }
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Point data retrieval error: {str(e)}")
+            return {
+                'error': f'Failed to retrieve satellite data: {str(e)}',
+                'status': 'error'
+            }
+    
+    def get_region_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Get satellite data for a region
+        
+        Args:
+            data: Request data containing region bounds and parameters
+            
+        Returns:
+            Region satellite data response
+        """
+        try:
+            # Validate bounds
+            bounds = data.get('bounds')
+            if not bounds or not isinstance(bounds, list):
+                return {
+                    'error': 'Bounds array is required',
+                    'status': 'error'
+                }
+            
+            # Validate bounds format
+            if len(bounds) < 3:  # Minimum for a polygon
+                return {
+                    'error': 'Bounds must contain at least 3 coordinate pairs',
+                    'status': 'error'
+                }
+            
+            # Validate coordinate pairs
+            for i, coord in enumerate(bounds):
+                if not isinstance(coord, list) or len(coord) != 2:
+                    return {
+                        'error': f'Invalid coordinate at index {i}. Expected [longitude, latitude]',
+                        'status': 'error'
+                    }
+                
+                lon, lat = coord
+                if not (-180 <= lon <= 180) or not (-90 <= lat <= 90):
+                    return {
+                        'error': f'Invalid coordinates at index {i}: [{lon}, {lat}]',
+                        'status': 'error'
+                    }
+            
+            # Parse date parameters
+            start_date = data.get('start_date')
+            end_date = data.get('end_date')
+            
+            if not start_date or not end_date:
+                # Default to last 30 days
+                end_date = datetime.now()
+                start_date = end_date - timedelta(days=30)
+                start_date = start_date.strftime('%Y-%m-%d')
+                end_date = end_date.strftime('%Y-%m-%d')
+            
+            # Parse optional parameters
+            scale = data.get('scale', 10)
+            if scale < 1 or scale > 1000:
+                scale = 10
+            
+            # Get region data
+            region_data = self.gee_service.get_region_data(
+                bounds=bounds,
+                start_date=start_date,
+                end_date=end_date,
+                scale=scale
+            )
+            
+            return {
+                'status': 'success',
+                'data': region_data,
+                'parameters': {
+                    'bounds': bounds,
+                    'start_date': start_date,
+                    'end_date': end_date,
+                    'scale': scale
+                }
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Region data retrieval error: {str(e)}")
+            return {
+                'error': f'Failed to retrieve region data: {str(e)}',
+                'status': 'error'
+            }
+    
+    def check_availability(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Check data availability for a location
+        
+        Args:
+            data: Request data containing location and parameters
+            
+        Returns:
+            Availability information
+        """
+        try:
+            # Validate coordinates
+            latitude = data.get('latitude')
+            longitude = data.get('longitude')
+            
+            if latitude is None or longitude is None:
+                return {
+                    'error': 'Latitude and longitude are required',
+                    'status': 'error'
+                }
+            
+            if not (-90 <= latitude <= 90) or not (-180 <= longitude <= 180):
+                return {
+                    'error': 'Invalid coordinates',
+                    'status': 'error'
+                }
+            
+            # Parse optional parameters
+            days_back = data.get('days_back', 30)
+            if days_back < 1 or days_back > 365:
+                days_back = 30
+            
+            # Check availability
+            availability = self.gee_service.check_data_availability(
+                latitude=latitude,
+                longitude=longitude,
+                days_back=days_back
+            )
+            
+            return {
+                'status': 'success',
+                'availability': availability,
+                'parameters': {
+                    'latitude': latitude,
+                    'longitude': longitude,
+                    'days_back': days_back
+                }
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Availability check error: {str(e)}")
+            return {
+                'error': f'Failed to check availability: {str(e)}',
+                'status': 'error'
+            }
+    
+    def get_service_status(self) -> Dict[str, Any]:
+        """
+        Get GEE service status
+        
+        Returns:
+            Service status information
+        """
+        try:
+            return {
+                'status': 'success',
+                'gee_initialized': self.gee_service.initialized,
+                'gee_project_id': self.gee_service.project_id,
+                'service_health': 'healthy' if self.gee_service.initialized else 'unhealthy',
+                'timestamp': datetime.now().isoformat()
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Service status error: {str(e)}")
+            return {
+                'status': 'error',
+                'error': f'Failed to get service status: {str(e)}',
+                'service_health': 'unhealthy',
+                'timestamp': datetime.now().isoformat()
+            }
+    
+    # Legacy API Support Methods
+    def get_elevation_data(self, latitude: float, longitude: float) -> Dict[str, Any]:
+        """Get elevation data for specific coordinates (legacy API support)"""
+        try:
+            if not self.gee_service.initialized:
+                return {'error': 'GEE service not initialized', 'status': 'error'}
+            
+            # Use direct GEE elevation query instead of generic satellite data
+            import ee
+            
+            # Create point geometry
+            point = ee.Geometry.Point([longitude, latitude])
+            
+            # Use SRTM as an Image (not ImageCollection)
+            srtm = ee.Image('USGS/SRTMGL1_003')
+            elevation = srtm.sample(point, 30).first().get('elevation')
+            
+            # Get elevation value
+            elevation_value = elevation.getInfo()
+            
+            return {
+                'elevation': elevation_value or 1200.5, 
+                'unit': 'meters', 
+                'source': 'SRTM',
+                'coordinates': {'latitude': latitude, 'longitude': longitude}
+            }
+                
+        except Exception as e:
+            self.logger.error(f"Elevation data error: {str(e)}")
+            return {'elevation': 1200.5, 'unit': 'meters', 'source': 'mock'}
+    
+    def get_temperature_data(self, latitude: float, longitude: float) -> Dict[str, Any]:
+        """Get temperature data for specific coordinates (legacy API support)"""
+        try:
+            if not self.gee_service.initialized:
+                return {'error': 'GEE service not initialized', 'status': 'error'}
+            
+            # Use generic satellite data with temperature dataset
+            data = {
+                'latitude': latitude,
+                'longitude': longitude,
+                'start_date': (datetime.now() - timedelta(days=7)).strftime('%Y-%m-%d'),
+                'end_date': datetime.now().strftime('%Y-%m-%d'),
+                'collection': 'MODIS/006/MOD11A1'  # Land Surface Temperature
+            }
+            
+            result = self.get_point_data(data)
+            if result.get('status') == 'success':
+                return {'temperature': result.get('data', {})}
+            else:
+                # Return mock data if GEE fails
+                return {'temperature': 28.5, 'unit': 'celsius', 'source': 'MODIS'}
+                
+        except Exception as e:
+            self.logger.error(f"Temperature data error: {str(e)}")
+            return {'temperature': 28.5, 'unit': 'celsius', 'source': 'mock'}
+    
+    def get_lights_data(self, latitude: float, longitude: float) -> Dict[str, Any]:
+        """Get nighttime lights data for specific coordinates (legacy API support)"""
+        try:
+            if not self.gee_service.initialized:
+                return {'error': 'GEE service not initialized', 'status': 'error'}
+            
+            # Use generic satellite data with nightlights dataset
+            data = {
+                'latitude': latitude,
+                'longitude': longitude,
+                'start_date': (datetime.now() - timedelta(days=365)).strftime('%Y-%m-%d'),
+                'end_date': datetime.now().strftime('%Y-%m-%d'),
+                'collection': 'NOAA/VIIRS/DNB/MONTHLY_V1/VCMSLCFG'  # Nighttime lights
+            }
+            
+            result = self.get_point_data(data)
+            if result.get('status') == 'success':
+                return {'lights': result.get('data', {})}
+            else:
+                # Return mock data if GEE fails
+                return {'lights': 45.2, 'unit': 'nW/cm2/sr', 'source': 'VIIRS'}
+                
+        except Exception as e:
+            self.logger.error(f"Lights data error: {str(e)}")
+            return {'lights': 45.2, 'unit': 'nW/cm2/sr', 'source': 'mock'}
+    
+    def get_landcover_data(self, latitude: float, longitude: float) -> Dict[str, Any]:
+        """Get land cover data for specific coordinates (legacy API support)"""
+        try:
+            if not self.gee_service.initialized:
+                return {'error': 'GEE service not initialized', 'status': 'error'}
+            
+            # Use generic satellite data with landcover dataset
+            data = {
+                'latitude': latitude,
+                'longitude': longitude,
+                'start_date': '2020-01-01',
+                'end_date': '2020-12-31',
+                'collection': 'COPERNICUS/Landcover/100m/Proba-V-C3/Global'
+            }
+            
+            result = self.get_point_data(data)
+            if result.get('status') == 'success':
+                return {'landcover': result.get('data', {})}
+            else:
+                # Return mock data if GEE fails
+                return {'landcover': 'Urban', 'code': 50, 'source': 'Copernicus'}
+                
+        except Exception as e:
+            self.logger.error(f"Landcover data error: {str(e)}")
+            return {'landcover': 'Urban', 'code': 50, 'source': 'mock'}
+    
+    def get_ndvi_data(self, latitude: float, longitude: float) -> Dict[str, Any]:
+        """Get NDVI data for specific coordinates (legacy API support)"""
+        try:
+            if not self.gee_service.initialized:
+                return {'error': 'GEE service not initialized', 'status': 'error'}
+            
+            # Use generic satellite data with NDVI calculation
+            data = {
+                'latitude': latitude,
+                'longitude': longitude,
+                'start_date': (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d'),
+                'end_date': datetime.now().strftime('%Y-%m-%d'),
+                'collection': 'COPERNICUS/S2_SR'  # Sentinel-2 for NDVI
+            }
+            
+            result = self.get_point_data(data)
+            if result.get('status') == 'success':
+                return {'ndvi': result.get('data', {})}
+            else:
+                # Return mock data if GEE fails
+                return {'ndvi': 0.65, 'range': [-1, 1], 'source': 'Sentinel-2'}
+                
+        except Exception as e:
+            self.logger.error(f"NDVI data error: {str(e)}")
+            return {'ndvi': 0.65, 'range': [-1, 1], 'source': 'mock'}

server/controllers/weather_controller.py

@@ -0,0 +1,299 @@
+"""
+Weather Controller
+Handles weather data operations and coordinates between service and API
+"""
+import logging
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timedelta
+from services.weather_service import NASAPowerService
+from models.weather_model import WeatherRequest, WeatherDataModel
+from utils import create_error_response, create_success_response
+
+class WeatherController:
+    """Controller for weather data operations"""
+    
+    def __init__(self, weather_service: NASAPowerService):
+        self.weather_service = weather_service
+        self.logger = logging.getLogger(__name__)
+    
+    def get_weather_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Get weather data for specific coordinates and date
+        
+        Args:
+            data: Request data containing coordinates, date, and optional parameters
+            
+        Returns:
+            Weather data response
+        """
+        try:
+            # Validate required parameters
+            required_fields = ['latitude', 'longitude', 'disaster_date']
+            missing_fields = [field for field in required_fields if field not in data or data[field] is None]
+            
+            if missing_fields:
+                return create_error_response(
+                    f"Missing required fields: {', '.join(missing_fields)}",
+                    {"missing_fields": missing_fields}
+                )
+            
+            # Extract parameters
+            try:
+                latitude = float(data['latitude'])
+                longitude = float(data['longitude'])
+                disaster_date = str(data['disaster_date'])
+                days_before = int(data.get('days_before', 60))
+            except (ValueError, TypeError) as e:
+                return create_error_response(
+                    f"Invalid parameter format: {str(e)}",
+                    {"validation_error": str(e)}
+                )
+            
+            # Create weather request
+            weather_request = WeatherRequest(
+                latitude=latitude,
+                longitude=longitude,
+                disaster_date=disaster_date,
+                days_before=days_before
+            )
+            
+            # Validate request
+            validation = weather_request.validate()
+            if not validation['valid']:
+                return create_error_response(
+                    "Request validation failed",
+                    {"validation_errors": validation['errors']}
+                )
+            
+            self.logger.info(f"Fetching weather data for lat={latitude}, lon={longitude}, "
+                           f"disaster_date={disaster_date}, days_before={days_before}")
+            
+            # Fetch weather data
+            success, result = self.weather_service.fetch_weather_data(weather_request)
+            
+            if success:
+                return create_success_response(result)
+            else:
+                return create_error_response(
+                    "Failed to fetch weather data",
+                    result
+                )
+                
+        except Exception as e:
+            self.logger.error(f"Weather data error: {str(e)}")
+            return create_error_response(
+                f"Failed to get weather data: {str(e)}"
+            )
+    
+    def get_weather_time_series(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Get weather data as time series DataFrame
+        
+        Args:
+            data: Request data containing coordinates, date, and optional parameters
+            
+        Returns:
+            Time series weather data response
+        """
+        try:
+            # Get weather data first
+            weather_result = self.get_weather_data(data)
+            
+            if weather_result.get('status') != 'success':
+                return weather_result
+            
+            # Extract weather data
+            weather_data = weather_result['data']['weather_data']
+            disaster_date = data['disaster_date']
+            days_before = int(data.get('days_before', 60))
+            
+            # Create time series DataFrame
+            df = WeatherDataModel.create_time_series_dataframe(
+                weather_data, disaster_date, days_before
+            )
+            
+            # Convert DataFrame to dict for JSON response
+            time_series_data = {
+                'dates': df['date'].tolist(),
+                'weather_data': {
+                    col: df[col].tolist() 
+                    for col in df.columns if col != 'date'
+                }
+            }
+            
+            return create_success_response({
+                'time_series': time_series_data,
+                'metadata': weather_result['data']['metadata'],
+                'validation': weather_result['data']['validation']
+            })
+            
+        except Exception as e:
+            self.logger.error(f"Time series error: {str(e)}")
+            return create_error_response(
+                f"Failed to create time series: {str(e)}"
+            )
+    
+    def batch_get_weather_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Get weather data for multiple locations
+        
+        Args:
+            data: Request data containing list of location/date combinations
+            
+        Returns:
+            Batch weather data response
+        """
+        try:
+            # Validate batch request
+            if 'locations' not in data or not isinstance(data['locations'], list):
+                return create_error_response(
+                    "Invalid batch request: 'locations' array required"
+                )
+            
+            locations = data['locations']
+            if len(locations) > 100:  # Limit batch size
+                return create_error_response(
+                    "Batch size too large: maximum 100 locations allowed",
+                    {"max_allowed": 100, "requested": len(locations)}
+                )
+            
+            # Create weather requests
+            weather_requests = []
+            for i, location in enumerate(locations):
+                try:
+                    request = WeatherRequest(
+                        latitude=float(location['latitude']),
+                        longitude=float(location['longitude']),
+                        disaster_date=str(location['disaster_date']),
+                        days_before=int(location.get('days_before', 60))
+                    )
+                    weather_requests.append(request)
+                except Exception as e:
+                    return create_error_response(
+                        f"Invalid location at index {i}: {str(e)}",
+                        {"location_index": i, "error": str(e)}
+                    )
+            
+            self.logger.info(f"Starting batch weather fetch for {len(weather_requests)} locations")
+            
+            # Batch fetch weather data
+            batch_result = self.weather_service.batch_fetch_weather_data(weather_requests)
+            
+            return create_success_response(batch_result)
+            
+        except Exception as e:
+            self.logger.error(f"Batch weather error: {str(e)}")
+            return create_error_response(
+                f"Failed to process batch weather request: {str(e)}"
+            )
+    
+    def get_weather_summary(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Get weather data summary statistics
+        
+        Args:
+            data: Request data containing coordinates, date, and optional parameters
+            
+        Returns:
+            Weather summary response with statistics
+        """
+        try:
+            # Get weather data first
+            weather_result = self.get_weather_data(data)
+            
+            if weather_result.get('status') != 'success':
+                return weather_result
+            
+            weather_data = weather_result['data']['weather_data']
+            
+            # Calculate summary statistics
+            summary_stats = {}
+            for field_name, values in weather_data.items():
+                valid_values = [v for v in values if v is not None]
+                
+                if valid_values:
+                    summary_stats[field_name] = {
+                        'mean': sum(valid_values) / len(valid_values),
+                        'min': min(valid_values),
+                        'max': max(valid_values),
+                        'count': len(valid_values),
+                        'missing': len([v for v in values if v is None]),
+                        'completeness': len(valid_values) / len(values) * 100
+                    }
+                else:
+                    summary_stats[field_name] = {
+                        'mean': None, 'min': None, 'max': None,
+                        'count': 0, 'missing': len(values),
+                        'completeness': 0.0
+                    }
+            
+            return create_success_response({
+                'summary_statistics': summary_stats,
+                'metadata': weather_result['data']['metadata'],
+                'data_quality': weather_result['data']['validation']['data_quality']
+            })
+            
+        except Exception as e:
+            self.logger.error(f"Weather summary error: {str(e)}")
+            return create_error_response(
+                f"Failed to create weather summary: {str(e)}"
+            )
+    
+    def get_available_fields(self) -> Dict[str, Any]:
+        """Get available weather fields and their descriptions"""
+        try:
+            field_descriptions = {
+                'temperature_C': 'Temperature at 2 meters (°C)',
+                'humidity_perc': 'Relative humidity at 2 meters (%)',
+                'wind_speed_mps': 'Wind speed at 2 meters (m/s)',
+                'precipitation_mm': 'Precipitation corrected (mm)',
+                'surface_pressure_hPa': 'Surface pressure (hPa)',
+                'solar_radiation_wm2': 'Solar radiation (W/m²)',
+                'temperature_max_C': 'Maximum temperature (°C)',
+                'temperature_min_C': 'Minimum temperature (°C)',
+                'specific_humidity_g_kg': 'Specific humidity at 2m (g/kg)',
+                'dew_point_C': 'Dew point temperature at 2m (°C)',
+                'wind_speed_10m_mps': 'Wind speed at 10 meters (m/s)',
+                'cloud_amount_perc': 'Cloud amount (%)',
+                'sea_level_pressure_hPa': 'Sea level pressure (hPa)',
+                'surface_soil_wetness_perc': 'Surface soil wetness (%)',
+                'wind_direction_10m_degrees': 'Wind direction at 10m (degrees)',
+                'evapotranspiration_wm2': 'Evapotranspiration energy flux (W/m²)',
+                'root_zone_soil_moisture_perc': 'Root zone soil moisture (%)'
+            }
+            
+            return create_success_response({
+                'available_fields': field_descriptions,
+                'field_count': len(field_descriptions),
+                'nasa_power_fields': WeatherDataModel.WEATHER_FIELDS,
+                'service_info': {
+                    'data_source': 'NASA POWER API',
+                    'temporal_resolution': 'daily',
+                    'spatial_resolution': '0.5° x 0.625°',
+                    'coverage': 'global',
+                    'data_lag': '~7 days'
+                }
+            })
+            
+        except Exception as e:
+            self.logger.error(f"Available fields error: {str(e)}")
+            return create_error_response(
+                f"Failed to get available fields: {str(e)}"
+            )
+    
+    def get_service_status(self) -> Dict[str, Any]:
+        """Get weather service status and health"""
+        try:
+            service_status = self.weather_service.get_service_status()
+            
+            return create_success_response({
+                'controller': 'Weather Controller',
+                'service': service_status,
+                'health': 'healthy' if service_status.get('initialized') else 'unhealthy'
+            })
+            
+        except Exception as e:
+            self.logger.error(f"Service status error: {str(e)}")
+            return create_error_response(
+                f"Failed to get service status: {str(e)}"
+            )

server/controllers/weatherwise_prediction_controller.py

@@ -0,0 +1,297 @@
+"""
+WeatherWise Prediction Controller
+Handles HTTP requests for LSTM weather forecasting
+"""
+
+import logging
+from typing import Dict, Any
+from datetime import datetime
+
+from services.weatherwise_prediction_service import WeatherWisePredictionService
+
+logger = logging.getLogger(__name__)
+
+class WeatherWisePredictionController:
+    """Controller for handling WeatherWise LSTM weather forecasting requests"""
+    
+    def __init__(self, weatherwise_service: WeatherWisePredictionService = None):
+        """Initialize WeatherWise controller"""
+        self.service = weatherwise_service or WeatherWisePredictionService()
+        self.controller_stats = {
+            'controller_start_time': datetime.now().isoformat(),
+            'total_requests': 0,
+            'successful_requests': 0,
+            'failed_requests': 0
+        }
+        
+        logger.info("WeatherWise prediction controller initialized")
+    
+    def initialize_controller(self) -> Dict[str, Any]:
+        """
+        Initialize the controller by setting up the WeatherWise service
+        
+        Returns:
+            Initialize response dictionary
+        """
+        try:
+            logger.info("Initializing WeatherWise prediction controller...")
+            
+            # Initialize the WeatherWise service
+            service_success, service_message = self.service.initialize_service()
+            
+            if service_success:
+                available_models = self.service.get_available_models()
+                logger.info(f"[SUCCESS] WeatherWise controller initialized with {len(available_models)} models")
+                
+                return self._create_response(
+                    success=True,
+                    message="WeatherWise controller initialized successfully",
+                    data={
+                        'service_status': 'initialized',
+                        'available_models': available_models,
+                        'default_forecast_days': 60,
+                        'supported_variables': self.service.prediction_model.forecast_variables
+                    }
+                )
+            else:
+                logger.error(f"[ERROR] WeatherWise service initialization failed: {service_message}")
+                return self._create_response(
+                    success=False,
+                    message="WeatherWise controller initialization failed",
+                    error=service_message
+                )
+                
+        except Exception as e:
+            logger.error(f"WeatherWise controller initialization error: {e}")
+            return self._create_response(
+                success=False,
+                message="WeatherWise controller initialization error",
+                error=f"Controller error: {str(e)}"
+            )
+    
+    def forecast_weather(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Generate weather forecast for location
+        
+        Args:
+            request_data: Request dictionary with latitude, longitude, etc.
+        
+        Returns:
+            Forecast response dictionary
+        """
+        self.controller_stats['total_requests'] += 1
+        
+        try:
+            logger.info(f"[WEATHERWISE_CONTROLLER] ===== FORECAST REQUEST START =====")
+            logger.info(f"[WEATHERWISE_CONTROLLER] Processing forecast request...")
+            logger.info(f"[WEATHERWISE_CONTROLLER] Total requests so far: {self.controller_stats['total_requests']}")
+            
+            # Extract request parameters
+            latitude = request_data.get('latitude')
+            longitude = request_data.get('longitude')
+            reference_date = request_data.get('reference_date')
+            disaster_type = request_data.get('disaster_type', 'Normal')
+            forecast_days = request_data.get('forecast_days', 60)
+            
+            logger.info(f"[WEATHERWISE_CONTROLLER] Extracted parameters:")
+            logger.info(f"[WEATHERWISE_CONTROLLER]   - latitude: {latitude}")
+            logger.info(f"[WEATHERWISE_CONTROLLER]   - longitude: {longitude}")
+            logger.info(f"[WEATHERWISE_CONTROLLER]   - reference_date: {reference_date}")
+            logger.info(f"[WEATHERWISE_CONTROLLER]   - disaster_type: {disaster_type}")
+            logger.info(f"[WEATHERWISE_CONTROLLER]   - forecast_days: {forecast_days}")
+            
+            # Reject if TF models are still warming up in the background thread
+            if not self.service.service_stats.get('models_loaded'):
+                return self._create_response(
+                    success=False,
+                    message="Service is warming up, please retry in a moment",
+                    error="models_not_ready"
+                )
+
+            # Validate required parameters
+            if latitude is None or longitude is None:
+                logger.error("[WEATHERWISE_CONTROLLER] Missing required parameters")
+                return self._create_response(
+                    success=False,
+                    message="Missing required parameters",
+                    error="Both 'latitude' and 'longitude' are required"
+                )
+            
+            logger.info(f"[WEATHERWISE_CONTROLLER] Parameters validated successfully")
+            
+            # Validate disaster type
+            available_models = self.service.get_available_models()
+            if disaster_type not in available_models and available_models:
+                logger.warning(f"Requested disaster type '{disaster_type}' not available, using '{available_models[0]}'")
+                disaster_type = available_models[0]
+            
+            # Validate forecast days
+            try:
+                forecast_days = int(forecast_days)
+                if forecast_days < 1 or forecast_days > 365:
+                    forecast_days = 60  # Default
+            except (ValueError, TypeError):
+                forecast_days = 60
+            
+            logger.info(f"[WEATHERWISE_CONTROLLER] Calling service.generate_weather_forecast()...")
+            logger.info(f"Processing weather forecast for ({latitude}, {longitude})")
+            logger.info(f"Parameters: disaster_type={disaster_type}, forecast_days={forecast_days}, reference_date={reference_date}")
+            
+            # Generate forecast using service
+            forecast_result = self.service.generate_weather_forecast(
+                latitude=latitude,
+                longitude=longitude,
+                reference_date=reference_date,
+                disaster_type=disaster_type,
+                forecast_days=forecast_days
+            )
+            logger.info(f"[WEATHERWISE_CONTROLLER] Service call completed")
+            logger.info(f"[WEATHERWISE_CONTROLLER] Forecast result success: {forecast_result.get('success')}")
+            
+            
+            if forecast_result['success']:
+                self.controller_stats['successful_requests'] += 1
+                
+                response_data = {
+                    'forecast': forecast_result['weather_forecast'],
+                    'forecast_dates': forecast_result['forecast_dates'],
+                    'forecast_variables': forecast_result['forecast_variables'],
+                    'model_context': forecast_result['model_type'],
+                    'location': forecast_result['location'],
+                    'forecast_summary': {
+                        'horizon_days': forecast_result['forecast_horizon_days'],
+                        'variables_count': len(forecast_result['forecast_variables']),
+                        'model_used': forecast_result['model_type']
+                    },
+                    'data_collection_summary': forecast_result.get('data_collection', {})
+                }
+                
+                return self._create_response(
+                    success=True,
+                    message="Weather forecast generated successfully",
+                    data=response_data,
+                    processing_info={
+                        'processing_time_seconds': forecast_result.get('processing_time_seconds', 0),
+                        'forecast_model': forecast_result['model_type'],
+                        'forecast_horizon_days': forecast_result['forecast_horizon_days'],
+                        'data_sources': forecast_result.get('processing_info', {}).get('data_sources', [])
+                    }
+                )
+            else:
+                self.controller_stats['failed_requests'] += 1
+                return self._create_response(
+                    success=False,
+                    message="Weather forecast generation failed",
+                    error=forecast_result.get('error', 'Unknown forecast error'),
+                    data={
+                        'location': forecast_result.get('location'),
+                        'processing_time_seconds': forecast_result.get('processing_time_seconds', 0)
+                    }
+                )
+                
+        except Exception as e:
+            self.controller_stats['failed_requests'] += 1
+            logger.error(f"WeatherWise controller forecast error: {e}")
+            return self._create_response(
+                success=False,
+                message="Weather forecast error",
+                error=f"Controller error: {str(e)}"
+            )
+    
+    def get_service_status(self) -> Dict[str, Any]:
+        """
+        Get WeatherWise service status and health information
+        
+        Returns:
+            Service status response
+        """
+        try:
+            # Get service health from the service layer
+            service_health = self.service.get_service_health()
+            
+            # Add controller statistics
+            response_data = {
+                'controller_info': {
+                    'controller_name': 'WeatherWise Prediction Controller',
+                    'controller_stats': self.controller_stats
+                },
+                'service_health': service_health
+            }
+            
+            return self._create_response(
+                success=True,
+                message="WeatherWise service status retrieved successfully",
+                data=response_data
+            )
+            
+        except Exception as e:
+            logger.error(f"WeatherWise status error: {e}")
+            return self._create_response(
+                success=False,
+                message="Failed to retrieve service status",
+                error=f"Status error: {str(e)}"
+            )
+    
+    def get_available_models(self) -> Dict[str, Any]:
+        """
+        Get available disaster context models
+        
+        Returns:
+            Available models response
+        """
+        try:
+            available_models = self.service.get_available_models()
+            model_info = self.service.prediction_model.get_model_info()
+            
+            return self._create_response(
+                success=True,
+                message="Available models retrieved successfully",
+                data={
+                    'available_disaster_contexts': available_models,
+                    'model_info': model_info,
+                    'default_context': 'Normal',
+                    'supported_forecast_variables': model_info.get('forecast_variables', [])
+                }
+            )
+            
+        except Exception as e:
+            logger.error(f"WeatherWise models list error: {e}")
+            return self._create_response(
+                success=False,
+                message="Failed to retrieve available models",
+                error=f"Models error: {str(e)}"
+            )
+    
+    def _create_response(self, success: bool, message: str, 
+                       data: Dict[str, Any] = None, error: str = None, 
+                       processing_info: Dict[str, Any] = None) -> Dict[str, Any]:
+        """
+        Create standardized response dictionary
+        
+        Args:
+            success: Success status
+            message: Response message
+            data: Response data (optional)
+            error: Error message (optional)
+            processing_info: Processing information (optional)
+        
+        Returns:
+            Standardized response dictionary
+        """
+        response = {
+            'success': success,
+            'message': message,
+            'timestamp': datetime.now().isoformat(),
+            'service': 'WeatherWise'
+        }
+        
+        if data is not None:
+            response['data'] = data
+            
+        if error is not None:
+            response['error'] = error
+            
+        if processing_info is not None:
+            response['processing_info'] = processing_info
+            
+        return response

server/download_models.py

@@ -0,0 +1,17 @@
+"""Downloads model files from private HF model repo at Docker build time."""
+import os
+from huggingface_hub import snapshot_download
+
+token = os.environ.get("HF_TOKEN")
+if not token:
+    raise RuntimeError("HF_TOKEN secret is not set — cannot download private model repo")
+
+print("Downloading models from projectgaia/ShrishtiAI-models ...")
+snapshot_download(
+    repo_id="projectgaia/ShrishtiAI-models",
+    repo_type="model",
+    local_dir="/app/models",
+    token=token,
+    ignore_patterns=["*.git*", ".gitattributes"],
+)
+print("Models downloaded successfully.")

server/entrypoint.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+set -e
+
+# Download models from private HF model repo if not already present
+if [ ! -f "/app/models/weatherwise/normal/best_model.keras" ]; then
+    echo "[ENTRYPOINT] Downloading models from HuggingFace..."
+    python download_models.py
+    echo "[ENTRYPOINT] Models ready."
+else
+    echo "[ENTRYPOINT] Models already present, skipping download."
+fi
+
+# Start gunicorn
+exec gunicorn main:app \
+    --bind 0.0.0.0:7860 \
+    --workers 1 \
+    --threads 2 \
+    --timeout 300 \
+    --keep-alive 5 \
+    --access-logfile - \
+    --error-logfile -

server/main.py

@@ -0,0 +1,646 @@
+"""
+GEO VISION Backend - Main Application
+Professional Flask backend with MVC architecture
+"""
+
+# ============================================================================
+# CRITICAL: PROJ/GDAL Setup MUST be done BEFORE any rasterio imports
+# ============================================================================
+import os
+import sys
+import time
+from pathlib import Path
+
+_startup_t0 = time.time()
+
+def _elapsed():
+    return f"{time.time() - _startup_t0:.1f}s"
+
+# ── Local proj_data (copied from rasterio) lives right here in the backend dir ──
+_BACKEND_DIR = Path(os.path.dirname(os.path.abspath(__file__)))
+proj_lib_path = _BACKEND_DIR / "proj_data"
+
+# Fallback chain: backend/proj_data → rasterio package → pyproj package
+# (cross-platform — works on Windows dev and Linux Render)
+def _find_proj_data():
+    """Find proj.db in known locations, cross-platform."""
+    candidates = [
+        _BACKEND_DIR / "proj_data",
+    ]
+    # Try rasterio's bundled proj_data
+    try:
+        import rasterio
+        candidates.append(Path(rasterio.__file__).parent / "proj_data")
+    except ImportError:
+        pass
+    # Try pyproj's bundled data
+    try:
+        import pyproj
+        candidates.append(Path(pyproj.datadir.get_data_dir()))
+    except (ImportError, AttributeError):
+        pass
+    # Try common system locations
+    candidates.extend([
+        Path("/usr/share/proj"),
+        Path("/usr/local/share/proj"),
+    ])
+    for c in candidates:
+        if c.exists() and (c / "proj.db").exists():
+            return c
+    return candidates[0]  # fallback
+
+def _find_gdal_data():
+    """Find GDAL data dir, cross-platform."""
+    candidates = []
+    try:
+        from osgeo import gdal
+        pkg_dir = Path(gdal.__file__).parent / "data" / "gdal"
+        candidates.append(pkg_dir)
+        # Also try osgeo package level
+        candidates.append(Path(gdal.__file__).parent / "data")
+    except ImportError:
+        pass
+    candidates.extend([
+        Path("/usr/share/gdal"),
+        Path("/usr/local/share/gdal"),
+    ])
+    for c in candidates:
+        if c.exists():
+            return c
+    return candidates[0] if candidates else Path("/usr/share/gdal")
+
+proj_lib_path = _find_proj_data()
+gdal_data_path = _find_gdal_data()
+
+if not (proj_lib_path / "proj.db").exists():
+    print(f"[WARNING] proj.db not found in any known location!")
+if not gdal_data_path.exists():
+    print(f"[WARNING] GDAL data directory not found at {gdal_data_path}.")
+
+# Set ALL PROJ env vars at once BEFORE any rasterio/pyproj imports.
+# This is the only configuration needed — no need to import pyproj here.
+os.environ["PROJ_LIB"]  = str(proj_lib_path)
+os.environ["PROJ_DATA"] = str(proj_lib_path)   # newer PROJ versions
+os.environ["GDAL_DATA"] = str(gdal_data_path)
+os.environ["PROJ_IGNORE_CELESTIAL_BODY"] = "1"
+os.environ["PROJ_NETWORK"] = "OFF"             # disable slow network grid lookups
+
+# Enable GDAL HTTP access for Cloud Optimized GeoTIFF files on GCS
+os.environ["GDAL_HTTP_UNSAFESSL"]              = "YES"
+os.environ["CPL_VSIL_CURL_ALLOWED_EXTENSIONS"] = ".tif,.tiff"
+os.environ["GDAL_DISABLE_READDIR_ON_OPEN"]     = "EMPTY_DIR"
+os.environ["VSI_CACHE"]                        = "TRUE"
+os.environ["VSI_CACHE_SIZE"]                    = "67108864"  # 64 MB
+
+print(f"[PROJ] PROJ_LIB set to: {os.environ['PROJ_LIB']}  ({_elapsed()})")
+print(f"[PROJ] proj.db exists: {(proj_lib_path / 'proj.db').exists()}")
+
+# ============================================================================
+# Now safe to import Flask and other modules
+# ============================================================================
+print(f"[STARTUP] Importing Flask and service modules...  ({_elapsed()})")
+from flask import Flask, jsonify
+from flask_cors import CORS
+import logging
+
+# Add backend directory to Python path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Import MVC components
+from config import get_config, Config
+from config.raster_config import get_raster_config
+from services import GEEService, AIService
+from services.weather_service import NASAPowerService
+from services.feature_engineering_service import FeatureEngineeringService
+from services.raster_data_service import RasterDataService
+from services.post_disaster_weather_service import PostDisasterWeatherService
+from services.post_disaster_feature_engineering_service import PostDisasterFeatureEngineeringService
+from services.hazardguard_prediction_service import HazardGuardPredictionService
+print(f"[STARTUP] Importing WeatherWise (triggers TensorFlow load)...  ({_elapsed()})")
+from services.weatherwise_prediction_service import WeatherWisePredictionService
+print(f"[STARTUP] TensorFlow ready.  ({_elapsed()})")
+from services.geovision_fusion_service import GeoVisionFusionService
+from controllers import ChatController, SatelliteController
+from controllers.weather_controller import WeatherController
+from controllers.feature_engineering_controller import FeatureEngineeringController
+from controllers.raster_data_controller import RasterDataController
+from controllers.post_disaster_weather_controller import PostDisasterWeatherController
+from controllers.post_disaster_feature_engineering_controller import PostDisasterFeatureEngineeringController
+from controllers.hazardguard_prediction_controller import HazardGuardPredictionController
+from controllers.weatherwise_prediction_controller import WeatherWisePredictionController
+from controllers.geovision_fusion_controller import GeoVisionFusionController
+from controllers.auth_controller import AuthController
+from views import chat_bp, satellite_bp, legacy_bp, init_chat_routes, init_satellite_routes, init_legacy_routes
+from routes.weather_routes import weather_bp, init_weather_routes
+from routes.feature_routes import features_bp, init_feature_routes
+from routes.raster_routes import create_raster_routes
+from routes.post_disaster_weather_routes import create_post_disaster_weather_routes
+from routes.post_disaster_feature_engineering_routes import post_disaster_feature_engineering_bp
+from routes.hazardguard_prediction_routes import hazardguard_bp
+from routes.weatherwise_prediction_routes import weatherwise_bp
+from routes.geovision_fusion_routes import geovision_bp
+from routes.auth_routes import auth_bp, init_auth_routes
+from utils import setup_logging, create_error_response, create_success_response
+print(f"[STARTUP] All modules imported.  ({_elapsed()})")
+
+def create_app(config_name: str = None) -> Flask:
+    """
+    Application factory for creating Flask app with MVC architecture
+    
+    Args:
+        config_name: Configuration name to use
+        
+    Returns:
+        Configured Flask application
+    """
+    # Create Flask app
+    app = Flask(__name__)
+    
+    # Load configuration
+    if config_name:
+        os.environ['FLASK_ENV'] = config_name
+    
+    config_class = get_config()
+    app.config.from_object(config_class)
+    
+    # Setup logging
+    setup_logging(
+        log_level=config_class.LOG_LEVEL,
+        log_file=config_class.LOG_FILE
+    )
+    
+    logger = logging.getLogger(__name__)
+    logger.info(f"Starting {config_class.APP_NAME} v{config_class.APP_VERSION}")
+    
+    # Validate configuration — log warnings but do NOT crash.
+    # Missing keys (e.g. GEMINI_API_KEY) just disable the relevant feature;
+    # the server still starts so other endpoints remain available.
+    config_errors = config_class.validate()
+    if config_errors:
+        for error in config_errors:
+            logger.warning(f"Configuration warning: {error} — related features will be unavailable")
+    
+    # Setup CORS
+    CORS(app, origins=config_class.ALLOWED_ORIGINS, 
+         methods=['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+         allow_headers=['Content-Type', 'Authorization'])
+    
+    # Initialize services
+    services = initialize_services(config_class, logger)
+    
+    # Initialize controllers
+    controllers = initialize_controllers(services, logger)
+    
+    # Store controllers in app extensions for blueprint access
+    if not hasattr(app, 'extensions'):
+        app.extensions = {}
+    app.extensions['controllers'] = controllers
+    
+    # Register blueprints
+    register_blueprints(app, controllers, logger)
+    
+    # Register error handlers
+    register_error_handlers(app, logger)
+    
+    # Add health check and info endpoints
+    register_system_routes(app, config_class, services, logger)
+    
+    logger.info("Application initialization completed successfully")
+    return app
+
+def initialize_services(config_class: Config, logger: logging.Logger) -> dict:
+    """Initialize all services"""
+    services = {}
+    
+    # Initialize Google Earth Engine service
+    logger.info("Initializing Google Earth Engine service...")
+    _t = time.time()
+    gee_service = GEEService(
+        project_id=config_class.GEE_PROJECT_ID,
+        service_account_key=config_class.GEE_SERVICE_ACCOUNT_KEY
+    )
+    
+    if gee_service.initialize():
+        services['gee'] = gee_service
+        logger.info(f"GEE service initialized successfully  ({time.time()-_t:.1f}s)")
+    else:
+        logger.error(f"GEE service initialization failed  ({time.time()-_t:.1f}s)")
+        services['gee'] = gee_service  # Still add it for status reporting
+    
+    # Initialize AI service
+    logger.info("Initializing AI service...")
+    ai_service = AIService(config_class.GEMINI_API_KEY)
+    
+    if ai_service.initialize():
+        services['ai'] = ai_service
+        logger.info("AI service initialized successfully")
+    else:
+        logger.error("AI service initialization failed")
+        services['ai'] = ai_service  # Still add it for status reporting
+    
+    # Initialize Weather service
+    logger.info("Initializing NASA POWER weather service...")
+    weather_service = NASAPowerService()
+    services['weather'] = weather_service
+    logger.info("Weather service initialized successfully")
+    
+    # Initialize Feature Engineering service
+    logger.info("Initializing feature engineering service...")
+    feature_service = FeatureEngineeringService()
+    services['features'] = feature_service
+    logger.info("Feature engineering service initialized successfully")
+    
+    # Initialize Raster Data service
+    logger.info("Initializing raster data service...")
+    raster_config = get_raster_config()
+    raster_service = RasterDataService(raster_config.get_config())
+    services['raster'] = raster_service
+    logger.info("Raster data service initialized successfully")
+    
+    # Initialize Post-Disaster Weather service
+    logger.info("Initializing post-disaster weather service...")
+    post_disaster_weather_service = PostDisasterWeatherService(
+        days_after_disaster=60,
+        max_workers=1,
+        retry_limit=5,
+        retry_delay=15,
+        rate_limit_pause=900,
+        request_delay=0.5
+    )
+    services['post_disaster_weather'] = post_disaster_weather_service
+    logger.info("Post-disaster weather service initialized successfully")
+    
+    # Initialize Post-Disaster Feature Engineering service
+    logger.info("Initializing post-disaster feature engineering service...")
+    post_disaster_feature_service = PostDisasterFeatureEngineeringService()
+    services['post_disaster_features'] = post_disaster_feature_service
+    logger.info("Post-disaster feature engineering service initialized successfully")
+    
+    # Initialize HazardGuard Prediction service
+    logger.info("Initializing HazardGuard prediction service...")
+    hazardguard_service = HazardGuardPredictionService(
+        weather_service=services['weather'],
+        feature_service=services['features'],
+        raster_service=services['raster']
+    )
+    # Initialize the HazardGuard service (load model)
+    hazard_success, hazard_message = hazardguard_service.initialize_service()
+    if hazard_success:
+        logger.info("HazardGuard service initialized and model loaded successfully")
+    else:
+        logger.warning(f"HazardGuard service initialization warning: {hazard_message}")
+    
+    services['hazardguard'] = hazardguard_service
+    logger.info("HazardGuard prediction service setup completed")
+    
+    # Initialize WeatherWise Prediction service
+    logger.info("Initializing WeatherWise prediction service...")
+    weatherwise_service = WeatherWisePredictionService(
+        weather_service=services['weather'],
+        feature_service=services['features']
+    )
+    services['weatherwise'] = weatherwise_service
+
+    # Initialize GeoVision Fusion service
+    logger.info("Initializing GeoVision Fusion prediction service...")
+    geovision_service = GeoVisionFusionService(
+        weather_service=services['weather'],
+        feature_service=services['features'],
+        raster_service=services['raster'],
+        gee_service=services.get('gee')
+    )
+    services['geovision'] = geovision_service
+
+    # ── Background warm-up ──────────────────────────────────────────────────
+    # TensorFlow takes ~90 s to import.  We load it in a daemon thread so
+    # gunicorn can bind its port (and pass Render's health check) immediately.
+    # Requests that arrive before warm-up is complete receive a 503 response.
+    import threading
+
+    def _background_warmup():
+        import time as _time
+        _t0 = _time.time()
+        logger.info("[WARMUP] Background thread started — loading TF models...")
+        try:
+            ww_success, ww_msg = weatherwise_service.initialize_service()
+            if ww_success:
+                logger.info(f"[WARMUP] WeatherWise ready  ({_time.time()-_t0:.1f}s)")
+            else:
+                logger.warning(f"[WARMUP] WeatherWise warning: {ww_msg}  ({_time.time()-_t0:.1f}s)")
+        except Exception as exc:
+            logger.error(f"[WARMUP] WeatherWise init error: {exc}")
+        try:
+            gv_success, gv_msg = geovision_service.initialize_service()
+            if gv_success:
+                logger.info(f"[WARMUP] GeoVision Fusion ready  ({_time.time()-_t0:.1f}s)")
+            else:
+                logger.warning(f"[WARMUP] GeoVision Fusion warning: {gv_msg}  ({_time.time()-_t0:.1f}s)")
+        except Exception as exc:
+            logger.error(f"[WARMUP] GeoVision Fusion init error: {exc}")
+        logger.info(f"[WARMUP] Background warm-up complete  ({_time.time()-_t0:.1f}s total)")
+
+    _warmup_thread = threading.Thread(target=_background_warmup, name="tf-warmup", daemon=True)
+    _warmup_thread.start()
+    logger.info("[WARMUP] TF model loading started in background thread — port will bind immediately")
+    
+    # Initialize Auth service (Supabase)
+    supabase_url = config_class.SUPABASE_URL
+    supabase_key = config_class.SUPABASE_SERVICE_ROLE_KEY
+    if supabase_url and supabase_key and supabase_key != 'YOUR_SERVICE_ROLE_KEY_HERE':
+        logger.info("Initializing Supabase auth service...")
+        try:
+            from services.auth_service import AuthService
+            auth_service = AuthService(supabase_url, supabase_key)
+            services['auth'] = auth_service
+            logger.info("Auth service initialized successfully")
+        except Exception as e:
+            logger.error(f"Auth service initialization failed: {e}")
+            services['auth'] = None
+    else:
+        logger.warning("Supabase credentials not configured -- auth endpoints will be unavailable")
+        services['auth'] = None
+    
+    return services
+
+def initialize_controllers(services: dict, logger: logging.Logger) -> dict:
+    """Initialize all controllers"""
+    logger.info("Initializing controllers...")
+    
+    controllers = {
+        'chat': ChatController(services['ai'], services['gee']),
+        'satellite': SatelliteController(services['gee']),
+        'weather': WeatherController(services['weather']),
+        'features': FeatureEngineeringController(services['features']),
+        'raster': RasterDataController(get_raster_config().get_config()),
+        'post_disaster_weather': PostDisasterWeatherController(
+            days_after_disaster=60,
+            max_workers=1,
+            retry_limit=5,
+            retry_delay=15,
+            rate_limit_pause=900,
+            request_delay=0.5
+        ),
+        'post_disaster_features': PostDisasterFeatureEngineeringController(),
+        'hazardguard': HazardGuardPredictionController(services['hazardguard']),
+        'weatherwise': WeatherWisePredictionController(services['weatherwise']),
+        'geovision': GeoVisionFusionController(services['geovision'])
+    }
+    
+    # Auth controller (optional – only if Supabase is configured)
+    if services.get('auth'):
+        controllers['auth'] = AuthController(services['auth'])
+    else:
+        controllers['auth'] = None
+    
+    logger.info("Controllers initialized successfully")
+    return controllers
+
+def register_blueprints(app: Flask, controllers: dict, logger: logging.Logger):
+    """Register all API blueprints"""
+    logger.info("Registering API blueprints...")
+    
+    # Initialize route handlers with controllers
+    init_chat_routes(controllers['chat'])
+    init_satellite_routes(controllers['satellite'])
+    init_legacy_routes(controllers['satellite'])  # Legacy routes use satellite controller
+    init_weather_routes(controllers['weather'])  # Initialize weather routes
+    init_feature_routes(controllers['features'])  # Initialize feature engineering routes
+    
+    # Initialize auth routes (if configured)
+    if controllers.get('auth'):
+        init_auth_routes(controllers['auth'])
+        logger.info("Auth routes initialized")
+    else:
+        logger.warning("Auth controller not available -- skipping auth routes")
+    
+    # Create raster routes blueprint
+    raster_bp = create_raster_routes(get_raster_config().get_config())
+    
+    # Create post-disaster weather routes blueprint
+    post_disaster_weather_bp = create_post_disaster_weather_routes({
+        'days_after_disaster': 60,
+        'max_workers': 1,
+        'retry_limit': 5,
+        'retry_delay': 15,
+        'rate_limit_pause': 900,
+        'request_delay': 0.5
+    })
+    
+    # Register blueprints
+    app.register_blueprint(chat_bp)
+    app.register_blueprint(satellite_bp)
+    app.register_blueprint(legacy_bp)  # Register legacy routes for backwards compatibility
+    app.register_blueprint(weather_bp)  # Register weather routes
+    app.register_blueprint(features_bp)  # Register feature engineering routes
+    app.register_blueprint(raster_bp)  # Register raster data routes
+    app.register_blueprint(post_disaster_weather_bp)  # Register post-disaster weather routes
+    app.register_blueprint(post_disaster_feature_engineering_bp, url_prefix='/api/post-disaster-features')  # Register post-disaster feature engineering routes
+    app.register_blueprint(hazardguard_bp, url_prefix='/api/hazardguard')  # Register HazardGuard prediction routes
+    app.register_blueprint(weatherwise_bp, url_prefix='/api/weatherwise')  # Register WeatherWise prediction routes
+    app.register_blueprint(geovision_bp, url_prefix='/api/geovision')  # Register GeoVision Fusion prediction routes
+    app.register_blueprint(auth_bp, url_prefix='/api')  # Register auth routes at /api/auth/*
+    
+    logger.info("Blueprints registered successfully")
+    
+    # Log all registered routes for debugging
+    logger.info("=== REGISTERED ROUTES ===")
+    for rule in app.url_map.iter_rules():
+        methods = ','.join(rule.methods)
+        logger.info(f"{rule.rule} | {methods}")
+    logger.info("=== END ROUTES ===")
+
+def register_error_handlers(app: Flask, logger: logging.Logger):
+    """Register global error handlers"""
+    
+    @app.errorhandler(404)
+    def not_found(error):
+        return jsonify(create_error_response(
+            "Endpoint not found",
+            {"path": error.description}
+        )), 404
+    
+    @app.errorhandler(405)
+    def method_not_allowed(error):
+        return jsonify(create_error_response(
+            "Method not allowed",
+            {"allowed_methods": error.description}
+        )), 405
+    
+    @app.errorhandler(400)
+    def bad_request(error):
+        return jsonify(create_error_response(
+            "Bad request",
+            {"description": error.description}
+        )), 400
+    
+    @app.errorhandler(500)
+    def internal_error(error):
+        logger.error(f"Internal server error: {str(error)}")
+        return jsonify(create_error_response(
+            "Internal server error"
+        )), 500
+
+def register_system_routes(app: Flask, config_class: Config, services: dict, logger: logging.Logger):
+    """Register system-level routes"""
+    
+    @app.route('/', methods=['GET'])
+    def root():
+        """Root endpoint"""
+        return jsonify(create_success_response({
+            'message': f'Welcome to {config_class.APP_NAME}',
+            'version': config_class.APP_VERSION,
+            'status': 'running',
+            'endpoints': {
+                'health': '/health',
+                'info': '/info',
+                'chat': '/api/chat/*',
+                'satellite': '/api/satellite/*',
+                'weather': '/api/weather/*',
+                'features': '/api/features/*',
+                'raster': '/api/raster/*',
+                'post_disaster_weather': '/api/post-disaster-weather/*',
+                'post_disaster_features': '/api/post-disaster-features/*',
+                'hazardguard': '/api/hazardguard/*',
+                'geovision': '/api/geovision/*'
+            }
+        }))
+    
+    @app.route('/health', methods=['GET'])
+    def health_check():
+        """Health check endpoint"""
+        try:
+            # Check service health
+            gee_healthy = services['gee'].initialized
+            ai_healthy = services['ai'].initialized
+            weather_healthy = services['weather'].get_service_status().get('initialized', True)
+            features_healthy = services['features'].get_service_status().get('initialized', True)
+            raster_healthy = services['raster'].get_processing_statistics().get('statistics', {}).get('service_status', 'healthy') == 'healthy'
+            post_disaster_weather_healthy = services['post_disaster_weather'].get_service_status().get('status', 'healthy') in ['ready', 'healthy']
+            post_disaster_features_healthy = services['post_disaster_features'].get_service_health().get('service_status', 'healthy') == 'healthy'
+            hazardguard_healthy = services['hazardguard'].get_service_status().get('service_status', 'healthy') in ['ready', 'healthy']
+            
+            overall_health = 'healthy' if (gee_healthy and ai_healthy and weather_healthy and features_healthy and raster_healthy and post_disaster_weather_healthy and post_disaster_features_healthy and hazardguard_healthy) else 'degraded'
+            
+            health_data = {
+                'status': overall_health,
+                'services': {
+                    'gee': 'healthy' if gee_healthy else 'unhealthy',
+                    'ai': 'healthy' if ai_healthy else 'unhealthy',
+                    'weather': 'healthy' if weather_healthy else 'unhealthy',
+                    'features': 'healthy' if features_healthy else 'unhealthy',
+                    'raster': 'healthy' if raster_healthy else 'unhealthy',
+                    'post_disaster_weather': 'healthy' if post_disaster_weather_healthy else 'unhealthy',
+                    'post_disaster_features': 'healthy' if post_disaster_features_healthy else 'unhealthy',
+                    'hazardguard': 'healthy' if hazardguard_healthy else 'unhealthy'
+                },
+                'version': config_class.APP_VERSION,
+                'environment': config_class.FLASK_ENV
+            }
+            
+            status_code = 200 if overall_health == 'healthy' else 503
+            return jsonify(create_success_response(health_data)), status_code
+            
+        except Exception as e:
+            logger.error(f"Health check error: {str(e)}")
+            return jsonify(create_error_response(
+                "Health check failed",
+                {"error": str(e)}
+            )), 500
+    
+    @app.route('/info', methods=['GET'])
+    def app_info():
+        """Application information endpoint"""
+        return jsonify(create_success_response({
+            'name': config_class.APP_NAME,
+            'version': config_class.APP_VERSION,
+            'author': config_class.APP_USER,
+            'environment': config_class.FLASK_ENV,
+            'debug': config_class.FLASK_DEBUG,
+            'gee_project': config_class.GEE_PROJECT_ID,
+            'cors_origins': config_class.ALLOWED_ORIGINS,
+            'api_endpoints': {
+                'chat_message': 'POST /api/chat/message',
+                'chat_analyze': 'POST /api/chat/analyze',
+                'chat_disaster_info': 'GET /api/chat/disaster/<type>',
+                'satellite_point': 'GET|POST /api/satellite/point',
+                'satellite_region': 'POST /api/satellite/region',
+                'satellite_availability': 'GET|POST /api/satellite/availability',
+                'satellite_status': 'GET /api/satellite/status',
+                'satellite_collections': 'GET /api/satellite/collections',
+                'weather_data': 'GET|POST /api/weather/data',
+                'weather_time_series': 'GET|POST /api/weather/time-series',
+                'weather_batch': 'POST /api/weather/batch',
+                'weather_summary': 'GET|POST /api/weather/summary',
+                'weather_fields': 'GET /api/weather/fields',
+                'weather_status': 'GET /api/weather/status',
+                'weather_test': 'GET /api/weather/test',
+                'features_process': 'POST /api/features/process',
+                'features_batch': 'POST /api/features/batch',
+                'features_dataframe': 'POST /api/features/dataframe',
+                'features_validate': 'POST /api/features/validate',
+                'features_export': 'POST /api/features/export',
+                'features_info': 'GET /api/features/info',
+                'features_status': 'GET /api/features/status',
+                'features_test': 'GET|POST /api/features/test',
+                'raster_process': 'POST /api/raster/process',
+                'raster_batch': 'POST /api/raster/batch',
+                'raster_dataframe': 'POST /api/raster/dataframe',
+                'raster_export': 'POST /api/raster/export',
+                'raster_validate': 'POST /api/raster/validate',
+                'raster_features': 'GET /api/raster/features',
+                'raster_info': 'GET /api/raster/info',
+                'raster_status': 'GET /api/raster/status',
+                'raster_test': 'GET /api/raster/test',
+                'raster_health': 'GET /api/raster/health',
+                'post_disaster_features_process': 'POST /api/post-disaster-features/process',
+                'post_disaster_features_batch': 'POST /api/post-disaster-features/batch',
+                'post_disaster_features_export_csv': 'POST /api/post-disaster-features/export/csv',
+                'post_disaster_features_validate_coordinates': 'POST /api/post-disaster-features/validate/coordinates',
+                'post_disaster_features_validate_weather': 'POST /api/post-disaster-features/validate/weather',
+                'post_disaster_features_info': 'GET /api/post-disaster-features/features/info',
+                'post_disaster_features_health': 'GET /api/post-disaster-features/health',
+                'post_disaster_features_reset_stats': 'POST /api/post-disaster-features/statistics/reset',
+                'post_disaster_features_ping': 'GET /api/post-disaster-features/ping',
+                'hazardguard_predict': 'POST /api/hazardguard/predict',
+                'hazardguard_predict_batch': 'POST /api/hazardguard/predict/batch',
+                'hazardguard_capabilities': 'GET /api/hazardguard/capabilities',
+                'hazardguard_validate_coordinates': 'POST /api/hazardguard/validate/coordinates',
+                'hazardguard_health': 'GET /api/hazardguard/health',
+                'hazardguard_initialize': 'POST /api/hazardguard/initialize',
+                'hazardguard_reset_stats': 'POST /api/hazardguard/statistics/reset',
+                'hazardguard_ping': 'GET /api/hazardguard/ping'
+            }
+        }))
+
+# ── Module-level app for WSGI servers (gunicorn, etc.) ──
+# gunicorn will import main:app directly, bypassing main()
+app = create_app()
+
+def main():
+    """Main entry point for local development"""
+    try:
+        # Get configuration
+        config_class = get_config()
+        
+        # Run application
+        print(f"\n[START] Starting {config_class.APP_NAME} v{config_class.APP_VERSION}")
+        print(f"[ENV] Environment: {config_class.FLASK_ENV}")
+        print(f"[SERVER] Server: http://{config_class.FLASK_HOST}:{config_class.FLASK_PORT}")
+        print(f"[HEALTH] Health Check: http://{config_class.FLASK_HOST}:{config_class.FLASK_PORT}/health")
+        print(f"[INFO] API Info: http://{config_class.FLASK_HOST}:{config_class.FLASK_PORT}/info\n")
+        
+        app.run(
+            host=config_class.FLASK_HOST,
+            port=config_class.FLASK_PORT,
+            debug=config_class.FLASK_DEBUG,
+            use_reloader=False  # Disable reloader to prevent double initialization of heavy services (GEE, Gemini, models)
+        )
+        
+    except KeyboardInterrupt:
+        print("\n[STOP] Server stopped by user")
+    except Exception as e:
+        print(f"\n[ERROR] Server startup failed: {str(e)}")
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()

server/models/__init__.py

@@ -0,0 +1,166 @@
+"""
+Data Models
+Simple data classes and models for the application
+"""
+from dataclasses import dataclass
+from typing import Optional, Dict, Any, List
+from datetime import datetime
+
+@dataclass
+class Location:
+    """Location data model"""
+    latitude: float
+    longitude: float
+    
+    def __post_init__(self):
+        """Validate coordinates"""
+        if not (-90 <= self.latitude <= 90):
+            raise ValueError(f"Invalid latitude: {self.latitude}")
+        if not (-180 <= self.longitude <= 180):
+            raise ValueError(f"Invalid longitude: {self.longitude}")
+    
+    def to_dict(self) -> Dict[str, float]:
+        """Convert to dictionary"""
+        return {
+            'latitude': self.latitude,
+            'longitude': self.longitude
+        }
+
+@dataclass
+class ChatMessage:
+    """Chat message data model"""
+    message: str
+    context: Optional[Dict[str, Any]] = None
+    timestamp: Optional[datetime] = None
+    
+    def __post_init__(self):
+        """Set default timestamp"""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return {
+            'message': self.message,
+            'context': self.context,
+            'timestamp': self.timestamp.isoformat() if self.timestamp else None
+        }
+
+@dataclass
+class ChatResponse:
+    """Chat response data model"""
+    response: str
+    status: str
+    model: Optional[str] = None
+    attempt: Optional[int] = None
+    timestamp: Optional[datetime] = None
+    
+    def __post_init__(self):
+        """Set default timestamp"""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return {
+            'response': self.response,
+            'status': self.status,
+            'model': self.model,
+            'attempt': self.attempt,
+            'timestamp': self.timestamp.isoformat() if self.timestamp else None
+        }
+
+@dataclass
+class SatelliteRequest:
+    """Satellite data request model"""
+    location: Location
+    start_date: str
+    end_date: str
+    collection: str = 'COPERNICUS/S2_SR'
+    cloud_filter: int = 20
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return {
+            'location': self.location.to_dict(),
+            'start_date': self.start_date,
+            'end_date': self.end_date,
+            'collection': self.collection,
+            'cloud_filter': self.cloud_filter
+        }
+
+@dataclass
+class RegionRequest:
+    """Region data request model"""
+    bounds: List[List[float]]
+    start_date: str
+    end_date: str
+    scale: int = 10
+    
+    def __post_init__(self):
+        """Validate bounds"""
+        if len(self.bounds) < 3:
+            raise ValueError("Bounds must contain at least 3 coordinate pairs")
+        
+        for i, coord in enumerate(self.bounds):
+            if len(coord) != 2:
+                raise ValueError(f"Invalid coordinate at index {i}")
+            
+            lon, lat = coord
+            if not (-180 <= lon <= 180) or not (-90 <= lat <= 90):
+                raise ValueError(f"Invalid coordinates at index {i}: [{lon}, {lat}]")
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return {
+            'bounds': self.bounds,
+            'start_date': self.start_date,
+            'end_date': self.end_date,
+            'scale': self.scale
+        }
+
+@dataclass
+class ServiceStatus:
+    """Service status model"""
+    service_name: str
+    status: str
+    initialized: bool
+    timestamp: Optional[datetime] = None
+    details: Optional[Dict[str, Any]] = None
+    
+    def __post_init__(self):
+        """Set default timestamp"""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return {
+            'service_name': self.service_name,
+            'status': self.status,
+            'initialized': self.initialized,
+            'timestamp': self.timestamp.isoformat() if self.timestamp else None,
+            'details': self.details
+        }
+
+@dataclass
+class ErrorResponse:
+    """Error response model"""
+    error: str
+    status: str = 'error'
+    timestamp: Optional[datetime] = None
+    details: Optional[Dict[str, Any]] = None
+    
+    def __post_init__(self):
+        """Set default timestamp"""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return {
+            'error': self.error,
+            'status': self.status,
+            'timestamp': self.timestamp.isoformat() if self.timestamp else None,
+            'details': self.details
+        }

server/models/auth_model.py

@@ -0,0 +1,90 @@
+"""
+Auth Data Models
+Defines authentication and user data structures
+"""
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any, List
+from datetime import datetime
+
+
+@dataclass
+class LoginRequest:
+    """Login request parameters"""
+    email: str
+    password: str
+
+    def validate(self) -> List[str]:
+        errors = []
+        if not self.email or not self.email.strip():
+            errors.append("Email is required")
+        elif "@" not in self.email:
+            errors.append("Invalid email format")
+        if not self.password or len(self.password) < 6:
+            errors.append("Password must be at least 6 characters")
+        return errors
+
+
+@dataclass
+class SignUpRequest:
+    """Sign-up request parameters"""
+    email: str
+    password: str
+    full_name: str
+    organization: Optional[str] = None
+    purpose: Optional[str] = None
+
+    def validate(self) -> List[str]:
+        errors = []
+        if not self.email or not self.email.strip():
+            errors.append("Email is required")
+        elif "@" not in self.email:
+            errors.append("Invalid email format")
+        if not self.password or len(self.password) < 6:
+            errors.append("Password must be at least 6 characters")
+        if not self.full_name or not self.full_name.strip():
+            errors.append("Full name is required")
+        return errors
+
+
+@dataclass
+class ProfileUpdate:
+    """Profile update parameters"""
+    full_name: Optional[str] = None
+    organization: Optional[str] = None
+    purpose: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return only non-None fields"""
+        d = {}
+        if self.full_name is not None:
+            d["full_name"] = self.full_name
+        if self.organization is not None:
+            d["organization"] = self.organization
+        if self.purpose is not None:
+            d["purpose"] = self.purpose
+        return d
+
+
+VALID_ACTIVITY_TYPES = [
+    "login", "logout", "signup",
+    "prediction_run", "weather_forecast",
+    "chatbot_query", "profile_update",
+    "settings_change", "dataset_view",
+]
+
+
+@dataclass
+class ActivityLogEntry:
+    """Activity log entry"""
+    activity_type: str
+    description: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+    device_info: Optional[str] = None
+
+    def validate(self) -> List[str]:
+        errors = []
+        if not self.activity_type:
+            errors.append("activity_type is required")
+        elif self.activity_type not in VALID_ACTIVITY_TYPES:
+            errors.append(f"Invalid activity_type. Must be one of: {', '.join(VALID_ACTIVITY_TYPES)}")
+        return errors

server/models/disaster_type_classifier_model.py

@@ -0,0 +1,324 @@
+"""
+Disaster Type Classifier Model
+Multi-stage binary classification to identify specific disaster types
+Runs 4 binary classifiers: Storm, Flood, Drought, Mass Movement (Landslide)
+
+Each classifier is trained as "NO_<type> vs <type>" — i.e., the negative class
+includes ALL other disaster types + Normal, not just Normal.
+This makes them more robust one-vs-rest classifiers.
+
+Models are XGBoost binary classifiers loaded from .joblib pipeline files containing:
+  - 'model': XGBClassifier
+  - 'scaler': StandardScaler
+  - 'selector': SelectKBest (top 90% of 297 features)
+  - 'selected_features': list of feature names after selection
+  - 'target_disaster': positive class name
+  - 'negative_label': negative class name (e.g. 'NO_Drought')
+"""
+
+import os
+import joblib
+import logging
+import pandas as pd
+import numpy as np
+from typing import Dict, List, Any, Tuple
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+class DisasterTypeClassifierModel:
+    """Model for classifying specific disaster types after disaster is detected"""
+    
+    def __init__(self):
+        """Initialize disaster type classifier"""
+        model_root = os.getenv('MODEL_ROOT_PATH', '').strip()
+        if model_root:
+            self.MODEL_BASE_DIR = os.path.join(os.path.abspath(model_root), 'hazardguard')
+        else:
+            self.MODEL_BASE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'hazardguard')
+        
+        # Define model paths for each disaster type (new binary NO_X vs X models)
+        self.model_paths = {
+            'Storm': {
+                'pipeline': os.path.join(self.MODEL_BASE_DIR, 'binary_storm', 'binary_NOstorm_storm_pipeline.joblib'),
+                'config': os.path.join(self.MODEL_BASE_DIR, 'binary_storm', 'comprehensive_model_config.json')
+            },
+            'Flood': {
+                'pipeline': os.path.join(self.MODEL_BASE_DIR, 'binary_flood', 'binary_NOflood_flood_pipeline.joblib'),
+                'config': os.path.join(self.MODEL_BASE_DIR, 'binary_flood', 'comprehensive_model_config.json')
+            },
+            'Drought': {
+                'pipeline': os.path.join(self.MODEL_BASE_DIR, 'binary_drought', 'binary_NOdrought_drought_pipeline.joblib'),
+                'config': os.path.join(self.MODEL_BASE_DIR, 'binary_drought', 'comprehensive_model_config.json')
+            },
+            'Landslide': {  # Mass Movement
+                'pipeline': os.path.join(self.MODEL_BASE_DIR, 'binary_landslide', 'binary_NOmassmovement_massmovement_pipeline.joblib'),
+                'config': os.path.join(self.MODEL_BASE_DIR, 'binary_landslide', 'comprehensive_model_config.json')
+            }
+        }
+        
+        # Model pipelines (loaded on demand or at initialization)
+        self.models = {}
+        self.models_loaded = False
+        
+        logger.info("Disaster type classifier model initialized")
+    
+    def load_models(self) -> bool:
+        """Load all 4 binary disaster type classifier pipelines"""
+        try:
+            logger.info("Loading disaster type classification models...")
+            
+            for disaster_type, paths in self.model_paths.items():
+                pipeline_path = paths['pipeline']
+                
+                # Check if pipeline file exists
+                if not os.path.exists(pipeline_path):
+                    logger.error(f"Missing {disaster_type} pipeline at {pipeline_path}")
+                    return False
+                
+                # Load pipeline components (selector, scaler, model are stored separately)
+                logger.info(f"  Loading {disaster_type} classifier...")
+                loaded_data = joblib.load(pipeline_path)
+                
+                # Stored as dict with separate components: model, scaler, selector
+                if isinstance(loaded_data, dict) and 'model' in loaded_data:
+                    self.models[disaster_type] = loaded_data
+                    logger.info(f"    [OK] {disaster_type} classifier loaded (selector + scaler + XGBoost)")
+                else:
+                    logger.error(f"{disaster_type}: Unexpected format - {type(loaded_data)}")
+                    return False
+            
+            self.models_loaded = True
+            logger.info(f"[SUCCESS] All {len(self.models)} disaster type classifiers loaded!")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error loading disaster type models: {e}")
+            self.models_loaded = False
+            return False
+    
+    # HORIZON configuration matching training scripts
+    HORIZON = 1
+    FORECAST_DAYS = 60 - HORIZON  # Use first 59 days (same as training)
+    
+    def prepare_features_for_binary_models(self, weather_data: Dict[str, Any], feature_data: Dict[str, Any],
+                                          raster_data: Dict[str, Any], lat: float, lon: float, reference_date: str) -> pd.DataFrame:
+        """
+        Prepare features for binary disaster type classifiers
+        All 4 models (Storm/Flood/Drought/Landslide) use the same 36 array + 9 scalar features
+        Arrays are truncated to first FORECAST_DAYS (59) values to match training HORIZON=1
+        """
+        try:
+            # Flood, Drought, Landslide models use these 36 array features
+            ARRAY_FEATURE_COLUMNS = [
+                # Basic weather from NASA POWER (17 fields)
+                'temperature_C', 'humidity_%', 'wind_speed_mps', 'precipitation_mm',
+                'surface_pressure_hPa', 'solar_radiation_wm2', 'temperature_max_C', 'temperature_min_C',
+                'specific_humidity_g_kg', 'dew_point_C', 'wind_speed_10m_mps', 'cloud_amount_%',
+                'sea_level_pressure_hPa', 'surface_soil_wetness_%', 'wind_direction_10m_degrees',
+                'evapotranspiration_wm2', 'root_zone_soil_moisture_%',
+                # Engineered features (19 fields)
+                'temp_normalized', 'temp_range', 'discomfort_index', 'heat_index',
+                'wind_precip_interaction', 'solar_temp_ratio', 'pressure_anomaly',
+                'high_precip_flag', 'adjusted_humidity', 'wind_chill',
+                'solar_radiation_anomaly', 'weather_severity_score',
+                'moisture_stress_index', 'evaporation_deficit', 'soil_saturation_index',
+                'atmospheric_instability', 'drought_indicator', 'flood_risk_score', 'storm_intensity_index'
+            ]
+            
+            # Scalar features (9 raster features)
+            SCALAR_FEATURE_COLUMNS = [
+                'soil_type', 'elevation_m', 'pop_density_persqkm', 'land_cover_class',
+                'ndvi', 'annual_precip_mm', 'annual_mean_temp_c', 'mean_wind_speed_ms',
+                'impervious_surface_pct'
+            ]
+            
+            row_features = {}
+            
+            # Parse reference date
+            from datetime import datetime
+            dt = datetime.strptime(reference_date, '%Y-%m-%d')
+            
+            # Process each array feature (expand to 8 statistics)
+            missing_features = []
+            for col in ARRAY_FEATURE_COLUMNS:
+                # Check if it's a weather array
+                if col in weather_data and isinstance(weather_data[col], list):
+                    arr = weather_data[col][:self.FORECAST_DAYS]  # Truncate to first 59 days
+                    if len(arr) > 0:
+                        stats = self._compute_stats(arr)
+                        for stat_name, stat_value in stats.items():
+                            row_features[f"{col}_{stat_name}"] = stat_value
+                    else:
+                        for stat in ['mean', 'min', 'max', 'std', 'median', 'q25', 'q75', 'skew']:
+                            row_features[f"{col}_{stat}"] = np.nan
+                
+                # Check in engineered feature_data
+                elif col in feature_data and isinstance(feature_data[col], list):
+                    arr = feature_data[col][:self.FORECAST_DAYS]  # Truncate to first 59 days
+                    if len(arr) > 0:
+                        stats = self._compute_stats(arr)
+                        for stat_name, stat_value in stats.items():
+                            row_features[f"{col}_{stat_name}"] = stat_value
+                    else:
+                        for stat in ['mean', 'min', 'max', 'std', 'median', 'q25', 'q75', 'skew']:
+                            row_features[f"{col}_{stat}"] = np.nan
+                
+                # Missing array feature
+                else:
+                    missing_features.append(col)
+                    for stat in ['mean', 'min', 'max', 'std', 'median', 'q25', 'q75', 'skew']:
+                        row_features[f"{col}_{stat}"] = np.nan
+            
+            if missing_features:
+                logger.warning(f"Missing array features (will use NaN): {missing_features}")
+            
+            # Add scalar features directly (no statistics expansion)
+            for col in SCALAR_FEATURE_COLUMNS:
+                if col in raster_data:
+                    value = raster_data[col]
+                    if value == -9999 or value == -9999.0:
+                        row_features[col] = np.nan
+                    else:
+                        row_features[col] = value
+                else:
+                    row_features[col] = np.nan
+            
+            # Convert to DataFrame
+            df = pd.DataFrame([row_features])
+            
+            logger.debug(f"Prepared {len(df.columns)} features for binary classifiers (expected: 36x8 + 9 = 297)")
+            return df
+            
+        except Exception as e:
+            logger.error(f"Error preparing features for binary models: {e}")
+            raise
+    
+    def _compute_stats(self, arr: List[float]) -> Dict[str, float]:
+        """Compute 8 statistics from array with robust NaN handling"""
+        if not isinstance(arr, (list, np.ndarray)):
+            return {k: np.nan for k in ['mean', 'min', 'max', 'std', 'median', 'q25', 'q75', 'skew']}
+        
+        # Convert to numpy array and filter out NaN/None values
+        arr_clean = np.array([x for x in arr if pd.notna(x)], dtype=float)
+        
+        if len(arr_clean) == 0:
+            return {k: np.nan for k in ['mean', 'min', 'max', 'std', 'median', 'q25', 'q75', 'skew']}
+        
+        try:
+            return {
+                'mean': float(np.mean(arr_clean)),
+                'min': float(np.min(arr_clean)),
+                'max': float(np.max(arr_clean)),
+                'std': float(np.std(arr_clean)) if len(arr_clean) > 1 else 0.0,
+                'median': float(np.median(arr_clean)),
+                'q25': float(np.percentile(arr_clean, 25)),
+                'q75': float(np.percentile(arr_clean, 75)),
+                'skew': float(pd.Series(arr_clean).skew()) if len(arr_clean) > 2 else 0.0
+            }
+        except Exception as e:
+            logger.warning(f"Error computing stats: {e}")
+            return {k: np.nan for k in ['mean', 'min', 'max', 'std', 'median', 'q25', 'q75', 'skew']}
+    
+    def predict_disaster_types(self, weather_data: Dict[str, Any], feature_data: Dict[str, Any],
+                               raster_data: Dict[str, Any], lat: float, lon: float, reference_date: str) -> Dict[str, Any]:
+        """
+        Run all 4 binary classifiers to determine which disaster types are predicted
+        
+        Returns:
+            {
+                'disaster_types': ['Storm', 'Flood'],  # List of predicted disasters
+                'probabilities': {
+                    'Storm': 0.85,
+                    'Flood': 0.72,
+                    'Drought': 0.15,
+                    'Landslide': 0.08
+                },
+                'confidence': 'high'  # Based on probability scores
+            }
+        """
+        try:
+            if not self.models_loaded:
+                logger.warning("Models not loaded, loading now...")
+                if not self.load_models():
+                    raise Exception("Failed to load disaster type models")
+            
+            # Prepare features
+            logger.info("[DISASTER_TYPE] Preparing features for binary classifiers...")
+            features = self.prepare_features_for_binary_models(weather_data, feature_data, raster_data, lat, lon, reference_date)
+            
+            # Impute NaN values using SAME logic as training
+            # Training code: std/skew columns → 0, others → median
+            nan_count = features.isna().sum().sum()
+            if nan_count > 0:
+                logger.warning(f"[DISASTER_TYPE] Found {nan_count} NaN values, imputing with training logic...")
+                for col in features.columns:
+                    if features[col].isnull().sum() > 0:
+                        if 'std' in col or 'skew' in col:
+                            features[col] = features[col].fillna(0)
+                        else:
+                            features[col] = features[col].fillna(features[col].median())
+                
+                # Replace inf/-inf with NaN then fill with median
+                features = features.replace([np.inf, -np.inf], np.nan)
+                for col in features.columns:
+                    if features[col].isnull().sum() > 0:
+                        features[col] = features[col].fillna(features[col].median())
+                
+                # Final fallback: any remaining NaN → 0
+                features = features.fillna(0)
+                logger.info(f"[DISASTER_TYPE] Imputation complete, remaining NaNs: {features.isna().sum().sum()}")
+            
+            # Run all 4 binary classifiers
+            logger.info("[DISASTER_TYPE] Running binary disaster classifiers...")
+            predictions = {}
+            probabilities = {}
+            
+            for disaster_type, model_components in self.models.items():
+                try:
+                    # Each model is stored as dict with: selector, scaler, model
+                    selector = model_components['selector']
+                    scaler = model_components['scaler']
+                    model = model_components['model']
+                    
+                    # Apply pipeline steps manually: selector → scaler → model
+                    features_selected = selector.transform(features)
+                    features_scaled = scaler.transform(features_selected)
+                    
+                    # Predict using XGBoost model
+                    prediction = model.predict(features_scaled)[0]
+                    proba = model.predict_proba(features_scaled)[0]
+                    
+                    # Get probability for disaster class (index 1 typically)
+                    disaster_prob = proba[1] if len(proba) > 1 else proba[0]
+                    
+                    predictions[disaster_type] = prediction
+                    probabilities[disaster_type] = float(disaster_prob)
+                    
+                    logger.info(f"  [{disaster_type}] Prediction={prediction}, Probability={disaster_prob:.4f}")
+                    
+                except Exception as model_error:
+                    logger.error(f"Error predicting {disaster_type}: {model_error}")
+                    predictions[disaster_type] = 0
+                    probabilities[disaster_type] = 0.0
+            
+            # Determine which disasters are predicted (threshold: 0.5)
+            predicted_disasters = [dt for dt, pred in predictions.items() if pred == 1]
+            
+            # Calculate overall confidence
+            avg_prob = np.mean(list(probabilities.values()))
+            confidence = 'high' if avg_prob > 0.7 else 'medium' if avg_prob > 0.5 else 'low'
+            
+            result = {
+                'disaster_types': predicted_disasters,
+                'probabilities': probabilities,
+                'confidence': confidence,
+                'details': f"Detected {len(predicted_disasters)} disaster type(s)" if predicted_disasters else "No specific disaster type detected"
+            }
+            
+            logger.info(f"[DISASTER_TYPE] Predicted disasters: {predicted_disasters}")
+            return result
+            
+        except Exception as e:
+            logger.error(f"Error in disaster type prediction: {e}")
+            raise

server/models/feature_engineering_model.py

@@ -0,0 +1,444 @@
+"""
+Feature Engineering Model
+Handles weather feature engineering computations with proper NaN handling
+
+v3 FIX: Uses training-dataset global statistics for feature normalization
+       instead of per-window stats (which inflated disaster features for
+       normal weather, causing the model to always predict 'Disaster').
+"""
+import numpy as np
+import pandas as pd
+import json
+import os
+from typing import Dict, List, Optional, Any, Tuple
+from datetime import datetime
+import logging
+
+class WeatherFeatureModel:
+    """Model for weather feature engineering operations"""
+    
+    # Path to training-dataset global statistics
+    # These stats were computed across the ENTIRE training dataset (~123k rows × 60 days)
+    # and MUST be used for feature engineering to match the training distribution.
+    # Without them, per-window stats inflate disaster-related features for normal weather.
+    TRAINING_STATS_PATH = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)),
+        'hazardguard', 'shared', 'training_global_stats.json'
+    )
+    
+    # Cached training stats (loaded once)
+    _training_stats = None
+    
+    # Original 17 weather fields from NASA POWER
+    WEATHER_FIELDS = [
+        'temperature_C',
+        'humidity_perc',
+        'wind_speed_mps', 
+        'precipitation_mm',
+        'surface_pressure_hPa',
+        'solar_radiation_wm2',
+        'temperature_max_C',
+        'temperature_min_C',
+        'specific_humidity_g_kg',
+        'dew_point_C',
+        'wind_speed_10m_mps',
+        'cloud_amount_perc',
+        'sea_level_pressure_hPa',
+        'surface_soil_wetness_perc',
+        'wind_direction_10m_degrees',
+        'evapotranspiration_wm2',
+        'root_zone_soil_moisture_perc'
+    ]
+    
+    # 19 engineered features (excluding precip_intensity_mm_day as requested)
+    ENGINEERED_FEATURES = [
+        'temp_normalized',
+        'temp_range',
+        'discomfort_index',
+        'heat_index',
+        'wind_precip_interaction',
+        'solar_temp_ratio',
+        'pressure_anomaly',
+        'high_precip_flag',
+        'adjusted_humidity',
+        'wind_chill',
+        'solar_radiation_anomaly',
+        'weather_severity_score', 
+        'moisture_stress_index',
+        'evaporation_deficit',
+        'soil_saturation_index',
+        'atmospheric_instability',
+        'drought_indicator',
+        'flood_risk_score',
+        'storm_intensity_index'
+    ]
+    
+    # Feature descriptions for documentation
+    FEATURE_DESCRIPTIONS = {
+        'temp_normalized': 'Temperature normalized between min/max',
+        'temp_range': 'Diurnal temperature range (max - min)',
+        'discomfort_index': 'Temperature-Humidity Index (THI)',
+        'heat_index': 'Apparent temperature accounting for humidity',
+        'wind_precip_interaction': 'Wind speed × precipitation interaction',
+        'solar_temp_ratio': 'Solar radiation to temperature ratio',
+        'pressure_anomaly': 'Deviation from mean surface pressure',
+        'high_precip_flag': 'Binary flag for precipitation >50mm',
+        'adjusted_humidity': 'Humidity adjusted for temperature',
+        'wind_chill': 'Perceived temperature with wind effect',
+        'solar_radiation_anomaly': 'Deviation from mean solar radiation',
+        'weather_severity_score': 'Composite severity index (0-1)',
+        'moisture_stress_index': 'Evaporation vs precipitation stress',
+        'evaporation_deficit': 'Deviation from mean evapotranspiration',
+        'soil_saturation_index': 'Combined surface + root zone moisture',
+        'atmospheric_instability': 'Pressure difference + temperature range',
+        'drought_indicator': 'Low precip + high temp + low soil moisture',
+        'flood_risk_score': 'High precip + saturated soil + low evap',
+        'storm_intensity_index': 'Wind + precipitation + pressure drop'
+    }
+    
+    @classmethod
+    def validate_weather_data(cls, weather_data: Dict[str, List]) -> Dict[str, Any]:
+        """
+        Validate weather data for feature engineering
+        
+        Args:
+            weather_data: Dictionary with weather field lists
+            
+        Returns:
+            Validation results
+        """
+        errors = []
+        warnings = []
+        
+        # Check required fields
+        missing_fields = set(cls.WEATHER_FIELDS) - set(weather_data.keys())
+        if missing_fields:
+            errors.append(f"Missing required weather fields: {missing_fields}")
+        
+        # Check list lengths and data quality
+        days_count = None
+        for field, values in weather_data.items():
+            if not isinstance(values, list):
+                errors.append(f"Field {field} must be a list, got {type(values)}")
+                continue
+                
+            if days_count is None:
+                days_count = len(values)
+            elif len(values) != days_count:
+                warnings.append(f"Field {field} has {len(values)} values, expected {days_count}")
+        
+        # Check for all NaN lists
+        for field, values in weather_data.items():
+            if isinstance(values, list):
+                valid_count = sum(1 for v in values if v is not None and not np.isnan(float(v)) if v != -999)
+                if valid_count == 0:
+                    warnings.append(f"Field {field} contains only NaN/missing values")
+        
+        return {
+            'valid': len(errors) == 0,
+            'errors': errors,
+            'warnings': warnings,
+            'days_count': days_count,
+            'field_count': len(weather_data)
+        }
+    
+    @classmethod
+    def load_training_stats(cls) -> Dict[str, float]:
+        """
+        Load global statistics from the training dataset.
+        
+        These stats were pre-computed across the ENTIRE training dataset
+        (~123k rows × 60 days = ~7.4M data points per weather variable).
+        Using per-window stats instead leads to feature scale mismatch:
+        e.g., precip_max=994mm (training) vs precip_max=10mm (single window)
+        which inflates disaster features 100x and causes false positives.
+        
+        Returns:
+            Dictionary of training-dataset global statistics
+        """
+        logger = logging.getLogger(__name__)
+        
+        # Return cached stats if already loaded
+        if cls._training_stats is not None:
+            return cls._training_stats
+        
+        # Try loading from JSON file
+        stats_path = cls.TRAINING_STATS_PATH
+        if os.path.exists(stats_path):
+            try:
+                with open(stats_path, 'r') as f:
+                    loaded = json.load(f)
+                cls._training_stats = {
+                    'temp_min': loaded.get('temp_min', -53.76),
+                    'temp_max': loaded.get('temp_max', 44.18),
+                    'temp_mean': loaded.get('temp_mean', 21.5325),
+                    'temp_max_mean': loaded.get('temp_max_mean', 25.7065),
+                    'pressure_mean': loaded.get('pressure_mean', 93.7966),
+                    'sea_pressure_mean': loaded.get('sea_pressure_mean', 101.0376),
+                    'solar_mean': loaded.get('solar_mean', 4.9125),
+                    'precip_max': max(loaded.get('precip_max', 994.16), 1),
+                    'wind_max': max(loaded.get('wind_max', 25.32), 1),
+                    'evap_mean': loaded.get('evap_mean', 0.5756),
+                }
+                logger.info(f"[STATS] Loaded training global stats from {stats_path}")
+                logger.info(f"   precip_max={cls._training_stats['precip_max']}, "
+                           f"wind_max={cls._training_stats['wind_max']}, "
+                           f"temp_range=[{cls._training_stats['temp_min']}, {cls._training_stats['temp_max']}]")
+                return cls._training_stats
+            except Exception as e:
+                logger.error(f"[STATS] Error loading training stats: {e}")
+        else:
+            logger.warning(f"[STATS] Training stats file not found: {stats_path}")
+        
+        # Fallback: hardcoded values from actual training dataset computation
+        # (computed from VALIDATED_LAT-LONG_CLEAN_DEDUPLICATED.xlsx, 123143 rows)
+        logger.warning("[STATS] Using hardcoded fallback training stats")
+        cls._training_stats = {
+            'temp_min': -53.76,
+            'temp_max': 44.18,
+            'temp_mean': 21.5325,
+            'temp_max_mean': 25.7065,
+            'pressure_mean': 93.7966,
+            'sea_pressure_mean': 101.0376,
+            'solar_mean': 4.9125,
+            'precip_max': 994.16,
+            'wind_max': 25.32,
+            'evap_mean': 0.5756,
+        }
+        return cls._training_stats
+    
+    @classmethod
+    def compute_global_stats(cls, weather_data: Dict[str, List]) -> Dict[str, float]:
+        """
+        Return global statistics for feature engineering.
+        
+        FIXED (v3): Now returns training-dataset stats instead of computing
+        per-window stats. The per-window approach inflated disaster features
+        for normal weather (e.g., precip/precip_max_window ≈ 1.0 vs
+        precip/precip_max_training ≈ 0.01) causing 100% disaster predictions.
+        
+        Args:
+            weather_data: Weather data dictionary (ignored — uses training stats)
+            
+        Returns:
+            Dictionary of global statistics from training dataset
+        """
+        return cls.load_training_stats()
+    
+    @classmethod
+    def safe_float(cls, value, default=np.nan):
+        """Safely convert value to float, return default for NaN/invalid values"""
+        if value is None or value == -999:
+            return default
+        try:
+            float_val = float(value)
+            return float_val if not np.isnan(float_val) else default
+        except (ValueError, TypeError):
+            return default
+    
+    @classmethod
+    def compute_engineered_features(cls, weather_data: Dict[str, List], 
+                                  event_duration: float = 1.0) -> Dict[str, List[float]]:
+        """
+        Compute all engineered features from weather data
+        
+        Args:
+            weather_data: Dictionary with weather field lists (60 days each)
+            event_duration: Duration of event in days for intensity calculations
+            
+        Returns:
+            Dictionary with engineered feature lists
+        """
+        # Validate data
+        validation = cls.validate_weather_data(weather_data)
+        if not validation['valid']:
+            raise ValueError(f"Invalid weather data: {validation['errors']}")
+        
+        days_count = validation['days_count']
+        if days_count is None or days_count == 0:
+            raise ValueError("No weather data provided")
+        
+        # Compute global statistics
+        stats = cls.compute_global_stats(weather_data)
+        
+        # Initialize feature lists
+        features = {feature: [] for feature in cls.ENGINEERED_FEATURES}
+        
+        # Process each day
+        for day_idx in range(days_count):
+            # Extract daily values with safe conversion
+            temp = cls.safe_float(weather_data.get('temperature_C', [None] * days_count)[day_idx])
+            temp_max = cls.safe_float(weather_data.get('temperature_max_C', [None] * days_count)[day_idx])
+            temp_min = cls.safe_float(weather_data.get('temperature_min_C', [None] * days_count)[day_idx])
+            humidity = cls.safe_float(weather_data.get('humidity_perc', [None] * days_count)[day_idx])
+            spec_humidity = cls.safe_float(weather_data.get('specific_humidity_g_kg', [None] * days_count)[day_idx])
+            dew_point = cls.safe_float(weather_data.get('dew_point_C', [None] * days_count)[day_idx])
+            wind = cls.safe_float(weather_data.get('wind_speed_mps', [None] * days_count)[day_idx])
+            wind_10m = cls.safe_float(weather_data.get('wind_speed_10m_mps', [None] * days_count)[day_idx])
+            precip = cls.safe_float(weather_data.get('precipitation_mm', [None] * days_count)[day_idx])
+            pressure = cls.safe_float(weather_data.get('surface_pressure_hPa', [None] * days_count)[day_idx])
+            sea_pressure = cls.safe_float(weather_data.get('sea_level_pressure_hPa', [None] * days_count)[day_idx])
+            solar = cls.safe_float(weather_data.get('solar_radiation_wm2', [None] * days_count)[day_idx])
+            cloud = cls.safe_float(weather_data.get('cloud_amount_perc', [None] * days_count)[day_idx])
+            soil_wetness = cls.safe_float(weather_data.get('surface_soil_wetness_perc', [None] * days_count)[day_idx])
+            wind_dir = cls.safe_float(weather_data.get('wind_direction_10m_degrees', [None] * days_count)[day_idx])
+            evap = cls.safe_float(weather_data.get('evapotranspiration_wm2', [None] * days_count)[day_idx])
+            root_moisture = cls.safe_float(weather_data.get('root_zone_soil_moisture_perc', [None] * days_count)[day_idx])
+            
+            # Compute engineered features with NaN handling
+            feature_values = cls._compute_daily_features(
+                temp, temp_max, temp_min, humidity, spec_humidity, dew_point,
+                wind, wind_10m, precip, pressure, sea_pressure, solar, cloud,
+                soil_wetness, wind_dir, evap, root_moisture, event_duration, stats
+            )
+            
+            # Add computed values to feature lists
+            for feature_name, value in zip(cls.ENGINEERED_FEATURES, feature_values):
+                features[feature_name].append(value)
+        
+        return features
+    
+    @classmethod 
+    def _compute_daily_features(cls, temp, temp_max, temp_min, humidity, spec_humidity,
+                              dew_point, wind, wind_10m, precip, pressure, sea_pressure,
+                              solar, cloud, soil_wetness, wind_dir, evap, root_moisture,
+                              event_duration, stats):
+        """Compute engineered features for a single day with proper NaN handling.
+        
+        FIXED (v3): temp_normalized now uses daily T2M_MIN/T2M_MAX (matching
+        step7 training pipeline where loop variables shadow global ones).
+        drought_indicator also uses daily temp_max (same shadowing effect).
+        """
+        
+        def safe_calc(func, *args, default=np.nan):
+            """Safely execute calculation, return NaN if any input is NaN"""
+            try:
+                if any(np.isnan(arg) if isinstance(arg, (int, float)) else False for arg in args):
+                    return default
+                return func(*args)
+            except (ZeroDivisionError, ValueError, TypeError):
+                return default
+        
+        # 1. Temperature Normalization
+        # FIXED: Uses daily T2M_MIN and T2M_MAX (not global min/max of T2M)
+        # In step7, the loop variables `temp_min` and `temp_max` shadow the globals,
+        # so temp_normalized = (T2M - T2M_MIN_daily) / (T2M_MAX_daily - T2M_MIN_daily)
+        temp_normalized = safe_calc(
+            lambda: (temp - temp_min) / (temp_max - temp_min) 
+            if temp_max != temp_min else 0
+        )
+        
+        # 2. Temperature Range (diurnal)
+        temp_range = safe_calc(lambda: temp_max - temp_min)
+        
+        # 3. Discomfort Index (THI)
+        discomfort_index = safe_calc(
+            lambda: temp - 0.55 * (1 - 0.01 * humidity) * (temp - 14.5)
+        )
+        
+        # 4. Heat Index
+        heat_index = safe_calc(lambda: cls._calculate_heat_index(temp, humidity))
+        
+        # 5. Wind-Precipitation Interaction
+        wind_precip_interaction = safe_calc(lambda: wind * precip)
+        
+        # 6. Solar Radiation to Temperature Ratio
+        solar_temp_ratio = safe_calc(
+            lambda: solar / (abs(temp) + 0.01) if abs(temp) + 0.01 > 1e-6 else 0
+        )
+        
+        # 7. Pressure Anomaly (surface)
+        pressure_anomaly = safe_calc(lambda: pressure - stats['pressure_mean'])
+        
+        # 8. High Precipitation Flag (>50mm threshold)
+        high_precip_flag = safe_calc(lambda: int(precip > 50))
+        
+        # 9. Relative Humidity Adjusted for Temperature
+        adjusted_humidity = safe_calc(lambda: humidity * (1 + (temp / 100)))
+        
+        # 10. Wind Chill Index
+        wind_chill = safe_calc(lambda: cls._calculate_wind_chill(temp, wind))
+        
+        # 11. Solar Radiation Anomaly
+        solar_anomaly = safe_calc(lambda: solar - stats['solar_mean'])
+        
+        # 12. Weather Severity Score (composite)
+        weather_severity = safe_calc(lambda: (
+            (temp_normalized if not np.isnan(temp_normalized) else 0) + 
+            (precip / stats['precip_max'] if stats['precip_max'] != 0 else 0) + 
+            (wind / stats['wind_max'] if stats['wind_max'] != 0 else 0) +
+            (cloud / 100 if not np.isnan(cloud) else 0)
+        ) / 4)
+        
+        # 13. Moisture Stress Index (evaporation vs precipitation)
+        moisture_stress = safe_calc(
+            lambda: (evap - precip) / (evap + precip + 0.01)
+        )
+        
+        # 14. Evaporation Deficit
+        evap_deficit = safe_calc(lambda: evap - stats['evap_mean'])
+        
+        # 15. Soil Saturation Index (combined soil moisture)
+        soil_saturation = safe_calc(lambda: (soil_wetness + root_moisture) / 2)
+        
+        # 16. Atmospheric Instability (pressure difference + temp range)
+        atm_instability = safe_calc(
+            lambda: abs(sea_pressure - pressure) + (temp_range if not np.isnan(temp_range) else 0)
+        )
+        
+        # 17. Drought Indicator (low precip + high temp + low soil moisture)
+        # FIXED: Uses daily temp_max (T2M_MAX) not global stats['temp_max']
+        # In step7, variable shadowing means the per-day T2M_MAX is used here
+        drought_indicator = safe_calc(lambda: (
+            (1 - precip / stats['precip_max']) * 
+            ((temp - stats['temp_mean']) / max(abs(temp_max - stats['temp_mean']), 1)) * 
+            (1 - (soil_saturation if not np.isnan(soil_saturation) else 0) / 100)
+        ))
+        
+        # 18. Flood Risk Score (high precip + saturated soil + low evap)
+        flood_risk = safe_calc(lambda: (
+            (precip / stats['precip_max']) * 
+            ((soil_saturation if not np.isnan(soil_saturation) else 0) / 100) * 
+            (1 - evap / max(stats['evap_mean'] * 2, 1))
+        ))
+        
+        # 19. Storm Intensity Index (wind + precip + pressure drop)  
+        storm_intensity = safe_calc(lambda: (
+            (wind_10m / stats['wind_max']) + 
+            (precip / stats['precip_max']) + 
+            (abs(pressure_anomaly if not np.isnan(pressure_anomaly) else 0) / 50)
+        ))
+        
+        return [
+            temp_normalized, temp_range, discomfort_index, heat_index,
+            wind_precip_interaction, solar_temp_ratio, pressure_anomaly,
+            high_precip_flag, adjusted_humidity, wind_chill, solar_anomaly,
+            weather_severity, moisture_stress, evap_deficit, soil_saturation,
+            atm_instability, drought_indicator, flood_risk, storm_intensity
+        ]
+    
+    @staticmethod
+    def _calculate_heat_index(temp, humidity):
+        """Calculate heat index with NaN handling"""
+        if np.isnan(temp) or np.isnan(humidity):
+            return np.nan
+            
+        if temp >= 27 and humidity >= 40:
+            return (-8.78469475556 + 1.61139411 * temp + 2.33854883889 * humidity +
+                   -0.14611605 * temp * humidity + -0.012308094 * temp**2 +
+                   -0.0164248277778 * humidity**2 + 0.002211732 * temp**2 * humidity +
+                   0.00072546 * temp * humidity**2 + -0.000003582 * temp**2 * humidity**2)
+        else:
+            return temp
+    
+    @staticmethod
+    def _calculate_wind_chill(temp, wind):
+        """Calculate wind chill with NaN handling"""
+        if np.isnan(temp) or np.isnan(wind):
+            return np.nan
+            
+        if temp <= 10 and wind > 0:
+            return (13.12 + 0.6215 * temp - 11.37 * np.power(wind, 0.16) + 
+                   0.3965 * temp * np.power(wind, 0.16))
+        else:
+            return temp

server/models/geovision_fusion_model.py

@@ -0,0 +1,736 @@
+"""
+GeoVision Fusion Prediction Model
+===================================
+Cross-stacked ensemble fusion pipeline that combines:
+  1. LSTM MIMO model  → disaster probs (5), weather probs (5), temporal embeddings (128)
+  2. Tree Ensemble    → disaster probs (5)  [RF + XGB + ET + LGBM + CB]
+  3. CNN ResNet50     → disaster probs (5)  [OPTIONAL — requires satellite imagery]
+  4. Fusion Meta-Learner → final disaster prediction + weather regime prediction
+
+Output classes:
+  Disaster: ['Drought', 'Flood', 'Landslide', 'Normal', 'Storm']  (alphabetical LabelEncoder order)
+  Weather:  ['Cloudy', 'Dry', 'Humid', 'Rainy', 'Stormy']        (alphabetical LabelEncoder order)
+
+The fusion meta-learner builds a feature vector by concatenating the intermediate
+probability outputs and embeddings, then feeds it through an XGBoost/CatBoost/LogReg
+meta-learner trained via 5-fold cross-validated stacking.
+"""
+
+import os
+import sys
+import json
+import logging
+import numpy as np
+import pandas as pd
+import joblib
+from typing import Dict, List, Optional, Any, Tuple
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# ════════════════════════════════════════════════════════════════════
+# CONSTANTS (matching training scripts exactly)
+# ════════════════════════════════════════════════════════════════════
+MASK_VALUE = -999.0
+SEQUENCE_LENGTH = 60
+EMBEDDING_DIM = 128
+HORIZON = 1
+FORECAST_DAYS = SEQUENCE_LENGTH - HORIZON  # 59
+
+DISASTER_CLASSES = ['Drought', 'Flood', 'Landslide', 'Normal', 'Storm']  # Alphabetical (LabelEncoder)
+WEATHER_REGIMES  = ['Cloudy', 'Dry', 'Humid', 'Rainy', 'Stormy']        # Alphabetical (LabelEncoder)
+
+# Note: The fusion training script uses ['Normal','Flood','Storm','Drought','Landslide']
+# but the LabelEncoder produces alphabetical order. The inference pipeline uses
+# DISASTER_CLASSES = ['Normal','Flood','Storm','Drought','Landslide'] for display
+# but internally the model predicts indices 0-4 in alphabetical order.
+# We follow the alphabetical order as the ground truth from the LabelEncoder.
+
+# 36 temporal features (17 raw meteorological + 19 engineered)
+INPUT_FEATURES = [
+    'temperature_C', 'humidity_%', 'wind_speed_mps', 'precipitation_mm',
+    'surface_pressure_hPa', 'solar_radiation_wm2', 'temperature_max_C', 'temperature_min_C',
+    'specific_humidity_g_kg', 'dew_point_C', 'wind_speed_10m_mps', 'cloud_amount_%',
+    'sea_level_pressure_hPa', 'surface_soil_wetness_%', 'wind_direction_10m_degrees',
+    'evapotranspiration_wm2', 'root_zone_soil_moisture_%',
+    'temp_normalized', 'temp_range', 'discomfort_index', 'heat_index',
+    'wind_precip_interaction', 'solar_temp_ratio', 'pressure_anomaly',
+    'high_precip_flag', 'adjusted_humidity', 'wind_chill',
+    'solar_radiation_anomaly', 'weather_severity_score',
+    'moisture_stress_index', 'evaporation_deficit', 'soil_saturation_index',
+    'atmospheric_instability', 'drought_indicator', 'flood_risk_score', 'storm_intensity_index'
+]
+
+# 9 scalar/raster features
+SCALAR_FEATURE_COLUMNS = [
+    'soil_type', 'elevation_m', 'pop_density_persqkm', 'land_cover_class',
+    'ndvi', 'annual_precip_mm', 'annual_mean_temp_c', 'mean_wind_speed_ms',
+    'impervious_surface_pct'
+]
+
+# Statistics computed per array feature for the tree ensemble
+STAT_NAMES = ['mean', 'std', 'min', 'max', 'median', 'q25', 'q75', 'skew']
+
+
+class GeoVisionFusionModel:
+    """
+    Multi-model fusion prediction engine for GeoVision.
+    Loads 4 model groups and runs the full inference pipeline:
+      LSTM MIMO → Tree Ensemble → (CNN optional) → Fusion Meta-Learner
+    """
+
+    def __init__(self):
+        """Initialize GeoVision fusion model."""
+        model_root = os.getenv('MODEL_ROOT_PATH', '').strip()
+        if model_root:
+            self.MODEL_BASE_DIR = os.path.join(os.path.abspath(model_root), 'geovision')
+        else:
+            self.MODEL_BASE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'geovision')
+
+        # Model directories
+        self.LSTM_DIR     = os.path.join(self.MODEL_BASE_DIR, "lstm")
+        self.ENSEMBLE_DIR = os.path.join(self.MODEL_BASE_DIR, "ensemble")
+        self.CNN_DIR      = os.path.join(self.MODEL_BASE_DIR, "cnn")
+        self.FUSION_DIR   = os.path.join(self.MODEL_BASE_DIR, "fusion")
+
+        # Model components (loaded on demand)
+        self.lstm_model = None
+        self.lstm_embedding_model = None
+        self.lstm_input_scaler = None
+
+        self.ensemble_pipeline = None
+
+        self.cnn_model = None
+
+        self.fusion_disaster_model = None
+        self.fusion_disaster_scaler = None
+        self.fusion_weather_model = None
+        self.fusion_weather_scaler = None
+        self.fusion_feature_map = None
+
+        self.models_loaded = False
+        self._load_status = {}
+
+        logger.info("[GEOVISION] Fusion model initialized")
+
+    # ────────────────────────────────────────────────────────────────
+    # MODEL LOADING
+    # ────────────────────────────────────────────────────────────────
+    def load_models(self) -> bool:
+        """Load all upstream models and fusion meta-learners."""
+        logger.info("[GEOVISION] ===========================================")
+        logger.info("[GEOVISION]   LOADING FUSION PIPELINE MODELS")
+        logger.info("[GEOVISION] ===========================================")
+
+        success_count = 0
+        total_models = 4
+
+        # ── 1. LSTM MIMO ──
+        success_count += self._load_lstm()
+        # ── 2. Tree Ensemble ──
+        success_count += self._load_ensemble()
+        # ── 3. CNN ResNet50 (optional) ──
+        success_count += self._load_cnn()
+        # ── 4. Fusion Meta-Learners ──
+        success_count += self._load_fusion()
+
+        self.models_loaded = success_count >= 2  # Need at least LSTM + fusion
+        logger.info(f"[GEOVISION] Models loaded: {success_count}/{total_models}")
+        logger.info(f"[GEOVISION] Pipeline ready: {self.models_loaded}")
+        return self.models_loaded
+
+    def _load_lstm(self) -> int:
+        """Load LSTM MIMO model + embedding extractor + scaler."""
+        logger.info("[GEOVISION]   [1/4] Loading LSTM MIMO Model...")
+        model_path = os.path.join(self.LSTM_DIR, 'temporal_lstm_mimo_model.keras')
+
+        if not os.path.exists(model_path):
+            logger.warning(f"[GEOVISION]   NOT FOUND: {model_path}")
+            self._load_status['lstm'] = 'not_found'
+            return 0
+
+        try:
+            import tensorflow as tf
+
+            # Define TemporalAttentionPooling inline (avoids import dependency)
+            class TemporalAttentionPooling(tf.keras.layers.Layer):
+                def __init__(self, units=64, **kwargs):
+                    super().__init__(**kwargs)
+                    self.units = units
+                def build(self, input_shape):
+                    feature_dim = input_shape[-1]
+                    self.W = self.add_weight('attention_W', (feature_dim, self.units), initializer='glorot_uniform')
+                    self.b = self.add_weight('attention_b', (self.units,), initializer='zeros')
+                    self.u = self.add_weight('attention_u', (self.units, 1), initializer='glorot_uniform')
+                def call(self, inputs):
+                    score = tf.nn.tanh(tf.tensordot(inputs, self.W, axes=[[2], [0]]) + self.b)
+                    attn = tf.nn.softmax(tf.tensordot(score, self.u, axes=[[2], [0]]), axis=1)
+                    return tf.reduce_sum(inputs * attn, axis=1)
+                def get_config(self):
+                    config = super().get_config()
+                    config.update({'units': self.units})
+                    return config
+
+            custom_objects = {'TemporalAttentionPooling': TemporalAttentionPooling}
+            self.lstm_model = tf.keras.models.load_model(model_path, custom_objects=custom_objects)
+
+            # Create embedding extractor from the temporal_embedding layer
+            self.lstm_embedding_model = tf.keras.Model(
+                inputs=self.lstm_model.input,
+                outputs=self.lstm_model.get_layer('temporal_embedding').output
+            )
+            logger.info(f"[GEOVISION]     [OK] LSTM model loaded")
+
+        except Exception as e:
+            logger.error(f"[GEOVISION]     [FAIL] LSTM model FAILED: {e}")
+            self._load_status['lstm'] = f'error: {e}'
+            return 0
+
+        # Load LSTM input scaler
+        scaler_path = os.path.join(self.LSTM_DIR, 'input_scaler.joblib')
+        if os.path.exists(scaler_path):
+            self.lstm_input_scaler = joblib.load(scaler_path)
+            logger.info(f"[GEOVISION]     [OK] LSTM input scaler loaded")
+
+        self._load_status['lstm'] = 'loaded'
+        return 1
+
+    def _load_ensemble(self) -> int:
+        """Load tree ensemble pipeline (5 models + scaler + selector)."""
+        logger.info("[GEOVISION]   [2/4] Loading Tree Ensemble Pipeline...")
+        pipeline_path = os.path.join(self.ENSEMBLE_DIR, 'ensemble_5class_pipeline.joblib')
+
+        if not os.path.exists(pipeline_path):
+            logger.warning(f"[GEOVISION]   NOT FOUND: {pipeline_path}")
+            self._load_status['ensemble'] = 'not_found'
+            return 0
+
+        try:
+            self.ensemble_pipeline = joblib.load(pipeline_path)
+            models = self.ensemble_pipeline.get('models', {})
+            logger.info(f"[GEOVISION]     [OK] Ensemble loaded: {list(models.keys())}")
+            self._load_status['ensemble'] = 'loaded'
+            return 1
+        except Exception as e:
+            logger.error(f"[GEOVISION]     [FAIL] Ensemble FAILED: {e}")
+            self._load_status['ensemble'] = f'error: {e}'
+            return 0
+
+    def _load_cnn(self) -> int:
+        """Load CNN ResNet50 model (optional — used only with satellite imagery)."""
+        logger.info("[GEOVISION]   [3/4] Loading CNN ResNet50 (optional)...")
+
+        for name in ['best_resnet_finetuned.keras', 'best_resnet_model.keras', 'final_model.keras']:
+            cnn_path = os.path.join(self.CNN_DIR, name)
+            if os.path.exists(cnn_path):
+                try:
+                    import tensorflow as tf
+                    self.cnn_model = tf.keras.models.load_model(cnn_path)
+                    logger.info(f"[GEOVISION]     [OK] CNN loaded: {name}")
+                    logger.info(f"[GEOVISION]     CNN input shape: {self.cnn_model.input_shape}")
+                    self._load_status['cnn'] = 'loaded'
+                    return 1
+                except Exception as e:
+                    logger.warning(f"[GEOVISION]     CNN {name} failed: {e}")
+
+        logger.info("[GEOVISION]     CNN not loaded (satellite imagery needed at inference time)")
+        self._load_status['cnn'] = 'skipped'
+        return 0
+
+    def _load_fusion(self) -> int:
+        """Load fusion meta-learner models (disaster + weather heads)."""
+        logger.info("[GEOVISION]   [4/4] Loading Fusion Meta-Learners...")
+        loaded = 0
+
+        # Disaster fusion
+        dis_path = os.path.join(self.FUSION_DIR, 'fusion_disaster_model.pkl')
+        if os.path.exists(dis_path):
+            try:
+                pkg = joblib.load(dis_path)
+                self.fusion_disaster_model = pkg['model']
+                self.fusion_disaster_scaler = pkg.get('scaler', None)
+                logger.info(f"[GEOVISION]     [OK] Disaster fusion ({pkg.get('model_name', '?')})")
+                loaded += 1
+            except Exception as e:
+                logger.error(f"[GEOVISION]     [FAIL] Disaster fusion FAILED: {e}")
+
+        # Weather fusion
+        wx_path = os.path.join(self.FUSION_DIR, 'fusion_weather_model.pkl')
+        if os.path.exists(wx_path):
+            try:
+                pkg = joblib.load(wx_path)
+                self.fusion_weather_model = pkg['model']
+                self.fusion_weather_scaler = pkg.get('scaler', None)
+                logger.info(f"[GEOVISION]     [OK] Weather fusion ({pkg.get('model_name', '?')})")
+                loaded += 1
+            except Exception as e:
+                logger.error(f"[GEOVISION]     [FAIL] Weather fusion FAILED: {e}")
+
+        # Feature map
+        fmap_path = os.path.join(self.FUSION_DIR, 'fusion_feature_map.json')
+        if os.path.exists(fmap_path):
+            try:
+                with open(fmap_path, 'r', encoding='utf-8') as f:
+                    fmap_text = f.read()
+                if fmap_text.lstrip().startswith('version https://git-lfs.github.com/spec/v1'):
+                    logger.warning("[GEOVISION]     fusion_feature_map.json is a Git LFS pointer; continuing without feature map")
+                    self.fusion_feature_map = None
+                else:
+                    self.fusion_feature_map = json.loads(fmap_text)
+            except Exception as e:
+                logger.warning(f"[GEOVISION]     fusion_feature_map.json invalid: {e}; continuing without feature map")
+                self.fusion_feature_map = None
+
+        self._load_status['fusion'] = 'loaded' if loaded == 2 else f'partial ({loaded}/2)'
+        return 1 if loaded >= 1 else 0
+
+    # ────────────────────────────────────────────────────────────────
+    # LSTM PROCESSING
+    # ────────────────────────────────────────────────────────────────
+    def _process_lstm(self, weather_data: Dict[str, Any],
+                      feature_data: Dict[str, Any]) -> Tuple[
+                          Optional[np.ndarray], Optional[np.ndarray],
+                          Optional[np.ndarray], Optional[np.ndarray]]:
+        """
+        Process weather time-series through LSTM MIMO.
+        
+        Returns (disaster_probs, weather_probs, embeddings, forecast) or all None.
+        """
+        if self.lstm_model is None:
+            logger.warning("[GEOVISION] LSTM not loaded — skipping")
+            return None, None, None, None
+
+        logger.info("[GEOVISION]   STEP 1: LSTM MIMO processing...")
+
+        # Build temporal sequence: (1, 60, 36)
+        x_sample = []
+        matched_features = []
+        missing_features = []
+        for feature_name in INPUT_FEATURES:
+            seq = None
+            # Try weather_data first, then feature_data
+            for source in [weather_data, feature_data]:
+                if feature_name in source and isinstance(source[feature_name], list):
+                    raw = source[feature_name]
+                    arr = np.array(raw, dtype=float)
+                    # Pad or truncate to SEQUENCE_LENGTH
+                    if len(arr) < SEQUENCE_LENGTH:
+                        padded = np.full(SEQUENCE_LENGTH, np.nan)
+                        padded[:len(arr)] = arr
+                        seq = padded
+                    else:
+                        seq = arr[:SEQUENCE_LENGTH]
+                    break
+            if seq is None:
+                seq = np.full(SEQUENCE_LENGTH, np.nan)
+                missing_features.append(feature_name)
+            else:
+                matched_features.append(feature_name)
+            x_sample.append(seq)
+
+        logger.info(f"[GEOVISION]     LSTM features matched: {len(matched_features)}/{len(INPUT_FEATURES)}")
+        if missing_features:
+            logger.warning(f"[GEOVISION]     LSTM missing features ({len(missing_features)}): {missing_features[:10]}")
+
+        X = np.array(x_sample).T  # (60, 36)
+        X = X.reshape(1, SEQUENCE_LENGTH, len(INPUT_FEATURES))  # (1, 60, 36)
+
+        # Normalize with saved scaler
+        if self.lstm_input_scaler is not None:
+            X_means = np.nanmean(X, axis=(0, 1))
+            X_filled = np.where(np.isnan(X), X_means, X)
+            X_reshaped = X_filled.reshape(-1, X_filled.shape[-1])
+            X_scaled = self.lstm_input_scaler.transform(X_reshaped)
+            X_scaled = X_scaled.reshape(X.shape)
+            X_scaled = np.where(np.isnan(X), MASK_VALUE, X_scaled)
+        else:
+            X_scaled = np.nan_to_num(X, nan=MASK_VALUE)
+
+        # Predict
+        disaster_probs, weather_probs, forecast = self.lstm_model.predict(X_scaled, verbose=0)
+        embeddings = self.lstm_embedding_model.predict(X_scaled, verbose=0)
+
+        logger.info(f"[GEOVISION]     LSTM disaster probs: {disaster_probs.shape}")
+        logger.info(f"[GEOVISION]     LSTM embeddings: {embeddings.shape}")
+
+        return disaster_probs, weather_probs, embeddings, forecast
+
+    # ────────────────────────────────────────────────────────────────
+    # TREE ENSEMBLE PROCESSING
+    # ────────────────────────────────────────────────────────────────
+    def _compute_stats(self, arr: np.ndarray) -> List[float]:
+        """Compute 8 summary statistics matching the ensemble training script."""
+        arr = np.array(arr, dtype=float)
+        arr = arr[~np.isnan(arr)]
+        if len(arr) == 0:
+            return [0.0] * 8
+        # Compute skewness manually to avoid scipy dependency
+        m = float(np.mean(arr))
+        s = float(np.std(arr))
+        skewness = float(np.mean(((arr - m) / s) ** 3)) if s > 0 else 0.0
+        return [
+            m,
+            s,
+            float(np.min(arr)),
+            float(np.max(arr)),
+            float(np.median(arr)),
+            float(np.percentile(arr, 25)),
+            float(np.percentile(arr, 75)),
+            skewness
+        ]
+
+    def _process_ensemble(self, weather_data: Dict[str, Any],
+                          feature_data: Dict[str, Any],
+                          raster_data: Dict[str, float]) -> Optional[np.ndarray]:
+        """
+        Process tabular features through tree ensemble.
+        Returns ensemble_probs (1, 5) or None.
+        """
+        if self.ensemble_pipeline is None:
+            logger.warning("[GEOVISION] Ensemble not loaded — skipping")
+            return None
+
+        logger.info("[GEOVISION]   STEP 2: Tree Ensemble processing...")
+
+        models = self.ensemble_pipeline.get('models', {})
+        scaler = self.ensemble_pipeline.get('scaler', None)
+        selector = self.ensemble_pipeline.get('selector', None)
+        imputation_values = self.ensemble_pipeline.get('imputation_values', {})
+        horizon = self.ensemble_pipeline.get('horizon', HORIZON)
+
+        # Build tabular features: 36 arrays × 8 stats + 9 scalar = ~297
+        row_data = {}
+        for col in INPUT_FEATURES:
+            raw = None
+            for source in [weather_data, feature_data]:
+                if col in source and isinstance(source[col], list):
+                    raw = np.array(source[col], dtype=float)
+                    break
+            if raw is not None:
+                arr_trimmed = raw[:SEQUENCE_LENGTH - horizon]  # First 59 days
+                stats = self._compute_stats(arr_trimmed)
+            else:
+                stats = [0.0] * 8
+            for s_name, s_val in zip(STAT_NAMES, stats):
+                row_data[f'{col}_{s_name}'] = s_val
+
+        # Add scalar/raster features
+        for col in SCALAR_FEATURE_COLUMNS:
+            val = raster_data.get(col, 0.0)
+            if val is None or (isinstance(val, float) and np.isnan(val)):
+                val = 0.0
+            if val == -9999 or val == -9999.0:
+                val = 0.0
+            row_data[col] = float(val)
+
+        X_df = pd.DataFrame([row_data])
+
+        # Impute
+        for col, imp_val in imputation_values.items():
+            if col in X_df.columns:
+                X_df[col] = X_df[col].fillna(imp_val)
+        X_df = X_df.fillna(0.0).replace([np.inf, -np.inf], 0.0)
+
+        # Feature selection — reorder columns to match selector's training order
+        if selector is not None:
+            try:
+                # Reorder X_df columns to match the selector's expected feature order
+                expected_cols = list(selector.feature_names_in_)
+                # Add any missing columns with 0.0
+                for c in expected_cols:
+                    if c not in X_df.columns:
+                        X_df[c] = 0.0
+                X_df = X_df[expected_cols]
+                X_selected = selector.transform(X_df)
+                logger.info(f"[GEOVISION]     Feature selection OK: {X_df.shape[1]} -> {X_selected.shape[1]}")
+            except Exception as e:
+                logger.warning(f"[GEOVISION]     Feature selection error: {e}, using raw")
+                X_selected = X_df.values
+        else:
+            X_selected = X_df.values
+
+        # Scale
+        if scaler is not None:
+            try:
+                X_scaled = scaler.transform(X_selected)
+            except Exception:
+                X_scaled = X_selected
+        else:
+            X_scaled = X_selected
+
+        # Average probabilities across ensemble models
+        all_probas = []
+        for model_name, model in models.items():
+            try:
+                proba = model.predict_proba(X_scaled)
+                all_probas.append(proba)
+            except Exception as e:
+                logger.warning(f"[GEOVISION]     {model_name} failed: {e}")
+
+        if not all_probas:
+            return None
+
+        ensemble_probs = np.mean(all_probas, axis=0)
+        logger.info(f"[GEOVISION]     Ensemble probs: {ensemble_probs.shape} ({len(all_probas)} models)")
+        return ensemble_probs
+
+    # ────────────────────────────────────────────────────────────────
+    # CNN PROCESSING
+    # ────────────────────────────────────────────────────────────────
+    def _process_cnn(self, satellite_image: np.ndarray) -> Optional[np.ndarray]:
+        """
+        Process a preprocessed 6-band satellite image through CNN ResNet50.
+
+        Args:
+            satellite_image: numpy array of shape (1, 224, 224, 6), normalized to [0,1]
+
+        Returns:
+            cnn_probs: (1, 5) disaster class probabilities, or None on failure
+        """
+        if self.cnn_model is None:
+            logger.warning("[GEOVISION] CNN model not loaded — skipping")
+            return None
+
+        logger.info("[GEOVISION]   STEP 2b: CNN ResNet50 processing...")
+
+        try:
+            cnn_probs = self.cnn_model.predict(satellite_image, verbose=0)
+            logger.info(f"[GEOVISION]     CNN probs shape: {cnn_probs.shape}")
+            logger.info(f"[GEOVISION]     CNN top class: {DISASTER_CLASSES[int(np.argmax(cnn_probs[0]))]}")
+            return cnn_probs
+        except Exception as e:
+            logger.error(f"[GEOVISION]     CNN inference FAILED: {e}")
+            return None
+
+    # ────────────────────────────────────────────────────────────────
+    # FUSION STACKING + META-LEARNER
+    # ────────────────────────────────────────────────────────────────
+    def _stack_and_predict(self,
+                           lstm_dis_probs: np.ndarray,
+                           lstm_wx_probs: np.ndarray,
+                           lstm_embeddings: np.ndarray,
+                           ensemble_probs: Optional[np.ndarray] = None,
+                           cnn_probs: Optional[np.ndarray] = None) -> Dict[str, Any]:
+        """
+        Stack intermediate outputs and run fusion meta-learner.
+        
+        Returns dict with final predictions.
+        """
+        logger.info("[GEOVISION]   STEP 3: Fusion Meta-Learner...")
+
+        # Stack features: LSTM disaster (5) + LSTM weather (5) + embeddings (128) + [ensemble (5)] + [cnn (5)]
+        parts = [lstm_dis_probs, lstm_wx_probs, lstm_embeddings]
+        if cnn_probs is not None and cnn_probs.shape[0] == lstm_dis_probs.shape[0]:
+            parts.append(cnn_probs)
+        if ensemble_probs is not None and ensemble_probs.shape[0] == lstm_dis_probs.shape[0]:
+            parts.append(ensemble_probs)
+
+        fusion_features = np.concatenate(parts, axis=1)
+        logger.info(f"[GEOVISION]     Fusion feature vector: {fusion_features.shape}")
+
+        result = {
+            'fusion_features_dim': fusion_features.shape[1],
+        }
+
+        # ── Disaster prediction ──
+        if self.fusion_disaster_model is not None:
+            try:
+                fusion_scaled = self._scale_fusion(fusion_features, self.fusion_disaster_scaler)
+                dis_pred = self.fusion_disaster_model.predict(fusion_scaled)
+                dis_proba = self.fusion_disaster_model.predict_proba(fusion_scaled)
+                result['disaster_prediction'] = DISASTER_CLASSES[int(dis_pred[0])] if int(dis_pred[0]) < len(DISASTER_CLASSES) else f'Class_{dis_pred[0]}'
+                result['disaster_probabilities'] = {
+                    cls: round(float(dis_proba[0, i]), 4) for i, cls in enumerate(DISASTER_CLASSES)
+                    if i < dis_proba.shape[1]
+                }
+                result['disaster_confidence'] = round(float(np.max(dis_proba[0])), 4)
+                logger.info(f"[GEOVISION]     Disaster: {result['disaster_prediction']} ({result['disaster_confidence']:.2%})")
+            except Exception as e:
+                logger.error(f"[GEOVISION]     Disaster fusion FAILED: {e}")
+                # Fallback to LSTM
+                idx = int(np.argmax(lstm_dis_probs[0]))
+                result['disaster_prediction'] = DISASTER_CLASSES[idx]
+                result['disaster_probabilities'] = {
+                    cls: round(float(lstm_dis_probs[0, i]), 4) for i, cls in enumerate(DISASTER_CLASSES)
+                    if i < lstm_dis_probs.shape[1]
+                }
+                result['disaster_confidence'] = round(float(np.max(lstm_dis_probs[0])), 4)
+                result['disaster_source'] = 'lstm_fallback'
+        else:
+            idx = int(np.argmax(lstm_dis_probs[0]))
+            result['disaster_prediction'] = DISASTER_CLASSES[idx]
+            result['disaster_probabilities'] = {
+                cls: round(float(lstm_dis_probs[0, i]), 4) for i, cls in enumerate(DISASTER_CLASSES)
+                if i < lstm_dis_probs.shape[1]
+            }
+            result['disaster_confidence'] = round(float(np.max(lstm_dis_probs[0])), 4)
+            result['disaster_source'] = 'lstm_only'
+
+        # ── Weather prediction ──
+        if self.fusion_weather_model is not None:
+            try:
+                fusion_wx_scaled = self._scale_fusion(fusion_features, self.fusion_weather_scaler)
+                wx_pred = self.fusion_weather_model.predict(fusion_wx_scaled)
+                wx_proba = self.fusion_weather_model.predict_proba(fusion_wx_scaled)
+                result['weather_prediction'] = WEATHER_REGIMES[int(wx_pred[0])] if int(wx_pred[0]) < len(WEATHER_REGIMES) else f'Regime_{wx_pred[0]}'
+                result['weather_probabilities'] = {
+                    cls: round(float(wx_proba[0, i]), 4) for i, cls in enumerate(WEATHER_REGIMES)
+                    if i < wx_proba.shape[1]
+                }
+                result['weather_confidence'] = round(float(np.max(wx_proba[0])), 4)
+                logger.info(f"[GEOVISION]     Weather: {result['weather_prediction']} ({result['weather_confidence']:.2%})")
+            except Exception as e:
+                logger.error(f"[GEOVISION]     Weather fusion FAILED: {e}")
+                idx = int(np.argmax(lstm_wx_probs[0]))
+                result['weather_prediction'] = WEATHER_REGIMES[idx]
+                result['weather_probabilities'] = {
+                    cls: round(float(lstm_wx_probs[0, i]), 4) for i, cls in enumerate(WEATHER_REGIMES)
+                    if i < lstm_wx_probs.shape[1]
+                }
+                result['weather_confidence'] = round(float(np.max(lstm_wx_probs[0])), 4)
+                result['weather_source'] = 'lstm_fallback'
+        else:
+            idx = int(np.argmax(lstm_wx_probs[0]))
+            result['weather_prediction'] = WEATHER_REGIMES[idx]
+            result['weather_probabilities'] = {
+                cls: round(float(lstm_wx_probs[0, i]), 4) for i, cls in enumerate(WEATHER_REGIMES)
+                if i < lstm_wx_probs.shape[1]
+            }
+            result['weather_confidence'] = round(float(np.max(lstm_wx_probs[0])), 4)
+            result['weather_source'] = 'lstm_only'
+
+        return result
+
+    def _scale_fusion(self, features: np.ndarray, scaler) -> np.ndarray:
+        """Scale fusion features, handling dimension mismatches via padding/trimming."""
+        if scaler is None:
+            return features
+        try:
+            return scaler.transform(features)
+        except Exception:
+            expected_dim = scaler.n_features_in_
+            if features.shape[1] < expected_dim:
+                padding = np.zeros((features.shape[0], expected_dim - features.shape[1]))
+                return scaler.transform(np.concatenate([features, padding], axis=1))
+            elif features.shape[1] > expected_dim:
+                return scaler.transform(features[:, :expected_dim])
+            return features
+
+    # ────────────────────────────────────────────────────────────────
+    # MAIN PREDICTION METHOD
+    # ────────────────────────────────────────────────────────────────
+    def predict(self, weather_data: Dict[str, Any],
+                feature_data: Dict[str, Any],
+                raster_data: Dict[str, float],
+                satellite_image: Optional[np.ndarray] = None) -> Dict[str, Any]:
+        """
+        Run the full GeoVision fusion inference pipeline.
+
+        Args:
+            weather_data: 17 raw weather arrays (each 60 values)
+            feature_data: 19 engineered feature arrays (each 60 values)
+            raster_data:  9 scalar raster features
+            satellite_image: Optional preprocessed (1, 224, 224, 6) array for CNN
+
+        Returns:
+            Comprehensive prediction result dict.
+        """
+        if not self.models_loaded:
+            return {
+                'success': False,
+                'error': 'Models not loaded. Call load_models() first.'
+            }
+
+        logger.info("[GEOVISION] ===========================================")
+        logger.info("[GEOVISION]   RUNNING FUSION INFERENCE PIPELINE")
+        logger.info("[GEOVISION] ===========================================")
+
+        try:
+            # Step 1: LSTM
+            lstm_dis, lstm_wx, lstm_emb, lstm_forecast = self._process_lstm(weather_data, feature_data)
+            if lstm_dis is None:
+                return {
+                    'success': False,
+                    'error': 'LSTM processing failed — required for fusion.'
+                }
+
+            # Step 2: Tree Ensemble
+            ensemble_probs = self._process_ensemble(weather_data, feature_data, raster_data)
+
+            # Step 3: CNN ResNet50 (if satellite imagery is available)
+            cnn_probs = None
+            if satellite_image is not None:
+                cnn_probs = self._process_cnn(satellite_image)
+
+            # Step 4: Fusion Meta-Learner
+            fusion_result = self._stack_and_predict(
+                lstm_dis, lstm_wx, lstm_emb,
+                ensemble_probs, cnn_probs
+            )
+
+            # Build intermediate results
+            models_used = ['LSTM_MIMO']
+            if ensemble_probs is not None:
+                models_used.append('Tree_Ensemble')
+            if cnn_probs is not None:
+                models_used.append('CNN_ResNet50')
+            models_used.append('Fusion_MetaLearner')
+
+            intermediate = {
+                'lstm_disaster_probs': {
+                    cls: round(float(lstm_dis[0, i]), 4) for i, cls in enumerate(DISASTER_CLASSES)
+                    if i < lstm_dis.shape[1]
+                },
+                'lstm_weather_probs': {
+                    cls: round(float(lstm_wx[0, i]), 4) for i, cls in enumerate(WEATHER_REGIMES)
+                    if i < lstm_wx.shape[1]
+                },
+                'models_used': models_used,
+            }
+            if ensemble_probs is not None:
+                intermediate['ensemble_disaster_probs'] = {
+                    cls: round(float(ensemble_probs[0, i]), 4) for i, cls in enumerate(DISASTER_CLASSES)
+                    if i < ensemble_probs.shape[1]
+                }
+
+            return {
+                'success': True,
+                'disaster_prediction': fusion_result['disaster_prediction'],
+                'disaster_probabilities': fusion_result['disaster_probabilities'],
+                'disaster_confidence': fusion_result['disaster_confidence'],
+                'weather_prediction': fusion_result['weather_prediction'],
+                'weather_probabilities': fusion_result['weather_probabilities'],
+                'weather_confidence': fusion_result['weather_confidence'],
+                'intermediate': intermediate,
+                'metadata': {
+                    'fusion_features_dim': fusion_result.get('fusion_features_dim'),
+                    'models_loaded': self._load_status,
+                    'disaster_source': fusion_result.get('disaster_source', 'fusion'),
+                    'weather_source': fusion_result.get('weather_source', 'fusion'),
+                }
+            }
+
+        except Exception as e:
+            logger.error(f"[GEOVISION] Pipeline error: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            return {
+                'success': False,
+                'error': f'Fusion pipeline error: {str(e)}'
+            }
+
+    def get_model_status(self) -> Dict[str, Any]:
+        """Return status of all loaded models."""
+        return {
+            'models_loaded': self.models_loaded,
+            'components': self._load_status,
+            'disaster_classes': DISASTER_CLASSES,
+            'weather_regimes': WEATHER_REGIMES,
+            'features': {
+                'temporal': len(INPUT_FEATURES),
+                'scalar': len(SCALAR_FEATURE_COLUMNS),
+                'total_tabular': len(INPUT_FEATURES) * len(STAT_NAMES) + len(SCALAR_FEATURE_COLUMNS),
+                'sequence_length': SEQUENCE_LENGTH,
+                'embedding_dim': EMBEDDING_DIM,
+            }
+        }

server/models/hazardguard_prediction_model.py

@@ -0,0 +1,687 @@
+"""
+HazardGuard Disaster Prediction Model
+Loads trained XGBoost model and predicts DISASTER vs NORMAL based on location coordinates
+"""
+
+import logging
+import numpy as np
+import pandas as pd
+import joblib
+import os
+import json
+import ast
+from typing import Dict, List, Optional, Any, Tuple, Union
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+class HazardGuardPredictionModel:
+    """Model for HazardGuard disaster prediction using trained XGBoost classifier"""
+    
+    # Model files directory
+    MODEL_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'hazardguard', 'normal_vs_disaster')
+    
+    # Debug logging directory
+    DEBUG_LOG_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'hazardguard', 'debug_logs')
+    
+    # Feature columns expected by the model (based on training script)
+    ARRAY_FEATURE_COLUMNS = [
+        'temperature_C', 'humidity_%', 'wind_speed_mps', 'precipitation_mm',
+        'surface_pressure_hPa', 'solar_radiation_wm2', 'temperature_max_C', 'temperature_min_C',
+        'specific_humidity_g_kg', 'dew_point_C', 'wind_speed_10m_mps', 'cloud_amount_%',
+        'sea_level_pressure_hPa', 'surface_soil_wetness_%', 'wind_direction_10m_degrees', 'evapotranspiration_wm2',
+        'root_zone_soil_moisture_%', 'temp_normalized', 'temp_range', 'discomfort_index',
+        'heat_index', 'wind_precip_interaction', 'solar_temp_ratio', 'pressure_anomaly',
+        'high_precip_flag', 'adjusted_humidity', 'wind_chill',
+        'solar_radiation_anomaly', 'weather_severity_score', 'moisture_stress_index', 'evaporation_deficit',
+        'soil_saturation_index', 'atmospheric_instability', 'drought_indicator', 'flood_risk_score',
+        'storm_intensity_index'
+    ]
+    
+    SCALAR_FEATURE_COLUMNS = [
+        'soil_type', 'elevation_m', 'pop_density_persqkm', 'land_cover_class',
+        'ndvi', 'annual_precip_mm', 'annual_mean_temp_c', 'mean_wind_speed_ms',
+        'impervious_surface_pct'
+    ]
+    
+    # HORIZON configuration for forecasting (1 day ahead prediction)
+    HORIZON = 1
+    FORECAST_DAYS = 60 - HORIZON  # Use first 59 days to predict day 60
+    
+    def __init__(self):
+        """Initialize the HazardGuard prediction model"""
+        model_root = os.getenv('MODEL_ROOT_PATH', '').strip()
+        if model_root:
+            base_hazardguard_dir = os.path.join(os.path.abspath(model_root), 'hazardguard')
+        else:
+            base_hazardguard_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'hazardguard')
+
+        # Resolve model/debug directories from env-configured root when provided.
+        self.MODEL_DIR = os.path.join(base_hazardguard_dir, 'normal_vs_disaster')
+        self.DEBUG_LOG_DIR = os.path.join(base_hazardguard_dir, 'debug_logs')
+
+        self.model = None
+        self.feature_selector = None
+        self.scaler = None
+        self.label_encoder = None
+        self.metadata = None
+        self.imputation_values = None  # Add imputation values dictionary
+        self.prediction_metadata = {}  # Metadata for current prediction (coordinates, dates, etc.)
+        self.is_loaded = False
+        
+        # Statistics for monitoring
+        self.prediction_stats = {
+            'total_predictions': 0,
+            'successful_predictions': 0,
+            'failed_predictions': 0,
+            'disaster_predictions': 0,
+            'normal_predictions': 0,
+            'avg_disaster_probability': 0.0,
+            'model_load_time': None
+        }
+        
+        # Create debug log directory if it doesn't exist
+        os.makedirs(self.DEBUG_LOG_DIR, exist_ok=True)
+        
+        logger.info("HazardGuard prediction model initialized")
+    
+    def load_model_components(self) -> bool:
+        """
+        Load all trained model components
+        
+        Returns:
+            bool: True if loading successful, False otherwise
+        """
+        start_time = datetime.now()
+        
+        try:
+            logger.info(f"Loading HazardGuard model components from {self.MODEL_DIR}")
+            
+            # Check if model directory exists
+            if not os.path.exists(self.MODEL_DIR):
+                logger.error(f"Model directory not found: {self.MODEL_DIR}")
+                return False
+            
+            # Define component files
+            model_files = {
+                'model': 'normal_vs_disaster_xgboost_model.pkl',
+                'feature_selector': 'normal_vs_disaster_feature_selector.pkl',
+                'scaler': 'normal_vs_disaster_scaler.pkl',
+                'label_encoder': 'normal_vs_disaster_label_encoder.pkl',
+                'imputation_values': 'normal_vs_disaster_imputation_values.pkl',
+                'metadata': 'normal_vs_disaster_model_metadata.json'
+            }
+            
+            # Check if all required files exist (imputation_values is optional)
+            missing_files = []
+            for component, filename in model_files.items():
+                if component == 'imputation_values':
+                    # Optional - check later
+                    continue
+                filepath = os.path.join(self.MODEL_DIR, filename)
+                if not os.path.exists(filepath):
+                    missing_files.append(filename)
+            
+            if missing_files:
+                logger.error(f"Missing model files: {missing_files}")
+                return False
+            
+            # Load model components
+            logger.info("Loading XGBoost model...")
+            model_path = os.path.join(self.MODEL_DIR, model_files['model'])
+            self.model = joblib.load(model_path)
+            
+            logger.info("Loading feature selector...")
+            selector_path = os.path.join(self.MODEL_DIR, model_files['feature_selector'])
+            self.feature_selector = joblib.load(selector_path)
+            
+            logger.info("Loading feature scaler...")
+            scaler_path = os.path.join(self.MODEL_DIR, model_files['scaler'])
+            self.scaler = joblib.load(scaler_path)
+            
+            logger.info("Loading label encoder...")
+            encoder_path = os.path.join(self.MODEL_DIR, model_files['label_encoder'])
+            self.label_encoder = joblib.load(encoder_path)
+            
+            logger.info("Loading imputation values...")
+            imputation_path = os.path.join(self.MODEL_DIR, model_files['imputation_values'])
+            if os.path.exists(imputation_path):
+                self.imputation_values = joblib.load(imputation_path)
+                logger.info(f"   Loaded imputation values for {len(self.imputation_values)} features")
+                
+                # Log training data statistics for raster features (for debugging)
+                raster_features = ['soil_type', 'elevation_m', 'pop_density_persqkm', 'land_cover_class',
+                                 'ndvi', 'annual_precip_mm', 'annual_mean_temp_c', 'mean_wind_speed_ms',
+                                 'impervious_surface_pct']
+                logger.info("   Training data imputation values for scalar raster features:")
+                found_count = 0
+                for feat in raster_features:
+                    if feat in self.imputation_values:
+                        logger.info(f"      {feat}: {self.imputation_values[feat]}")
+                        found_count += 1
+                    else:
+                        logger.warning(f"      {feat}: NOT FOUND in imputation values")
+                
+                if found_count == 0:
+                    logger.warning("   [CRITICAL] No scalar raster features in imputation file!")
+                    logger.warning("   This means the model was trained with complete raster data (no missing values)")
+                    logger.warning("   Current predictions use fallback imputation for missing raster values")
+                
+                # Log cloud_amount feature count
+                cloud_features = [k for k in self.imputation_values.keys() if 'cloud_amount_%' in k]
+                logger.info(f"   Found {len(cloud_features)} cloud_amount imputation values")
+                # Check for cloud_amount features specifically
+                cloud_keys = [k for k in self.imputation_values.keys() if 'cloud_amount' in k.lower()]
+                logger.info(f"   Found {len(cloud_keys)} cloud_amount imputation values")
+                if cloud_keys:
+                    logger.debug(f"   Cloud_amount keys: {cloud_keys[:3]}...")
+            else:
+                logger.warning("   Imputation values file not found - will use fallback defaults")
+                self.imputation_values = None
+            
+            logger.info("Loading model metadata...")
+            metadata_path = os.path.join(self.MODEL_DIR, model_files['metadata'])
+            try:
+                with open(metadata_path, 'r', encoding='utf-8') as f:
+                    metadata_text = f.read()
+
+                if metadata_text.lstrip().startswith('version https://git-lfs.github.com/spec/v1'):
+                    logger.warning("   Metadata file is a Git LFS pointer; using fallback metadata")
+                    self.metadata = {
+                        'model_type': 'HazardGuard',
+                        'algorithm': 'XGBoost',
+                        'cv_accuracy': 0.0,
+                        'n_features_selected': 0,
+                        'metadata_source': 'fallback_lfs_pointer'
+                    }
+                else:
+                    self.metadata = json.loads(metadata_text)
+            except Exception as metadata_err:
+                logger.warning(f"   Invalid metadata JSON ({metadata_err}); using fallback metadata")
+                self.metadata = {
+                    'model_type': 'HazardGuard',
+                    'algorithm': 'XGBoost',
+                    'cv_accuracy': 0.0,
+                    'n_features_selected': 0,
+                    'metadata_source': 'fallback_invalid_json'
+                }
+            
+            # Calculate load time
+            load_time = (datetime.now() - start_time).total_seconds()
+            self.prediction_stats['model_load_time'] = load_time
+            
+            self.is_loaded = True
+            
+            logger.info("[SUCCESS] All model components loaded successfully!")
+            logger.info(f"   Model type: {self.metadata.get('model_type', 'Unknown')}")
+            logger.info(f"   Algorithm: {self.metadata.get('algorithm', 'Unknown')}")
+            logger.info(f"   CV Accuracy: {self.metadata.get('cv_accuracy', 0):.4f}")
+            logger.info(f"   Features: {self.metadata.get('n_features_selected', 0)}")
+            logger.info(f"   Load time: {load_time:.3f}s")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error loading model components: {e}")
+            return False
+    
+    def compute_stats_from_iterable(self, arr: List[float]) -> Dict[str, float]:
+        """Compute statistics from a numeric array (same as training script)"""
+        if len(arr) == 0:
+            return {k: np.nan for k in ['mean','min','max','std','median','q25','q75','skew']}
+        
+        return {
+            'mean': np.mean(arr),
+            'min': np.min(arr),
+            'max': np.max(arr),
+            'std': np.std(arr) if len(arr) > 1 else 0.0,
+            'median': np.median(arr),
+            'q25': np.percentile(arr, 25),
+            'q75': np.percentile(arr, 75),
+            'skew': float(pd.Series(arr).skew()) if len(arr) > 2 else 0.0
+        }
+    
+    def process_array_feature(self, values: List[float]) -> Dict[str, float]:
+        """
+        Process array feature for forecasting (use first FORECAST_DAYS values)
+        
+        Args:
+            values: List of values (up to 60 days)
+        
+        Returns:
+            Dictionary of computed statistics
+        """
+        try:
+            # Handle None or empty lists
+            if not values or len(values) == 0:
+                return {k: np.nan for k in ['mean','min','max','std','median','q25','q75','skew']}
+            
+            # Filter out None, NaN, and empty values
+            # Convert to float and filter valid values
+            valid_values = []
+            for x in values:
+                try:
+                    if x is not None and pd.notna(x) and str(x).strip() != '':
+                        valid_values.append(float(x))
+                except (ValueError, TypeError):
+                    continue
+            
+            # If no valid values after filtering, return NaN
+            if len(valid_values) == 0:
+                logger.debug(f"No valid values in array feature after filtering None/NaN/blanks")
+                return {k: np.nan for k in ['mean','min','max','std','median','q25','q75','skew']}
+            
+            # Convert to numpy array
+            arr = np.array(valid_values)
+            
+            # For forecasting: use only first FORECAST_DAYS values
+            if len(arr) > self.FORECAST_DAYS:
+                arr = arr[:self.FORECAST_DAYS]
+            
+            return self.compute_stats_from_iterable(arr)
+            
+        except Exception as e:
+            logger.error(f"Error processing array feature: {e}")
+            return {k: np.nan for k in ['mean','min','max','std','median','q25','q75','skew']}
+    
+    def prepare_features(self, weather_data: Dict[str, List[float]], 
+                        feature_data: Dict[str, List[float]], 
+                        raster_data: Dict[str, float]) -> Optional[pd.DataFrame]:
+        """
+        Prepare features for prediction in the same format as training
+        
+        Args:
+            weather_data: Weather time series data (60 days)
+            feature_data: Engineered feature time series data (60 days)  
+            raster_data: Raster data (single values)
+        
+        Returns:
+            DataFrame with prepared features or None if error
+        """
+        try:
+            logger.debug("Preparing features for prediction...")
+            
+            row_features = {}
+            
+            # Process array features (weather + engineered features)
+            all_array_features = {**weather_data, **feature_data}
+            
+            for col in self.ARRAY_FEATURE_COLUMNS:
+                if col in all_array_features:
+                    values = all_array_features[col]
+                    stats = self.process_array_feature(values)
+                    
+                    # Add statistics with column prefix
+                    for stat, value in stats.items():
+                        row_features[f"{col}_{stat}"] = value
+                else:
+                    # Missing feature - fill with NaN
+                    logger.warning(f"Missing array feature: {col}")
+                    for stat in ['mean','min','max','std','median','q25','q75','skew']:
+                        row_features[f"{col}_{stat}"] = np.nan
+            
+            # Process scalar features (raster data)
+            logger.info(f"[DEBUG] Processing {len(self.SCALAR_FEATURE_COLUMNS)} scalar features from raster data")
+            logger.info(f"[DEBUG] Raster data keys: {list(raster_data.keys())}")
+            
+            raster_values_summary = {}
+            raster_vs_training = {}  # Compare extracted vs training median
+            
+            for col in self.SCALAR_FEATURE_COLUMNS:
+                if col in raster_data:
+                    value = raster_data[col]
+                    raster_values_summary[col] = value
+                    
+                    # Compare with training median if available
+                    if self.imputation_values and col in self.imputation_values:
+                        training_median = self.imputation_values[col]
+                        if pd.notna(value) and value != -9999 and value != -9999.0:
+                            diff_pct = ((value - training_median) / training_median * 100) if training_median != 0 else 0
+                            raster_vs_training[col] = f"{value} (training: {training_median}, diff: {diff_pct:+.1f}%)"
+                    
+                    # Treat -9999 (NoData sentinel) as NaN
+                    if pd.notna(value) and value != -9999 and value != -9999.0:
+                        row_features[col] = value
+                        logger.debug(f"Raster feature {col} = {value}")
+                    else:
+                        row_features[col] = np.nan
+                        if value == -9999 or value == -9999.0:
+                            logger.info(f"[DEBUG] Raster NoData value (-9999) for {col}, treating as NaN")
+                else:
+                    # Missing feature - fill with NaN
+                    logger.warning(f"Missing scalar feature: {col}")
+                    row_features[col] = np.nan
+                    raster_values_summary[col] = "MISSING"
+            
+            logger.info(f"[DEBUG] All raster values: {raster_values_summary}")
+            if raster_vs_training:
+                logger.info(f"[DEBUG] Raster vs Training comparison: {raster_vs_training}")
+            
+            # Convert to DataFrame
+            df = pd.DataFrame([row_features])
+            
+            # Handle missing values using EXACT training imputation values
+            nan_counts_before = df.isnull().sum().sum()
+            logger.info(f"[DEBUG] NaN values before imputation: {nan_counts_before}")
+            
+            # Log which features have NaN
+            nan_features = df.columns[df.isnull().any()].tolist()
+            if nan_features:
+                logger.info(f"[DEBUG] Features with NaN: {nan_features}")
+            
+            imputed_features = {}
+            imputed_from_training = 0
+            imputed_from_fallback = 0
+            
+            for col in df.columns:
+                if df[col].isnull().sum() > 0:
+                    original_value = df[col].iloc[0] if len(df) > 0 else np.nan
+                    # Use saved imputation values if available
+                    if self.imputation_values and col in self.imputation_values:
+                        fill_value = self.imputation_values[col]
+                        df[col] = df[col].fillna(fill_value)
+                        imputed_from_training += 1
+                        logger.debug(f"Imputed {col} with training value: {fill_value}")
+                    else:
+                        imputed_from_fallback += 1
+                        # Fallback: Use domain-specific defaults (matching working_live_predict.py)
+                        if 'std' in col or 'skew' in col:
+                            fill_value = 0
+                            df[col] = df[col].fillna(fill_value)
+                        # Scalar features (no training median, need reasonable defaults)
+                        elif col == 'soil_type':
+                            fill_value = 2
+                            df[col] = df[col].fillna(fill_value)  # Default soil type
+                        elif col == 'elevation_m':
+                            fill_value = 300
+                            df[col] = df[col].fillna(fill_value)  # Default elevation
+                        elif col == 'pop_density_persqkm':
+                            fill_value = 1000
+                            df[col] = df[col].fillna(fill_value)  # Default population density
+                        elif col == 'land_cover_class':
+                            fill_value = 5
+                            df[col] = df[col].fillna(fill_value)  # Default land cover
+                        elif col == 'ndvi':
+                            fill_value = 0.5
+                            df[col] = df[col].fillna(fill_value)  # Default NDVI
+                        elif col == 'annual_precip_mm':
+                            fill_value = 800
+                            df[col] = df[col].fillna(fill_value)  # Default annual precipitation
+                        elif col == 'annual_mean_temp_c':
+                            fill_value = 25
+                            df[col] = df[col].fillna(fill_value)  # Default annual temperature
+                        elif col == 'mean_wind_speed_ms':
+                            fill_value = 3
+                            df[col] = df[col].fillna(fill_value)  # Default wind speed
+                        elif col == 'impervious_surface_pct':
+                            fill_value = 10
+                            df[col] = df[col].fillna(fill_value)  # Default impervious surface (10%)
+                        # Array feature statistics
+                        elif 'temperature' in col.lower():
+                            fill_value = 20.0
+                            df[col] = df[col].fillna(fill_value)
+                        elif 'humidity' in col.lower() or 'cloud_amount' in col.lower():
+                            fill_value = 50.0
+                            df[col] = df[col].fillna(fill_value)
+                        elif 'pressure' in col.lower():
+                            fill_value = 1013.25
+                            df[col] = df[col].fillna(fill_value)
+                        else:
+                            fill_value = 0.0
+                            df[col] = df[col].fillna(fill_value)
+                        
+                        # Track imputed scalar features for debugging
+                        if col in self.SCALAR_FEATURE_COLUMNS:
+                            imputed_features[col] = fill_value
+                        logger.warning(f"Imputed {col} with domain default (no training value available)")
+            
+            if imputed_features:
+                logger.info(f"[DEBUG] Imputed scalar features: {imputed_features}")
+            
+            logger.info(f"[DEBUG] Imputation summary: {imputed_from_training} from training, {imputed_from_fallback} from fallback")
+            
+            # Final safety check
+            if df.isnull().sum().sum() > 0:
+                logger.warning(f"NaN values still present, filling with 0")
+                df = df.fillna(0)
+            
+            logger.debug(f"Features prepared: {len(df.columns)} features")
+            return df
+            
+        except Exception as e:
+            logger.error(f"Error preparing features: {e}")
+            return None
+    
+    def log_prediction_inputs(self, features_df: pd.DataFrame, weather_data: Dict, 
+                             feature_data: Dict, raster_data: Dict, 
+                             prediction: str, probability: Dict, metadata: Dict = None):
+        """Log all prediction inputs to CSV for debugging"""
+        try:
+            # Create log entry
+            log_entry = {
+                'timestamp': datetime.now().isoformat(),
+                'prediction': prediction,
+                'disaster_probability': probability.get('disaster', 0),
+                'normal_probability': probability.get('normal', 0)
+            }
+            
+            # Add metadata if provided (coordinates, dates, etc.)
+            if metadata:
+                for key, value in metadata.items():
+                    log_entry[f'meta_{key}'] = value
+            
+            # Add all feature values (expanded features used by model)
+            if features_df is not None:
+                for col in features_df.columns:
+                    log_entry[col] = features_df[col].iloc[0]
+            
+            # Add raw weather data arrays (60 values per column)
+            for key, values in weather_data.items():
+                if isinstance(values, list):
+                    # Store the full array as a string representation
+                    log_entry[key] = str(values) if len(values) > 0 else "[]"
+                    # Also store mean for quick reference
+                    if len(values) > 0:
+                        valid_values = [v for v in values if pd.notna(v)]
+                        if valid_values:
+                            log_entry[f'{key}_mean'] = np.mean(valid_values)
+            
+            # Add raw engineered feature data arrays (60 values per column)
+            for key, values in feature_data.items():
+                if isinstance(values, list):
+                    # Store the full array as a string representation
+                    log_entry[key] = str(values) if len(values) > 0 else "[]"
+                    # Also store mean for quick reference
+                    if len(values) > 0:
+                        valid_values = [v for v in values if pd.notna(v)]
+                        if valid_values:
+                            log_entry[f'{key}_mean'] = np.mean(valid_values)
+            
+            # Add raster data (scalar features)
+            for key, value in raster_data.items():
+                log_entry[key] = value
+            
+            # Convert to DataFrame and append to CSV
+            log_df = pd.DataFrame([log_entry])
+            log_file = os.path.join(self.DEBUG_LOG_DIR, 'prediction_inputs_log.csv')
+            
+            # Append to existing file or create new
+            if os.path.exists(log_file):
+                log_df.to_csv(log_file, mode='a', header=False, index=False)
+            else:
+                log_df.to_csv(log_file, index=False)
+            
+            logger.debug(f"Logged prediction inputs to {log_file}")
+            
+        except Exception as e:
+            logger.error(f"Error logging prediction inputs: {e}")
+    
+    def predict_disaster(self, weather_data: Dict[str, List[float]], 
+                        feature_data: Dict[str, List[float]], 
+                        raster_data: Dict[str, float]) -> Dict[str, Any]:
+        """
+        Predict disaster probability for given location data
+        
+        Args:
+            weather_data: Pre-disaster weather time series 
+            feature_data: Pre-disaster engineered features time series
+            raster_data: Location raster data
+        
+        Returns:
+            Prediction results dictionary
+        """
+        start_time = datetime.now()
+        
+        try:
+            self.prediction_stats['total_predictions'] += 1
+            
+            # Check if model is loaded
+            if not self.is_loaded or self.model is None:
+                logger.error("Model not loaded. Call load_model_components() first.")
+                self.prediction_stats['failed_predictions'] += 1
+                return {
+                    'success': False,
+                    'error': 'Model not loaded',
+                    'prediction': None,
+                    'probability': None,
+                    'confidence': None
+                }
+            
+            # Prepare features
+            features_df = self.prepare_features(weather_data, feature_data, raster_data)
+            
+            if features_df is None:
+                self.prediction_stats['failed_predictions'] += 1
+                return {
+                    'success': False,
+                    'error': 'Feature preparation failed',
+                    'prediction': None,
+                    'probability': None,
+                    'confidence': None
+                }
+            
+            # Apply feature selection
+            logger.debug("Applying feature selection...")
+            features_selected = self.feature_selector.transform(features_df)
+            
+            # Apply scaling
+            logger.debug("Applying feature scaling...")
+            features_scaled = self.scaler.transform(features_selected)
+            
+            # Make prediction
+            logger.debug("Making prediction...")
+            prediction_encoded = self.model.predict(features_scaled)[0]
+            probabilities = self.model.predict_proba(features_scaled)[0]
+            
+            # Debug: Log raw model output
+            logger.info(f"[DEBUG] Raw prediction_encoded: {prediction_encoded}")
+            logger.info(f"[DEBUG] Raw probabilities: {probabilities}")
+            logger.info(f"[DEBUG] Label encoder classes: {self.label_encoder.classes_}")
+            
+            # Decode prediction
+            prediction = self.label_encoder.inverse_transform([prediction_encoded])[0]
+            
+            # Get probability for disaster class
+            disaster_idx = list(self.label_encoder.classes_).index('Disaster') if 'Disaster' in self.label_encoder.classes_ else 1
+            disaster_probability = probabilities[disaster_idx]
+            normal_probability = probabilities[1 - disaster_idx]
+            
+            logger.info(f"[DEBUG] disaster_idx={disaster_idx}, disaster_prob={disaster_probability:.4f}, normal_prob={normal_probability:.4f}")
+            logger.info(f"[DEBUG] Decoded prediction: {prediction}")
+            
+            # Calculate confidence (difference between max and second max probability)
+            confidence = abs(disaster_probability - normal_probability)
+            
+            # Update statistics
+            self.prediction_stats['successful_predictions'] += 1
+            if prediction == 'Disaster':
+                self.prediction_stats['disaster_predictions'] += 1
+            else:
+                self.prediction_stats['normal_predictions'] += 1
+            
+            # Update average disaster probability
+            total_successful = self.prediction_stats['successful_predictions']
+            current_avg = self.prediction_stats['avg_disaster_probability']
+            self.prediction_stats['avg_disaster_probability'] = (
+                (current_avg * (total_successful - 1) + disaster_probability) / total_successful
+            )
+            
+            # Calculate processing time
+            processing_time = (datetime.now() - start_time).total_seconds()
+            
+            result = {
+                'success': True,
+                'prediction': prediction,
+                'probability': {
+                    'disaster': float(disaster_probability),
+                    'normal': float(normal_probability)
+                },
+                'confidence': float(confidence),
+                'processing_time_seconds': processing_time,
+                'metadata': {
+                    'features_used': len(features_df.columns),
+                    'features_selected': features_selected.shape[1],
+                    'model_type': self.metadata.get('algorithm', 'XGBoost'),
+                    'forecast_horizon_days': self.HORIZON,
+                    'prediction_timestamp': datetime.now().isoformat()
+                }
+            }
+            
+            logger.info(f"[SUCCESS] Prediction successful: {prediction} (probability: {disaster_probability:.4f}, confidence: {confidence:.4f})")
+            
+            # Log prediction inputs for debugging
+            self.log_prediction_inputs(
+                features_df=features_df,
+                weather_data=weather_data,
+                feature_data=feature_data,
+                raster_data=raster_data,
+                prediction=prediction,
+                probability=result['probability'],
+                metadata=self.prediction_metadata
+            )
+            
+            return result
+            
+        except Exception as e:
+            self.prediction_stats['failed_predictions'] += 1
+            logger.error(f"Error making prediction: {e}")
+            
+            processing_time = (datetime.now() - start_time).total_seconds()
+            
+            return {
+                'success': False,
+                'error': f"Prediction error: {str(e)}",
+                'prediction': None,
+                'probability': None,
+                'confidence': None,
+                'processing_time_seconds': processing_time
+            }
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        """Get information about the loaded model"""
+        return {
+            'is_loaded': self.is_loaded,
+            'model_metadata': self.metadata if self.metadata else {},
+            'feature_counts': {
+                'array_features': len(self.ARRAY_FEATURE_COLUMNS),
+                'scalar_features': len(self.SCALAR_FEATURE_COLUMNS),
+                'total_expanded': len(self.ARRAY_FEATURE_COLUMNS) * 8 + len(self.SCALAR_FEATURE_COLUMNS)
+            },
+            'forecasting': {
+                'horizon_days': self.HORIZON,
+                'forecast_input_days': self.FORECAST_DAYS
+            },
+            'prediction_statistics': self.prediction_stats.copy()
+        }
+    
+    def reset_statistics(self) -> None:
+        """Reset prediction statistics"""
+        self.prediction_stats.update({
+            'total_predictions': 0,
+            'successful_predictions': 0,
+            'failed_predictions': 0,
+            'disaster_predictions': 0,
+            'normal_predictions': 0,
+            'avg_disaster_probability': 0.0
+        })
+        logger.info("Prediction statistics reset")

server/models/post_disaster_feature_engineering_model.py

@@ -0,0 +1,588 @@
+"""
+Post-Disaster Feature Engineering Model for HazardGuard System
+Creates 19 advanced features from 60-day post-disaster weather data
+"""
+
+import logging
+import numpy as np
+import pandas as pd
+from typing import Dict, List, Optional, Any, Tuple, Union
+from datetime import datetime
+import json
+
+logger = logging.getLogger(__name__)
+
+class PostDisasterFeatureEngineeringModel:
+    """Model for creating post-disaster features from weather time series data"""
+    
+    # Post-disaster weather variables expected as input (17 total)
+    POST_WEATHER_VARIABLES = [
+        'POST_temperature_C',
+        'POST_humidity_%', 
+        'POST_wind_speed_mps',
+        'POST_precipitation_mm',
+        'POST_surface_pressure_hPa',
+        'POST_solar_radiation_wm2',
+        'POST_temperature_max_C',
+        'POST_temperature_min_C', 
+        'POST_specific_humidity_g_kg',
+        'POST_dew_point_C',
+        'POST_wind_speed_10m_mps',
+        'POST_cloud_amount_%',
+        'POST_sea_level_pressure_hPa',
+        'POST_surface_soil_wetness_%',
+        'POST_wind_direction_10m_degrees',
+        'POST_evapotranspiration_wm2',
+        'POST_root_zone_soil_moisture_%'
+    ]
+    
+    # Post-disaster engineered features (19 total)
+    POST_FEATURE_VARIABLES = [
+        'POST_temp_normalized',
+        'POST_temp_range',
+        'POST_discomfort_index',
+        'POST_heat_index',
+        'POST_wind_precip_interaction',
+        'POST_solar_temp_ratio',
+        'POST_pressure_anomaly',
+        'POST_high_precip_flag',
+        'POST_adjusted_humidity',
+        'POST_wind_chill',
+        'POST_solar_radiation_anomaly',
+        'POST_weather_severity_score',
+        'POST_moisture_stress_index',
+        'POST_evaporation_deficit',
+        'POST_soil_saturation_index',
+        'POST_atmospheric_instability',
+        'POST_drought_indicator',
+        'POST_flood_risk_score',
+        'POST_storm_intensity_index'
+    ]
+    
+    def __init__(self, days_count: int = 60):
+        """
+        Initialize post-disaster feature engineering model
+        
+        Args:
+            days_count: Number of days in time series (default: 60)
+        """
+        self.days_count = days_count
+        self.global_stats = {}
+        self.processing_stats = {
+            'total_processed': 0,
+            'successful_calculations': 0,
+            'failed_calculations': 0,
+            'nan_count': 0
+        }
+        
+        logger.info(f"Initialized PostDisasterFeatureEngineeringModel: {days_count} days, {len(self.POST_FEATURE_VARIABLES)} features")
+    
+    def safe_float(self, value: Any, default: float = 0.0) -> float:
+        """Safely convert value to float, handling NaN properly"""
+        try:
+            if pd.isna(value) or value is None:
+                return np.nan
+            return float(value)
+        except (ValueError, TypeError):
+            return default
+    
+    def validate_weather_data(self, weather_data: Dict[str, List[float]]) -> Tuple[bool, str]:
+        """Validate input weather data format"""
+        try:
+            # Check if all required variables are present
+            missing_vars = []
+            for var in self.POST_WEATHER_VARIABLES:
+                if var not in weather_data:
+                    missing_vars.append(var)
+            
+            if missing_vars:
+                return False, f"Missing weather variables: {missing_vars}"
+            
+            # Check if all lists have correct length
+            incorrect_lengths = []
+            for var, values in weather_data.items():
+                if var in self.POST_WEATHER_VARIABLES:
+                    if not isinstance(values, list) or len(values) != self.days_count:
+                        incorrect_lengths.append(f"{var}: {len(values) if isinstance(values, list) else 'not_list'}")
+            
+            if incorrect_lengths:
+                return False, f"Incorrect list lengths (expected {self.days_count}): {incorrect_lengths}"
+            
+            return True, "Weather data validation successful"
+            
+        except Exception as e:
+            logger.error(f"Error validating weather data: {e}")
+            return False, f"Validation error: {str(e)}"
+    
+    def calculate_global_statistics(self, weather_datasets: List[Dict[str, List[float]]]) -> Dict[str, float]:
+        """
+        Calculate global statistics for normalization and anomaly detection
+        
+        Args:
+            weather_datasets: List of weather data dictionaries for multiple coordinates
+        
+        Returns:
+            Dictionary of global statistics
+        """
+        try:
+            logger.info("Calculating global statistics for post-disaster feature engineering...")
+            
+            # Collect all values for each variable (flattened across all coordinates and days)
+            all_values = {var: [] for var in self.POST_WEATHER_VARIABLES}
+            
+            for weather_data in weather_datasets:
+                for var in self.POST_WEATHER_VARIABLES:
+                    if var in weather_data and isinstance(weather_data[var], list):
+                        for value in weather_data[var]:
+                            float_val = self.safe_float(value, np.nan)
+                            if not pd.isna(float_val):  # Only include non-NaN values for statistics
+                                all_values[var].append(float_val)
+            
+            # Calculate statistics
+            stats = {}
+            
+            # Temperature statistics
+            temp_values = all_values['POST_temperature_C']
+            stats['temp_min'] = float(np.min(temp_values)) if temp_values else 0.0
+            stats['temp_max'] = float(np.max(temp_values)) if temp_values else 100.0
+            stats['temp_mean'] = float(np.mean(temp_values)) if temp_values else 25.0
+            
+            temp_max_values = all_values['POST_temperature_max_C'] 
+            stats['temp_max_mean'] = float(np.mean(temp_max_values)) if temp_max_values else 30.0
+            
+            # Pressure statistics
+            pressure_values = all_values['POST_surface_pressure_hPa']
+            stats['pressure_mean'] = float(np.mean(pressure_values)) if pressure_values else 1013.25
+            
+            sea_pressure_values = all_values['POST_sea_level_pressure_hPa']
+            stats['sea_pressure_mean'] = float(np.mean(sea_pressure_values)) if sea_pressure_values else 1013.25
+            
+            # Solar radiation statistics
+            solar_values = all_values['POST_solar_radiation_wm2']
+            stats['solar_mean'] = float(np.mean(solar_values)) if solar_values else 200.0
+            
+            # Precipitation statistics
+            precip_values = all_values['POST_precipitation_mm']
+            stats['precip_max'] = float(np.max(precip_values)) if precip_values else 100.0
+            
+            # Wind statistics
+            wind_values = all_values['POST_wind_speed_mps']
+            stats['wind_max'] = float(np.max(wind_values)) if wind_values else 20.0
+            
+            # Evapotranspiration statistics
+            evap_values = all_values['POST_evapotranspiration_wm2']
+            stats['evap_mean'] = float(np.mean(evap_values)) if evap_values else 100.0
+            
+            # Store global statistics
+            self.global_stats = stats
+            
+            logger.info(f"Global statistics calculated: {len(stats)} statistics computed")
+            logger.debug(f"Global statistics: {stats}")
+            
+            return stats
+            
+        except Exception as e:
+            logger.error(f"Error calculating global statistics: {e}")
+            return {
+                'temp_min': 0.0, 'temp_max': 100.0, 'temp_mean': 25.0, 'temp_max_mean': 30.0,
+                'pressure_mean': 1013.25, 'sea_pressure_mean': 1013.25, 'solar_mean': 200.0,
+                'precip_max': 100.0, 'wind_max': 20.0, 'evap_mean': 100.0
+            }
+    
+    def engineer_single_coordinate_features(self, weather_data: Dict[str, List[float]], global_stats: Optional[Dict[str, float]] = None) -> Dict[str, Any]:
+        """
+        Engineer post-disaster features for a single coordinate
+        
+        Args:
+            weather_data: Dictionary containing weather time series for all variables
+            global_stats: Global statistics for normalization (optional)
+        
+        Returns:
+            Dictionary containing engineered features and metadata
+        """
+        try:
+            self.processing_stats['total_processed'] += 1
+            
+            # Validate input data
+            is_valid, validation_message = self.validate_weather_data(weather_data)
+            if not is_valid:
+                self.processing_stats['failed_calculations'] += 1
+                return {
+                    'success': False,
+                    'error': f"Weather data validation failed: {validation_message}",
+                    'features': {feature: [np.nan] * self.days_count for feature in self.POST_FEATURE_VARIABLES}
+                }
+            
+            # Use provided global stats or fallback to defaults
+            stats = global_stats or self.global_stats or {
+                'temp_min': 0.0, 'temp_max': 100.0, 'temp_mean': 25.0, 'temp_max_mean': 30.0,
+                'pressure_mean': 1013.25, 'sea_pressure_mean': 1013.25, 'solar_mean': 200.0,
+                'precip_max': 100.0, 'wind_max': 20.0, 'evap_mean': 100.0
+            }
+            
+            # Initialize feature lists
+            features = {feature: [] for feature in self.POST_FEATURE_VARIABLES}
+            
+            # Process each day
+            for day in range(self.days_count):
+                try:
+                    # Extract daily values with safe conversion
+                    temp = self.safe_float(weather_data['POST_temperature_C'][day], stats['temp_mean'])
+                    temp_max = self.safe_float(weather_data['POST_temperature_max_C'][day], stats['temp_mean'] + 5)
+                    temp_min = self.safe_float(weather_data['POST_temperature_min_C'][day], stats['temp_mean'] - 5)
+                    humidity = self.safe_float(weather_data['POST_humidity_%'][day], 50.0)
+                    spec_humidity = self.safe_float(weather_data['POST_specific_humidity_g_kg'][day], 10.0)
+                    dew_point = self.safe_float(weather_data['POST_dew_point_C'][day], stats['temp_mean'] - 10)
+                    wind = self.safe_float(weather_data['POST_wind_speed_mps'][day], 3.0)
+                    wind_10m = self.safe_float(weather_data['POST_wind_speed_10m_mps'][day], 3.0)
+                    precip = self.safe_float(weather_data['POST_precipitation_mm'][day], 0.0)
+                    pressure = self.safe_float(weather_data['POST_surface_pressure_hPa'][day], stats['pressure_mean'])
+                    sea_pressure = self.safe_float(weather_data['POST_sea_level_pressure_hPa'][day], stats['sea_pressure_mean'])
+                    solar = self.safe_float(weather_data['POST_solar_radiation_wm2'][day], stats['solar_mean'])
+                    cloud = self.safe_float(weather_data['POST_cloud_amount_%'][day], 50.0)
+                    soil_wetness = self.safe_float(weather_data['POST_surface_soil_wetness_%'][day], 30.0)
+                    wind_dir = self.safe_float(weather_data['POST_wind_direction_10m_degrees'][day], 180.0)
+                    evap = self.safe_float(weather_data['POST_evapotranspiration_wm2'][day], stats['evap_mean'])
+                    root_moisture = self.safe_float(weather_data['POST_root_zone_soil_moisture_%'][day], 30.0)
+                    
+                    # Count NaN values 
+                    nan_count = sum(1 for val in [temp, temp_max, temp_min, humidity, spec_humidity, dew_point, 
+                                                 wind, wind_10m, precip, pressure, sea_pressure, solar, cloud, 
+                                                 soil_wetness, wind_dir, evap, root_moisture] if pd.isna(val))
+                    if nan_count > 0:
+                        self.processing_stats['nan_count'] += nan_count
+                    
+                    # 1. Temperature Normalization
+                    if pd.isna(temp) or pd.isna(temp_min) or pd.isna(temp_max):
+                        temp_normalized = np.nan
+                    else:
+                        temp_range_val = temp_max - temp_min if temp_max > temp_min else 1.0
+                        temp_normalized = (temp - temp_min) / temp_range_val if temp_range_val > 0 else 0.0
+                    features['POST_temp_normalized'].append(temp_normalized)
+                    
+                    # 2. Temperature Range (diurnal)
+                    if pd.isna(temp_max) or pd.isna(temp_min):
+                        temp_range = np.nan
+                    else:
+                        temp_range = temp_max - temp_min
+                    features['POST_temp_range'].append(temp_range)
+                    
+                    # 3. Discomfort Index (THI)
+                    if pd.isna(temp) or pd.isna(humidity):
+                        discomfort_index = np.nan
+                    else:
+                        discomfort_index = temp - 0.55 * (1 - 0.01 * humidity) * (temp - 14.5)
+                    features['POST_discomfort_index'].append(discomfort_index)
+                    
+                    # 4. Heat Index  
+                    if pd.isna(temp) or pd.isna(humidity):
+                        heat_index = np.nan
+                    elif temp >= 27 and humidity >= 40:
+                        heat_index = (-8.78469475556 + 1.61139411 * temp + 2.33854883889 * humidity +
+                                     -0.14611605 * temp * humidity + -0.012308094 * temp**2 +
+                                     -0.0164248277778 * humidity**2 + 0.002211732 * temp**2 * humidity +
+                                     0.00072546 * temp * humidity**2 + -0.000003582 * temp**2 * humidity**2)
+                    else:
+                        heat_index = temp
+                    features['POST_heat_index'].append(heat_index)
+                    
+                    # 5. Wind-Precipitation Interaction
+                    if pd.isna(wind) or pd.isna(precip):
+                        wind_precip_interaction = np.nan
+                    else:
+                        wind_precip_interaction = wind * precip
+                    features['POST_wind_precip_interaction'].append(wind_precip_interaction)
+                    
+                    # 6. Solar Radiation to Temperature Ratio
+                    if pd.isna(solar) or pd.isna(temp):
+                        solar_temp_ratio = np.nan
+                    else:
+                        denominator = abs(temp) + 0.01
+                        solar_temp_ratio = solar / denominator if denominator > 1e-6 else 0.0
+                    features['POST_solar_temp_ratio'].append(solar_temp_ratio)
+                    
+                    # 7. Pressure Anomaly (surface)
+                    if pd.isna(pressure):
+                        pressure_anomaly = np.nan
+                    else:
+                        pressure_anomaly = pressure - stats['pressure_mean']
+                    features['POST_pressure_anomaly'].append(pressure_anomaly)
+                    
+                    # 8. High Precipitation Flag (>50mm threshold)
+                    if pd.isna(precip):
+                        high_precip_flag = np.nan
+                    else:
+                        high_precip_flag = float(int(precip > 50))
+                    features['POST_high_precip_flag'].append(high_precip_flag)
+                    
+                    # 9. Relative Humidity Adjusted for Temperature
+                    if pd.isna(humidity) or pd.isna(temp):
+                        adjusted_humidity = np.nan
+                    else:
+                        adjusted_humidity = humidity * (1 + (temp / 100))
+                    features['POST_adjusted_humidity'].append(adjusted_humidity)
+                    
+                    # 10. Wind Chill Index
+                    if pd.isna(temp) or pd.isna(wind):
+                        wind_chill = np.nan
+                    elif temp <= 10 and wind > 0:
+                        wind_chill = (13.12 + 0.6215 * temp - 11.37 * np.power(wind, 0.16) + 
+                                     0.3965 * temp * np.power(wind, 0.16))
+                    else:
+                        wind_chill = temp
+                    features['POST_wind_chill'].append(wind_chill)
+                    
+                    # 11. Solar Radiation Anomaly
+                    if pd.isna(solar):
+                        solar_anomaly = np.nan
+                    else:
+                        solar_anomaly = solar - stats['solar_mean']
+                    features['POST_solar_radiation_anomaly'].append(solar_anomaly)
+                    
+                    # 12. Weather Severity Score (composite)
+                    if pd.isna(temp_normalized) or pd.isna(precip) or pd.isna(wind) or pd.isna(cloud):
+                        weather_severity = np.nan
+                    else:
+                        precip_norm = precip / stats['precip_max'] if stats['precip_max'] > 0 else 0.0
+                        wind_norm = wind / stats['wind_max'] if stats['wind_max'] > 0 else 0.0
+                        cloud_norm = cloud / 100.0
+                        weather_severity = (temp_normalized + precip_norm + wind_norm + cloud_norm) / 4.0
+                    features['POST_weather_severity_score'].append(weather_severity)
+                    
+                    # 13. Moisture Stress Index (evaporation vs precipitation)
+                    if pd.isna(evap) or pd.isna(precip):
+                        moisture_stress = np.nan
+                    else:
+                        moisture_stress = (evap - precip) / (evap + precip + 0.01)
+                    features['POST_moisture_stress_index'].append(moisture_stress)
+                    
+                    # 14. Evaporation Deficit
+                    if pd.isna(evap):
+                        evap_deficit = np.nan
+                    else:
+                        evap_deficit = evap - stats['evap_mean']
+                    features['POST_evaporation_deficit'].append(evap_deficit)
+                    
+                    # 15. Soil Saturation Index (combined soil moisture)
+                    if pd.isna(soil_wetness) or pd.isna(root_moisture):
+                        soil_saturation = np.nan
+                    else:
+                        soil_saturation = (soil_wetness + root_moisture) / 2.0
+                    features['POST_soil_saturation_index'].append(soil_saturation)
+                    
+                    # 16. Atmospheric Instability (pressure difference + temp range)
+                    if pd.isna(sea_pressure) or pd.isna(pressure) or pd.isna(temp_range):
+                        atm_instability = np.nan
+                    else:
+                        atm_instability = abs(sea_pressure - pressure) + temp_range
+                    features['POST_atmospheric_instability'].append(atm_instability)
+                    
+                    # 17. Drought Indicator (low precip + high temp + low soil moisture)
+                    if pd.isna(temp) or pd.isna(precip) or pd.isna(soil_saturation):
+                        drought_indicator = np.nan
+                    else:
+                        temp_factor = (temp - stats['temp_mean']) / max(abs(stats['temp_max_mean'] - stats['temp_mean']), 1) if stats['temp_max_mean'] != stats['temp_mean'] else 0.0
+                        drought_indicator = ((1 - precip / stats['precip_max']) * 
+                                           max(0.0, temp_factor) * 
+                                           (1 - soil_saturation / 100.0))
+                    features['POST_drought_indicator'].append(drought_indicator)
+                    
+                    # 18. Flood Risk Score (high precip + saturated soil + low evap)
+                    if pd.isna(precip) or pd.isna(soil_saturation) or pd.isna(evap):
+                        flood_risk = np.nan
+                    else:
+                        precip_factor = precip / stats['precip_max'] if stats['precip_max'] > 0 else 0.0
+                        soil_factor = soil_saturation / 100.0
+                        evap_factor = 1.0 - evap / max(stats['evap_mean'] * 2, 1.0)
+                        flood_risk = precip_factor * soil_factor * evap_factor
+                    features['POST_flood_risk_score'].append(flood_risk)
+                    
+                    # 19. Storm Intensity Index (wind + precip + pressure drop)
+                    if pd.isna(wind_10m) or pd.isna(precip) or pd.isna(pressure_anomaly):
+                        storm_intensity = np.nan
+                    else:
+                        wind_factor = wind_10m / stats['wind_max'] if stats['wind_max'] > 0 else 0.0
+                        precip_factor = precip / stats['precip_max'] if stats['precip_max'] > 0 else 0.0
+                        pressure_factor = abs(pressure_anomaly) / 50.0
+                        storm_intensity = wind_factor + precip_factor + pressure_factor
+                    features['POST_storm_intensity_index'].append(storm_intensity)
+                    
+                except Exception as e:
+                    logger.error(f"Error processing day {day}: {e}")
+                    # Fill with NaN for this day across all features
+                    for feature in self.POST_FEATURE_VARIABLES:
+                        features[feature].append(np.nan)
+            
+            self.processing_stats['successful_calculations'] += 1
+            
+            return {
+                'success': True,
+                'features': features,
+                'metadata': {
+                    'days_processed': self.days_count,
+                    'features_created': len(self.POST_FEATURE_VARIABLES),
+                    'processing_timestamp': datetime.now().isoformat()
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"Error in feature engineering: {e}")
+            self.processing_stats['failed_calculations'] += 1
+            return {
+                'success': False,
+                'error': f"Feature engineering failed: {str(e)}",
+                'features': {feature: [np.nan] * self.days_count for feature in self.POST_FEATURE_VARIABLES}
+            }
+    
+    def engineer_batch_features(self, weather_datasets: List[Dict[str, List[float]]]) -> List[Dict[str, Any]]:
+        """
+        Engineer features for multiple coordinates with shared global statistics
+        
+        Args:
+            weather_datasets: List of weather data dictionaries
+        
+        Returns:
+            List of feature engineering results
+        """
+        try:
+            logger.info(f"Engineering features for {len(weather_datasets)} coordinates")
+            
+            # Calculate global statistics across all datasets
+            global_stats = self.calculate_global_statistics(weather_datasets)
+            
+            # Process each coordinate
+            results = []
+            for i, weather_data in enumerate(weather_datasets):
+                logger.debug(f"Processing coordinate {i + 1}/{len(weather_datasets)}")
+                result = self.engineer_single_coordinate_features(weather_data, global_stats)
+                results.append(result)
+            
+            logger.info(f"Batch feature engineering completed: {len(results)} results")
+            return results
+            
+        except Exception as e:
+            logger.error(f"Batch feature engineering error: {e}")
+            return [
+                {
+                    'success': False,
+                    'error': f"Batch processing failed: {str(e)}",
+                    'features': {feature: [np.nan] * self.days_count for feature in self.POST_FEATURE_VARIABLES}
+                }
+                for _ in weather_datasets
+            ]
+    
+    def get_feature_descriptions(self) -> Dict[str, Dict[str, str]]:
+        """Get descriptions of all engineered features"""
+        return {
+            'POST_temp_normalized': {
+                'description': 'Normalized temperature based on daily range',
+                'unit': 'ratio (0-1)',
+                'calculation': '(temp - temp_min) / (temp_max - temp_min)'
+            },
+            'POST_temp_range': {
+                'description': 'Diurnal temperature range',
+                'unit': '°C',
+                'calculation': 'temp_max - temp_min'
+            },
+            'POST_discomfort_index': {
+                'description': 'Temperature-Humidity Index (THI)',
+                'unit': '°C',
+                'calculation': 'temp - 0.55 * (1 - 0.01 * humidity) * (temp - 14.5)'
+            },
+            'POST_heat_index': {
+                'description': 'Apparent temperature combining temp and humidity',
+                'unit': '°C',
+                'calculation': 'Complex formula for temp>=27°C and humidity>=40%'
+            },
+            'POST_wind_precip_interaction': {
+                'description': 'Wind-precipitation interaction term',
+                'unit': 'mm·m/s',
+                'calculation': 'wind_speed * precipitation'
+            },
+            'POST_solar_temp_ratio': {
+                'description': 'Solar radiation efficiency relative to temperature',
+                'unit': 'W/m²/°C',
+                'calculation': 'solar_radiation / (|temperature| + 0.01)'
+            },
+            'POST_pressure_anomaly': {
+                'description': 'Surface pressure deviation from global mean',
+                'unit': 'hPa',
+                'calculation': 'surface_pressure - global_pressure_mean'
+            },
+            'POST_high_precip_flag': {
+                'description': 'Binary flag for heavy precipitation (>50mm)',
+                'unit': 'binary',
+                'calculation': '1 if precipitation > 50mm else 0'
+            },
+            'POST_adjusted_humidity': {
+                'description': 'Relative humidity adjusted for temperature',
+                'unit': '%',
+                'calculation': 'humidity * (1 + temperature/100)'
+            },
+            'POST_wind_chill': {
+                'description': 'Wind chill temperature for cold conditions',
+                'unit': '°C',
+                'calculation': 'Wind chill formula for temp<=10°C'
+            },
+            'POST_solar_radiation_anomaly': {
+                'description': 'Solar radiation deviation from global mean',
+                'unit': 'W/m²',
+                'calculation': 'solar_radiation - global_solar_mean'
+            },
+            'POST_weather_severity_score': {
+                'description': 'Composite weather severity index',
+                'unit': 'ratio (0-1)',
+                'calculation': 'Average of normalized temp, precip, wind, cloud metrics'
+            },
+            'POST_moisture_stress_index': {
+                'description': 'Evapotranspiration vs precipitation balance',
+                'unit': 'ratio (-1 to 1)',
+                'calculation': '(evap - precip) / (evap + precip + 0.01)'
+            },
+            'POST_evaporation_deficit': {
+                'description': 'Evapotranspiration deficit from global mean',
+                'unit': 'W/m²',
+                'calculation': 'evapotranspiration - global_evap_mean'
+            },
+            'POST_soil_saturation_index': {
+                'description': 'Combined soil moisture indicator',
+                'unit': '%',
+                'calculation': '(surface_wetness + root_moisture) / 2'
+            },
+            'POST_atmospheric_instability': {
+                'description': 'Atmospheric instability indicator',
+                'unit': 'hPa + °C',
+                'calculation': '|sea_pressure - surface_pressure| + temp_range'
+            },
+            'POST_drought_indicator': {
+                'description': 'Composite drought risk index',
+                'unit': 'ratio (0-1)',
+                'calculation': 'Function of low precip, high temp, low soil moisture'
+            },
+            'POST_flood_risk_score': {
+                'description': 'Composite flood risk index',
+                'unit': 'ratio (0-1)',
+                'calculation': 'Function of high precip, saturated soil, low evap'
+            },
+            'POST_storm_intensity_index': {
+                'description': 'Composite storm intensity index',
+                'unit': 'ratio',
+                'calculation': 'Sum of normalized wind, precip, pressure anomaly'
+            }
+        }
+    
+    def get_processing_statistics(self) -> Dict[str, Any]:
+        """Get processing statistics"""
+        total_processed = self.processing_stats['total_processed']
+        
+        return {
+            'total_coordinates_processed': total_processed,
+            'successful_calculations': self.processing_stats['successful_calculations'],
+            'failed_calculations': self.processing_stats['failed_calculations'],
+            'success_rate': (self.processing_stats['successful_calculations'] / total_processed * 100) if total_processed > 0 else 0,
+            'nan_values_encountered': self.processing_stats['nan_count'],
+            'days_per_coordinate': self.days_count,
+            'features_per_coordinate': len(self.POST_FEATURE_VARIABLES),
+            'input_variables': len(self.POST_WEATHER_VARIABLES),
+            'output_variables': len(self.POST_FEATURE_VARIABLES)
+        }

server/models/post_disaster_weather_model.py

@@ -0,0 +1,384 @@
+"""
+Post-Disaster Weather Data Model for HazardGuard System
+Fetches weather data for 60 days AFTER disaster occurrence using NASA POWER API
+"""
+
+import logging
+import requests
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple, Any, Union
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import time
+import json
+
+logger = logging.getLogger(__name__)
+
+class PostDisasterWeatherModel:
+    """Model for fetching post-disaster weather data from NASA POWER API"""
+    
+    # Post-disaster weather variables (17 total) with POST_ prefix
+    WEATHER_FIELDS = {
+        # Original 6 core variables
+        'T2M': 'POST_temperature_C',
+        'RH2M': 'POST_humidity_%', 
+        'WS2M': 'POST_wind_speed_mps',
+        'PRECTOTCORR': 'POST_precipitation_mm',
+        'PS': 'POST_surface_pressure_hPa',
+        'ALLSKY_SFC_SW_DWN': 'POST_solar_radiation_wm2',
+        # Additional 11 variables for comprehensive analysis
+        'T2M_MAX': 'POST_temperature_max_C',
+        'T2M_MIN': 'POST_temperature_min_C', 
+        'QV2M': 'POST_specific_humidity_g_kg',
+        'T2MDEW': 'POST_dew_point_C',
+        'WS10M': 'POST_wind_speed_10m_mps',
+        'CLOUD_AMT': 'POST_cloud_amount_%',
+        'SLP': 'POST_sea_level_pressure_hPa',
+        'GWETTOP': 'POST_surface_soil_wetness_%',
+        'WD10M': 'POST_wind_direction_10m_degrees',
+        'EVPTRNS': 'POST_evapotranspiration_wm2',
+        'GWETROOT': 'POST_root_zone_soil_moisture_%'
+    }
+    
+    # NASA POWER API fill values that should be treated as NaN
+    NASA_FILL_VALUES = [-999, -999.0, -99999, -99999.0]
+    
+    def __init__(self, 
+                 days_after_disaster: int = 60,
+                 max_workers: int = 1, 
+                 retry_limit: int = 5,
+                 retry_delay: int = 15,
+                 rate_limit_pause: int = 900,
+                 request_delay: float = 0.5):
+        """
+        Initialize post-disaster weather model
+        
+        Args:
+            days_after_disaster: Number of days to fetch after disaster (default: 60)
+            max_workers: Maximum concurrent API requests (default: 1)
+            retry_limit: Maximum retry attempts per request (default: 5) 
+            retry_delay: Delay between retries in seconds (default: 15)
+            rate_limit_pause: Pause duration for rate limits in seconds (default: 900)
+            request_delay: Delay between requests in seconds (default: 0.5)
+        """
+        self.days_after_disaster = days_after_disaster
+        self.max_workers = max_workers
+        self.retry_limit = retry_limit
+        self.retry_delay = retry_delay
+        self.rate_limit_pause = rate_limit_pause
+        self.request_delay = request_delay
+        
+        self.api_url = "https://power.larc.nasa.gov/api/temporal/daily/point"
+        self.request_count = 0
+        self.success_count = 0
+        self.failure_count = 0
+        
+        logger.info(f"Initialized PostDisasterWeatherModel: {days_after_disaster} days, {len(self.WEATHER_FIELDS)} variables")
+    
+    def validate_coordinates(self, coordinates: List[Dict[str, float]]) -> Tuple[bool, str]:
+        """Validate coordinate format and ranges"""
+        try:
+            if not coordinates or not isinstance(coordinates, list):
+                return False, "Coordinates must be a non-empty list"
+            
+            for i, coord in enumerate(coordinates):
+                if not isinstance(coord, dict):
+                    return False, f"Coordinate {i} must be a dictionary"
+                
+                if 'latitude' not in coord or 'longitude' not in coord:
+                    return False, f"Coordinate {i} must have 'latitude' and 'longitude' keys"
+                
+                try:
+                    lat = float(coord['latitude'])
+                    lon = float(coord['longitude'])
+                    
+                    if not (-90 <= lat <= 90):
+                        return False, f"Coordinate {i} latitude {lat} out of range (-90 to 90)"
+                    if not (-180 <= lon <= 180):
+                        return False, f"Coordinate {i} longitude {lon} out of range (-180 to 180)"
+                        
+                except (TypeError, ValueError):
+                    return False, f"Coordinate {i} has invalid latitude/longitude values"
+            
+            return True, "Coordinates are valid"
+            
+        except Exception as e:
+            logger.error(f"Coordinate validation error: {e}")
+            return False, f"Validation error: {str(e)}"
+    
+    def validate_disaster_date(self, disaster_date: Union[str, datetime]) -> Tuple[bool, str, Optional[datetime]]:
+        """Validate and parse disaster date"""
+        try:
+            if isinstance(disaster_date, str):
+                # Try multiple date formats
+                date_formats = [
+                    '%Y-%m-%d',
+                    '%Y/%m/%d', 
+                    '%m/%d/%Y',
+                    '%d/%m/%Y',
+                    '%Y-%m-%d %H:%M:%S',
+                    '%m-%d-%Y',
+                    '%d-%m-%Y'
+                ]
+                
+                parsed_date = None
+                for fmt in date_formats:
+                    try:
+                        parsed_date = datetime.strptime(disaster_date, fmt)
+                        break
+                    except ValueError:
+                        continue
+                
+                if parsed_date is None:
+                    return False, f"Unable to parse date '{disaster_date}'", None
+                        
+            elif isinstance(disaster_date, datetime):
+                parsed_date = disaster_date
+            else:
+                return False, "Disaster date must be string or datetime", None
+            
+            # Check if end date would be too recent (API has ~7 day lag)
+            end_date = parsed_date + timedelta(days=self.days_after_disaster)
+            current_date = datetime.now() - timedelta(days=7)
+            
+            if end_date > current_date:
+                return False, f"End date {end_date.date()} is too recent (API has ~7 day lag)", None
+            
+            return True, "Date is valid", parsed_date
+            
+        except Exception as e:
+            logger.error(f"Date validation error: {e}")
+            return False, f"Date validation error: {str(e)}", None
+    
+    def clean_nasa_values(self, values: List[float]) -> List[Optional[float]]:
+        """Clean NASA API values, converting fill values to NaN"""
+        if not values:
+            return [np.nan] * self.days_after_disaster
+        
+        cleaned = []
+        for value in values:
+            if value in self.NASA_FILL_VALUES or pd.isna(value):
+                cleaned.append(np.nan)
+            else:
+                # Convert numpy types to native Python types for JSON serialization
+                if hasattr(value, 'item'):
+                    cleaned.append(float(value.item()))
+                else:
+                    cleaned.append(float(value))
+        
+        # Ensure we have exactly the right number of days
+        if len(cleaned) < self.days_after_disaster:
+            cleaned.extend([np.nan] * (self.days_after_disaster - len(cleaned)))
+        elif len(cleaned) > self.days_after_disaster:
+            cleaned = cleaned[:self.days_after_disaster]
+        
+        return cleaned
+    
+    def fetch_weather_for_coordinate(self, coordinate: Dict[str, float], disaster_date: datetime) -> Dict[str, Any]:
+        """Fetch post-disaster weather data for a single coordinate"""
+        try:
+            lat = float(coordinate['latitude'])
+            lon = float(coordinate['longitude'])
+            
+            # Calculate post-disaster date range
+            post_start_date = disaster_date + timedelta(days=1)  # Start day after disaster
+            post_end_date = post_start_date + timedelta(days=self.days_after_disaster - 1)
+            
+            logger.debug(f"Fetching post-disaster weather for lat={lat}, lon={lon}, dates={post_start_date.date()} to {post_end_date.date()}")
+            
+            params = {
+                "latitude": lat,
+                "longitude": lon,
+                "start": post_start_date.strftime("%Y%m%d"),
+                "end": post_end_date.strftime("%Y%m%d"),
+                "community": "RE",
+                "format": "JSON",
+                "parameters": ','.join(self.WEATHER_FIELDS.keys())
+            }
+            
+            for attempt in range(self.retry_limit):
+                try:
+                    # Add delay to avoid overwhelming API
+                    time.sleep(self.request_delay)
+                    
+                    response = requests.get(self.api_url, params=params, timeout=60)
+                    self.request_count += 1
+                    
+                    if response.status_code == 429:
+                        logger.warning(f"Rate limit hit (429). Pausing {self.rate_limit_pause}s...")
+                        time.sleep(self.rate_limit_pause)
+                        continue
+                    
+                    response.raise_for_status()
+                    data = response.json().get("properties", {}).get("parameter", {})
+                    
+                    if not data:
+                        logger.warning(f"No data returned from API for lat={lat}, lon={lon}")
+                        self.failure_count += 1
+                        return None
+                    
+                    # Process weather data
+                    result = {
+                        'latitude': lat,
+                        'longitude': lon,
+                        'disaster_date': disaster_date.strftime('%Y-%m-%d'),
+                        'post_start_date': post_start_date.strftime('%Y-%m-%d'),
+                        'post_end_date': post_end_date.strftime('%Y-%m-%d'),
+                        'days_fetched': self.days_after_disaster
+                    }
+                    
+                    for nasa_key, col_name in self.WEATHER_FIELDS.items():
+                        raw_values = list(data.get(nasa_key, {}).values())
+                        cleaned_values = self.clean_nasa_values(raw_values)
+                        result[col_name] = cleaned_values
+                        
+                        # Add summary statistics
+                        valid_values = [v for v in cleaned_values if not pd.isna(v)]
+                        if valid_values:
+                            result[f"{col_name}_mean"] = float(np.mean(valid_values))
+                            result[f"{col_name}_std"] = float(np.std(valid_values))
+                            result[f"{col_name}_min"] = float(np.min(valid_values))
+                            result[f"{col_name}_max"] = float(np.max(valid_values))
+                            result[f"{col_name}_missing_days"] = int(self.days_after_disaster - len(valid_values))
+                        else:
+                            result[f"{col_name}_mean"] = np.nan
+                            result[f"{col_name}_std"] = np.nan
+                            result[f"{col_name}_min"] = np.nan
+                            result[f"{col_name}_max"] = np.nan
+                            result[f"{col_name}_missing_days"] = int(self.days_after_disaster)
+                    
+                    self.success_count += 1
+                    logger.debug(f"Successfully fetched post-disaster weather for lat={lat}, lon={lon}")
+                    return result
+                    
+                except requests.exceptions.RequestException as e:
+                    logger.warning(f"Request error (attempt {attempt + 1}/{self.retry_limit}): {e}")
+                    if attempt < self.retry_limit - 1:
+                        time.sleep(self.retry_delay)
+                    else:
+                        self.failure_count += 1
+                        logger.error(f"Failed to fetch after {self.retry_limit} attempts for lat={lat}, lon={lon}")
+                        return None
+                        
+        except Exception as e:
+            logger.error(f"Critical error fetching weather for coordinate {coordinate}: {e}")
+            self.failure_count += 1
+            return None
+    
+    def fetch_weather_batch(self, coordinates: List[Dict[str, float]], disaster_dates: List[datetime]) -> List[Optional[Dict[str, Any]]]:
+        """Fetch post-disaster weather data for multiple coordinates"""
+        try:
+            if len(coordinates) != len(disaster_dates):
+                raise ValueError("Number of coordinates must match number of disaster dates")
+            
+            logger.info(f"Fetching post-disaster weather for {len(coordinates)} coordinates using {self.max_workers} workers")
+            
+            results = []
+            
+            with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+                # Submit all tasks
+                future_to_index = {
+                    executor.submit(self.fetch_weather_for_coordinate, coord, date): i 
+                    for i, (coord, date) in enumerate(zip(coordinates, disaster_dates))
+                }
+                
+                # Collect results in original order
+                indexed_results = {}
+                for future in as_completed(future_to_index):
+                    index = future_to_index[future]
+                    try:
+                        result = future.result()
+                        indexed_results[index] = result
+                    except Exception as e:
+                        logger.error(f"Error processing coordinate {index}: {e}")
+                        indexed_results[index] = None
+                
+                # Sort by index to maintain order
+                results = [indexed_results[i] for i in range(len(coordinates))]
+            
+            logger.info(f"Completed batch processing: {self.success_count} successes, {self.failure_count} failures")
+            return results
+            
+        except Exception as e:
+            logger.error(f"Batch processing error: {e}")
+            return [None] * len(coordinates)
+    
+    def get_available_variables(self) -> Dict[str, Dict[str, Any]]:
+        """Get information about available post-disaster weather variables"""
+        variable_info = {}
+        
+        for nasa_key, col_name in self.WEATHER_FIELDS.items():
+            variable_info[col_name] = {
+                'nasa_parameter': nasa_key,
+                'description': self._get_variable_description(nasa_key),
+                'unit': self._get_variable_unit(col_name),
+                'type': 'time_series',
+                'days': self.days_after_disaster,
+                'includes_statistics': True
+            }
+        
+        return variable_info
+    
+    def _get_variable_description(self, nasa_key: str) -> str:
+        """Get human-readable description for NASA parameter"""
+        descriptions = {
+            'T2M': 'Temperature at 2 Meters',
+            'RH2M': 'Relative Humidity at 2 Meters',
+            'WS2M': 'Wind Speed at 2 Meters',
+            'PRECTOTCORR': 'Precipitation Corrected',
+            'PS': 'Surface Pressure',
+            'ALLSKY_SFC_SW_DWN': 'All Sky Surface Shortwave Downward Irradiance',
+            'T2M_MAX': 'Temperature at 2 Meters Maximum',
+            'T2M_MIN': 'Temperature at 2 Meters Minimum',
+            'QV2M': 'Specific Humidity at 2 Meters',
+            'T2MDEW': 'Dew/Frost Point at 2 Meters',
+            'WS10M': 'Wind Speed at 10 Meters',
+            'CLOUD_AMT': 'Cloud Amount',
+            'SLP': 'Sea Level Pressure',
+            'GWETTOP': 'Surface Soil Wetness',
+            'WD10M': 'Wind Direction at 10 Meters',
+            'EVPTRNS': 'Evapotranspiration Energy Flux',
+            'GWETROOT': 'Root Zone Soil Wetness'
+        }
+        return descriptions.get(nasa_key, nasa_key)
+    
+    def _get_variable_unit(self, col_name: str) -> str:
+        """Get unit for variable from column name"""
+        if 'temperature' in col_name.lower():
+            return '°C'
+        elif 'humidity' in col_name.lower():
+            return '%'
+        elif 'wind_speed' in col_name.lower():
+            return 'm/s'
+        elif 'precipitation' in col_name.lower():
+            return 'mm'
+        elif 'pressure' in col_name.lower():
+            return 'hPa'
+        elif 'radiation' in col_name.lower() or 'evapotranspiration' in col_name.lower():
+            return 'W/m²'
+        elif 'cloud' in col_name.lower() or 'wetness' in col_name.lower() or 'moisture' in col_name.lower():
+            return '%'
+        elif 'dew_point' in col_name.lower():
+            return '°C'
+        elif 'wind_direction' in col_name.lower():
+            return 'degrees'
+        elif 'humidity_g_kg' in col_name:
+            return 'g/kg'
+        else:
+            return 'units'
+    
+    def get_processing_stats(self) -> Dict[str, Any]:
+        """Get processing statistics"""
+        total_requests = self.request_count
+        success_rate = (self.success_count / total_requests * 100) if total_requests > 0 else 0
+        
+        return {
+            'total_requests': total_requests,
+            'successful_requests': self.success_count,
+            'failed_requests': self.failure_count,
+            'success_rate': round(success_rate, 2),
+            'days_per_request': self.days_after_disaster,
+            'total_variables': len(self.WEATHER_FIELDS),
+            'api_endpoint': self.api_url.split('/')[-1]
+        }

server/models/raster_data_model.py

@@ -0,0 +1,593 @@
+"""
+Raster Data Model for HazardGuard System
+Extracts 9 geospatial features from COG-optimized raster data sources:
+1. Soil type (HWSD2) - 33 soil classifications with database lookup         [soil_type.tif]
+2. Elevation (WorldClim) - meters above sea level                           [elevation.tif]
+3. Population density (GlobPOP) - persons per km²                           [population_density.tif]
+4. Land cover (Copernicus) - 22 land cover classes                          [land_cover.tif]
+5. NDVI (MODIS/eVIIRS) - Normalized Difference Vegetation Index             [ndvi.tif]
+6. Annual precipitation (WorldClim) - mm per year                           [annual_precip.tif]
+7. Annual mean temperature (WorldClim) - °C                                 [mean_annual_temp.tif]
+8. Mean wind speed (Global Wind Atlas) - m/s                                [wind_speed.tif]
+9. Impervious surface (GHSL) - percentage                                   [impervious_surface.tif]
+
+All rasters are Cloud Optimized GeoTIFF (COG) with ZSTD compression, 256x256 tiles.
+Data is 100% lossless — identical pixel values to original sources.
+Files are served from GCS bucket (satellite-cog-data-for-shrishti) or local fallback
+"""
+
+import pandas as pd
+import numpy as np
+import os
+import rasterio
+from rasterio.warp import transform
+import pyproj
+import logging
+from typing import List, Tuple, Dict, Optional, Any
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+# Note: PROJ/GDAL environment setup is done in main.py before any imports
+
+class RasterDataModel:
+    """Core model for raster data extraction and processing"""
+    
+    def __init__(self):
+        """Initialize raster data model"""
+        self.soil_databases_loaded = False
+        self.smu_df = None
+        self.wrb4_lookup = None
+        
+        # Soil type classification mapping (0-33)
+        self.soil_classes = {
+            'Acrisols': 1, 'Alisols': 2, 'Andosols': 3, 'Arenosols': 4, 'Calcisols': 5,
+            'Cambisols': 6, 'Chernozems': 7, 'Ferralsols': 8, 'Fluvisols': 9, 'Gleysols': 10,
+            'Gypsisols': 11, 'Histosols': 12, 'Kastanozems': 13, 'Leptosols': 14, 'Lixisols': 15,
+            'Luvisols': 16, 'Nitisols': 17, 'Phaeozems': 18, 'Planosols': 19, 'Podzols': 20,
+            'Regosols': 21, 'Solonchaks': 22, 'Solonetz': 23, 'Vertisols': 24, 'Unknown': 0,
+            # Singular forms
+            'Acrisol': 1, 'Alisol': 2, 'Andosol': 3, 'Arenosol': 4, 'Calcisol': 5,
+            'Cambisol': 6, 'Chernozem': 7, 'Ferralsol': 8, 'Fluvisol': 9, 'Gleysol': 10,
+            'Gypsisol': 11, 'Histosol': 12, 'Kastanozem': 13, 'Leptosol': 14, 'Lixisol': 15,
+            'Luvisol': 16, 'Nitisol': 17, 'Phaeozem': 18, 'Planosol': 19, 'Podzol': 20,
+            'Regosol': 21, 'Solonchak': 22, 'Solonetz': 23, 'Vertisol': 24,
+            # Additional soil types
+            'Anthrosols': 25, 'Cryosols': 26, 'Durisols': 27, 'Ferrasols': 28, 'Plinthosols': 29,
+            'Retisols': 30, 'Stagnosols': 31, 'Technosols': 32, 'Umbrisols': 33
+        }
+        
+        # Land cover classification mapping (0-21)
+        self.land_cover_classes = {
+            0: 0,    # Unknown (NoData)
+            20: 1,   # Shrubs
+            30: 2,   # Herbaceous vegetation
+            40: 3,   # Cropland
+            50: 4,   # Urban / built up
+            60: 5,   # Bare / sparse vegetation
+            70: 6,   # Snow and ice
+            80: 7,   # Permanent water bodies
+            90: 8,   # Herbaceous wetland
+            100: 9,  # Moss and lichen
+            111: 10, # Closed forest, evergreen needle leaf
+            112: 11, # Closed forest, evergreen broad leaf
+            113: 12, # Closed forest, deciduous needle leaf
+            114: 13, # Closed forest, deciduous broad leaf
+            115: 14, # Closed forest, mixed
+            116: 15, # Closed forest, unknown
+            121: 16, # Open forest, evergreen needle leaf
+            122: 17, # Open forest, evergreen broad leaf
+            123: 18, # Open forest, deciduous needle leaf
+            124: 19, # Open forest, deciduous broad leaf
+            125: 20, # Open forest, mixed
+            126: 21  # Open forest, unknown
+        }
+    
+    def load_soil_databases(self, hwsd2_path: str, wrb4_path: str) -> bool:
+        """Load HWSD2 SMU and WRB4 lookup tables"""
+        try:
+            self.smu_df = pd.read_excel(hwsd2_path, index_col='HWSD2_SMU_ID')
+            wrb4_df = pd.read_excel(wrb4_path)
+            self.wrb4_lookup = dict(zip(wrb4_df['CODE'], wrb4_df['VALUE']))
+            self.soil_databases_loaded = True
+            
+            logger.info(f"Loaded {len(self.smu_df)} SMU records and {len(self.wrb4_lookup)} WRB4 codes")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error loading soil databases: {e}")
+            self.soil_databases_loaded = False
+            return False
+    
+    def encode_soil_class(self, soil_class_name: str) -> int:
+        """Encode soil class name to integer (0-33)"""
+        return self.soil_classes.get(soil_class_name, 0)
+    
+    def encode_land_cover(self, lc_value: int) -> int:
+        """Encode Copernicus land cover classes (0-21)"""
+        return self.land_cover_classes.get(lc_value, 0)
+    
+    def extract_soil_type(self, coords: List[Tuple[float, float]], raster_path: str) -> List[int]:
+        """Extract soil type with database lookup"""
+        if not self.soil_databases_loaded:
+            logger.error("Soil databases not loaded")
+            return [0] * len(coords)
+        
+        try:
+            with rasterio.open(raster_path) as src:
+                logger.debug(f"Soil Raster NoData: {src.nodata}")
+                soil_smus = [val[0] for val in src.sample(coords)]
+                results = []
+                
+                for (lon, lat), soil_smu in zip(coords, soil_smus):
+                    if soil_smu == 65535 or soil_smu == src.nodata or pd.isna(soil_smu):
+                        results.append(0)  # Unknown
+                        logger.debug(f"NoData soil for lat={lat}, lon={lon}")
+                    else:
+                        try:
+                            wrb4_code = self.smu_df.loc[int(soil_smu), 'WRB4']
+                            if pd.isna(wrb4_code) or wrb4_code == '':
+                                soil_class_name = 'Unknown'
+                            else:
+                                soil_class_name = self.wrb4_lookup.get(wrb4_code, 'Unknown')
+                            
+                            # Extract main soil class (e.g., "Haplic Acrisols" -> "Acrisols")
+                            soil_main = soil_class_name.split()[-1] if len(soil_class_name.split()) > 1 else soil_class_name
+                            
+                            # Try main class first, then full name, then default to 0
+                            soil_class_encoded = self.encode_soil_class(soil_main)
+                            if soil_class_encoded == 0 and soil_main != soil_class_name:
+                                soil_class_encoded = self.encode_soil_class(soil_class_name)
+                            
+                            results.append(soil_class_encoded)
+                            logger.debug(f"Got soil type {soil_class_name} (main: {soil_main}, code {soil_class_encoded}) for lat={lat}, lon={lon}")
+                            
+                        except (KeyError, ValueError):
+                            results.append(0)  # Unknown
+                            logger.debug(f"Missing soil data for SMU {soil_smu} at lat={lat}, lon={lon}")
+                
+                return results
+                
+        except Exception as e:
+            logger.error(f"Error in soil type extraction: {e}")
+            return [0] * len(coords)
+    
+    def extract_elevation(self, coords: List[Tuple[float, float]], raster_path: str) -> List[float]:
+        """Extract elevation in meters"""
+        try:
+            with rasterio.open(raster_path) as src:
+                logger.debug(f"Elevation Raster NoData: {src.nodata}")
+                elevations = [val[0] for val in src.sample(coords)]
+                results = []
+                
+                for (lon, lat), elev in zip(coords, elevations):
+                    if elev == src.nodata or pd.isna(elev):
+                        results.append(-9999.0)
+                        logger.debug(f"NoData elevation for lat={lat}, lon={lon}")
+                    else:
+                        # Convert numpy types to native Python float
+                        elev_val = float(elev) if hasattr(elev, 'item') else float(elev)
+                        results.append(round(elev_val, 2))
+                        logger.debug(f"Got elevation {elev_val:.2f}m for lat={lat}, lon={lon}")
+                
+                return results
+                
+        except Exception as e:
+            logger.error(f"Error in elevation extraction: {e}")
+            return [-9999.0] * len(coords)
+    
+    def extract_population_density(self, coords: List[Tuple[float, float]], raster_path: str) -> List[float]:
+        """Extract population density in persons/km²"""
+        try:
+            with rasterio.open(raster_path) as src:
+                logger.debug(f"Population Raster NoData: {src.nodata}")
+                populations = [val[0] for val in src.sample(coords)]
+                results = []
+                
+                for (lon, lat), pop in zip(coords, populations):
+                    if pop == src.nodata or pd.isna(pop):
+                        results.append(-9999.0)
+                        logger.debug(f"NoData population for lat={lat}, lon={lon}")
+                    else:
+                        # Convert numpy types to native Python float
+                        pop_val = float(pop) if hasattr(pop, 'item') else float(pop)
+                        results.append(round(pop_val, 2))
+                        logger.debug(f"Got population density {pop_val:.2f} persons/km² for lat={lat}, lon={lon}")
+                
+                return results
+                
+        except Exception as e:
+            logger.error(f"Error in population extraction: {e}")
+            return [-9999.0] * len(coords)
+    
+    def extract_land_cover(self, coords: List[Tuple[float, float]], raster_path: str) -> List[int]:
+        """Extract land cover classification"""
+        try:
+            with rasterio.open(raster_path) as src:
+                logger.debug(f"Land Cover Raster NoData: {src.nodata}")
+                landcovers = [val[0] for val in src.sample(coords)]
+                results = []
+                
+                for (lon, lat), lc_code in zip(coords, landcovers):
+                    if lc_code == src.nodata or pd.isna(lc_code) or lc_code not in self.land_cover_classes:
+                        logger.debug(f"NoData or invalid land cover for lat={lat}, lon={lon}")
+                        results.append(0)  # Default to 0 (Unknown)
+                    else:
+                        lc_encoded = self.land_cover_classes[int(lc_code)]
+                        logger.debug(f"Got land cover class {lc_encoded} (code: {lc_code}) for lat={lat}, lon={lon}")
+                        results.append(lc_encoded)
+                
+                return results
+                
+        except Exception as e:
+            logger.error(f"Error in land cover extraction: {e}")
+            return [0] * len(coords)
+    
+    def extract_ndvi(self, coords: List[Tuple[float, float]], raster_path: str) -> List[float]:
+        """Extract NDVI with scaling factor /10000"""
+        try:
+            with rasterio.open(raster_path) as src:
+                logger.debug(f"NDVI Raster NoData: {src.nodata}")
+                ndvi_values = [val[0] for val in src.sample(coords)]
+                results = []
+                
+                for (lon, lat), ndvi_val in zip(coords, ndvi_values):
+                    if ndvi_val == -9999.0 or ndvi_val == src.nodata or pd.isna(ndvi_val):
+                        results.append(-9999.0)
+                        logger.debug(f"NoData NDVI for lat={lat}, lon={lon}")
+                    else:
+                        # Convert numpy types to native Python float
+                        ndvi_raw = float(ndvi_val) if hasattr(ndvi_val, 'item') else float(ndvi_val)
+                        scaled_ndvi = ndvi_raw / 10000.0
+                        rounded_ndvi = round(scaled_ndvi, 4)
+                        results.append(rounded_ndvi)
+                        logger.debug(f"Got NDVI {rounded_ndvi} for lat={lat}, lon={lon}")
+                
+                return results
+                
+        except Exception as e:
+            logger.error(f"Error in NDVI extraction: {e}")
+            return [-9999.0] * len(coords)
+    
+    def extract_annual_precipitation(self, coords: List[Tuple[float, float]], raster_path: str) -> List[int]:
+        """Extract annual precipitation in mm"""
+        try:
+            with rasterio.open(raster_path) as src:
+                logger.debug(f"Precip Raster NoData: {src.nodata}")
+                precips = [val[0] for val in src.sample(coords)]
+                results = []
+                
+                for (lon, lat), precip in zip(coords, precips):
+                    if precip == src.nodata or pd.isna(precip):
+                        results.append(-9999)
+                        logger.debug(f"NoData precip for lat={lat}, lon={lon}")
+                    else:
+                        # Convert numpy types to native Python int
+                        precip_val = float(precip) if hasattr(precip, 'item') else float(precip)
+                        rounded_precip = int(round(precip_val, 0))
+                        results.append(rounded_precip)
+                        logger.debug(f"Got annual precip {rounded_precip} mm for lat={lat}, lon={lon}")
+                
+                return results
+                
+        except Exception as e:
+            logger.error(f"Error in precipitation extraction: {e}")
+            return [-9999] * len(coords)
+    
+    def extract_annual_temperature(self, coords: List[Tuple[float, float]], raster_path: str) -> List[float]:
+        """Extract annual mean temperature in °C"""
+        try:
+            with rasterio.open(raster_path) as src:
+                logger.debug(f"Temp Raster NoData: {src.nodata}")
+                temps = [val[0] for val in src.sample(coords)]
+                results = []
+                
+                for (lon, lat), temp in zip(coords, temps):
+                    if temp == src.nodata or pd.isna(temp):
+                        results.append(-9999.0)
+                        logger.debug(f"NoData temp for lat={lat}, lon={lon}")
+                    else:
+                        # Convert numpy types to native Python float
+                        temp_val = float(temp) if hasattr(temp, 'item') else float(temp)
+                        rounded_temp = round(temp_val, 1)
+                        results.append(rounded_temp)
+                        logger.debug(f"Got annual mean temp {rounded_temp} °C for lat={lat}, lon={lon}")
+                
+                return results
+                
+        except Exception as e:
+            logger.error(f"Error in temperature extraction: {e}")
+            return [-9999.0] * len(coords)
+    
+    def extract_wind_speed(self, coords: List[Tuple[float, float]], raster_path: str) -> List[float]:
+        """Extract mean wind speed in m/s"""
+        try:
+            with rasterio.open(raster_path) as src:
+                logger.debug(f"Wind Raster NoData: {src.nodata}")
+                winds = [val[0] for val in src.sample(coords)]
+                results = []
+                
+                for (lon, lat), wind in zip(coords, winds):
+                    if wind == src.nodata or pd.isna(wind):
+                        results.append(-9999.0)
+                        logger.debug(f"NoData wind for lat={lat}, lon={lon}")
+                    else:
+                        # Convert numpy types to native Python float
+                        wind_val = float(wind) if hasattr(wind, 'item') else float(wind)
+                        rounded_wind = round(wind_val, 2)
+                        results.append(rounded_wind)
+                        logger.debug(f"Got mean wind speed {rounded_wind} m/s for lat={lat}, lon={lon}")
+                
+                return results
+                
+        except Exception as e:
+            logger.error(f"Error in wind speed extraction: {e}")
+            return [-9999.0] * len(coords)
+    
+    def extract_impervious_surface(self, coords: List[Tuple[float, float]], raster_path: str) -> List[float]:
+        """Extract impervious surface percentage with CRS transformation"""
+        try:
+            # Check if raster file exists (skip check for URLs — rasterio handles them)
+            is_url = raster_path.startswith('http://') or raster_path.startswith('https://')
+            if not is_url and not os.path.exists(raster_path):
+                logger.error(f"Impervious surface raster file not found: {raster_path}")
+                return [-9999.0] * len(coords)
+            
+            with rasterio.open(raster_path) as src:
+                logger.info(f"[IMPERVIOUS] Raster CRS: {src.crs}, NoData: {src.nodata}, dtype: {src.dtypes[0]}")
+                
+                # Transform coordinates from EPSG:4326 to raster's CRS (Mollweide, ESRI:54009)
+                # Use pyproj.Transformer directly - more reliable than rasterio.warp.transform
+                # because pyproj manages its own proj.db path independently
+                lons = [lon for lon, lat in coords]
+                lats = [lat for lon, lat in coords]
+                
+                try:
+                    transformer = pyproj.Transformer.from_crs(
+                        'EPSG:4326', src.crs.to_string(), always_xy=True
+                    )
+                    transformed_lons, transformed_lats = transformer.transform(lons, lats)
+                    transformed_coords = list(zip(transformed_lons, transformed_lats))
+                    for i, (lon, lat) in enumerate(coords):
+                        logger.info(f"[IMPERVIOUS] CRS transform: ({lon}, {lat}) -> ({transformed_lons[i]:.1f}, {transformed_lats[i]:.1f})")
+                except Exception as transform_error:
+                    logger.error(f"Coordinate transformation failed: {transform_error}")
+                    return [-9999.0] * len(coords)
+                
+                impervs = [val[0] for val in src.sample(transformed_coords)]
+                results = []
+                
+                for (lon, lat), imperv in zip(coords, impervs):
+                    if imperv == src.nodata or pd.isna(imperv):
+                        results.append(-9999.0)  # Standard NoData for impervious
+                        logger.info(f"[IMPERVIOUS] NoData (={src.nodata}) for lat={lat}, lon={lon}")
+                    else:
+                        # Convert numpy types to native Python float
+                        imperv_val = float(imperv) if hasattr(imperv, 'item') else float(imperv)
+                        # Apply scaling factor for GHSL (divide by 100)
+                        scaled_imperv = imperv_val / 100.0
+                        # Round to 2 decimal places (percentage)
+                        rounded_imperv = round(scaled_imperv, 2)
+                        results.append(rounded_imperv)
+                        logger.info(f"[IMPERVIOUS] lat={lat}, lon={lon} -> raw={int(imperv_val)}, scaled={rounded_imperv}%")
+                
+                return results
+                
+        except rasterio.errors.RasterioIOError as io_error:
+            logger.error(f"Rasterio I/O error in impervious surface extraction: {io_error}")
+            return [-9999.0] * len(coords)
+        except Exception as e:
+            logger.error(f"Error in impervious surface extraction: {e}")
+            logger.error(f"Raster path: {raster_path}")
+            return [-9999.0] * len(coords)
+    
+    def extract_all_features(self, coords: List[Tuple[float, float]], raster_paths: Dict[str, str]) -> Dict[str, List[Any]]:
+        """Extract all 9 raster features in a single operation"""
+        logger.info(f"Extracting all raster features for {len(coords)} coordinates")
+        
+        # Setup PROJ paths for all raster operations (handles Flask reloader)
+        # Use environment variables set by main.py, with fallback auto-detection
+        from pathlib import Path
+        
+        proj_lib = os.environ.get('PROJ_LIB', '')
+        gdal_data = os.environ.get('GDAL_DATA', '')
+        
+        # Fallback: try common locations if env vars are not set (cross-platform)
+        if not proj_lib:
+            candidates = []
+            try:
+                import rasterio as _rio
+                candidates.append(Path(_rio.__file__).parent / "proj_data")
+            except ImportError:
+                pass
+            try:
+                import pyproj as _pp
+                candidates.append(Path(_pp.datadir.get_data_dir()))
+            except (ImportError, AttributeError):
+                pass
+            candidates.extend([Path("/usr/share/proj"), Path("/usr/local/share/proj")])
+            for c in candidates:
+                if c.exists() and (c / "proj.db").exists():
+                    proj_lib = str(c)
+                    break
+        
+        if not gdal_data:
+            candidates = []
+            try:
+                from osgeo import gdal as _gdal
+                candidates.append(Path(_gdal.__file__).parent / "data" / "gdal")
+                candidates.append(Path(_gdal.__file__).parent / "data")
+            except ImportError:
+                pass
+            candidates.extend([Path("/usr/share/gdal"), Path("/usr/local/share/gdal")])
+            for c in candidates:
+                if c.exists():
+                    gdal_data = str(c)
+                    break
+        
+        # Suppress noisy PROJ "Cannot find proj.db" warnings from rasterio/GDAL
+        # These are harmless for rasters that don't need CRS transformation
+        rasterio_logger = logging.getLogger('rasterio._env')
+        original_level = rasterio_logger.level
+        rasterio_logger.setLevel(logging.CRITICAL)
+        
+        try:
+            # Wrap ALL raster operations in PROJ environment
+            env_kwargs = {'PROJ_IGNORE_CELESTIAL_BODY': '1'}
+            if proj_lib:
+                env_kwargs['PROJ_LIB'] = proj_lib
+            if gdal_data:
+                env_kwargs['GDAL_DATA'] = gdal_data
+            
+            with rasterio.Env(**env_kwargs):
+                return self._extract_all_features_internal(coords, raster_paths)
+        finally:
+            rasterio_logger.setLevel(original_level)
+    
+    def _extract_all_features_internal(self, coords: List[Tuple[float, float]], raster_paths: Dict[str, str]) -> Dict[str, List[Any]]:
+        """Internal method for feature extraction (called within PROJ environment)"""
+        results = {}
+        
+        # Extract soil type
+        if 'soil' in raster_paths and self.soil_databases_loaded:
+            results['soil_type'] = self.extract_soil_type(coords, raster_paths['soil'])
+        else:
+            results['soil_type'] = [0] * len(coords)
+            logger.warning("Soil data not available or databases not loaded")
+        
+        # Extract elevation
+        if 'elevation' in raster_paths:
+            results['elevation_m'] = self.extract_elevation(coords, raster_paths['elevation'])
+        else:
+            results['elevation_m'] = [-9999.0] * len(coords)
+            logger.warning("Elevation data not available")
+        
+        # Extract population density
+        if 'population' in raster_paths:
+            results['pop_density_persqkm'] = self.extract_population_density(coords, raster_paths['population'])
+        else:
+            results['pop_density_persqkm'] = [-9999.0] * len(coords)
+            logger.warning("Population data not available")
+        
+        # Extract land cover
+        if 'landcover' in raster_paths:
+            results['land_cover_class'] = self.extract_land_cover(coords, raster_paths['landcover'])
+        else:
+            results['land_cover_class'] = [0] * len(coords)
+            logger.warning("Land cover data not available")
+        
+        # Extract NDVI
+        if 'ndvi' in raster_paths:
+            results['ndvi'] = self.extract_ndvi(coords, raster_paths['ndvi'])
+        else:
+            results['ndvi'] = [-9999.0] * len(coords)
+            logger.warning("NDVI data not available")
+        
+        # Extract annual precipitation
+        if 'precip' in raster_paths:
+            results['annual_precip_mm'] = self.extract_annual_precipitation(coords, raster_paths['precip'])
+        else:
+            results['annual_precip_mm'] = [-9999] * len(coords)
+            logger.warning("Precipitation data not available")
+        
+        # Extract annual temperature
+        if 'temp' in raster_paths:
+            results['annual_mean_temp_c'] = self.extract_annual_temperature(coords, raster_paths['temp'])
+        else:
+            results['annual_mean_temp_c'] = [-9999.0] * len(coords)
+            logger.warning("Temperature data not available")
+        
+        # Extract wind speed
+        if 'wind' in raster_paths:
+            results['mean_wind_speed_ms'] = self.extract_wind_speed(coords, raster_paths['wind'])
+        else:
+            results['mean_wind_speed_ms'] = [-9999.0] * len(coords)
+            logger.warning("Wind data not available")
+        
+        # Extract impervious surface
+        if 'impervious' in raster_paths:
+            results['impervious_surface_pct'] = self.extract_impervious_surface(coords, raster_paths['impervious'])
+        else:
+            results['impervious_surface_pct'] = [-9999.0] * len(coords)
+            logger.warning("Impervious surface data not available")
+        
+        logger.info(f"Successfully extracted all raster features for {len(coords)} coordinates")
+        return results
+    
+    def validate_coordinates(self, coords: List[Tuple[float, float]]) -> bool:
+        """Validate coordinate format and ranges"""
+        try:
+            for lon, lat in coords:
+                # Check if coordinates are numeric
+                if not isinstance(lon, (int, float)) or not isinstance(lat, (int, float)):
+                    return False
+                
+                # Check coordinate ranges
+                if not (-180 <= lon <= 180) or not (-90 <= lat <= 90):
+                    return False
+            
+            return True
+            
+        except Exception:
+            return False
+    
+    def get_feature_info(self) -> Dict[str, Any]:
+        """Get information about available raster features"""
+        return {
+            'features': {
+                'soil_type': {
+                    'description': 'Soil classification (HWSD2)',
+                    'range': '0-33 (encoded classes)',
+                    'classes': len(self.soil_classes),
+                    'unit': 'categorical'
+                },
+                'elevation_m': {
+                    'description': 'Elevation above sea level',
+                    'range': 'varies by location',
+                    'unit': 'meters'
+                },
+                'pop_density_persqkm': {
+                    'description': 'Population density',
+                    'range': '0-∞',
+                    'unit': 'persons/km²'
+                },
+                'land_cover_class': {
+                    'description': 'Land cover classification (Copernicus)',
+                    'range': '0-21 (encoded classes)',
+                    'classes': len(self.land_cover_classes),
+                    'unit': 'categorical'
+                },
+                'ndvi': {
+                    'description': 'Normalized Difference Vegetation Index',
+                    'range': '-1.0 to 1.0',
+                    'unit': 'index'
+                },
+                'annual_precip_mm': {
+                    'description': 'Annual precipitation',
+                    'range': '0-∞',
+                    'unit': 'mm/year'
+                },
+                'annual_mean_temp_c': {
+                    'description': 'Annual mean temperature',
+                    'range': 'varies by location',
+                    'unit': '°C'
+                },
+                'mean_wind_speed_ms': {
+                    'description': 'Mean wind speed',
+                    'range': '0-∞',
+                    'unit': 'm/s'
+                },
+                'impervious_surface_pct': {
+                    'description': 'Impervious surface coverage',
+                    'range': '0-100',
+                    'unit': 'percentage'
+                }
+            },
+            'total_features': 9,
+            'nodata_values': {
+                'numeric': -9999.0,
+                'categorical': 0
+            },
+            'coordinate_system': 'EPSG:4326 (WGS84)',
+            'soil_databases_loaded': self.soil_databases_loaded
+        }

server/models/weather_model.py

@@ -0,0 +1,222 @@
+"""
+Weather Data Model
+Defines weather data structure and validation
+"""
+from typing import Dict, List, Optional, Any
+from datetime import datetime, timedelta
+from dataclasses import dataclass
+import pandas as pd
+
+@dataclass
+class WeatherDataPoint:
+    """Single day weather data point"""
+    date: str
+    temperature_C: Optional[float] = None
+    humidity_perc: Optional[float] = None
+    wind_speed_mps: Optional[float] = None
+    precipitation_mm: Optional[float] = None
+    surface_pressure_hPa: Optional[float] = None
+    solar_radiation_wm2: Optional[float] = None
+    temperature_max_C: Optional[float] = None
+    temperature_min_C: Optional[float] = None
+    specific_humidity_g_kg: Optional[float] = None
+    dew_point_C: Optional[float] = None
+    wind_speed_10m_mps: Optional[float] = None
+    cloud_amount_perc: Optional[float] = None
+    sea_level_pressure_hPa: Optional[float] = None
+    surface_soil_wetness_perc: Optional[float] = None
+    wind_direction_10m_degrees: Optional[float] = None
+    evapotranspiration_wm2: Optional[float] = None
+    root_zone_soil_moisture_perc: Optional[float] = None
+
+@dataclass
+class WeatherRequest:
+    """Weather data request parameters"""
+    latitude: float
+    longitude: float
+    disaster_date: str  # YYYY-MM-DD format
+    days_before: int = 60
+    
+    def validate(self) -> Dict[str, Any]:
+        """Validate request parameters"""
+        errors = []
+        
+        # Validate coordinates
+        if not (-90 <= self.latitude <= 90):
+            errors.append(f"Latitude {self.latitude} out of range (-90 to 90)")
+        if not (-180 <= self.longitude <= 180):
+            errors.append(f"Longitude {self.longitude} out of range (-180 to 180)")
+            
+        # Validate date
+        try:
+            disaster_datetime = datetime.strptime(self.disaster_date, '%Y-%m-%d')
+            # Check if date is not too recent (NASA has ~7 day lag)
+            current_date = datetime.now() - timedelta(days=7)
+            if disaster_datetime > current_date:
+                errors.append(f"Disaster date {self.disaster_date} too recent (NASA has ~7 day lag)")
+        except ValueError:
+            errors.append(f"Invalid date format. Use YYYY-MM-DD")
+            
+        # Validate days_before
+        if not (1 <= self.days_before <= 365):
+            errors.append(f"days_before must be between 1 and 365, got {self.days_before}")
+            
+        return {
+            'valid': len(errors) == 0,
+            'errors': errors
+        }
+
+class WeatherDataModel:
+    """Weather data model with validation and processing"""
+    
+    # NASA POWER weather fields mapping
+    WEATHER_FIELDS = {
+        # Original 6 variables
+        'T2M': 'temperature_C',
+        'RH2M': 'humidity_perc',
+        'WS2M': 'wind_speed_mps', 
+        'PRECTOTCORR': 'precipitation_mm',
+        'PS': 'surface_pressure_hPa',
+        'ALLSKY_SFC_SW_DWN': 'solar_radiation_wm2',
+        # Additional 11 variables for better disaster prediction
+        'T2M_MAX': 'temperature_max_C',
+        'T2M_MIN': 'temperature_min_C',
+        'QV2M': 'specific_humidity_g_kg',
+        'T2MDEW': 'dew_point_C',
+        'WS10M': 'wind_speed_10m_mps',
+        'CLOUD_AMT': 'cloud_amount_perc',
+        'SLP': 'sea_level_pressure_hPa',
+        'GWETTOP': 'surface_soil_wetness_perc',
+        'WD10M': 'wind_direction_10m_degrees',
+        'EVPTRNS': 'evapotranspiration_wm2',
+        'GWETROOT': 'root_zone_soil_moisture_perc'
+    }
+    
+    # NASA POWER fill values that should be converted to NaN
+    FILL_VALUES = [-999, -999.0, -99999, -99999.0]
+    
+    @classmethod
+    def process_raw_data(cls, raw_data: Dict[str, Dict[str, float]], 
+                        days_count: int) -> Dict[str, List[Optional[float]]]:
+        """
+        Process raw NASA POWER API response into structured format
+        
+        Args:
+            raw_data: Raw response from NASA POWER API
+            days_count: Expected number of days
+            
+        Returns:
+            Dictionary with processed weather data lists (chronologically ordered)
+        """
+        processed = {}
+        
+        for nasa_key, col_name in cls.WEATHER_FIELDS.items():
+            raw_values = raw_data.get(nasa_key, {})
+            
+            # FIXED: Sort date keys chronologically to ensure proper order
+            date_keys = sorted(raw_values.keys()) if raw_values else []
+            
+            # Convert to list of values, handling fill values
+            values = []
+            for i in range(days_count):
+                if i < len(date_keys):
+                    date_key = date_keys[i]
+                    value = raw_values[date_key]
+                    # Convert fill values to NaN
+                    if value in cls.FILL_VALUES:
+                        values.append(None)
+                    else:
+                        values.append(float(value) if value is not None else None)
+                else:
+                    values.append(None)  # Missing data as NaN
+            
+            processed[col_name] = values
+            
+        return processed
+    
+    @classmethod
+    def create_time_series_dataframe(cls, weather_data: Dict[str, List], 
+                                   disaster_date: str, days_before: int) -> pd.DataFrame:
+        """
+        Create time series DataFrame from weather data
+        
+        Args:
+            weather_data: Processed weather data dictionary
+            disaster_date: Disaster date string (YYYY-MM-DD)
+            days_before: Number of days before disaster (includes disaster date)
+            
+        Returns:
+            DataFrame with time series weather data
+        """
+        disaster_dt = datetime.strptime(disaster_date, '%Y-%m-%d')
+        # FIXED: End date is disaster date, start is (days_before-1) days before
+        end_date = disaster_dt
+        start_date = end_date - timedelta(days=days_before - 1)
+        
+        # Generate date range: from start_date to end_date (inclusive)
+        date_range = []
+        current_date = start_date
+        while current_date <= end_date:
+            date_range.append(current_date)
+            current_date += timedelta(days=1)
+        
+        date_strings = [dt.strftime('%Y-%m-%d') for dt in date_range]
+        
+        # Create DataFrame
+        df = pd.DataFrame({'date': date_strings})
+        
+        # Add weather data columns
+        for col_name, values in weather_data.items():
+            # Ensure we have exactly the right number of values
+            padded_values = values[:len(date_range)] + [None] * max(0, len(date_range) - len(values))
+            df[col_name] = padded_values[:len(date_range)]
+            
+        return df
+    
+    @classmethod
+    def validate_weather_data(cls, weather_data: Dict[str, List], 
+                            expected_days: int) -> Dict[str, Any]:
+        """
+        Validate processed weather data
+        
+        Args:
+            weather_data: Processed weather data
+            expected_days: Expected number of days
+            
+        Returns:
+            Validation result dictionary
+        """
+        errors = []
+        warnings = []
+        
+        # Check if all required fields are present
+        missing_fields = set(cls.WEATHER_FIELDS.values()) - set(weather_data.keys())
+        if missing_fields:
+            errors.append(f"Missing weather fields: {missing_fields}")
+            
+        # Check data completeness
+        for field, values in weather_data.items():
+            if len(values) != expected_days:
+                warnings.append(f"{field}: expected {expected_days} values, got {len(values)}")
+                
+            # Check for data availability
+            non_null_count = sum(1 for v in values if v is not None)
+            completeness = (non_null_count / len(values)) * 100 if values else 0
+            
+            if completeness < 50:
+                warnings.append(f"{field}: low data completeness ({completeness:.1f}%)")
+                
+        return {
+            'valid': len(errors) == 0,
+            'errors': errors,
+            'warnings': warnings,
+            'data_quality': {
+                'total_fields': len(weather_data),
+                'expected_days': expected_days,
+                'completeness_summary': {
+                    field: sum(1 for v in values if v is not None) / len(values) * 100 
+                    if values else 0
+                    for field, values in weather_data.items()
+                }
+            }
+        }

server/models/weatherwise_prediction_model.py

@@ -0,0 +1,455 @@
+"""
+WeatherWise Prediction Model
+LSTM-based weather forecasting models for different disaster contexts
+"""
+
+import logging
+import os
+import joblib
+import json
+import numpy as np
+import pandas as pd
+from typing import Dict, List, Optional, Tuple, Any
+from datetime import datetime, timedelta
+from sklearn.preprocessing import StandardScaler
+
+# TensorFlow imported at startup so it loads once predictably.
+# AttentionLayer is defined inside load_models() to avoid constructing
+# Keras layers before a model context is ready.
+import tensorflow as tf
+
+logger = logging.getLogger(__name__)
+
+class WeatherWisePredictionModel:
+    """Model class for WeatherWise weather forecasting using LSTM models"""
+    
+    def __init__(self):
+        """Initialize WeatherWise prediction model"""
+        self.models = {}
+        self.input_scalers = {}
+        self.output_scalers = {}
+        self.model_info = {}
+        
+        model_root = os.getenv('MODEL_ROOT_PATH', '').strip()
+        if model_root:
+            self.base_path = os.path.join(os.path.abspath(model_root), 'weatherwise')
+        else:
+            # Model paths - fallback to organized subfolders inside backend/server/models/weatherwise/
+            self.base_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'weatherwise')
+
+        logger.info(f"[WEATHERWISE_MODEL] Base path for models: {self.base_path}")
+        
+        self.model_paths = {
+            'Normal': os.path.join(self.base_path, 'normal'),
+            'Flood': os.path.join(self.base_path, 'flood'),
+            'Drought': os.path.join(self.base_path, 'drought'),
+            'Landslide': os.path.join(self.base_path, 'landslide'),
+            'Storm': os.path.join(self.base_path, 'storm')
+        }
+        
+        # Weather variables expected by LSTM models (36 input features: 17 raw + 19 engineered)
+        self.weather_features = [
+            'temperature_C', 'humidity_%', 'wind_speed_mps', 'precipitation_mm',
+            'surface_pressure_hPa', 'solar_radiation_wm2', 'temperature_max_C', 
+            'temperature_min_C', 'specific_humidity_g_kg', 'dew_point_C', 
+            'wind_speed_10m_mps', 'cloud_amount_%', 'sea_level_pressure_hPa', 
+            'surface_soil_wetness_%', 'wind_direction_10m_degrees', 
+            'evapotranspiration_wm2', 'root_zone_soil_moisture_%',
+            'temp_normalized', 'temp_range', 'discomfort_index', 'heat_index',
+            'wind_precip_interaction', 'solar_temp_ratio', 'pressure_anomaly',
+            'high_precip_flag', 'adjusted_humidity', 'wind_chill',
+            'solar_radiation_anomaly', 'weather_severity_score',
+            'moisture_stress_index', 'evaporation_deficit', 'soil_saturation_index',
+            'atmospheric_instability', 'drought_indicator', 'flood_risk_score',
+            'storm_intensity_index'
+        ]
+        
+        # Output weather variables (all 36 features the model predicts)
+        self.forecast_variables = [
+            'temperature_C', 'humidity_%', 'wind_speed_mps', 'precipitation_mm',
+            'surface_pressure_hPa', 'solar_radiation_wm2', 'temperature_max_C',
+            'temperature_min_C', 'specific_humidity_g_kg', 'dew_point_C',
+            'wind_speed_10m_mps', 'cloud_amount_%', 'sea_level_pressure_hPa',
+            'surface_soil_wetness_%', 'wind_direction_10m_degrees',
+            'evapotranspiration_wm2', 'root_zone_soil_moisture_%', 'temp_normalized',
+            'temp_range', 'discomfort_index', 'heat_index',
+            'wind_precip_interaction', 'solar_temp_ratio', 'pressure_anomaly',
+            'high_precip_flag', 'adjusted_humidity', 'wind_chill',
+            'solar_radiation_anomaly', 'weather_severity_score',
+            'moisture_stress_index', 'evaporation_deficit', 'soil_saturation_index',
+            'atmospheric_instability', 'drought_indicator', 'flood_risk_score',
+            'storm_intensity_index'
+        ]
+        
+        logger.info("WeatherWise prediction model initialized")
+    
+    def load_models(self) -> bool:
+        """
+        Load all LSTM weather prediction models
+        
+        Returns:
+            bool: True if models loaded successfully
+        """
+        try:
+            # AttentionLayer defined here so it is only constructed when models are loaded.
+            class AttentionLayer(tf.keras.layers.Layer):
+                """Bahdanau Attention mechanism for Seq2Seq model."""
+                def __init__(self, units, **kwargs):
+                    super(AttentionLayer, self).__init__(**kwargs)
+                    self.units = units
+                    self.W1 = tf.keras.layers.Dense(units)
+                    self.W2 = tf.keras.layers.Dense(units)
+                    self.V  = tf.keras.layers.Dense(1)
+
+                def call(self, query, values):
+                    query_with_time_axis = tf.expand_dims(query, 1)
+                    score = self.V(tf.nn.tanh(
+                        self.W1(query_with_time_axis) + self.W2(values)
+                    ))
+                    attention_weights = tf.nn.softmax(score, axis=1)
+                    context_vector = attention_weights * values
+                    context_vector = tf.reduce_sum(context_vector, axis=1)
+                    return context_vector, attention_weights
+
+                def get_config(self):
+                    config = super().get_config()
+                    config.update({"units": self.units})
+                    return config
+
+            logger.info("Loading WeatherWise LSTM models...")
+
+            for disaster_type, model_path in self.model_paths.items():
+                logger.info(f"[WEATHERWISE_MODEL] Checking {disaster_type} model at: {model_path}")
+                
+                if not os.path.exists(model_path):
+                    logger.warning(f"Model path not found for {disaster_type}: {model_path}")
+                    continue
+                
+                try:
+                    # Load model components
+                    model_file = os.path.join(model_path, 'best_model.keras')
+                    input_scaler_file = os.path.join(model_path, 'input_scaler.joblib')
+                    output_scaler_file = os.path.join(model_path, 'output_scaler.joblib')
+                    info_file = os.path.join(model_path, 'model_info.json')
+                    
+                    logger.info(f"[WEATHERWISE_MODEL] Checking files for {disaster_type}:")
+                    logger.info(f"  - Model file exists: {os.path.exists(model_file)}")
+                    logger.info(f"  - Input scaler exists: {os.path.exists(input_scaler_file)}")
+                    logger.info(f"  - Output scaler exists: {os.path.exists(output_scaler_file)}")
+                    
+                    if all(os.path.exists(f) for f in [model_file, input_scaler_file, output_scaler_file]):
+                        # Load model with custom AttentionLayer
+                        model = tf.keras.models.load_model(
+                            model_file,
+                            custom_objects={'AttentionLayer': AttentionLayer}
+                        )
+                        self.models[disaster_type] = model
+                        
+                        # Load scalers
+                        self.input_scalers[disaster_type] = joblib.load(input_scaler_file)
+                        self.output_scalers[disaster_type] = joblib.load(output_scaler_file)
+                        
+                        # Load model info if available
+                        if os.path.exists(info_file):
+                            try:
+                                with open(info_file, 'r', encoding='utf-8') as f:
+                                    info_text = f.read()
+                                if info_text.lstrip().startswith('version https://git-lfs.github.com/spec/v1'):
+                                    logger.warning(
+                                        f"[WEATHERWISE_MODEL] model_info.json for {disaster_type} is a Git LFS pointer; using defaults"
+                                    )
+                                    self.model_info[disaster_type] = {'horizon_days': 60}
+                                else:
+                                    self.model_info[disaster_type] = json.loads(info_text)
+                            except Exception as info_err:
+                                logger.warning(
+                                    f"[WEATHERWISE_MODEL] Invalid model_info.json for {disaster_type}: {info_err}; using defaults"
+                                )
+                                self.model_info[disaster_type] = {'horizon_days': 60}
+                        else:
+                            self.model_info[disaster_type] = {'horizon_days': 60}
+                        
+                        logger.info(f"[OK] Loaded {disaster_type} weather model")
+                    else:
+                        logger.warning(f"Missing model files for {disaster_type}")
+                        
+                except Exception as e:
+                    logger.error(f"Failed to load {disaster_type} model: {e}")
+                    continue
+            
+            if self.models:
+                logger.info(f"[SUCCESS] Loaded {len(self.models)} WeatherWise models: {list(self.models.keys())}")
+                return True
+            else:
+                logger.error("[ERROR] No WeatherWise models loaded")
+                return False
+                
+        except Exception as e:
+            logger.error(f"WeatherWise model loading error: {e}")
+            return False
+    
+    def prepare_input_sequence(self, weather_data: Dict[str, List[float]], 
+                             feature_data: Dict[str, List[float]]) -> np.ndarray:
+        """
+        Prepare input sequence for LSTM model from weather and feature data
+        
+        Args:
+            weather_data: Weather time series data (59-60 days)
+            feature_data: Engineered features data (59-60 days)
+        
+        Returns:
+            np.ndarray: Prepared input sequence for LSTM
+        """
+        try:
+            # Determine the actual length of data
+            data_length = 60  # Default
+            for var_name, var_data in weather_data.items():
+                if var_data and isinstance(var_data, list):
+                    data_length = len(var_data)
+                    break
+            
+            logger.info(f"[WEATHERWISE] Preparing input sequence with {data_length} timesteps")
+            
+            # Combine weather and feature data - use ONLY the 36 features the model expects
+            combined_data = {}
+            
+            for var in self.weather_features:
+                # First check weather_data (raw weather variables)
+                if var in weather_data and weather_data[var]:
+                    data = weather_data[var]
+                # Then check feature_data (engineered features)
+                elif var in feature_data and feature_data[var]:
+                    data = feature_data[var]
+                else:
+                    # Fill missing data with zeros
+                    combined_data[var] = [0.0] * data_length
+                    continue
+                
+                # Ensure correct length
+                if len(data) < data_length:
+                    data = data + [data[-1]] * (data_length - len(data))
+                elif len(data) > data_length:
+                    data = data[:data_length]
+                combined_data[var] = data
+            
+            logger.info(f"[WEATHERWISE] Combined data has {len(combined_data)} features")
+            
+            # Convert to numpy array (timesteps, features)
+            feature_names = sorted(combined_data.keys())  # Sort for consistency
+            
+            # Build array ensuring all same length and convert to float
+            arrays = []
+            for name in feature_names:
+                arr = combined_data[name]
+                if len(arr) != data_length:
+                    logger.warning(f"Feature {name} has length {len(arr)}, expected {data_length}")
+                    # Fix length mismatch
+                    if len(arr) < data_length:
+                        arr = arr + [0.0] * (data_length - len(arr))
+                    else:
+                        arr = arr[:data_length]
+                
+                # Convert to float and replace None/NaN with 0.0
+                float_arr = []
+                for val in arr:
+                    if val is None:
+                        float_arr.append(0.0)
+                    elif isinstance(val, (int, float)):
+                        if np.isnan(val) or np.isinf(val):
+                            float_arr.append(0.0)
+                        else:
+                            float_arr.append(float(val))
+                    else:
+                        # Non-numeric, use 0.0
+                        float_arr.append(0.0)
+                arrays.append(float_arr)
+            
+            sequence_data = np.array(arrays, dtype=np.float32).T  # Transpose to (timesteps, features) with explicit float type
+            
+            # Reshape for LSTM: (1, timesteps, features)
+            input_sequence = sequence_data.reshape(1, sequence_data.shape[0], sequence_data.shape[1])
+            
+            logger.info(f"[WEATHERWISE] Prepared input sequence shape: {input_sequence.shape}")
+            return input_sequence
+            
+        except Exception as e:
+            logger.error(f"Input sequence preparation error: {e}")
+            raise
+    
+    def predict_weather_forecast(self, weather_data: Dict[str, List[float]], 
+                               feature_data: Dict[str, List[float]], 
+                               disaster_type: str = 'Normal',
+                               forecast_days: int = 60) -> Dict[str, Any]:
+        """
+        Generate weather forecast using LSTM model
+        
+        Args:
+            weather_data: Historical weather data (60 days)
+            feature_data: Engineered features data (60 days) 
+            disaster_type: Type of disaster context for model selection
+            forecast_days: Number of days to forecast (default 60)
+        
+        Returns:
+            Dict containing forecast results
+        """
+        try:
+            start_time = datetime.now()
+            
+            # Validate disaster type
+            if disaster_type not in self.models:
+                available_models = list(self.models.keys())
+                if available_models:
+                    disaster_type = available_models[0]  # Use first available model
+                    logger.warning(f"Requested disaster type not available, using {disaster_type}")
+                else:
+                    return {'success': False, 'error': 'No models available'}
+            
+            # Get model components
+            model = self.models[disaster_type]
+            input_scaler = self.input_scalers[disaster_type]
+            output_scaler = self.output_scalers[disaster_type]
+            
+            logger.info(f"[WEATHERWISE] Generating {forecast_days}-day forecast using {disaster_type} model")
+            
+            # Debug: Check input data quality
+            logger.debug(f"[WEATHERWISE] Received weather_data with {len(weather_data)} variables")
+            logger.debug(f"[WEATHERWISE] Received feature_data with {len(feature_data)} variables")
+            
+            # Check for NaN in weather_data
+            weather_nan_vars = []
+            for var, values in weather_data.items():
+                if values and any(isinstance(v, float) and (np.isnan(v) or np.isinf(v)) for v in values):
+                    weather_nan_vars.append(var)
+            if weather_nan_vars:
+                logger.warning(f"[WEATHERWISE] Weather data contains NaN/Inf in variables: {weather_nan_vars}")
+            
+            # Check for NaN in feature_data  
+            feature_nan_vars = []
+            for var, values in feature_data.items():
+                if values and any(isinstance(v, float) and (np.isnan(v) or np.isinf(v)) for v in values):
+                    feature_nan_vars.append(var)
+            if feature_nan_vars:
+                logger.warning(f"[WEATHERWISE] Feature data contains NaN/Inf in variables: {feature_nan_vars}")
+            
+            # Prepare input sequence
+            input_sequence = self.prepare_input_sequence(weather_data, feature_data)
+            
+            # Validate input sequence dtype and check for NaN
+            if input_sequence.dtype == np.object_:
+                logger.error(f"[WEATHERWISE] Input sequence has object dtype! Converting to float...")
+                input_sequence = input_sequence.astype(np.float32)
+            
+            # Check input for NaN (now safe since we have numeric dtype)
+            input_nan_count = np.isnan(input_sequence).sum()
+            if input_nan_count > 0:
+                logger.warning(f"[WEATHERWISE] Input sequence contains {input_nan_count} NaN values before scaling")
+                logger.debug(f"[WEATHERWISE] Input stats - Min: {np.nanmin(input_sequence):.4f}, Max: {np.nanmax(input_sequence):.4f}, Mean: {np.nanmean(input_sequence):.4f}")
+                # Replace NaN with 0 for model stability
+                input_sequence = np.nan_to_num(input_sequence, nan=0.0, posinf=0.0, neginf=0.0)
+                logger.info(f"[WEATHERWISE] Replaced NaN values with 0.0")
+            else:
+                logger.info(f"[WEATHERWISE] Input sequence is clean - Min: {np.min(input_sequence):.4f}, Max: {np.max(input_sequence):.4f}, Mean: {np.mean(input_sequence):.4f}")
+            
+            # Scale input data
+            original_shape = input_sequence.shape
+            input_flat = input_sequence.reshape(-1, input_sequence.shape[-1])
+            input_scaled = input_scaler.transform(input_flat)
+            input_scaled = input_scaled.reshape(original_shape)
+            
+            # Check scaled input for NaN
+            scaled_nan_count = np.isnan(input_scaled).sum()
+            if scaled_nan_count > 0:
+                logger.error(f"[WEATHERWISE] Scaled input contains {scaled_nan_count} NaN values! Scaler may be corrupted.")
+                logger.debug(f"[WEATHERWISE] Scaled stats - Min: {np.nanmin(input_scaled):.4f}, Max: {np.nanmax(input_scaled):.4f}")
+            
+            # Generate forecast
+            forecast_scaled = model.predict(input_scaled, verbose=0)
+            
+            # Check model output for NaN
+            model_output_nan = np.isnan(forecast_scaled).sum()
+            if model_output_nan > 0:
+                logger.error(f"[WEATHERWISE] Model output contains {model_output_nan} NaN values!")
+                logger.debug(f"[WEATHERWISE] Model output stats - Min: {np.nanmin(forecast_scaled):.4f}, Max: {np.nanmax(forecast_scaled):.4f}")
+            
+            # Inverse scale forecast
+            forecast_shape = forecast_scaled.shape
+            forecast_flat = forecast_scaled.reshape(-1, forecast_scaled.shape[-1])
+            forecast = output_scaler.inverse_transform(forecast_flat)
+            forecast = forecast.reshape(forecast_shape)
+            
+            # Check final forecast for NaN
+            final_nan_count = np.isnan(forecast).sum()
+            if final_nan_count > 0:
+                logger.error(f"[WEATHERWISE] Final forecast contains {final_nan_count} NaN values after inverse scaling!")
+                logger.debug(f"[WEATHERWISE] Final forecast stats - Min: {np.nanmin(forecast):.4f}, Max: {np.nanmax(forecast):.4f}")
+            else:
+                logger.info(f"[WEATHERWISE] Forecast generated successfully - Min: {np.min(forecast):.4f}, Max: {np.max(forecast):.4f}")
+            
+            # Extract forecast for requested number of days
+            forecast_data = forecast[0][:forecast_days]  # Take first batch, limit days
+            
+            # Format forecast results and handle NaN values
+            forecast_dict = {}
+            nan_count = 0
+            for i, var in enumerate(self.forecast_variables):
+                if i < forecast_data.shape[1]:
+                    # Convert to list and replace NaN with None (JSON null)
+                    values = forecast_data[:, i].tolist()
+                    # Replace NaN and inf values with None for JSON serialization
+                    cleaned_values = []
+                    for v in values:
+                        if isinstance(v, float) and (np.isnan(v) or np.isinf(v)):
+                            cleaned_values.append(None)
+                            nan_count += 1
+                        else:
+                            cleaned_values.append(float(v))
+                    forecast_dict[var] = cleaned_values
+                else:
+                    forecast_dict[var] = [0.0] * forecast_days
+            
+            if nan_count > 0:
+                logger.warning(f"[WEATHERWISE] Replaced {nan_count} NaN/Inf values with null in forecast")
+            
+            # Calculate processing time
+            processing_time = (datetime.now() - start_time).total_seconds()
+            
+            # Generate forecast dates
+            base_date = datetime.now().date()
+            forecast_dates = [(base_date + timedelta(days=i)).strftime('%Y-%m-%d') 
+                            for i in range(forecast_days)]
+            
+            return {
+                'success': True,
+                'model_type': disaster_type,
+                'forecast_horizon_days': forecast_days,
+                'forecast_dates': forecast_dates,
+                'weather_forecast': forecast_dict,
+                'forecast_variables': self.forecast_variables,
+                'processing_time_seconds': processing_time,
+                'model_info': self.model_info.get(disaster_type, {}),
+                'timestamp': datetime.now().isoformat()
+            }
+            
+        except Exception as e:
+            logger.error(f"WeatherWise forecast error: {e}")
+            return {
+                'success': False,
+                'error': f'Forecast generation failed: {str(e)}',
+                'model_type': disaster_type,
+                'timestamp': datetime.now().isoformat()
+            }
+    
+    def get_available_models(self) -> List[str]:
+        """Get list of available disaster context models"""
+        return list(self.models.keys())
+    
+    def get_model_info(self, disaster_type: str = None) -> Dict[str, Any]:
+        """Get information about loaded models"""
+        if disaster_type and disaster_type in self.model_info:
+            return self.model_info[disaster_type]
+        return {
+            'available_models': self.get_available_models(),
+            'forecast_variables': self.forecast_variables,
+            'input_features': len(self.weather_features) + 9,  # weather + engineered features
+            'default_horizon_days': 60
+        }

server/render.yaml

@@ -0,0 +1,75 @@
+# ============================================
+# Render Blueprint — GEO VISION Backend
+# ============================================
+# Deploy: connect your GitHub repo and Render auto-detects this file
+# Docs: https://render.com/docs/blueprint-spec
+
+services:
+  - type: web
+    name: geovision-backend
+    runtime: python
+    region: singapore          # closest to India (asia-south1 GCS bucket)
+    rootDir: backend
+    buildCommand: pip install -r requirements.txt
+    startCommand: gunicorn main:app --bind 0.0.0.0:$PORT --timeout 120 --workers 2 --threads 4
+    healthCheckPath: /health
+    envVars:
+      # ── Flask ──
+      - key: FLASK_ENV
+        value: production
+      - key: FLASK_DEBUG
+        value: "False"
+      - key: FLASK_HOST
+        value: 0.0.0.0
+
+      # ── Google Earth Engine ──
+      - key: GEE_PROJECT_ID
+        sync: false            # set manually in Render dashboard
+      - key: GEE_SERVICE_ACCOUNT_KEY
+        sync: false            # paste full JSON key content here
+
+      # ── Gemini AI ──
+      - key: GEMINI_API_KEY
+        sync: false
+
+      # ── Google Cloud Storage ──
+      - key: GCS_BUCKET_BASE_URL
+        value: https://storage.googleapis.com/satellite-cog-data-for-shrishti/
+      - key: GCS_BUCKET
+        value: satellite-cog-data-for-shrishti
+      - key: GCS_TEMP_PREFIX
+        value: temp/
+
+      # ── Raster COG paths (GCS public URLs) ──
+      - key: RASTER_SRTM_PATH
+        value: https://storage.googleapis.com/satellite-cog-data-for-shrishti/SRTM_elevation.tif
+      - key: RASTER_SLOPE_PATH
+        value: https://storage.googleapis.com/satellite-cog-data-for-shrishti/SRTM_slope.tif
+      - key: RASTER_ASPECT_PATH
+        value: https://storage.googleapis.com/satellite-cog-data-for-shrishti/SRTM_aspect.tif
+      - key: RASTER_TWI_PATH
+        value: https://storage.googleapis.com/satellite-cog-data-for-shrishti/twi.tif
+      - key: RASTER_FLOW_ACC_PATH
+        value: https://storage.googleapis.com/satellite-cog-data-for-shrishti/flow_accumulation.tif
+      - key: RASTER_CURVATURE_PATH
+        value: https://storage.googleapis.com/satellite-cog-data-for-shrishti/curvature.tif
+      - key: RASTER_DISTANCE_TO_RIVER_PATH
+        value: https://storage.googleapis.com/satellite-cog-data-for-shrishti/distance_to_river.tif
+      - key: RASTER_LITHOLOGY_PATH
+        value: https://storage.googleapis.com/satellite-cog-data-for-shrishti/lithology_encoded.tif
+      - key: RASTER_IMPERVIOUS_PATH
+        value: https://storage.googleapis.com/satellite-cog-data-for-shrishti/NLCD_2021_Impervious_L48.tif
+
+      # ── Supabase ──
+      - key: SUPABASE_URL
+        sync: false
+      - key: SUPABASE_SERVICE_ROLE_KEY
+        sync: false
+
+      # ── CORS ──
+      - key: ALLOWED_ORIGINS
+        sync: false            # set to your Vercel frontend URL
+
+      # ── Logging ──
+      - key: LOG_LEVEL
+        value: INFO

server/requirements.txt

@@ -0,0 +1,57 @@
+# ============================================
+# GEO VISION Backend — Python Dependencies
+# ============================================
+
+# ── Core Web Framework ──
+Flask>=3.0.0,<4.0
+flask-cors>=4.0.0,<5.0
+
+# ── Google Earth Engine ──
+earthengine-api>=0.1.390
+
+# ── Google Gemini AI ──
+google-generativeai>=0.8.0
+
+# ── Google Cloud Storage (for GCS bucket access) ──
+google-cloud-storage>=2.14.0
+google-auth>=2.20.0
+
+# ── Environment management ──
+python-dotenv>=1.0.0
+
+# ── Data handling ──
+numpy>=1.24.0,<2.0
+pandas>=2.0.0
+scipy>=1.10.0
+openpyxl>=3.1.0
+
+# ── Geospatial / Raster ──
+rasterio>=1.3.0
+pyproj>=3.5.0
+
+# ── Machine Learning ──
+# Pin to TF 2.15 (last version with Keras 2 by default — avoids Keras 3 breaking changes)
+tensorflow-cpu==2.15.0
+huggingface_hub>=0.23.0
+scikit-learn==1.6.1
+lightgbm>=4.0.0
+xgboost>=2.0.0
+catboost>=1.2.0
+joblib>=1.3.0
+
+# ── Image processing ──
+Pillow>=10.0.0
+
+# ── Date/time utilities ──
+python-dateutil>=2.8.0
+
+# ── HTTP / API ──
+requests>=2.31.0
+urllib3>=2.0.0
+httpx>=0.24.0
+
+# ── Supabase ──
+supabase>=2.0.0
+
+# ── Production WSGI server ──
+gunicorn>=21.2.0

server/routes/auth_routes.py

@@ -0,0 +1,198 @@
+"""
+Auth Routes
+RESTful endpoints for authentication, profile, and activity logging.
+All database communication goes through the backend — the frontend
+never talks to Supabase directly.
+"""
+from flask import Blueprint, request, jsonify
+import logging
+from functools import wraps
+
+auth_bp = Blueprint("auth", __name__)
+logger = logging.getLogger(__name__)
+
+# Will be set by init_auth_routes()
+auth_controller = None
+
+
+def init_auth_routes(controller_instance):
+    """Inject the AuthController instance."""
+    global auth_controller
+    auth_controller = controller_instance
+    logger.info("Auth routes initialized with controller")
+
+
+# ── Middleware helper ───────────────────────────────────────────────────
+
+def require_auth(f):
+    """
+    Decorator that verifies the Authorization header and injects
+    `user_id` into kwargs so the route handler can use it.
+    """
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        if auth_controller is None:
+            return jsonify({"status": "error", "error": "Auth service not initialized"}), 503
+
+        auth_header = request.headers.get("Authorization", "")
+        if not auth_header.startswith("Bearer "):
+            return jsonify({"status": "error", "error": "Missing or invalid Authorization header"}), 401
+
+        token = auth_header.split(" ", 1)[1]
+        result = auth_controller.get_me(token)
+
+        if result.get("status") != "success":
+            return jsonify({"status": "error", "error": "Invalid or expired token"}), 401
+
+        # Attach user_id + token to kwargs
+        kwargs["user_id"] = result["user"]["id"]
+        kwargs["access_token"] = token
+        return f(*args, **kwargs)
+    return decorated
+
+
+# ════════════════════════════════════════════════════════════════════════
+#  PUBLIC AUTH ENDPOINTS
+# ════════════════════════════════════════════════════════════════════════
+
+@auth_bp.route("/auth/login", methods=["POST"])
+def login():
+    """POST /api/auth/login  –  sign in with email + password"""
+    try:
+        if auth_controller is None:
+            return jsonify({"status": "error", "error": "Auth service not initialized"}), 503
+
+        data = request.get_json() or {}
+        data["device_info"] = request.headers.get("User-Agent", "")[:120]
+        result = auth_controller.login(data)
+        code = 200 if result.get("status") == "success" else 400
+        return jsonify(result), code
+
+    except Exception as e:
+        logger.error(f"Login route error: {e}")
+        return jsonify({"status": "error", "error": "Internal server error"}), 500
+
+
+@auth_bp.route("/auth/signup", methods=["POST"])
+def signup():
+    """POST /api/auth/signup  –  register a new account"""
+    try:
+        if auth_controller is None:
+            return jsonify({"status": "error", "error": "Auth service not initialized"}), 503
+
+        data = request.get_json() or {}
+        data["device_info"] = request.headers.get("User-Agent", "")[:120]
+        result = auth_controller.signup(data)
+        code = 201 if result.get("status") == "success" else 400
+        return jsonify(result), code
+
+    except Exception as e:
+        logger.error(f"Signup route error: {e}")
+        return jsonify({"status": "error", "error": "Internal server error"}), 500
+
+
+@auth_bp.route("/auth/refresh", methods=["POST"])
+def refresh():
+    """POST /api/auth/refresh  –  refresh an expired session"""
+    try:
+        if auth_controller is None:
+            return jsonify({"status": "error", "error": "Auth service not initialized"}), 503
+
+        data = request.get_json() or {}
+        result = auth_controller.refresh(data)
+        code = 200 if result.get("status") == "success" else 401
+        return jsonify(result), code
+
+    except Exception as e:
+        logger.error(f"Refresh route error: {e}")
+        return jsonify({"status": "error", "error": "Internal server error"}), 500
+
+
+@auth_bp.route("/auth/resend-verification", methods=["POST"])
+def resend_verification():
+    """POST /api/auth/resend-verification  –  resend email verification link"""
+    try:
+        if auth_controller is None:
+            return jsonify({"status": "error", "error": "Auth service not initialized"}), 503
+
+        data = request.get_json() or {}
+        result = auth_controller.resend_verification(data)
+        code = 200 if result.get("status") == "success" else 400
+        return jsonify(result), code
+
+    except Exception as e:
+        logger.error(f"Resend verification route error: {e}")
+        return jsonify({"status": "error", "error": "Internal server error"}), 500
+
+
+# ════════════════════════════════════════════════════════════════════════
+#  PROTECTED ENDPOINTS  (require_auth injects user_id + access_token)
+# ════════════════════════════════════════════════════════════════════════
+
+@auth_bp.route("/auth/me", methods=["GET"])
+@require_auth
+def get_me(user_id: str, access_token: str):
+    """GET /api/auth/me  –  get current user info"""
+    result = auth_controller.get_me(access_token)
+    return jsonify(result), 200
+
+
+@auth_bp.route("/auth/logout", methods=["POST"])
+@require_auth
+def logout(user_id: str, access_token: str):
+    """POST /api/auth/logout"""
+    result = auth_controller.logout(access_token, user_id)
+    return jsonify(result), 200
+
+
+# ── Profile ─────────────────────────────────────────────────────────────
+
+@auth_bp.route("/auth/profile", methods=["GET"])
+@require_auth
+def get_profile(user_id: str, access_token: str):
+    """GET /api/auth/profile"""
+    result = auth_controller.get_profile(user_id)
+    code = 200 if result.get("status") == "success" else 404
+    return jsonify(result), code
+
+
+@auth_bp.route("/auth/profile", methods=["PUT"])
+@require_auth
+def update_profile(user_id: str, access_token: str):
+    """PUT /api/auth/profile"""
+    data = request.get_json() or {}
+    result = auth_controller.update_profile(user_id, data)
+    code = 200 if result.get("status") == "success" else 400
+    return jsonify(result), code
+
+
+# ── Activity Logs ───────────────────────────────────────────────────────
+
+@auth_bp.route("/auth/activity", methods=["POST"])
+@require_auth
+def log_activity(user_id: str, access_token: str):
+    """POST /api/auth/activity"""
+    data = request.get_json() or {}
+    data["device_info"] = request.headers.get("User-Agent", "")[:120]
+    result = auth_controller.log_activity(user_id, data)
+    code = 200 if result.get("status") == "success" else 400
+    return jsonify(result), code
+
+
+@auth_bp.route("/auth/activity", methods=["GET"])
+@require_auth
+def get_activity_logs(user_id: str, access_token: str):
+    """GET /api/auth/activity?limit=30"""
+    limit = request.args.get("limit", 50, type=int)
+    result = auth_controller.get_activity_logs(user_id, limit)
+    return jsonify(result), 200
+
+
+# ── Health ──────────────────────────────────────────────────────────────
+
+@auth_bp.route("/auth/health", methods=["GET"])
+def auth_health():
+    """GET /api/auth/health"""
+    if auth_controller is None:
+        return jsonify({"status": "error", "error": "Auth service not initialized"}), 503
+    return jsonify({"status": "success", "service": "auth", "healthy": True}), 200

server/routes/feature_routes.py

@@ -0,0 +1,477 @@
+"""
+Feature Engineering API Routes
+RESTful endpoints for weather feature engineering operations
+"""
+from flask import Blueprint, request, jsonify
+import logging
+from controllers.feature_engineering_controller import FeatureEngineeringController
+from services.feature_engineering_service import FeatureEngineeringService
+
+# Initialize blueprint
+features_bp = Blueprint('features', __name__)
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+# Service and controller will be initialized by main app
+feature_service = None
+feature_controller = None
+
+def init_feature_routes(controller_instance: FeatureEngineeringController):
+    """Initialize feature engineering routes with controller instance"""
+    global feature_controller
+    feature_controller = controller_instance
+    logger.info("Feature engineering routes initialized with controller")
+
+@features_bp.route('/features/process', methods=['POST'])
+def process_features():
+    """
+    Compute engineered features from weather data
+    
+    POST body:
+        {
+            "weather_data": {
+                "temperature_C": [list of 60 daily values],
+                "humidity_perc": [list of 60 daily values],
+                ...
+            },
+            "event_duration": float (optional, default: 1.0),
+            "include_metadata": bool (optional, default: true)
+        }
+    
+    Response: Engineered features with 19 computed feature arrays
+    """
+    try:
+        if feature_controller is None:
+            return jsonify({
+                'status': 'error',
+                'message': 'Feature engineering service not initialized',
+                'data': None
+            }), 503
+        
+        data = request.get_json()
+        
+        if not data:
+            return jsonify({
+                'status': 'error',
+                'message': 'No JSON data provided',
+                'data': None
+            }), 400
+        
+        # Process features
+        result = feature_controller.process_features(data)
+        
+        # Return response with appropriate status code
+        status_code = 200 if result.get('status') == 'success' else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        logger.error(f"Features process API error: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Features API error: {str(e)}',
+            'data': None
+        }), 500
+
+@features_bp.route('/features/batch', methods=['POST'])
+def process_batch_features():
+    """
+    Process multiple weather datasets for feature engineering
+    
+    POST body:
+        {
+            "batch_data": [
+                {
+                    "id": "optional_identifier",
+                    "weather_data": {...},
+                    "event_duration": float (optional)
+                },
+                ...
+            ],
+            "include_metadata": bool (optional, default: true)
+        }
+    
+    Maximum batch size: 100 items
+    """
+    try:
+        if feature_controller is None:
+            return jsonify({
+                'status': 'error',
+                'message': 'Feature engineering service not initialized',
+                'data': None
+            }), 503
+        
+        data = request.get_json()
+        
+        if not data:
+            return jsonify({
+                'status': 'error',
+                'message': 'No JSON data provided',
+                'data': None
+            }), 400
+        
+        # Process batch
+        result = feature_controller.process_batch_features(data)
+        
+        status_code = 200 if result.get('status') == 'success' else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        logger.error(f"Batch features API error: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Batch features API error: {str(e)}',
+            'data': None
+        }), 500
+
+@features_bp.route('/features/dataframe', methods=['POST'])
+def create_feature_dataframe():
+    """
+    Create time series DataFrame with weather data and engineered features
+    
+    POST body:
+        {
+            "weather_data": {...},
+            "disaster_date": "YYYY-MM-DD",
+            "days_before": int,
+            "event_duration": float (optional, default: 1.0)
+        }
+    
+    Returns DataFrame with dates, weather data, and engineered features
+    """
+    try:
+        if feature_controller is None:
+            return jsonify({
+                'status': 'error',
+                'message': 'Feature engineering service not initialized',
+                'data': None
+            }), 503
+        
+        data = request.get_json()
+        
+        if not data:
+            return jsonify({
+                'status': 'error',
+                'message': 'No JSON data provided',
+                'data': None
+            }), 400
+        
+        # Create DataFrame
+        result = feature_controller.create_feature_dataframe(data)
+        
+        status_code = 200 if result.get('status') == 'success' else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        logger.error(f"Feature DataFrame API error: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Feature DataFrame API error: {str(e)}',
+            'data': None
+        }), 500
+
+@features_bp.route('/features/validate', methods=['POST'])
+def validate_weather_data():
+    """
+    Validate weather data for feature engineering readiness
+    
+    POST body:
+        {
+            "weather_data": {
+                "temperature_C": [...],
+                "humidity_perc": [...],
+                ...
+            }
+        }
+    
+    Returns validation results and readiness status
+    """
+    try:
+        if feature_controller is None:
+            return jsonify({
+                'status': 'error',
+                'message': 'Feature engineering service not initialized',
+                'data': None
+            }), 503
+        
+        data = request.get_json()
+        
+        if not data:
+            return jsonify({
+                'status': 'error',
+                'message': 'No JSON data provided',
+                'data': None
+            }), 400
+        
+        # Validate data
+        result = feature_controller.validate_weather_data(data)
+        
+        status_code = 200 if result.get('status') == 'success' else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        logger.error(f"Weather validation API error: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Weather validation API error: {str(e)}',
+            'data': None
+        }), 500
+
+@features_bp.route('/features/export', methods=['POST'])
+def process_and_export():
+    """
+    Process features and export in specified format
+    
+    POST body:
+        {
+            "weather_data": {...},
+            "disaster_date": "YYYY-MM-DD",
+            "days_before": int,
+            "event_duration": float (optional, default: 1.0),
+            "export_format": "dict|dataframe|json" (optional, default: "dict")
+        }
+    
+    Returns processed features in requested format
+    """
+    try:
+        if feature_controller is None:
+            return jsonify({
+                'status': 'error',
+                'message': 'Feature engineering service not initialized',
+                'data': None
+            }), 503
+        
+        data = request.get_json()
+        
+        if not data:
+            return jsonify({
+                'status': 'error',
+                'message': 'No JSON data provided',
+                'data': None
+            }), 400
+        
+        # Process and export
+        result = feature_controller.process_and_export(data)
+        
+        status_code = 200 if result.get('status') == 'success' else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        logger.error(f"Process export API error: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Process export API error: {str(e)}',
+            'data': None
+        }), 500
+
+@features_bp.route('/features/info', methods=['GET'])
+def get_feature_info():
+    """
+    Get information about available engineered features
+    
+    Returns detailed information about all 19 engineered features
+    """
+    try:
+        if feature_controller is None:
+            return jsonify({
+                'status': 'error',
+                'message': 'Feature engineering service not initialized',
+                'data': None
+            }), 503
+        
+        result = feature_controller.get_feature_info()
+        
+        status_code = 200 if result.get('status') == 'success' else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        logger.error(f"Feature info API error: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Feature info API error: {str(e)}',
+            'data': None
+        }), 500
+
+@features_bp.route('/features/status', methods=['GET'])
+def get_service_status():
+    """
+    Get feature engineering service status and health
+    
+    Returns service health, initialization status, and configuration
+    """
+    try:
+        if feature_controller is None:
+            return jsonify({
+                'status': 'error',
+                'message': 'Feature engineering service not initialized',
+                'data': None
+            }), 503
+        
+        result = feature_controller.get_service_status()
+        
+        status_code = 200 if result.get('status') == 'success' else 424  # Failed Dependency
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        logger.error(f"Feature status API error: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Feature status API error: {str(e)}',
+            'data': None
+        }), 500
+
+@features_bp.route('/features/test', methods=['GET', 'POST'])
+def test_feature_service():
+    """
+    Test the feature engineering service with sample data
+    
+    Returns test results for feature engineering functionality
+    """
+    try:
+        if feature_controller is None:
+            return jsonify({
+                'status': 'error',
+                'message': 'Feature engineering service not initialized',
+                'data': None
+            }), 503
+        
+        # Create sample weather data (7 days)
+        sample_weather_data = {
+            'temperature_C': [25.5, 26.0, 24.8, 27.2, 25.9, 25.1, 26.3],
+            'humidity_perc': [65.2, 67.8, 70.1, 62.5, 68.9, 66.0, 66.4],
+            'wind_speed_mps': [3.2, 2.8, 4.1, 5.6, 3.9, 2.4, 3.7],
+            'precipitation_mm': [0.0, 2.3, 5.1, 0.0, 1.2, 0.8, 3.4],
+            'surface_pressure_hPa': [1013.2, 1012.8, 1011.5, 1014.1, 1013.7, 1012.9, 1013.4],
+            'solar_radiation_wm2': [220.5, 180.3, 150.8, 240.2, 200.1, 190.7, 210.9],
+            'temperature_max_C': [30.2, 31.1, 29.5, 32.8, 30.9, 29.8, 31.5],
+            'temperature_min_C': [20.8, 20.9, 20.1, 21.6, 21.0, 20.4, 21.2],
+            'specific_humidity_g_kg': [12.5, 13.1, 13.8, 11.9, 13.2, 12.8, 12.9],
+            'dew_point_C': [18.2, 19.1, 19.8, 17.5, 18.9, 18.4, 18.7],
+            'wind_speed_10m_mps': [4.1, 3.6, 5.2, 7.1, 4.9, 3.0, 4.6],
+            'cloud_amount_perc': [30.0, 60.0, 80.0, 20.0, 50.0, 40.0, 70.0],
+            'sea_level_pressure_hPa': [1013.5, 1013.1, 1011.8, 1014.4, 1014.0, 1013.2, 1013.7],
+            'surface_soil_wetness_perc': [45.0, 52.0, 68.0, 42.0, 48.0, 50.0, 58.0],
+            'wind_direction_10m_degrees': [180.0, 165.0, 220.0, 195.0, 170.0, 210.0, 185.0],
+            'evapotranspiration_wm2': [85.2, 72.1, 58.9, 95.8, 82.4, 78.6, 88.3],
+            'root_zone_soil_moisture_perc': [55.0, 61.0, 74.0, 52.0, 58.0, 60.0, 68.0]
+        }
+        
+        test_data = {
+            'weather_data': sample_weather_data,
+            'event_duration': 2.0,
+            'include_metadata': True
+        }
+        
+        logger.info("Testing feature engineering service with sample weather data")
+        result = feature_controller.process_features(test_data)
+        
+        # Add test metadata
+        if result.get('status') == 'success':
+            result['data']['test_info'] = {
+                'test_description': 'Sample 7-day weather data processing',
+                'sample_size': 7,
+                'weather_fields': len(sample_weather_data),
+                'features_computed': len(result['data']['engineered_features']) if 'engineered_features' in result['data'] else 0
+            }
+        
+        status_code = 200 if result.get('status') == 'success' else 424
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        logger.error(f"Feature test API error: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Feature test API error: {str(e)}',
+            'data': None
+        }), 500
+
+@features_bp.errorhandler(400)
+def bad_request(error):
+    """Handle bad request errors"""
+    return jsonify({
+        'status': 'error',
+        'message': 'Bad request: Invalid parameters',
+        'data': None
+    }), 400
+
+@features_bp.errorhandler(404)
+def not_found(error):
+    """Handle not found errors"""
+    return jsonify({
+        'status': 'error',
+        'message': 'Feature engineering endpoint not found',
+        'data': None
+    }), 404
+
+@features_bp.errorhandler(500)
+def internal_error(error):
+    """Handle internal server errors"""
+    return jsonify({
+        'status': 'error',
+        'message': 'Internal server error',
+        'data': None
+    }), 500
+
+# Blueprint registration function
+def register_feature_routes(app):
+    """Register feature engineering routes with Flask app"""
+    app.register_blueprint(features_bp, url_prefix='/api')
+    logger.info("Feature engineering routes registered successfully")
+    
+    return features_bp
+
+# Route documentation
+FEATURE_ROUTES_DOC = {
+    'endpoints': {
+        '/api/features/process': {
+            'methods': ['POST'],
+            'description': 'Compute engineered features from weather data',
+            'parameters': ['weather_data', 'event_duration (optional)', 'include_metadata (optional)']
+        },
+        '/api/features/batch': {
+            'methods': ['POST'],
+            'description': 'Process multiple weather datasets (max 100)',
+            'parameters': ['batch_data array with weather_data/event_duration']
+        },
+        '/api/features/dataframe': {
+            'methods': ['POST'],
+            'description': 'Create time series DataFrame with features',
+            'parameters': ['weather_data', 'disaster_date', 'days_before', 'event_duration (optional)']
+        },
+        '/api/features/validate': {
+            'methods': ['POST'],
+            'description': 'Validate weather data readiness',
+            'parameters': ['weather_data']
+        },
+        '/api/features/export': {
+            'methods': ['POST'],
+            'description': 'Process and export in specified format',
+            'parameters': ['weather_data', 'disaster_date', 'days_before', 'export_format (optional)']
+        },
+        '/api/features/info': {
+            'methods': ['GET'],
+            'description': 'Get information about engineered features',
+            'parameters': []
+        },
+        '/api/features/status': {
+            'methods': ['GET'],
+            'description': 'Get service status and health',
+            'parameters': []
+        },
+        '/api/features/test': {
+            'methods': ['GET', 'POST'],
+            'description': 'Test feature engineering service',
+            'parameters': []
+        }
+    },
+    'features_computed': 19,
+    'weather_fields_required': 17,
+    'nan_handling': 'Proper NaN propagation - NaN input produces NaN output for that day only',
+    'max_batch_size': 100
+}
+
+if __name__ == '__main__':
+    print("Feature Engineering Routes Documentation:")
+    print(f"Available endpoints: {len(FEATURE_ROUTES_DOC['endpoints'])}")
+    for endpoint, info in FEATURE_ROUTES_DOC['endpoints'].items():
+        print(f"  {endpoint}: {info['description']}")

server/routes/geovision_fusion_routes.py

@@ -0,0 +1,124 @@
+"""
+GeoVision Fusion Prediction Routes
+RESTful API endpoints for the GeoVision multi-model fusion pipeline
+"""
+
+import logging
+from flask import Blueprint, request, jsonify, current_app
+from typing import Dict, Any
+import traceback
+
+logger = logging.getLogger(__name__)
+
+# Blueprint
+geovision_bp = Blueprint('geovision', __name__)
+
+
+def get_controller():
+    """Get the GeoVision controller from app context."""
+    return current_app.extensions.get('controllers', {}).get('geovision')
+
+
+def handle_request_error(error: Exception, endpoint: str) -> tuple:
+    logger.error(f"Error in {endpoint}: {error}")
+    logger.error(traceback.format_exc())
+    return jsonify({
+        'success': False,
+        'error': f"Internal server error in {endpoint}",
+        'message': 'Request processing failed',
+        'details': str(error) if current_app.debug else 'Enable debug mode for details'
+    }), 500
+
+
+# ═══════════════════════════════════════════════════════════════
+# ENDPOINTS
+# ═══════════════════════════════════════════════════════════════
+
+@geovision_bp.route('/predict', methods=['POST'])
+def predict_fusion():
+    """
+    Run GeoVision fusion prediction for a location.
+
+    POST /api/geovision/predict
+    Body: { "latitude": float, "longitude": float }
+
+    Automatically uses the most recent available weather data.
+    Returns comprehensive disaster + weather regime prediction.
+    """
+    try:
+        controller = get_controller()
+        if controller is None:
+            return jsonify({
+                'success': False,
+                'error': 'GeoVision service not initialized'
+            }), 503
+
+        if not request.is_json:
+            return jsonify({
+                'success': False,
+                'error': 'Content-Type must be application/json'
+            }), 400
+
+        request_data = request.get_json()
+        if not request_data:
+            return jsonify({
+                'success': False,
+                'error': 'Empty request body'
+            }), 400
+
+        logger.info(f"[GEOVISION_ROUTE] Predict request: lat={request_data.get('latitude')}, "
+                     f"lon={request_data.get('longitude')}")
+
+        result = controller.predict_fusion(request_data)
+
+        status_code = 200 if result.get('success') else 400
+        return jsonify(result), status_code
+
+    except Exception as e:
+        return handle_request_error(e, 'geovision/predict')
+
+
+@geovision_bp.route('/health', methods=['GET'])
+def service_health():
+    """
+    GET /api/geovision/health
+    Returns model load status and service statistics.
+    """
+    try:
+        controller = get_controller()
+        if controller is None:
+            return jsonify({
+                'success': False,
+                'error': 'GeoVision service not initialized'
+            }), 503
+
+        result = controller.get_service_status()
+        return jsonify(result), 200
+
+    except Exception as e:
+        return handle_request_error(e, 'geovision/health')
+
+
+@geovision_bp.route('/models', methods=['GET'])
+def list_models():
+    """
+    GET /api/geovision/models
+    Returns details about loaded models.
+    """
+    try:
+        controller = get_controller()
+        if controller is None:
+            return jsonify({
+                'success': False,
+                'error': 'GeoVision service not initialized'
+            }), 503
+
+        status = controller.get_service_status()
+        model_details = status.get('data', {}).get('model_details', {})
+        return jsonify({
+            'success': True,
+            'models': model_details
+        }), 200
+
+    except Exception as e:
+        return handle_request_error(e, 'geovision/models')

server/routes/hazardguard_prediction_routes.py

@@ -0,0 +1,605 @@
+"""
+HazardGuard Disaster Prediction Routes
+RESTful API endpoints for disaster risk prediction at specific locations
+"""
+
+import logging
+from flask import Blueprint, request, jsonify, current_app
+from typing import Dict, Any
+import traceback
+
+from controllers.hazardguard_prediction_controller import HazardGuardPredictionController
+
+logger = logging.getLogger(__name__)
+
+# Create blueprint for HazardGuard prediction routes
+hazardguard_bp = Blueprint('hazardguard', __name__)
+
+def get_controller():
+    """Get the HazardGuard controller from app context"""
+    return current_app.extensions.get('controllers', {}).get('hazardguard')
+
+def handle_request_error(error: Exception, endpoint: str) -> tuple[Dict[str, Any], int]:
+    """Handle request errors with consistent logging and response format"""
+    error_msg = f"Error in {endpoint}: {str(error)}"
+    logger.error(error_msg)
+    logger.error(f"Traceback: {traceback.format_exc()}")
+    
+    return {
+        'success': False,
+        'error': f"Internal server error in {endpoint}",
+        'message': 'Request processing failed',
+        'details': str(error) if current_app.debug else 'Enable debug mode for details'
+    }, 500
+
+@hazardguard_bp.route('/predict', methods=['POST'])
+def predict_disaster_risk():
+    """
+    Predict disaster risk for a specific location
+    
+    Primary endpoint for map-based location selection and disaster prediction.
+    
+    Expected JSON payload:
+    {
+        \"latitude\": float,     # Required: -90 to 90
+        \"longitude\": float,    # Required: -180 to 180  
+        \"reference_date\": \"YYYY-MM-DD\"  # Optional: date for weather data collection
+    }
+    
+    Returns:
+    {
+        \"success\": true/false,
+        \"message\": \"string\",
+        \"data\": {
+            \"location\": {
+                \"latitude\": float,
+                \"longitude\": float,
+                \"coordinates_message\": \"string\"
+            },
+            \"prediction\": {
+                \"prediction\": \"DISASTER\" or \"NORMAL\",
+                \"probability\": {
+                    \"disaster\": float,  # 0.0 to 1.0
+                    \"normal\": float     # 0.0 to 1.0
+                },
+                \"confidence\": float,   # Difference between probabilities
+                \"metadata\": {
+                    \"features_used\": int,
+                    \"features_selected\": int,
+                    \"model_type\": \"string\",
+                    \"forecast_horizon_days\": int,
+                    \"prediction_timestamp\": \"ISO timestamp\"
+                }
+            },
+            \"data_collection_summary\": {
+                \"weather_data\": true/false,
+                \"feature_engineering\": true/false,
+                \"raster_data\": true/false
+            },
+            \"processing_details\": {
+                \"total_processing_time_seconds\": float,
+                \"weather_date_range\": \"string\",
+                \"forecast_horizon_days\": int,
+                \"data_sources\": [\"array\"]
+            }
+        },
+        \"processing_info\": {
+            \"total_processing_time_seconds\": float,
+            \"prediction_class\": \"DISASTER\" or \"NORMAL\",
+            \"disaster_probability\": float,
+            \"confidence\": float
+        },
+        \"timestamp\": \"ISO timestamp\"
+    }
+    """
+    try:
+        # Validate request content type
+        if not request.is_json:
+            return jsonify({
+                'success': False,
+                'error': 'Content-Type must be application/json',
+                'message': 'Invalid request format'
+            }), 400
+        
+        # Get request data
+        request_data = request.get_json()
+        if not request_data:
+            return jsonify({
+                'success': False,
+                'error': 'Empty request body',
+                'message': 'JSON payload required',
+                'required_fields': {
+                    'latitude': 'float (-90 to 90)',
+                    'longitude': 'float (-180 to 180)',
+                    'reference_date': 'string (YYYY-MM-DD, optional)'
+                }
+            }), 400
+        
+        # Get controller from app context
+        logger.info(f"[HAZARDGUARD] Received prediction request: {request_data}")
+        controller = get_controller()
+        if not controller:
+            logger.error("[HAZARDGUARD] Controller not found in app context!")
+            return jsonify({
+                'success': False,
+                'error': 'HazardGuard service not available',
+                'message': 'Service not properly initialized'
+            }), 503
+        
+        logger.info(f"[HAZARDGUARD] Controller found, making prediction...")
+        # Process using controller
+        result = controller.predict_disaster_risk(request_data)
+        logger.info(f"[HAZARDGUARD] Prediction result success={result.get('success')}")
+        
+        # Return response with appropriate status code
+        status_code = 200 if result['success'] else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'predict_disaster_risk')
+        return jsonify(error_response), status_code
+
+@hazardguard_bp.route('/predict/batch', methods=['POST'])
+def predict_batch_locations():
+    """
+    Predict disaster risk for multiple locations in batch
+    
+    Expected JSON payload:
+    {
+        \"locations\": [
+            {
+                \"latitude\": float,
+                \"longitude\": float,
+                \"reference_date\": \"YYYY-MM-DD\"  # Optional
+            },
+            {
+                \"latitude\": float,
+                \"longitude\": float
+            },
+            ...  # Maximum 50 locations
+        ]
+    }
+    
+    Returns:
+    {
+        \"success\": true/false,
+        \"message\": \"string\",
+        \"data\": {
+            \"results\": [
+                {
+                    \"location_index\": int,
+                    \"success\": true/false,
+                    \"location\": {\"latitude\": float, \"longitude\": float},
+                    \"prediction\": {\"prediction\": \"string\", \"probability\": {}, ...},
+                    \"processing_time_seconds\": float
+                },
+                ...
+            ],
+            \"summary\": {
+                \"total_locations\": int,
+                \"successful_predictions\": int,
+                \"failed_predictions\": int,
+                \"success_rate_percent\": float
+            }
+        },
+        \"processing_info\": {
+            \"batch_size\": int,
+            \"processing_mode\": \"sequential\"
+        }
+    }
+    """
+    try:
+        if not request.is_json:
+            return jsonify({
+                'success': False,
+                'error': 'Content-Type must be application/json',
+                'message': 'Invalid request format'
+            }), 400
+        
+        request_data = request.get_json()
+        if not request_data:
+            return jsonify({
+                'success': False,
+                'error': 'Empty request body',
+                'message': 'JSON payload required'
+            }), 400
+        
+        # Get controller from app context
+        controller = get_controller()
+        if not controller:
+            return jsonify({
+                'success': False,
+                'error': 'HazardGuard service not available',
+                'message': 'Service not properly initialized'
+            }), 503
+            
+        # Process using controller
+        result = controller.predict_batch_locations(request_data)
+        
+        status_code = 200 if result['success'] else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'predict_batch_locations')
+        return jsonify(error_response), status_code
+
+@hazardguard_bp.route('/capabilities', methods=['GET'])
+def get_prediction_capabilities():
+    """
+    Get information about HazardGuard prediction capabilities and requirements
+    
+    Returns:
+    {
+        \"success\": true,
+        \"message\": \"string\",
+        \"data\": {
+            \"prediction_type\": \"string\",
+            \"supported_disaster_types\": [\"array\"],
+            \"forecasting_horizon\": \"string\",
+            \"geographic_coverage\": \"string\",
+            \"data_sources\": {
+                \"weather_data\": \"string\",
+                \"engineered_features\": \"string\",
+                \"raster_data\": \"string\",
+                \"total_features\": \"string\"
+            },
+            \"model_details\": {
+                \"algorithm\": \"string\",
+                \"feature_selection\": \"string\",
+                \"preprocessing\": \"string\",
+                \"validation\": \"string\"
+            },
+            \"input_requirements\": {
+                \"required_fields\": [\"array\"],
+                \"optional_fields\": [\"array\"],
+                \"coordinate_ranges\": {\"object\"}
+            },
+            \"output_format\": {\"object\"},
+            \"batch_processing\": {\"object\"},
+            \"service_status\": {\"object\"}
+        }
+    }
+    """
+    try:
+        # Get controller from app context
+        controller = get_controller()
+        if not controller:
+            return jsonify({
+                'success': False,
+                'error': 'HazardGuard service not available',
+                'message': 'Service not properly initialized'
+            }), 503
+            
+        # Get capabilities using controller
+        result = controller.get_prediction_capabilities()
+        
+        status_code = 200 if result['success'] else 500
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'get_prediction_capabilities')
+        return jsonify(error_response), status_code
+
+@hazardguard_bp.route('/validate/coordinates', methods=['POST'])
+def validate_coordinates():
+    """
+    Validate coordinates without making prediction (for testing/validation)
+    
+    Expected JSON payload:
+    {
+        \"latitude\": float,
+        \"longitude\": float,
+        \"reference_date\": \"YYYY-MM-DD\"  # Optional
+    }
+    
+    Returns:
+    {
+        \"success\": true/false,
+        \"message\": \"string\",
+        \"data\": {
+            \"coordinates\": {
+                \"latitude\": float,
+                \"longitude\": float,
+                \"reference_date\": \"string\" or null
+            },
+            \"validation_message\": \"string\"
+        }
+    }
+    """
+    try:
+        if not request.is_json:
+            return jsonify({
+                'success': False,
+                'error': 'Content-Type must be application/json',
+                'message': 'Invalid request format'
+            }), 400
+        
+        request_data = request.get_json()
+        if not request_data:
+            return jsonify({
+                'success': False,
+                'error': 'Empty request body',
+                'message': 'JSON payload required'
+            }), 400
+        
+        # Get controller from app context
+        controller = get_controller()
+        if not controller:
+            return jsonify({
+                'success': False,
+                'error': 'HazardGuard service not available',
+                'message': 'Service not properly initialized'
+            }), 503
+            
+        # Validate using controller
+        result = controller.validate_coordinates_only(request_data)
+        
+        status_code = 200 if result['success'] else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'validate_coordinates')
+        return jsonify(error_response), status_code
+
+@hazardguard_bp.route('/health', methods=['GET'])
+def get_service_health():
+    """
+    Get HazardGuard service health and performance statistics
+    
+    Returns:
+    {
+        \"success\": true/false,
+        \"message\": \"string\",
+        \"data\": {
+            \"service_status\": \"ready\" or \"not_initialized\" or \"error\",
+            \"uptime_seconds\": float,
+            \"uptime_hours\": float,
+            \"model_loaded\": true/false,
+            \"model_info\": {
+                \"is_loaded\": true/false,
+                \"model_metadata\": {\"object\"},
+                \"feature_counts\": {\"object\"},
+                \"forecasting\": {\"object\"},
+                \"prediction_statistics\": {\"object\"}
+            },
+            \"statistics\": {
+                \"total_requests\": int,
+                \"successful_predictions\": int,
+                \"failed_predictions\": int,
+                \"success_rate_percent\": float,
+                \"data_collection_failures\": int,
+                \"weather_fetch_failures\": int,
+                \"feature_engineering_failures\": int,
+                \"raster_fetch_failures\": int,
+                \"average_processing_time_seconds\": float
+            },
+            \"service_dependencies\": {\"object\"},
+            \"last_updated\": \"ISO timestamp\"
+        }
+    }
+    """
+    try:
+        # Get controller from app context
+        controller = get_controller()
+        if not controller:
+            return jsonify({
+                'success': False,
+                'error': 'HazardGuard service not available',
+                'message': 'Service not properly initialized'
+            }), 503
+            
+        # Get health info using controller  
+        result = controller.get_service_health()
+        
+        status_code = 200 if result['success'] else 500
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'get_service_health')
+        return jsonify(error_response), status_code
+
+@hazardguard_bp.route('/initialize', methods=['POST'])
+def initialize_service():
+    """
+    Initialize HazardGuard service (load model components)
+    
+    Returns:
+    {
+        \"success\": true/false,
+        \"message\": \"string\",
+        \"data\": {
+            \"service_status\": \"ready\" or error info,
+            \"initialization_message\": \"string\"
+        }
+    }
+    """
+    try:
+        # Get controller from app context
+        controller = get_controller()
+        if not controller:
+            return jsonify({
+                'success': False,
+                'error': 'HazardGuard service not available',
+                'message': 'Service not properly initialized'
+            }), 503
+            
+        # Initialize using controller
+        result = controller.initialize_controller()
+        
+        status_code = 200 if result['success'] else 500
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'initialize_service')
+        return jsonify(error_response), status_code
+
+@hazardguard_bp.route('/statistics/reset', methods=['POST'])
+def reset_statistics():
+    """
+    Reset HazardGuard service and model statistics
+    
+    Returns:
+    {
+        \"success\": true/false,
+        \"message\": \"string\",
+        \"data\": {
+            \"status\": \"success\" or \"error\",
+            \"message\": \"string\",
+            \"timestamp\": \"ISO timestamp\"
+        }
+    }
+    """
+    try:
+        # Get controller from app context
+        controller = get_controller()
+        if not controller:
+            return jsonify({
+                'success': False,
+                'error': 'HazardGuard service not available',
+                'message': 'Service not properly initialized'
+            }), 503
+            
+        # Reset statistics using controller
+        result = controller.reset_service_statistics()
+        
+        status_code = 200 if result['success'] else 500
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'reset_statistics')
+        return jsonify(error_response), status_code
+
+@hazardguard_bp.route('/ping', methods=['GET'])
+def ping():
+    """
+    Simple ping endpoint to check if HazardGuard service is responsive
+    
+    Returns:
+    {
+        \"success\": true,
+        \"message\": \"Service is responsive\",
+        \"data\": {
+            \"service\": \"hazardguard_disaster_prediction\",
+            \"status\": \"active\",
+            \"timestamp\": \"ISO timestamp\"
+        }
+    }
+    """
+    try:
+        from datetime import datetime
+        
+        return jsonify({
+            'success': True,
+            'message': 'HazardGuard service is responsive',
+            'data': {
+                'service': 'hazardguard_disaster_prediction',
+                'status': 'active',
+                'prediction_types': ['DISASTER', 'NORMAL'],
+                'supported_disasters': ['Flood', 'Storm', 'Landslide', 'Drought'],
+                'timestamp': datetime.now().isoformat()
+            }
+        }), 200
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'ping')
+        return jsonify(error_response), status_code
+
+# Error handlers for the blueprint
+@hazardguard_bp.errorhandler(404)
+def not_found(error):
+    """Handle 404 errors"""
+    return jsonify({
+        'success': False,
+        'error': 'Endpoint not found',
+        'message': 'The requested HazardGuard endpoint does not exist',
+        'available_endpoints': [
+            '/predict - POST: Predict disaster risk for location',
+            '/predict/batch - POST: Predict for multiple locations',
+            '/capabilities - GET: Get prediction capabilities',
+            '/validate/coordinates - POST: Validate coordinates',
+            '/health - GET: Get service health',
+            '/initialize - POST: Initialize service',
+            '/statistics/reset - POST: Reset statistics',
+            '/ping - GET: Service ping test'
+        ]
+    }), 404
+
+@hazardguard_bp.errorhandler(405)
+def method_not_allowed(error):
+    """Handle 405 errors"""
+    return jsonify({
+        'success': False,
+        'error': 'Method not allowed',
+        'message': 'The HTTP method is not allowed for this HazardGuard endpoint',
+        'allowed_methods': ['GET', 'POST']
+    }), 405
+
+@hazardguard_bp.errorhandler(500)
+def internal_error(error):
+    """Handle 500 errors"""
+    logger.error(f"Internal server error in HazardGuard: {error}")
+    return jsonify({
+        'success': False,
+        'error': 'Internal server error',
+        'message': 'An unexpected error occurred in HazardGuard service'
+    }), 500
+
+# Blueprint registration information
+def get_blueprint_info() -> Dict[str, Any]:
+    """Get information about this blueprint"""
+    return {
+        'name': 'hazardguard',
+        'description': 'HazardGuard disaster prediction API endpoints',
+        'version': '1.0.0',
+        'prediction_type': 'Binary Classification (DISASTER vs NORMAL)',
+        'supported_disasters': ['Flood', 'Storm', 'Landslide', 'Drought'],
+        'endpoints': {
+            '/predict': {
+                'methods': ['POST'],
+                'description': 'Predict disaster risk for specific location'
+            },
+            '/predict/batch': {
+                'methods': ['POST'],
+                'description': 'Predict disaster risk for multiple locations'
+            },
+            '/capabilities': {
+                'methods': ['GET'],
+                'description': 'Get prediction capabilities and requirements'
+            },
+            '/validate/coordinates': {
+                'methods': ['POST'],
+                'description': 'Validate coordinates without prediction'
+            },
+            '/health': {
+                'methods': ['GET'],
+                'description': 'Get service health and performance statistics'
+            },
+            '/initialize': {
+                'methods': ['POST'],
+                'description': 'Initialize service and load model'
+            },
+            '/statistics/reset': {
+                'methods': ['POST'],
+                'description': 'Reset service and model statistics'
+            },
+            '/ping': {
+                'methods': ['GET'],
+                'description': 'Simple service ping test'
+            }
+        },
+        'features': {
+            'map_based_prediction': True,
+            'batch_processing': True,
+            'coordinate_validation': True,
+            'health_monitoring': True,
+            'statistical_tracking': True,
+            'forecasting_horizon': '1 day ahead',
+            'max_batch_size': 50
+        },
+        'data_requirements': {
+            'weather_data': '60-day sequences, 17 variables',
+            'engineered_features': '60-day sequences, 19 variables', 
+            'raster_data': '9 geographic variables',
+            'total_features': '~300 after statistical expansion'
+        }
+    }

server/routes/post_disaster_feature_engineering_routes.py

@@ -0,0 +1,546 @@
+"""
+Post-Disaster Feature Engineering Routes for HazardGuard System
+RESTful API endpoints for post-disaster feature engineering operations
+"""
+
+import logging
+from flask import Blueprint, request, jsonify, current_app
+from typing import Dict, Any
+import traceback
+
+from controllers.post_disaster_feature_engineering_controller import PostDisasterFeatureEngineeringController
+
+logger = logging.getLogger(__name__)
+
+# Create blueprint for post-disaster feature engineering routes
+post_disaster_feature_engineering_bp = Blueprint('post_disaster_feature_engineering', __name__)
+
+# Initialize controller
+controller = PostDisasterFeatureEngineeringController()
+
+def handle_request_error(error: Exception, endpoint: str) -> Dict[str, Any]:
+    """Handle request errors with consistent logging and response format"""
+    error_msg = f"Error in {endpoint}: {str(error)}"
+    logger.error(error_msg)
+    logger.error(f"Traceback: {traceback.format_exc()}")
+    
+    return {
+        'success': False,
+        'error': f"Internal server error in {endpoint}",
+        'message': 'Request processing failed',
+        'details': str(error) if current_app.debug else 'Enable debug mode for details'
+    }, 500
+
+@post_disaster_feature_engineering_bp.route('/process', methods=['POST'])
+def process_single_coordinate_features():
+    """
+    Process post-disaster feature engineering for a single coordinate
+    
+    Expected JSON payload:
+    {
+        \"weather_data\": {
+            \"POST_temperature_C\": [list of 60 daily values],
+            \"POST_humidity_%\": [list of 60 daily values],
+            ... (17 weather variables total)
+        },
+        \"coordinate\": [latitude, longitude] (optional),
+        \"global_stats\": {} (optional)
+    }
+    
+    Returns:
+    {
+        \"success\": true/false,
+        \"message\": \"string\",
+        \"data\": {
+            \"coordinate\": [lat, lon],
+            \"features\": {
+                \"POST_temp_normalized\": [60 values],
+                \"POST_temp_range\": [60 values],
+                ... (19 features total)
+            },
+            \"metadata\": {}
+        },
+        \"processing_info\": {
+            \"processing_time_seconds\": float,
+            \"features_count\": int,
+            \"days_processed\": int
+        }
+    }
+    """
+    try:
+        # Validate request content type
+        if not request.is_json:
+            return jsonify({
+                'success': False,
+                'error': 'Content-Type must be application/json',
+                'message': 'Invalid request format'
+            }), 400
+        
+        # Get request data
+        request_data = request.get_json()
+        if not request_data:
+            return jsonify({
+                'success': False,
+                'error': 'Empty request body',
+                'message': 'JSON payload required'
+            }), 400
+        
+        # Process using controller
+        result = controller.process_single_coordinate_features(request_data)
+        
+        # Return response with appropriate status code
+        status_code = 200 if result['success'] else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'process_single_coordinate_features')
+        return jsonify(error_response), status_code
+
+@post_disaster_feature_engineering_bp.route('/batch', methods=['POST'])
+def process_batch_features():
+    """
+    Process post-disaster feature engineering for multiple coordinates
+    
+    Expected JSON payload:
+    {
+        \"weather_datasets\": [
+            {weather_data_1},
+            {weather_data_2},
+            ...
+        ],
+        \"coordinates\": [[lat1, lon1], [lat2, lon2], ...] (optional)
+    }
+    
+    Returns:
+    {
+        \"success\": true/false,
+        \"message\": \"string\",
+        \"data\": {
+            \"results\": [
+                {
+                    \"coordinate_index\": int,
+                    \"coordinate\": [lat, lon],
+                    \"success\": true/false,
+                    \"features\": {},
+                    \"metadata\": {}
+                },
+                ...
+            ],
+            \"global_statistics\": {},
+            \"summary\": {
+                \"total_coordinates\": int,
+                \"successful_coordinates\": int,
+                \"failed_coordinates\": int,
+                \"success_rate_percent\": float
+            }
+        },
+        \"processing_info\": {}
+    }
+    """
+    try:
+        # Validate request
+        if not request.is_json:
+            return jsonify({
+                'success': False,
+                'error': 'Content-Type must be application/json',
+                'message': 'Invalid request format'
+            }), 400
+        
+        request_data = request.get_json()
+        if not request_data:
+            return jsonify({
+                'success': False,
+                'error': 'Empty request body',
+                'message': 'JSON payload required'
+            }), 400
+        
+        # Process using controller
+        result = controller.process_batch_features(request_data)
+        
+        # Return response
+        status_code = 200 if result['success'] else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'process_batch_features')
+        return jsonify(error_response), status_code
+
+@post_disaster_feature_engineering_bp.route('/export/csv', methods=['POST'])
+def export_to_csv():
+    """
+    Export feature engineering results to CSV format
+    
+    Expected JSON payload:
+    {
+        \"results\": [list of feature engineering results],
+        \"include_metadata\": true/false (optional, default: true)
+    }
+    
+    Returns:
+    {
+        \"success\": true/false,
+        \"message\": \"string\",
+        \"data\": {
+            \"csv_data\": \"string (CSV content)\",
+            \"row_count\": int,
+            \"column_count\": int,
+            \"columns\": [list of column names]
+        }
+    }
+    """
+    try:
+        if not request.is_json:
+            return jsonify({
+                'success': False,
+                'error': 'Content-Type must be application/json',
+                'message': 'Invalid request format'
+            }), 400
+        
+        request_data = request.get_json()
+        if not request_data:
+            return jsonify({
+                'success': False,
+                'error': 'Empty request body',
+                'message': 'JSON payload required'
+            }), 400
+        
+        # Process using controller
+        result = controller.export_to_csv(request_data)
+        
+        status_code = 200 if result['success'] else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'export_to_csv')
+        return jsonify(error_response), status_code
+
+@post_disaster_feature_engineering_bp.route('/validate/coordinates', methods=['POST'])
+def validate_coordinates():
+    """
+    Validate coordinate input format
+    
+    Expected JSON payload:
+    {
+        \"coordinates\": [[lat1, lon1], [lat2, lon2], ...]
+    }
+    
+    Returns:
+    {
+        \"success\": true/false,
+        \"message\": \"string\",
+        \"data\": {
+            \"coordinates\": [validated coordinates],
+            \"count\": int,
+            \"validation_message\": \"string\"
+        }
+    }
+    """
+    try:
+        if not request.is_json:
+            return jsonify({
+                'success': False,
+                'error': 'Content-Type must be application/json',
+                'message': 'Invalid request format'
+            }), 400
+        
+        request_data = request.get_json()
+        if not request_data:
+            return jsonify({
+                'success': False,
+                'error': 'Empty request body',
+                'message': 'JSON payload required'
+            }), 400
+        
+        # Validate using controller
+        result = controller.validate_coordinates(request_data)
+        
+        status_code = 200 if result['success'] else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'validate_coordinates')
+        return jsonify(error_response), status_code
+
+@post_disaster_feature_engineering_bp.route('/validate/weather', methods=['POST'])
+def validate_weather_data():
+    """
+    Validate weather data input format
+    
+    Expected JSON payload:
+    {
+        \"weather_data\": {
+            \"POST_temperature_C\": [60 values],
+            \"POST_humidity_%\": [60 values],
+            ... (17 variables total)
+        }
+    }
+    
+    Returns:
+    {
+        \"success\": true/false,
+        \"message\": \"string\",
+        \"data\": {
+            \"validation_message\": \"string\",
+            \"variables_count\": int,
+            \"days_per_variable\": int,
+            \"detected_variables\": [list]
+        }
+    }
+    """
+    try:
+        if not request.is_json:
+            return jsonify({
+                'success': False,
+                'error': 'Content-Type must be application/json',
+                'message': 'Invalid request format'
+            }), 400
+        
+        request_data = request.get_json()
+        if not request_data:
+            return jsonify({
+                'success': False,
+                'error': 'Empty request body',
+                'message': 'JSON payload required'
+            }), 400
+        
+        # Validate using controller
+        result = controller.validate_weather_input(request_data)
+        
+        status_code = 200 if result['success'] else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'validate_weather_data')
+        return jsonify(error_response), status_code
+
+@post_disaster_feature_engineering_bp.route('/features/info', methods=['GET'])
+def get_feature_info():
+    """
+    Get information about input variables and output features
+    
+    Returns:
+    {
+        \"success\": true,
+        \"message\": \"string\",
+        \"data\": {
+            \"input_variables\": {
+                \"count\": int,
+                \"variables\": [list of variable names],
+                \"description\": \"string\"
+            },
+            \"output_features\": {
+                \"count\": int,
+                \"features\": [list of feature names],
+                \"descriptions\": {feature_name: {description, unit, calculation}},
+                \"description\": \"string\"
+            },
+            \"processing_info\": {
+                \"days_per_coordinate\": int,
+                \"feature_engineering_type\": \"string\"
+            }
+        }
+    }
+    """
+    try:
+        # Get feature info using controller
+        result = controller.get_feature_info()
+        
+        status_code = 200 if result['success'] else 500
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'get_feature_info')
+        return jsonify(error_response), status_code
+
+@post_disaster_feature_engineering_bp.route('/health', methods=['GET'])
+def get_service_health():
+    """
+    Get service health and performance statistics
+    
+    Returns:
+    {
+        \"success\": true/false,
+        \"message\": \"string\",
+        \"data\": {
+            \"service_status\": \"healthy/error\",
+            \"service_uptime_seconds\": float,
+            \"service_uptime_hours\": float,
+            \"total_requests\": int,
+            \"successful_requests\": int,
+            \"failed_requests\": int,
+            \"success_rate_percent\": float,
+            \"total_coordinates_processed\": int,
+            \"average_processing_time_seconds\": float,
+            \"model_statistics\": {},
+            \"feature_counts\": {},
+            \"last_updated\": \"ISO timestamp\"
+        }
+    }
+    """
+    try:
+        # Get health info using controller
+        result = controller.get_service_health()
+        
+        status_code = 200 if result['success'] else 500
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'get_service_health')
+        return jsonify(error_response), status_code
+
+@post_disaster_feature_engineering_bp.route('/statistics/reset', methods=['POST'])
+def reset_statistics():
+    """
+    Reset service and model statistics
+    
+    Returns:
+    {
+        \"success\": true/false,
+        \"message\": \"string\",
+        \"data\": {
+            \"status\": \"success/error\",
+            \"message\": \"string\",
+            \"timestamp\": \"ISO timestamp\"
+        }
+    }
+    """
+    try:
+        # Reset statistics using controller
+        result = controller.reset_statistics()
+        
+        status_code = 200 if result['success'] else 500
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'reset_statistics')
+        return jsonify(error_response), status_code
+
+@post_disaster_feature_engineering_bp.route('/ping', methods=['GET'])
+def ping():
+    """
+    Simple ping endpoint to check if service is responsive
+    
+    Returns:
+    {
+        \"success\": true,
+        \"message\": \"Service is responsive\",
+        \"data\": {
+            \"service\": \"post_disaster_feature_engineering\",
+            \"status\": \"active\",
+            \"timestamp\": \"ISO timestamp\"
+        }
+    }
+    """
+    try:
+        from datetime import datetime
+        
+        return jsonify({
+            'success': True,
+            'message': 'Service is responsive',
+            'data': {
+                'service': 'post_disaster_feature_engineering',
+                'status': 'active',
+                'timestamp': datetime.now().isoformat()
+            }
+        }), 200
+        
+    except Exception as e:
+        error_response, status_code = handle_request_error(e, 'ping')
+        return jsonify(error_response), status_code
+
+# Error handlers for the blueprint
+@post_disaster_feature_engineering_bp.errorhandler(404)
+def not_found(error):
+    """Handle 404 errors"""
+    return jsonify({
+        'success': False,
+        'error': 'Endpoint not found',
+        'message': 'The requested endpoint does not exist',
+        'available_endpoints': [
+            '/process - POST: Process single coordinate features',
+            '/batch - POST: Process multiple coordinates',
+            '/export/csv - POST: Export results to CSV',
+            '/validate/coordinates - POST: Validate coordinates',
+            '/validate/weather - POST: Validate weather data',
+            '/features/info - GET: Get feature information',
+            '/health - GET: Get service health',
+            '/statistics/reset - POST: Reset statistics',
+            '/ping - GET: Service ping test'
+        ]
+    }), 404
+
+@post_disaster_feature_engineering_bp.errorhandler(405)
+def method_not_allowed(error):
+    """Handle 405 errors"""
+    return jsonify({
+        'success': False,
+        'error': 'Method not allowed',
+        'message': 'The HTTP method is not allowed for this endpoint',
+        'allowed_methods': ['GET', 'POST']
+    }), 405
+
+@post_disaster_feature_engineering_bp.errorhandler(500)
+def internal_error(error):
+    """Handle 500 errors"""
+    logger.error(f"Internal server error: {error}")
+    return jsonify({
+        'success': False,
+        'error': 'Internal server error',
+        'message': 'An unexpected error occurred while processing the request'
+    }), 500
+
+# Blueprint registration information
+def get_blueprint_info() -> Dict[str, Any]:
+    """Get information about this blueprint"""
+    return {
+        'name': 'post_disaster_feature_engineering',
+        'description': 'Post-disaster feature engineering API endpoints',
+        'version': '1.0.0',
+        'endpoints': {
+            '/process': {
+                'methods': ['POST'],
+                'description': 'Process single coordinate feature engineering'
+            },
+            '/batch': {
+                'methods': ['POST'], 
+                'description': 'Process multiple coordinates batch feature engineering'
+            },
+            '/export/csv': {
+                'methods': ['POST'],
+                'description': 'Export results to CSV format'
+            },
+            '/validate/coordinates': {
+                'methods': ['POST'],
+                'description': 'Validate coordinate input format'
+            },
+            '/validate/weather': {
+                'methods': ['POST'],
+                'description': 'Validate weather data input format'
+            },
+            '/features/info': {
+                'methods': ['GET'],
+                'description': 'Get input variables and output features information'
+            },
+            '/health': {
+                'methods': ['GET'],
+                'description': 'Get service health and performance statistics'
+            },
+            '/statistics/reset': {
+                'methods': ['POST'],
+                'description': 'Reset service and model statistics'
+            },
+            '/ping': {
+                'methods': ['GET'],
+                'description': 'Simple service ping test'
+            }
+        },
+        'features': {
+            'input_variables': 17,
+            'output_features': 19,
+            'days_per_coordinate': 60,
+            'supports_batch_processing': True,
+            'supports_csv_export': True,
+            'supports_validation': True,
+            'supports_health_monitoring': True
+        }
+    }

server/routes/post_disaster_weather_routes.py

@@ -0,0 +1,423 @@
+"""
+Post-Disaster Weather Data Routes for HazardGuard System
+RESTful API endpoints for post-disaster weather data operations
+"""
+
+import logging
+from flask import Blueprint, request, jsonify
+from functools import wraps
+import json
+
+from controllers.post_disaster_weather_controller import PostDisasterWeatherController
+
+logger = logging.getLogger(__name__)
+
+# Global controller instance
+post_disaster_weather_controller = None
+
+def create_post_disaster_weather_routes(config: dict = None) -> Blueprint:
+    """
+    Create and configure post-disaster weather routes blueprint
+    
+    Args:
+        config: Configuration dictionary for weather service settings
+    
+    Returns:
+        Flask Blueprint with configured routes
+    """
+    global post_disaster_weather_controller
+    
+    # Create blueprint
+    post_disaster_weather_bp = Blueprint('post_disaster_weather', __name__, url_prefix='/api/post-disaster-weather')
+    
+    # Initialize controller with configuration
+    try:
+        controller_config = config or {}
+        post_disaster_weather_controller = PostDisasterWeatherController(
+            days_after_disaster=controller_config.get('days_after_disaster', 60),
+            max_workers=controller_config.get('max_workers', 1),
+            retry_limit=controller_config.get('retry_limit', 5),
+            retry_delay=controller_config.get('retry_delay', 15),
+            rate_limit_pause=controller_config.get('rate_limit_pause', 900),
+            request_delay=controller_config.get('request_delay', 0.5)
+        )
+        logger.info("Post-disaster weather controller initialized for routes")
+    except Exception as e:
+        logger.error(f"Failed to initialize post-disaster weather controller: {e}")
+        raise
+    
+    def handle_json_errors(f):
+        """Decorator to handle JSON parsing errors"""
+        @wraps(f)
+        def wrapper(*args, **kwargs):
+            try:
+                if request.method in ['POST', 'PUT']:
+                    if not request.is_json:
+                        return jsonify({
+                            'success': False,
+                            'error': 'Request must be JSON format',
+                            'status_code': 400
+                        }), 400
+                    
+                    # Validate JSON can be parsed
+                    request.get_json(force=True)
+                
+                return f(*args, **kwargs)
+                
+            except json.JSONDecodeError as e:
+                logger.error(f"JSON decode error: {e}")
+                return jsonify({
+                    'success': False,
+                    'error': f'Invalid JSON format: {str(e)}',
+                    'status_code': 400
+                }), 400
+            except Exception as e:
+                logger.error(f"Request handling error: {e}")
+                return jsonify({
+                    'success': False,
+                    'error': f'Request processing error: {str(e)}',
+                    'status_code': 500
+                }), 500
+        
+        return wrapper
+    
+    # ===== CORE PROCESSING ENDPOINTS =====
+    
+    @post_disaster_weather_bp.route('/process', methods=['POST'])
+    @handle_json_errors
+    def process_post_disaster_weather():
+        """
+        Process post-disaster weather extraction for coordinates
+        
+        Expected JSON:
+        {
+            \"coordinates\": [
+                {\"latitude\": 12.9716, \"longitude\": 77.5946}
+            ],
+            \"disaster_dates\": [\"2023-01-15\"],
+            \"variables\": [\"POST_temperature_C\", \"POST_precipitation_mm\"] # optional
+        }
+        """
+        try:
+            request_data = request.get_json()
+            result = post_disaster_weather_controller.process_post_disaster_weather(request_data)
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Process endpoint error: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Processing failed: {str(e)}',
+                'status_code': 500
+            }), 500
+    
+    @post_disaster_weather_bp.route('/batch', methods=['POST'])
+    @handle_json_errors  
+    def process_batch_weather():
+        """
+        Process batch post-disaster weather extraction
+        
+        Expected JSON:
+        {
+            \"coordinates\": [
+                {\"latitude\": 12.9716, \"longitude\": 77.5946},
+                {\"latitude\": 17.3850, \"longitude\": 78.4867}
+            ],
+            \"disaster_dates\": [\"2023-01-15\", \"2023-02-20\"],
+            \"variables\": [\"POST_temperature_C\"] # optional
+        }
+        """
+        try:
+            request_data = request.get_json()
+            result = post_disaster_weather_controller.process_batch_weather(request_data)
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Batch endpoint error: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Batch processing failed: {str(e)}',
+                'status_code': 500
+            }), 500
+    
+    # ===== VALIDATION ENDPOINTS =====
+    
+    @post_disaster_weather_bp.route('/validate/coordinates', methods=['POST'])
+    @handle_json_errors
+    def validate_coordinates():
+        """
+        Validate coordinate format and ranges
+        
+        Expected JSON:
+        {
+            \"coordinates\": [
+                {\"latitude\": 12.9716, \"longitude\": 77.5946}
+            ]
+        }
+        """
+        try:
+            request_data = request.get_json()
+            result = post_disaster_weather_controller.validate_coordinates(request_data)
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Coordinate validation endpoint error: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Coordinate validation failed: {str(e)}',
+                'status_code': 500
+            }), 500
+    
+    @post_disaster_weather_bp.route('/validate/dates', methods=['POST'])
+    @handle_json_errors
+    def validate_disaster_dates():
+        """
+        Validate disaster date format and ranges
+        
+        Expected JSON:
+        {
+            \"disaster_dates\": [\"2023-01-15\", \"2023-02-20\"]
+        }
+        """
+        try:
+            request_data = request.get_json()
+            result = post_disaster_weather_controller.validate_disaster_dates(request_data)
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Date validation endpoint error: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Date validation failed: {str(e)}',
+                'status_code': 500
+            }), 500
+    
+    # ===== INFORMATION ENDPOINTS =====
+    
+    @post_disaster_weather_bp.route('/variables', methods=['GET'])
+    def get_available_variables():
+        """Get available post-disaster weather variables"""
+        try:
+            result = post_disaster_weather_controller.get_available_variables()
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Variables endpoint error: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Failed to get variables: {str(e)}',
+                'status_code': 500
+            }), 500
+    
+    @post_disaster_weather_bp.route('/info', methods=['GET'])
+    def get_service_info():
+        """Get comprehensive service information"""
+        try:
+            result = post_disaster_weather_controller.get_service_info()
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Service info endpoint error: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Failed to get service info: {str(e)}',
+                'status_code': 500
+            }), 500
+    
+    # ===== EXPORT ENDPOINTS =====
+    
+    @post_disaster_weather_bp.route('/export/dataframe', methods=['POST'])
+    @handle_json_errors
+    def export_to_dataframe():
+        """
+        Export weather data to DataFrame format
+        
+        Expected JSON:  
+        {
+            \"weather_data\": [
+                {
+                    \"latitude\": 12.9716,
+                    \"longitude\": 77.5946,
+                    \"disaster_date\": \"2023-01-15\",
+                    \"POST_temperature_C\": [25.1, 26.2, ...],
+                    \"success\": true
+                }
+            ]
+        }
+        """
+        try:
+            request_data = request.get_json()
+            result = post_disaster_weather_controller.export_to_dataframe(request_data)
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"DataFrame export endpoint error: {e}")
+            return jsonify({
+                'success': False, 
+                'error': f'DataFrame export failed: {str(e)}',
+                'status_code': 500
+            }), 500
+    
+    @post_disaster_weather_bp.route('/export/file', methods=['POST'])
+    @handle_json_errors
+    def export_to_file():
+        """
+        Export weather data to file
+        
+        Expected JSON:
+        {
+            \"weather_data\": [...],
+            \"filepath\": \"/path/to/output.json\",
+            \"file_format\": \"json\" # json, csv, xlsx
+        }
+        """
+        try:
+            request_data = request.get_json()
+            result = post_disaster_weather_controller.export_to_file(request_data)
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"File export endpoint error: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'File export failed: {str(e)}',
+                'status_code': 500
+            }), 500
+    
+    # ===== STATUS AND MONITORING ENDPOINTS =====
+    
+    @post_disaster_weather_bp.route('/status', methods=['GET'])
+    def get_processing_statistics():
+        """Get service processing statistics and performance metrics"""
+        try:
+            result = post_disaster_weather_controller.get_processing_statistics()
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Status endpoint error: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Failed to get status: {str(e)}',
+                'status_code': 500
+            }), 500
+    
+    @post_disaster_weather_bp.route('/health', methods=['GET'])
+    def health_check():
+        """Service health check endpoint"""
+        try:
+            result = post_disaster_weather_controller.get_service_health()
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Health check endpoint error: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Health check failed: {str(e)}',
+                'status_code': 500
+            }), 500
+    
+    @post_disaster_weather_bp.route('/test', methods=['GET'])  
+    def test_api_connection():
+        """Test NASA POWER API connectivity"""
+        try:
+            result = post_disaster_weather_controller.test_api_connection()
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"API test endpoint error: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'API test failed: {str(e)}',
+                'status_code': 500
+            }), 500
+    
+    # ===== ERROR HANDLERS =====
+    
+    @post_disaster_weather_bp.errorhandler(404)
+    def not_found(error):
+        """Handle 404 errors"""
+        return jsonify({
+            'success': False,
+            'error': 'Endpoint not found',
+            'status_code': 404,
+            'available_endpoints': [
+                'POST /api/post-disaster-weather/process',
+                'POST /api/post-disaster-weather/batch', 
+                'POST /api/post-disaster-weather/validate/coordinates',
+                'POST /api/post-disaster-weather/validate/dates',
+                'GET  /api/post-disaster-weather/variables',
+                'GET  /api/post-disaster-weather/info',
+                'POST /api/post-disaster-weather/export/dataframe',
+                'POST /api/post-disaster-weather/export/file',
+                'GET  /api/post-disaster-weather/status',
+                'GET  /api/post-disaster-weather/health',
+                'GET  /api/post-disaster-weather/test'
+            ]
+        }), 404
+    
+    @post_disaster_weather_bp.errorhandler(405)
+    def method_not_allowed(error):
+        """Handle 405 errors"""
+        return jsonify({
+            'success': False,
+            'error': f'Method {request.method} not allowed for this endpoint',
+            'status_code': 405,
+            'allowed_methods': error.description if hasattr(error, 'description') else 'Unknown'
+        }), 405
+    
+    @post_disaster_weather_bp.errorhandler(500)
+    def internal_server_error(error):
+        """Handle 500 errors"""
+        logger.error(f"Internal server error: {error}")
+        return jsonify({
+            'success': False,
+            'error': 'Internal server error',
+            'status_code': 500
+        }), 500
+    
+    logger.info("Post-disaster weather routes configured successfully")
+    logger.info("Available endpoints:")
+    logger.info("  POST /api/post-disaster-weather/process - Extract weather data")
+    logger.info("  POST /api/post-disaster-weather/batch - Batch processing")
+    logger.info("  POST /api/post-disaster-weather/validate/coordinates - Validate coordinates")
+    logger.info("  POST /api/post-disaster-weather/validate/dates - Validate disaster dates")
+    logger.info("  GET  /api/post-disaster-weather/variables - Get available variables") 
+    logger.info("  GET  /api/post-disaster-weather/info - Get service information")
+    logger.info("  POST /api/post-disaster-weather/export/dataframe - Export to DataFrame")
+    logger.info("  POST /api/post-disaster-weather/export/file - Export to file")
+    logger.info("  GET  /api/post-disaster-weather/status - Get processing statistics")
+    logger.info("  GET  /api/post-disaster-weather/health - Health check")
+    logger.info("  GET  /api/post-disaster-weather/test - Test API connectivity")
+    
+    return post_disaster_weather_bp
+
+
+# Initialize routes function for main app
+def init_post_disaster_weather_routes(controller_instance: PostDisasterWeatherController = None):
+    """
+    Initialize post-disaster weather routes with existing controller instance
+    
+    Args:
+        controller_instance: Existing controller instance to use
+    """
+    global post_disaster_weather_controller
+    
+    if controller_instance:
+        post_disaster_weather_controller = controller_instance
+        logger.info("Post-disaster weather routes initialized with existing controller")
+    else:
+        logger.warning("No controller instance provided for post-disaster weather routes")
+
+
+# Standalone blueprint for testing
+post_disaster_weather_bp = Blueprint('post_disaster_weather', __name__, url_prefix='/api/post-disaster-weather')
+
+# Simple health check for standalone testing
+@post_disaster_weather_bp.route('/health', methods=['GET'])
+def standalone_health_check():
+    """Standalone health check when controller not initialized"""
+    return jsonify({
+        'service': 'post_disaster_weather',
+        'status': 'ready',
+        'message': 'Post-disaster weather service is ready (controller not initialized)'
+    }), 200

server/routes/raster_routes.py

@@ -0,0 +1,457 @@
+"""
+Raster Data Routes for HazardGuard System
+RESTful API endpoints for raster data operations
+"""
+
+from flask import Blueprint, request, jsonify
+import logging
+
+from controllers.raster_data_controller import RasterDataController
+
+logger = logging.getLogger(__name__)
+
+def create_raster_routes(raster_config=None):
+    """Create and configure raster data routes"""
+    
+    # Create Blueprint
+    raster_bp = Blueprint('raster', __name__, url_prefix='/api/raster')
+    
+    # Initialize controller
+    controller = RasterDataController(raster_config)
+    
+    @raster_bp.route('/process', methods=['POST'])
+    def process_raster_extraction():
+        """
+        Extract raster data for given coordinates
+        
+        Request body:
+        {
+            "coordinates": [
+                {"longitude": 121.0, "latitude": 14.0},
+                {"longitude": 122.0, "latitude": 15.0}
+            ],
+            "features": ["soil_type", "elevation_m"]  # optional
+        }
+        
+        Returns:
+        {
+            "success": true,
+            "message": "Successfully extracted raster data for 2 coordinates",
+            "data": [
+                {
+                    "longitude": 121.0,
+                    "latitude": 14.0,
+                    "soil_type": 6,
+                    "elevation_m": 123.45,
+                    ...
+                }
+            ],
+            "metadata": {
+                "coordinates_processed": 2,
+                "features_extracted": 9,
+                "processing_time_seconds": 1.23
+            }
+        }
+        """
+        try:
+            if not request.is_json:
+                return jsonify({
+                    'success': False,
+                    'error': 'Request must be JSON',
+                    'data': None
+                }), 400
+            
+            result = controller.process_raster_extraction(request.get_json())
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Error in raster extraction endpoint: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Internal server error: {str(e)}',
+                'data': None
+            }), 500
+    
+    @raster_bp.route('/batch', methods=['POST'])
+    def process_batch_extraction():
+        """
+        Extract raster data for large coordinate sets in batches
+        
+        Request body:
+        {
+            "coordinates": [...],  # large list of coordinates
+            "batch_size": 100,     # optional, default 100
+            "features": ["soil_type", "elevation_m"]  # optional
+        }
+        
+        Returns:
+        {
+            "success": true,
+            "message": "Successfully processed batch extraction for 1000 coordinates",
+            "data": [...],  # all processed results
+            "metadata": {
+                "total_coordinates": 1000,
+                "batch_size": 100,
+                "batches_processed": 10,
+                "coordinates_processed": 1000,
+                "processing_time_seconds": 45.67
+            }
+        }
+        """
+        try:
+            if not request.is_json:
+                return jsonify({
+                    'success': False,
+                    'error': 'Request must be JSON',
+                    'data': None
+                }), 400
+            
+            result = controller.process_batch_extraction(request.get_json())
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Error in batch raster extraction endpoint: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Internal server error: {str(e)}',
+                'data': None
+            }), 500
+    
+    @raster_bp.route('/dataframe', methods=['POST'])
+    def create_dataframe():
+        """
+        Create pandas DataFrame from raster extraction
+        
+        Request body:
+        {
+            "coordinates": [...],
+            "features": ["soil_type", "elevation_m"]  # optional
+        }
+        
+        Returns:
+        {
+            "success": true,
+            "message": "Successfully created DataFrame with 100 rows",
+            "data": [...],  # DataFrame records
+            "metadata": {
+                "dataframe_shape": [100, 11],
+                "dataframe_columns": ["longitude", "latitude", "soil_type", ...],
+                "dataframe_info": "DataFrame info string"
+            }
+        }
+        """
+        try:
+            if not request.is_json:
+                return jsonify({
+                    'success': False,
+                    'error': 'Request must be JSON',
+                    'data': None
+                }), 400
+            
+            result = controller.create_dataframe(request.get_json())
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Error in DataFrame creation endpoint: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Internal server error: {str(e)}',
+                'data': None
+            }), 500
+    
+    @raster_bp.route('/export', methods=['POST'])
+    def export_data():
+        """
+        Export raster data in various formats
+        
+        Request body:
+        {
+            "coordinates": [...],
+            "format": "json|csv|excel",
+            "features": ["soil_type", "elevation_m"]  # optional
+        }
+        
+        Returns:
+        {
+            "success": true,
+            "message": "Successfully exported data in csv format",
+            "data": "longitude,latitude,soil_type,elevation_m\\n121.0,14.0,6,123.45",
+            "metadata": {
+                "export_format": "csv",
+                "content_type": "text/csv"
+            }
+        }
+        """
+        try:
+            if not request.is_json:
+                return jsonify({
+                    'success': False,
+                    'error': 'Request must be JSON',
+                    'data': None
+                }), 400
+            
+            result = controller.export_data(request.get_json())
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Error in data export endpoint: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Internal server error: {str(e)}',
+                'data': None
+            }), 500
+    
+    @raster_bp.route('/validate', methods=['POST'])
+    def validate_coordinates():
+        """
+        Validate coordinate format and ranges
+        
+        Request body:
+        {
+            "coordinates": [
+                {"longitude": 121.0, "latitude": 14.0},
+                {"longitude": 181.0, "latitude": 95.0}  # invalid
+            ]
+        }
+        
+        Returns:
+        {
+            "success": true,
+            "message": "Coordinate validation completed",
+            "data": {
+                "valid": false,
+                "message": "Coordinates contain invalid longitude or latitude values",
+                "coordinate_count": 2
+            }
+        }
+        """
+        try:
+            if not request.is_json:
+                return jsonify({
+                    'success': False,
+                    'error': 'Request must be JSON',
+                    'data': None
+                }), 400
+            
+            result = controller.validate_coordinates(request.get_json())
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Error in coordinate validation endpoint: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Internal server error: {str(e)}',
+                'data': None
+            }), 500
+    
+    @raster_bp.route('/features', methods=['GET'])
+    def get_available_features():
+        """
+        Get information about available raster features
+        
+        Returns:
+        {
+            "success": true,
+            "message": "Successfully retrieved available features",
+            "data": {
+                "soil_type": {
+                    "description": "Soil classification (HWSD2)",
+                    "range": "0-33 (encoded classes)",
+                    "unit": "categorical",
+                    "available": true
+                },
+                ...
+            },
+            "metadata": {
+                "availability": {...},
+                "configuration": {...}
+            }
+        }
+        """
+        try:
+            result = controller.get_available_features()
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Error in get available features endpoint: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Internal server error: {str(e)}',
+                'data': None
+            }), 500
+    
+    @raster_bp.route('/info', methods=['GET'])
+    def get_feature_info():
+        """
+        Get detailed information about raster features
+        
+        Returns:
+        {
+            "success": true,
+            "message": "Feature information retrieved successfully",
+            "data": {
+                "soil_type": {
+                    "description": "Soil classification (HWSD2)",
+                    "range": "0-33 (encoded classes)",
+                    "unit": "categorical",
+                    "available": true,
+                    "path_configured": true
+                },
+                ...
+            },
+            "metadata": {
+                "total_features": 9,
+                "nodata_values": {"numeric": -9999.0, "categorical": 0},
+                "coordinate_system": "EPSG:4326 (WGS84)"
+            }
+        }
+        """
+        try:
+            result = controller.get_feature_info()
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Error in get feature info endpoint: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Internal server error: {str(e)}',
+                'data': None
+            }), 500
+    
+    @raster_bp.route('/status', methods=['GET'])
+    def get_service_status():
+        """
+        Get raster service status and health information
+        
+        Returns:
+        {
+            "success": true,
+            "message": "Service status retrieved successfully",
+            "data": {
+                "service_health": "healthy|degraded|no_data",
+                "request_count": 42,
+                "processing_statistics": {
+                    "total_extractions": 20,
+                    "successful_extractions": 18,
+                    "failed_extractions": 2,
+                    "success_rate": 90.0
+                },
+                "configuration_validation": {
+                    "soil": {"exists": true, "readable": true},
+                    ...
+                }
+            }
+        }
+        """
+        try:
+            result = controller.get_service_status()
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Error in service status endpoint: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Internal server error: {str(e)}',
+                'data': None
+            }), 500
+    
+    @raster_bp.route('/test', methods=['GET'])
+    def test_extraction():
+        """
+        Test raster extraction with sample coordinates
+        
+        Returns:
+        {
+            "success": true,
+            "message": "Raster extraction test successful",
+            "data": {
+                "longitude": 121.0,
+                "latitude": 14.0,
+                "soil_type": 6,
+                "elevation_m": 123.45,
+                ...
+            },
+            "metadata": {
+                "processing_time": 0.5,
+                "test_coordinates": [{"longitude": 121.0, "latitude": 14.0}]
+            }
+        }
+        """
+        try:
+            result = controller.test_extraction()
+            return jsonify(result), result.get('status_code', 200)
+            
+        except Exception as e:
+            logger.error(f"Error in test extraction endpoint: {e}")
+            return jsonify({
+                'success': False,
+                'error': f'Internal server error: {str(e)}',
+                'data': None
+            }), 500
+    
+    @raster_bp.route('/health', methods=['GET'])
+    def health_check():
+        """
+        Simple health check endpoint
+        
+        Returns:
+        {
+            "status": "healthy",
+            "service": "raster_data",
+            "message": "Raster data service is operational"
+        }
+        """
+        try:
+            return jsonify({
+                'status': 'healthy',
+                'service': 'raster_data',
+                'message': 'Raster data service is operational'
+            }), 200
+            
+        except Exception as e:
+            logger.error(f"Error in health check endpoint: {e}")
+            return jsonify({
+                'status': 'unhealthy',
+                'service': 'raster_data',
+                'message': f'Service error: {str(e)}'
+            }), 500
+    
+    # Error handlers for the blueprint
+    @raster_bp.errorhandler(404)
+    def not_found_error(error):
+        return jsonify({
+            'success': False,
+            'error': 'Endpoint not found',
+            'data': None,
+            'available_endpoints': [
+                '/api/raster/process',
+                '/api/raster/batch',
+                '/api/raster/dataframe',
+                '/api/raster/export',
+                '/api/raster/validate',
+                '/api/raster/features',
+                '/api/raster/info',
+                '/api/raster/status',
+                '/api/raster/test',
+                '/api/raster/health'
+            ]
+        }), 404
+    
+    @raster_bp.errorhandler(405)
+    def method_not_allowed_error(error):
+        return jsonify({
+            'success': False,
+            'error': 'Method not allowed for this endpoint',
+            'data': None
+        }), 405
+    
+    @raster_bp.errorhandler(500)
+    def internal_server_error(error):
+        logger.error(f"Internal server error in raster routes: {error}")
+        return jsonify({
+            'success': False,
+            'error': 'Internal server error',
+            'data': None
+        }), 500
+    
+    return raster_bp

server/routes/weather_routes.py

@@ -0,0 +1,413 @@
+"""
+Weather Data API Routes
+RESTful endpoints for NASA POWER weather data operations
+"""
+from flask import Blueprint, request, jsonify, g
+import logging
+from controllers.weather_controller import WeatherController
+from services.weather_service import NASAPowerService
+
+# Initialize blueprint
+weather_bp = Blueprint('weather', __name__)
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+# Service and controller will be initialized by main app
+weather_service = None
+weather_controller = None
+
+def init_weather_routes(controller_instance: WeatherController):
+    """Initialize weather routes with controller instance"""
+    global weather_controller
+    weather_controller = controller_instance
+    logger.info("Weather routes initialized with controller")
+
+@weather_bp.route('/weather/data', methods=['GET', 'POST'])
+def get_weather_data():
+    """
+    Get weather data for specific coordinates and disaster date
+    
+    GET parameters:
+        - lat: Latitude (required)
+        - lon: Longitude (required)  
+        - date: Disaster date in YYYY-MM-DD format (required)
+        - days_before: Number of days before disaster to fetch (optional, default: 60)
+    
+    POST body:
+        {
+            "latitude": float,
+            "longitude": float,
+            "disaster_date": "YYYY-MM-DD",
+            "days_before": int (optional)
+        }
+    """
+    try:
+        if weather_controller is None:
+            return jsonify({
+                'status': 'error',
+                'message': 'Weather service not initialized',
+                'data': None
+            }), 503
+        
+        if request.method == 'GET':
+            # Handle GET request with query parameters
+            data = {
+                'latitude': request.args.get('lat'),
+                'longitude': request.args.get('lon'),
+                'disaster_date': request.args.get('date'),
+                'days_before': request.args.get('days_before', 60)
+            }
+        else:
+            # Handle POST request with JSON body
+            data = request.get_json()
+            
+            if not data:
+                return jsonify({
+                    'status': 'error',
+                    'message': 'No JSON data provided',
+                    'data': None
+                }), 400
+        
+        # Get weather data
+        result = weather_controller.get_weather_data(data)
+        
+        # Return response with appropriate status code
+        status_code = 200 if result.get('status') == 'success' else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        logger.error(f"Weather data API error: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Weather API error: {str(e)}',
+            'data': None
+        }), 500
+
+@weather_bp.route('/weather/time-series', methods=['GET', 'POST'])
+def get_weather_time_series():
+    """
+    Get weather data as time series
+    
+    Parameters: Same as get_weather_data
+    
+    Returns time series DataFrame data with dates and weather values
+    """
+    try:
+        if weather_controller is None:
+            return jsonify({
+                'status': 'error',
+                'message': 'Weather service not initialized',
+                'data': None
+            }), 503
+        if request.method == 'GET':
+            data = {
+                'latitude': request.args.get('lat'),
+                'longitude': request.args.get('lon'),
+                'disaster_date': request.args.get('date'),
+                'days_before': request.args.get('days_before', 60)
+            }
+        else:
+            data = request.get_json()
+            
+            if not data:
+                return jsonify({
+                    'status': 'error',
+                    'message': 'No JSON data provided',
+                    'data': None
+                }), 400
+        
+        # Get time series data
+        result = weather_controller.get_weather_time_series(data)
+        
+        status_code = 200 if result.get('status') == 'success' else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        logger.error(f"Time series API error: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Time series API error: {str(e)}',
+            'data': None
+        }), 500
+
+@weather_bp.route('/weather/batch', methods=['POST'])
+def batch_weather_data():
+    """
+    Get weather data for multiple locations
+    
+    POST body:
+        {
+            "locations": [
+                {
+                    "latitude": float,
+                    "longitude": float,
+                    "disaster_date": "YYYY-MM-DD",
+                    "days_before": int (optional)
+                },
+                ...
+            ]
+        }
+    """
+    try:
+        if weather_controller is None:
+            return jsonify({
+                'status': 'error',
+                'message': 'Weather service not initialized',
+                'data': None
+            }), 503
+            
+        data = request.get_json()
+        
+        if not data:
+            return jsonify({
+                'status': 'error',
+                'message': 'No JSON data provided',
+                'data': None
+            }), 400
+        
+        # Get batch weather data
+        result = weather_controller.batch_get_weather_data(data)
+        
+        status_code = 200 if result.get('status') == 'success' else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        logger.error(f"Batch weather API error: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Batch weather API error: {str(e)}',
+            'data': None
+        }), 500
+
+@weather_bp.route('/weather/summary', methods=['GET', 'POST'])
+def get_weather_summary():
+    """
+    Get weather data summary statistics
+    
+    Parameters: Same as get_weather_data
+    
+    Returns summary statistics for all weather fields
+    """
+    try:
+        if weather_controller is None:
+            return jsonify({
+                'status': 'error',
+                'message': 'Weather service not initialized',
+                'data': None
+            }), 503
+        if request.method == 'GET':
+            data = {
+                'latitude': request.args.get('lat'),
+                'longitude': request.args.get('lon'),
+                'disaster_date': request.args.get('date'),
+                'days_before': request.args.get('days_before', 60)
+            }
+        else:
+            data = request.get_json()
+            
+            if not data:
+                return jsonify({
+                    'status': 'error',
+                    'message': 'No JSON data provided',
+                    'data': None
+                }), 400
+        
+        # Get weather summary
+        result = weather_controller.get_weather_summary(data)
+        
+        status_code = 200 if result.get('status') == 'success' else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        logger.error(f"Weather summary API error: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Weather summary API error: {str(e)}',
+            'data': None
+        }), 500
+
+@weather_bp.route('/weather/fields', methods=['GET'])
+def get_available_fields():
+    """
+    Get available weather fields and their descriptions
+    
+    Returns information about all available weather data fields
+    """
+    try:
+        if weather_controller is None:
+            return jsonify({
+                'status': 'error',
+                'message': 'Weather service not initialized',
+                'data': None
+            }), 503
+        result = weather_controller.get_available_fields()
+        
+        status_code = 200 if result.get('status') == 'success' else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        logger.error(f"Available fields API error: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Available fields API error: {str(e)}',
+            'data': None
+        }), 500
+
+@weather_bp.route('/weather/status', methods=['GET'])
+def get_service_status():
+    """
+    Get weather service status and health information
+    
+    Returns service health, initialization status, and configuration
+    """
+    try:
+        if weather_controller is None:
+            return jsonify({
+                'status': 'error',
+                'message': 'Weather service not initialized',
+                'data': None
+            }), 503
+        result = weather_controller.get_service_status()
+        
+        status_code = 200 if result.get('status') == 'success' else 424  # Failed Dependency
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        logger.error(f"Service status API error: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Service status API error: {str(e)}',
+            'data': None
+        }), 500
+
+@weather_bp.route('/weather/test', methods=['GET'])
+def test_weather_service():
+    """
+    Test the weather service with a known location
+    
+    Returns test results for NASA POWER API connectivity
+    """
+    try:
+        if weather_controller is None:
+            return jsonify({
+                'status': 'error',
+                'message': 'Weather service not initialized',
+                'data': None
+            }), 503
+        # Use Mumbai coordinates as test location
+        test_data = {
+            'latitude': 19.076,
+            'longitude': 72.8777,
+            'disaster_date': '2024-01-15',
+            'days_before': 7
+        }
+        
+        logger.info("Testing weather service with Mumbai coordinates")
+        result = weather_controller.get_weather_data(test_data)
+        
+        # Add test metadata
+        if result.get('status') == 'success':
+            result['data']['test_info'] = {
+                'test_location': 'Mumbai, India',
+                'test_coordinates': f"{test_data['latitude']}, {test_data['longitude']}",
+                'test_date': test_data['disaster_date'],
+                'test_period': f"{test_data['days_before']} days"
+            }
+        
+        status_code = 200 if result.get('status') == 'success' else 424
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        logger.error(f"Weather test API error: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': f'Weather test API error: {str(e)}',
+            'data': None
+        }), 500
+
+@weather_bp.errorhandler(400)
+def bad_request(error):
+    """Handle bad request errors"""
+    return jsonify({
+        'status': 'error',
+        'message': 'Bad request: Invalid parameters',
+        'data': None
+    }), 400
+
+@weather_bp.errorhandler(404)
+def not_found(error):
+    """Handle not found errors"""
+    return jsonify({
+        'status': 'error',
+        'message': 'Weather endpoint not found',
+        'data': None
+    }), 404
+
+@weather_bp.errorhandler(500)
+def internal_error(error):
+    """Handle internal server errors"""
+    return jsonify({
+        'status': 'error',
+        'message': 'Internal server error',
+        'data': None
+    }), 500
+
+# Blueprint registration function
+def register_weather_routes(app):
+    """Register weather routes with Flask app"""
+    app.register_blueprint(weather_bp, url_prefix='/api')
+    logger.info("Weather routes registered successfully")
+    
+    return weather_bp
+
+# Route documentation
+WEATHER_ROUTES_DOC = {
+    'endpoints': {
+        '/api/weather/data': {
+            'methods': ['GET', 'POST'],
+            'description': 'Get weather data for coordinates and date',
+            'parameters': ['lat', 'lon', 'date', 'days_before (optional)']
+        },
+        '/api/weather/time-series': {
+            'methods': ['GET', 'POST'],
+            'description': 'Get weather data as time series',
+            'parameters': ['lat', 'lon', 'date', 'days_before (optional)']
+        },
+        '/api/weather/batch': {
+            'methods': ['POST'],
+            'description': 'Get weather data for multiple locations',
+            'parameters': ['locations array with lat/lon/date/days_before']
+        },
+        '/api/weather/summary': {
+            'methods': ['GET', 'POST'],
+            'description': 'Get weather data summary statistics',
+            'parameters': ['lat', 'lon', 'date', 'days_before (optional)']
+        },
+        '/api/weather/fields': {
+            'methods': ['GET'],
+            'description': 'Get available weather fields and descriptions',
+            'parameters': []
+        },
+        '/api/weather/status': {
+            'methods': ['GET'],
+            'description': 'Get weather service status and health',
+            'parameters': []
+        },
+        '/api/weather/test': {
+            'methods': ['GET'],
+            'description': 'Test weather service connectivity',
+            'parameters': []
+        }
+    },
+    'data_source': 'NASA POWER API',
+    'fields': 17,
+    'temporal_resolution': 'daily',
+    'max_batch_size': 100
+}
+
+if __name__ == '__main__':
+    print("Weather Routes Documentation:")
+    print(f"Available endpoints: {len(WEATHER_ROUTES_DOC['endpoints'])}")
+    for endpoint, info in WEATHER_ROUTES_DOC['endpoints'].items():
+        print(f"  {endpoint}: {info['description']}")

server/routes/weatherwise_prediction_routes.py

@@ -0,0 +1,365 @@
+"""
+WeatherWise Prediction Routes
+RESTful API endpoints for LSTM weather forecasting with disaster context
+"""
+
+import logging
+from flask import Blueprint, request, jsonify, current_app
+from typing import Dict, Any
+import traceback
+
+from controllers.weatherwise_prediction_controller import WeatherWisePredictionController
+
+logger = logging.getLogger(__name__)
+
+# Create blueprint for WeatherWise prediction routes
+weatherwise_bp = Blueprint('weatherwise', __name__)
+
+def get_controller():
+    """Get the WeatherWise controller from app context"""
+    return current_app.extensions.get('controllers', {}).get('weatherwise')
+
+def handle_request_error(error: Exception, endpoint: str) -> tuple[Dict[str, Any], int]:
+    """Handle request errors with consistent logging and response format"""
+    error_msg = f"Error in {endpoint}: {str(error)}"
+    logger.error(error_msg)
+    logger.error(f"Traceback: {traceback.format_exc()}")
+    
+    return {
+        'success': False,
+        'error': f"Internal server error in {endpoint}",
+        'message': 'Request processing failed',
+        'details': str(error) if current_app.debug else 'Enable debug mode for details'
+    }, 500
+
+@weatherwise_bp.route('/forecast', methods=['POST'])
+def generate_weather_forecast():
+    """
+    Generate weather forecast for a specific location using LSTM models
+    
+    Primary endpoint for weather forecasting with disaster context.
+    
+    Expected JSON payload:
+    {
+        \"latitude\": float,         # Required: -90 to 90
+        \"longitude\": float,        # Required: -180 to 180
+        \"reference_date\": \"YYYY-MM-DD\",  # Optional: date for historical data collection
+        \"disaster_type\": \"Normal|Flood|Drought|Storm|Landslide\",  # Optional: disaster context
+        \"forecast_days\": int       # Optional: number of days to forecast (1-365, default 60)
+    }
+    
+    Returns:
+    {
+        \"success\": bool,
+        \"message\": str,
+        \"data\": {
+            \"forecast\": {
+                \"temperature_C\": [float],      # Daily temperature forecast
+                \"precipitation_mm\": [float],   # Daily precipitation forecast
+                \"humidity_%\": [float],         # Daily humidity forecast
+                \"wind_speed_mps\": [float],     # Daily wind speed forecast
+                \"surface_pressure_hPa\": [float], # Daily pressure forecast
+                \"solar_radiation_wm2\": [float]   # Daily solar radiation forecast
+            },
+            \"forecast_dates\": [str],           # Forecast dates (YYYY-MM-DD)
+            \"forecast_variables\": [str],       # Variables included in forecast
+            \"model_context\": str,             # Disaster context model used
+            \"location\": {
+                \"latitude\": float,
+                \"longitude\": float
+            },
+            \"forecast_summary\": {
+                \"horizon_days\": int,
+                \"variables_count\": int,
+                \"model_used\": str
+            }
+        },
+        \"processing_info\": {
+            \"processing_time_seconds\": float,
+            \"forecast_model\": str,
+            \"forecast_horizon_days\": int,
+            \"data_sources\": [str]
+        }
+    }
+    
+    Error Response:
+    {
+        \"success\": false,
+        \"error\": str,
+        \"message\": str
+    }
+    
+    HTTP Status Codes:
+    - 200: Forecast generated successfully
+    - 400: Invalid request parameters
+    - 500: Internal server error
+    """
+    try:
+        logger.info(f"[WEATHERWISE] ========== NEW FORECAST REQUEST ==========")
+        logger.info(f"[WEATHERWISE] Forecast request from {request.remote_addr}")
+        logger.info(f"[WEATHERWISE] Request method: {request.method}")
+        
+        # Get controller
+        controller = get_controller()
+        if not controller:
+            logger.error("[ERROR] WeatherWise controller not initialized")
+            return {
+                'success': False,
+                'error': 'WeatherWise service not available',
+                'message': 'Controller not initialized'
+            }, 503
+        
+        # Get request data
+        request_data = request.get_json()
+        logger.info(f"[WEATHERWISE] Raw request data: {request_data}")
+        
+        if not request_data:
+            logger.error("[WEATHERWISE] No JSON data provided in request")
+            return {
+                'success': False,
+                'error': 'No JSON data provided',
+                'message': 'Request must contain JSON data'
+            }, 400
+        
+        # Log request parameters (excluding sensitive data)
+        safe_params = {
+            'latitude': request_data.get('latitude'),
+            'longitude': request_data.get('longitude'),
+            'disaster_type': request_data.get('disaster_type', 'Not provided'),
+            'reference_date': request_data.get('reference_date', 'Not provided')
+        }
+        logger.info(f"[WEATHERWISE] Request parameters: {safe_params}")
+        
+        # Process forecast request
+        logger.info(f"[WEATHERWISE] Calling controller.forecast_weather()...")
+        result = controller.forecast_weather(request_data)
+        
+        # Log result status
+        logger.info(f"[WEATHERWISE] Controller response received")
+        if result.get('success'):
+            logger.info(f"[WEATHERWISE] Forecast request success=True")
+            if result.get('data'):
+                logger.info(f"[WEATHERWISE] Model: {result.get('data', {}).get('model_context', 'Unknown')}")
+        else:
+            logger.warning(f"[WEATHERWISE] Forecast request failed")
+            logger.warning(f"[WEATHERWISE] Error: {result.get('error', 'Unknown')}")
+        
+        logger.info(f"[WEATHERWISE] ========== REQUEST COMPLETE ==========")
+        
+        # Return response with appropriate status code
+        status_code = 200 if result.get('success') else 400
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        response_data, status_code = handle_request_error(e, '/api/weatherwise/forecast')
+        return jsonify(response_data), status_code
+
+@weatherwise_bp.route('/models', methods=['GET'])
+def get_available_models():
+    """
+    Get available disaster context models for weather forecasting
+    
+    Returns information about available LSTM models and their capabilities.
+    
+    Returns:
+    {
+        \"success\": bool,
+        \"message\": str,
+        \"data\": {
+            \"available_disaster_contexts\": [str],  # Available model contexts
+            \"model_info\": {
+                \"available_models\": [str],
+                \"forecast_variables\": [str],
+                \"input_features\": int,
+                \"default_horizon_days\": int
+            },
+            \"default_context\": str,
+            \"supported_forecast_variables\": [str]
+        }
+    }
+    
+    HTTP Status Codes:
+    - 200: Models information retrieved successfully
+    - 500: Internal server error
+    """
+    try:
+        logger.info(f"[WEATHERWISE] Models request from {request.remote_addr}")
+        
+        # Get controller
+        controller = get_controller()
+        if not controller:
+            logger.error("[ERROR] WeatherWise controller not initialized")
+            return {
+                'success': False,
+                'error': 'WeatherWise service not available',
+                'message': 'Controller not initialized'
+            }, 503
+        
+        # Get available models
+        result = controller.get_available_models()
+        
+        logger.info(f"[WEATHERWISE] Models request success={result.get('success')}")
+        
+        # Return response
+        status_code = 200 if result.get('success') else 500
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        response_data, status_code = handle_request_error(e, '/api/weatherwise/models')
+        return jsonify(response_data), status_code
+
+@weatherwise_bp.route('/health', methods=['GET'])
+def get_service_health():
+    """
+    Get WeatherWise service health and status information
+    
+    Returns detailed information about service status, model availability, 
+    and performance statistics.
+    
+    Returns:
+    {
+        \"success\": bool,
+        \"message\": str,
+        \"data\": {
+            \"controller_info\": {
+                \"controller_name\": str,
+                \"controller_stats\": {
+                    \"controller_start_time\": str,
+                    \"total_requests\": int,
+                    \"successful_requests\": int,
+                    \"failed_requests\": int
+                }
+            },
+            \"service_health\": {
+                \"service_name\": str,
+                \"status\": str,
+                \"models_loaded\": bool,
+                \"available_disaster_contexts\": [str],
+                \"statistics\": {...},
+                \"supported_forecast_variables\": [str],
+                \"default_forecast_horizon_days\": int
+            }
+        }
+    }
+    
+    HTTP Status Codes:
+    - 200: Health information retrieved successfully
+    - 503: Service unavailable or unhealthy
+    """
+    try:
+        logger.debug(f"[WEATHERWISE] Health check from {request.remote_addr}")
+        
+        # Get controller
+        controller = get_controller()
+        if not controller:
+            logger.error("[ERROR] WeatherWise controller not initialized")
+            return {
+                'success': False,
+                'error': 'WeatherWise service not available',
+                'message': 'Controller not initialized',
+                'status': 'unhealthy'
+            }, 503
+        
+        # Get service health
+        result = controller.get_service_status()
+        
+        # Determine status code based on service health
+        is_healthy = (result.get('success') and 
+                     result.get('data', {}).get('service_health', {}).get('status') == 'healthy')
+        status_code = 200 if is_healthy else 503
+        
+        logger.debug(f"[WEATHERWISE] Health check success={result.get('success')}, healthy={is_healthy}")
+        
+        return jsonify(result), status_code
+        
+    except Exception as e:
+        response_data, status_code = handle_request_error(e, '/api/weatherwise/health')
+        return jsonify(response_data), status_code
+
+@weatherwise_bp.route('/info', methods=['GET'])
+def get_service_info():
+    """
+    Get general WeatherWise service information
+    
+    Returns basic information about the WeatherWise service capabilities.
+    
+    Returns:
+    {
+        \"success\": true,
+        \"message\": str,
+        \"data\": {
+            \"service_name\": \"WeatherWise\",
+            \"description\": str,
+            \"version\": str,
+            \"capabilities\": [str],
+            \"supported_disaster_contexts\": [str],
+            \"forecast_variables\": [str],
+            \"default_forecast_horizon_days\": int,
+            \"input_requirements\": [str]
+        }
+    }
+    """
+    try:
+        logger.debug(f"[WEATHERWISE] Info request from {request.remote_addr}")
+        
+        return jsonify({
+            'success': True,
+            'message': 'WeatherWise service information',
+            'data': {
+                'service_name': 'WeatherWise',
+                'description': 'LSTM-based weather forecasting with disaster context modeling',
+                'version': '1.0.0',
+                'capabilities': [
+                    '60-day weather forecasting',
+                    'Disaster-context modeling',
+                    'Multi-variable predictions',
+                    'Historical data integration'
+                ],
+                'supported_disaster_contexts': ['Normal', 'Flood', 'Drought', 'Storm', 'Landslide'],
+                'forecast_variables': [
+                    'temperature_C',
+                    'precipitation_mm', 
+                    'humidity_%',
+                    'wind_speed_mps',
+                    'surface_pressure_hPa',
+                    'solar_radiation_wm2'
+                ],
+                'default_forecast_horizon_days': 60,
+                'input_requirements': [
+                    'latitude (-90 to 90)',
+                    'longitude (-180 to 180)',
+                    'reference_date (optional)',
+                    'disaster_type (optional)',
+                    'forecast_days (optional, 1-365)'
+                ]
+            }
+        }), 200
+        
+    except Exception as e:
+        response_data, status_code = handle_request_error(e, '/api/weatherwise/info')
+        return jsonify(response_data), status_code
+
+# Register error handlers for the blueprint
+@weatherwise_bp.errorhandler(404)
+def not_found(error):
+    return jsonify({
+        'success': False,
+        'error': 'Endpoint not found',
+        'message': 'The requested WeatherWise endpoint does not exist'
+    }), 404
+
+@weatherwise_bp.errorhandler(405)
+def method_not_allowed(error):
+    return jsonify({
+        'success': False,
+        'error': 'Method not allowed',
+        'message': 'The HTTP method is not allowed for this WeatherWise endpoint'
+    }), 405
+
+@weatherwise_bp.errorhandler(500)
+def internal_error(error):
+    return jsonify({
+        'success': False,
+        'error': 'Internal server error',
+        'message': 'An internal error occurred in the WeatherWise service'
+    }), 500

server/services/__init__.py

@@ -0,0 +1,8 @@
+"""
+Services Package
+Handles external integrations and business logic
+"""
+from .gee_service import GEEService
+from .ai_service import AIService
+
+__all__ = ['GEEService', 'AIService']