Update api.py

api.py

@@ -50,6 +50,10 @@ from src.allocation import (
     get_allocation_summary, reset_all_allocations, initialize_default_teams
 )
 from src.live_data_fetcher import IMDCycloneDataFetcher, CycloneFeatureEngineer
+from src.live_data_fetcher import (
+    IMDCycloneDataFetcher, CycloneFeatureEngineer,
+    IMDFloodDataFetcher   # ← add this
+)
 
 
 # ============================================================================
@@ -83,6 +87,7 @@ multi_hazard         = MultiHazardPredictor(MODEL_DIR)
 lane_mapper          = LaneFloodMapper(flood_predictor)
 imd_fetcher = IMDCycloneDataFetcher()
 cyclone_engineer = CycloneFeatureEngineer()
+flood_fetcher = IMDFloodDataFetcher()
 
 
 # ── Replace the existing FloodFeatures block and add the rest ──────────────
@@ -373,35 +378,438 @@ import numpy as np  # needed for explain endpoint
 
 @app.get("/predict/cyclone/live")
 def predict_cyclone_live():
+    """
+    Fetch live IMD data, predict cyclone risk, return prediction
+    + a heatmap-ready GeoJSON point for frontend rendering.
+    Falls back to RSMC page scrape if bulletin TXT is unavailable.
+    """
+    # ── Step 1: Try bulletin TXT ───────────────────────────────────────────
     bulletin = imd_fetcher.fetch_hourly_bulletin()
-    if bulletin["status"] != "success":
-        raise HTTPException(502, f"IMD fetch failed: {bulletin.get('message')}")
+    raw_params = {}
+
+    if bulletin["status"] == "success":
+        raw_params = imd_fetcher.parse_cyclone_parameters(bulletin["content"])
+
+    # ── Step 2: Fallback to page scrape ───────────────────────────────────
+    if not raw_params:
+        page_data = imd_fetcher.fetch_rsmc_page_alerts()
+        if page_data["alerts"]:
+            # Try to parse coords from alert text
+            combined_text = " ".join(page_data["alerts"])
+            raw_params = imd_fetcher.parse_cyclone_parameters(combined_text)
 
-    raw_params = imd_fetcher.parse_cyclone_parameters(bulletin["content"])
+    # ── Step 3: If still no params, return no-storm status ────────────────
     if not raw_params:
-        raise HTTPException(404, "No cyclone parameters detected in IMD bulletin")
+        return {
+            "status": "no_active_storm",
+            "message": "No active cyclone detected in IMD feeds",
+            "source": bulletin.get("url_used", "IMD RSMC"),
+            "timestamp": datetime.now().isoformat(),
+            "heatmap_geojson": None,
+        }
 
+    # ── Step 4: Engineer features and predict ─────────────────────────────
     engineered = cyclone_engineer.engineer_features(raw_params)
-    features   = cyclone_engineer.to_model_features(engineered)  # ← bridge
+    features   = cyclone_engineer.to_model_features(engineered)
 
     errors = cyclone_predictor.validate_input(features)
     if errors:
         raise HTTPException(422, {"validation_errors": errors})
 
     result = cyclone_predictor.predict(features, 50)
+
+    # ── Step 5: Build heatmap GeoJSON ─────────────────────────────────────
+    lat = raw_params.get("LAT")
+    lon = raw_params.get("LON")
+    heatmap_geojson = _build_cyclone_heatmap_geojson(
+        lat=lat,
+        lon=lon,
+        risk_score=result.risk_score,
+        risk_tier=result.risk_tier.value,
+        uncertainty=result.uncertainty,
+        raw_params=raw_params,
+        features=features,
+    ) if (lat and lon) else None
+
     return {
-        "source": "IMD RSMC live bulletin",
+        "status": "active_storm",
+        "source": bulletin.get("url_used", "IMD RSMC page"),
         "raw_parameters": raw_params,
-        "model_features_used": features,          # helpful for debugging
+        "model_features_used": features,
+        "heatmap_geojson": heatmap_geojson,
         **prediction_result_to_dict(result),
     }
 
+
 @app.get("/live/cyclone/raw")
 def get_live_cyclone_raw():
-    return imd_fetcher.fetch_hourly_bulletin()
+    """
+    Returns raw IMD bulletin content + RSMC page alerts.
+    Useful for debugging what IMD is currently publishing.
+    """
+    bulletin = imd_fetcher.fetch_hourly_bulletin()
+    page     = imd_fetcher.fetch_rsmc_page_alerts()
+    return {
+        "bulletin": bulletin,
+        "rsmc_page": page,
+        "timestamp": datetime.now().isoformat(),
+    }
 
 
+@app.get("/live/cyclone/heatmap")
+def get_cyclone_heatmap():
+    """
+    Dedicated heatmap endpoint — returns GeoJSON FeatureCollection
+    with risk-annotated points ready for Leaflet / Mapbox heatmap layer.
+    Frontend can poll this every N minutes and re-render.
+    """
+    bulletin   = imd_fetcher.fetch_hourly_bulletin()
+    raw_params = {}
 
+    if bulletin["status"] == "success":
+        raw_params = imd_fetcher.parse_cyclone_parameters(bulletin["content"])
+
+    if not raw_params:
+        page_data  = imd_fetcher.fetch_rsmc_page_alerts()
+        combined   = " ".join(page_data.get("alerts", []))
+        raw_params = imd_fetcher.parse_cyclone_parameters(combined)
+
+    if not raw_params or "LAT" not in raw_params or "LON" not in raw_params:
+        # Return empty FeatureCollection — frontend renders nothing
+        return {
+            "type": "FeatureCollection",
+            "features": [],
+            "metadata": {
+                "status": "no_active_storm",
+                "timestamp": datetime.now().isoformat(),
+                "message": "No active cyclone with known coordinates detected",
+            }
+        }
+
+    engineered = cyclone_engineer.engineer_features(raw_params)
+    features   = cyclone_engineer.to_model_features(engineered)
+    result     = cyclone_predictor.predict(features, 50)
+
+    geojson = _build_cyclone_heatmap_geojson(
+        lat=raw_params["LAT"],
+        lon=raw_params["LON"],
+        risk_score=result.risk_score,
+        risk_tier=result.risk_tier.value,
+        uncertainty=result.uncertainty,
+        raw_params=raw_params,
+        features=features,
+    )
+
+    return geojson
+
+
+# ── Helper — builds heatmap GeoJSON ───────────────────────────────────────
+
+def _build_cyclone_heatmap_geojson(
+    lat: float,
+    lon: float,
+    risk_score: float,
+    risk_tier: str,
+    uncertainty: float,
+    raw_params: dict,
+    features: dict,
+) -> dict:
+    """
+    Returns a GeoJSON FeatureCollection with:
+    - A Point at storm centre with full risk properties
+    - Radius rings at 50km, 150km, 300km for heatmap intensity falloff
+
+    Frontend usage (Leaflet example):
+        L.heatLayer(
+            geojson.features.map(f => [
+                f.geometry.coordinates[1],
+                f.geometry.coordinates[0],
+                f.properties.intensity
+            ]),
+            { radius: 60, blur: 40, maxZoom: 10 }
+        )
+    """
+    import math
+
+    color_map = {
+        "LOW":      "#2ecc71",
+        "MODERATE": "#f39c12",
+        "HIGH":     "#e74c3c",
+        "CRITICAL": "#8e44ad",
+    }
+
+    features_list = []
+
+    # Centre point — full intensity
+    features_list.append({
+        "type": "Feature",
+        "geometry": {"type": "Point", "coordinates": [lon, lat]},
+        "properties": {
+            "risk_score":   risk_score,
+            "risk_tier":    risk_tier,
+            "uncertainty":  uncertainty,
+            "intensity":    risk_score,          # Leaflet heatmap weight
+            "color":        color_map.get(risk_tier, "#95a5a6"),
+            "wind_kmh":     raw_params.get("MAX_WIND", 0) * 1.852,
+            "pressure_hpa": raw_params.get("MIN_PRESSURE", 1000),
+            "point_type":   "storm_centre",
+            "label":        f"Cyclone Risk: {risk_tier} ({risk_score:.2f})",
+        }
+    })
+
+    # Falloff rings — intensity decreases with distance
+    for radius_km, falloff in [(50, 0.85), (150, 0.60), (300, 0.30)]:
+        # Generate 8 cardinal points on the ring
+        for bearing_deg in range(0, 360, 45):
+            bearing = math.radians(bearing_deg)
+            R = 6371  # Earth radius km
+            lat_r  = math.radians(lat)
+            lon_r  = math.radians(lon)
+            d_r    = radius_km / R
+
+            ring_lat = math.degrees(math.asin(
+                math.sin(lat_r) * math.cos(d_r) +
+                math.cos(lat_r) * math.sin(d_r) * math.cos(bearing)
+            ))
+            ring_lon = math.degrees(lon_r + math.atan2(
+                math.sin(bearing) * math.sin(d_r) * math.cos(lat_r),
+                math.cos(d_r) - math.sin(lat_r) * math.sin(math.radians(ring_lat))
+            ))
+
+            features_list.append({
+                "type": "Feature",
+                "geometry": {
+                    "type": "Point",
+                    "coordinates": [ring_lon, ring_lat]
+                },
+                "properties": {
+                    "risk_score":  round(risk_score * falloff, 4),
+                    "intensity":   round(risk_score * falloff, 4),
+                    "risk_tier":   risk_tier,
+                    "point_type":  f"ring_{radius_km}km",
+                    "radius_km":   radius_km,
+                    "color":       color_map.get(risk_tier, "#95a5a6"),
+                }
+            })
+
+    return {
+        "type": "FeatureCollection",
+        "features": features_list,
+        "metadata": {
+            "storm_centre":   {"lat": lat, "lon": lon},
+            "risk_score":     risk_score,
+            "risk_tier":      risk_tier,
+            "uncertainty":    uncertainty,
+            "wind_kmh":       round(raw_params.get("MAX_WIND", 0) * 1.852, 1),
+            "pressure_hpa":   raw_params.get("MIN_PRESSURE", 1000),
+            "timestamp":      datetime.now().isoformat(),
+            "source":         "IMD RSMC + FNN Cyclone Predictor",
+            "total_points":   len(features_list),
+            "rendering_hint": {
+                "leaflet_heatmap": "use intensity property as weight",
+                "mapbox_circle":   "use risk_score for fill-opacity, color for fill-color",
+                "refresh_seconds": 1800,
+            }
+        }
+    }
+
+@app.get("/live/flood/heatmap")
+def get_flood_heatmap():
+    """
+    Fetches live rainfall from IMD city stations, runs FNN flood
+    prediction for each city, returns heatmap-ready GeoJSON.
+
+    Frontend usage (Leaflet heatmap):
+        fetch('/live/flood/heatmap')
+          .then(r => r.json())
+          .then(geojson => {
+            L.heatLayer(
+              geojson.features.map(f => [
+                f.geometry.coordinates[1],
+                f.geometry.coordinates[0],
+                f.properties.intensity
+              ]),
+              { radius: 80, blur: 50, maxZoom: 8, max: 1.0 }
+            ).addTo(map);
+          });
+
+    Each feature also has 'color' and 'risk_tier' for circle/marker layers.
+    """
+    if not flood_predictor.is_ready():
+        raise HTTPException(503, "Flood model not loaded. Run train_model.py first.")
+
+    city_data = flood_fetcher.fetch_all_cities()
+
+    color_map = {
+        "LOW":      "#2ecc71",
+        "MODERATE": "#f39c12",
+        "HIGH":     "#e74c3c",
+        "CRITICAL": "#8e44ad",
+    }
+
+    features_list = []
+    failed_cities = []
+    successful_cities = []
+
+    for city_obs in city_data:
+        city = city_obs["city"]
+
+        # Use observed rainfall or fallback to 0
+        rainfall_mm = city_obs.get("rainfall_mm")
+        if rainfall_mm is None:
+            # IMD fetch failed for this city — use 0 rainfall
+            # Still render city with baseline risk
+            rainfall_mm = 0.0
+            data_source = "baseline (IMD unavailable)"
+        else:
+            data_source = "IMD live"
+
+        lat = city_obs.get("lat", 0)
+        lon = city_obs.get("lon", 0)
+
+        if not lat or not lon:
+            failed_cities.append(city)
+            continue
+
+        # Build full flood feature vector
+        static  = city_obs.get("static_features", {})
+        soil_sat = flood_fetcher.estimate_soil_saturation(rainfall_mm)
+
+        flood_features = {
+            "rainfall_mm":             float(rainfall_mm),
+            "elevation_m":             static.get("elevation_m", 50.0),
+            "soil_saturation_pct":     soil_sat,
+            "dist_river":              static.get("dist_river", 2.0),
+            "drainage_capacity_index": static.get("drainage_capacity_index", 0.5),
+            "flow_accumulation":       static.get("flow_accumulation", 0.5),
+            "twi":                     static.get("twi", 8.0),
+        }
+
+        # Validate and predict
+        errors = flood_predictor.validate_input(flood_features)
+        if errors:
+            failed_cities.append(f"{city}: {errors}")
+            continue
+
+        try:
+            result = flood_predictor.predict(flood_features, n_mc_samples=30)
+        except Exception as e:
+            failed_cities.append(f"{city}: {str(e)}")
+            continue
+
+        successful_cities.append(city)
+
+        features_list.append({
+            "type": "Feature",
+            "geometry": {
+                "type": "Point",
+                "coordinates": [lon, lat]
+            },
+            "properties": {
+                # Heatmap rendering
+                "intensity":   result.risk_score,
+                "color":       color_map.get(result.risk_tier.value, "#95a5a6"),
+
+                # Risk info
+                "city":        city,
+                "risk_score":  result.risk_score,
+                "risk_tier":   result.risk_tier.value,
+                "uncertainty": result.uncertainty,
+                "ci_lower":    result.confidence_interval[0],
+                "ci_upper":    result.confidence_interval[1],
+
+                # Input data (useful for tooltip display)
+                "rainfall_mm":         round(rainfall_mm, 1),
+                "soil_saturation_pct": round(soil_sat, 1),
+                "elevation_m":         static.get("elevation_m"),
+                "data_source":         data_source,
+
+                # Tooltip-ready label
+                "label": (
+                    f"{city}: {result.risk_tier.value} flood risk "
+                    f"(score={result.risk_score:.2f}, "
+                    f"rain={rainfall_mm:.1f}mm)"
+                ),
+            }
+        })
+
+    return {
+        "type": "FeatureCollection",
+        "features": features_list,
+        "metadata": {
+            "timestamp":         datetime.now().isoformat(),
+            "source":            "IMD City Weather + FNN Flood Model",
+            "cities_monitored":  len(city_data),
+            "cities_successful": len(successful_cities),
+            "cities_failed":     len(failed_cities),
+            "successful":        successful_cities,
+            "failed":            failed_cities,
+            "data_note": (
+                "Rainfall from IMD city stations where available. "
+                "Cities with unavailable data show baseline risk (0mm rainfall). "
+                "Static features (elevation, drainage, TWI) from training dataset."
+            ),
+            "rendering_hint": {
+                "leaflet_heatmap": "use 'intensity' property as weight",
+                "leaflet_circles": "use 'color' for fillColor, 'risk_score' for radius scaling",
+                "mapbox":          "use 'risk_score' for fill-opacity, 'color' for fill-color",
+                "refresh_seconds": 3600,
+            }
+        }
+    }
+
+
+@app.get("/live/flood/city/{city_name}")
+def get_flood_risk_single_city(city_name: str):
+    """
+    Get live flood risk for a single city by name.
+    City names: Mumbai, Chennai, Kolkata, Delhi, Hyderabad,
+                Bangalore, Bhubaneswar, Patna, Guwahati, Kochi
+    """
+    if not flood_predictor.is_ready():
+        raise HTTPException(503, "Flood model not loaded.")
+
+    # Normalise city name
+    city_name = city_name.strip().title()
+    station_id = flood_fetcher.CITY_STATIONS.get(city_name)
+
+    if not station_id:
+        raise HTTPException(404, {
+            "error": f"City '{city_name}' not monitored.",
+            "available_cities": list(flood_fetcher.CITY_STATIONS.keys())
+        })
+
+    obs = flood_fetcher.fetch_city_rainfall(city_name, station_id)
+    rainfall_mm = obs.get("rainfall_mm") or 0.0
+    lat, lon = flood_fetcher.STATION_COORDS[city_name]
+    static   = flood_fetcher.CITY_STATIC_FEATURES[city_name]
+    soil_sat = flood_fetcher.estimate_soil_saturation(rainfall_mm)
+
+    flood_features = {
+        "rainfall_mm":             float(rainfall_mm),
+        "elevation_m":             static["elevation_m"],
+        "soil_saturation_pct":     soil_sat,
+        "dist_river":              static["dist_river"],
+        "drainage_capacity_index": static["drainage_capacity_index"],
+        "flow_accumulation":       static["flow_accumulation"],
+        "twi":                     static["twi"],
+    }
+
+    errors = flood_predictor.validate_input(flood_features)
+    if errors:
+        raise HTTPException(422, {"validation_errors": errors})
+
+    result = flood_predictor.predict(flood_features, n_mc_samples=50)
+
+    return {
+        "city":          city_name,
+        "coordinates":   {"lat": lat, "lon": lon},
+        "rainfall_mm":   rainfall_mm,
+        "imd_status":    obs["status"],
+        "flood_features": flood_features,
+        **prediction_result_to_dict(result),
+        "timestamp":     datetime.now().isoformat(),
+    }
 # ============================================================================
 # LANE-LEVEL FLOOD MAP ENDPOINTS
 # ============================================================================