Update app.py

app.py

@@ -1,159 +1,551 @@
+# app.py
 import os
+import time
+import math
 import joblib
+import ee
+import pandas as pd
 import numpy as np
+from datetime import datetime, date, timedelta
 from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-import logging
-import sys
+from pydantic import BaseModel, Field
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Optional, List, Dict, Tuple
+# google oauth helpers
+from google.oauth2.credentials import Credentials
+from google.auth.transport.requests import Request as GoogleRequest
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# ------------------------------
+# CONFIG / FILENAMES
+# ------------------------------
+MODEL_FILE = Path("mil_bloom_model.joblib")
+SCALER_FILE = Path("mil_scaler.joblib")
+FEATURES_FILE = Path("mil_features.joblib")
+PHENO_FILE = Path("phenologythingy.csv")
+SPECIES_STATS_FILE = Path("species_stats.csv")
 
-app = FastAPI(title="Bloom Prediction ML API")
+ELEV_IMAGE_ID = "USGS/SRTMGL1_003"
+BUFFER_METERS = int(os.environ.get("BUFFER_METERS", 200))
+MAX_DAYS_BACK = int(os.environ.get("MAX_DAYS_BACK", 30))
+MIN_COUNT_FOR_SPECIES = int(os.environ.get("MIN_COUNT_FOR_SPECIES", 20))
+TOP_K_SPECIES = int(os.environ.get("TOP_K_SPECIES", 5))
+DOY_BINS = 366
+DOY_SMOOTH = 15
+EPS_STD = 1.0
 
-# ML Model artifacts (upload these to your Hugging Face Space)
-MODEL_PATH = "mil_bloom_model.joblib"
-SCALER_PATH = "mil_scaler.joblib" 
-FEATURES_PATH = "mil_features.joblib"
+# EE OAuth env vars expected to be set in HF Space secrets
+CLIENT_ID = os.environ.get("CLIENT_ID")
+CLIENT_SECRET = os.environ.get("CLIENT_SECRET")
+REFRESH_TOKEN = os.environ.get("REFRESH_TOKEN")
+EE_PROJECT = os.environ.get("PROJECT") or os.environ.get("EE_PROJECT") or None
 
-# Global variables for ML model
+EE_SCOPES = [
+    "https://www.googleapis.com/auth/earthengine",
+    "https://www.googleapis.com/auth/cloud-platform",
+    "https://www.googleapis.com/auth/drive",
+    "https://www.googleapis.com/auth/devstorage.full_control",
+]
+
+# ------------------------------
+# Pydantic models
+# ------------------------------
+class BloomPredictionRequest(BaseModel):
+    lat: float = Field(..., ge=-90, le=90)
+    lon: float = Field(..., ge=-180, le=180)
+    date: str = Field(..., description="YYYY-MM-DD")
+
+class MonthlyResult(BaseModel):
+    month: int
+    sample_date: str
+    ml_bloom_probability: Optional[float] = None
+    ml_prediction: Optional[str] = None
+    ml_confidence: Optional[str] = None
+    species_top: Optional[List[Tuple[str, float]]] = None
+    species_probs: Optional[Dict[str, float]] = None
+    elevation_m: Optional[float] = None
+    data_quality: Optional[dict] = None
+    satellite: Optional[str] = None
+    note: Optional[str] = None
+
+class BloomPredictionResponse(BaseModel):
+    success: bool
+    analysis_date: str
+    requested_date: str
+    monthly_results: List[MonthlyResult]
+    processing_time: float
+
+# ------------------------------
+# Globals
+# ------------------------------
 ML_MODEL = None
 SCALER = None
 FEATURE_COLUMNS = None
+SPECIES_STATS_DF = None
+DOY_HIST_MAP: Dict[str, np.ndarray] = {}
 
-class PredictionRequest(BaseModel):
-    features: dict
-    parameters: dict = {}
+# ------------------------------
+# Helpers
+# ------------------------------
+def gaussian_pdf(x, mean, std):
+    std = max(std, 1e-6)
+    coef = 1.0 / (std * math.sqrt(2 * math.pi))
+    z = (x - mean) / std
+    return coef * math.exp(-0.5 * z * z)
 
-class PredictionResponse(BaseModel):
-    success: bool
-    bloom_probability: float
-    prediction: str
-    confidence: str
-    message: str = ""
-
-def load_ml_model():
-    """Load the ML model and artifacts"""
-    global ML_MODEL, SCALER, FEATURE_COLUMNS
-    
+def circular_histogram(doys, bins=DOY_BINS, smooth_window=DOY_SMOOTH):
+    if len(doys) == 0:
+        return np.ones(bins) / bins
+    counts = np.bincount(doys.astype(int), minlength=bins+1)[1:]
+    window = np.ones(smooth_window) / smooth_window
+    doubled = np.concatenate([counts, counts])
+    smoothed = np.convolve(doubled, window, mode='same')[:bins]
+    total = smoothed.sum()
+    if total <= 0:
+        return np.ones(bins) / bins
+    return smoothed / total
+
+# ------------------------------
+# Earth Engine init (OAuth refresh-token or fallback)
+# ------------------------------
+def initialize_ee_from_env():
     try:
-        ML_MODEL = joblib.load(MODEL_PATH)
-        SCALER = joblib.load(SCALER_PATH)
-        FEATURE_COLUMNS = joblib.load(FEATURES_PATH)
-        logger.info("✅ ML model loaded successfully in Hugging Face Space")
-        logger.info(f"✅ Features: {FEATURE_COLUMNS}")
+        if CLIENT_ID and CLIENT_SECRET and REFRESH_TOKEN:
+            creds = Credentials(
+                token=None,
+                refresh_token=REFRESH_TOKEN,
+                client_id=CLIENT_ID,
+                client_secret=CLIENT_SECRET,
+                token_uri="https://oauth2.googleapis.com/token",
+                scopes=EE_SCOPES
+            )
+            request = GoogleRequest()
+            creds.refresh(request)
+            ee.Initialize(credentials=creds, project=EE_PROJECT)
+            print("✅ Earth Engine initialized with OAuth credentials")
+            return True
+        else:
+            ee.Initialize(project=EE_PROJECT) if EE_PROJECT else ee.Initialize()
+            print("✅ Earth Engine initialized (default)")
+            return True
     except Exception as e:
-        logger.error(f"❌ Failed to load ML model: {e}")
-        raise
-
-def predict_bloom(features_dict: dict):
-    """
-    ML prediction logic - same as your original but now runs on Hugging Face
-    """
-    if ML_MODEL is None:
-        raise ValueError("ML model not loaded")
-    
-    # Extract features in correct order
+        print("❌ Earth Engine initialization failed:", e)
+        return False
+
+def get_elevation_from_ee(lat, lon):
     try:
-        features_array = np.array([[
-            float(features_dict['ndvi']),
-            float(features_dict['ndwi']), 
-            float(features_dict['evi']),
-            float(features_dict['lst']),
-            float(features_dict['cloud_cover']),
-            float(features_dict['month']),
-            float(features_dict['day_of_year'])
-        ]])
-        
-        # Scale features
-        features_scaled = SCALER.transform(features_array)
-        
-        # Get prediction
-        probabilities = ML_MODEL.predict_proba(features_scaled)
-        
-        if probabilities.shape[1] == 2:
-            bloom_probability = probabilities[0, 1]
-        else:
-            bloom_probability = probabilities[0, 0]
-        
-        prediction = ML_MODEL.predict(features_scaled)[0]
-        
-        # Apply your business logic (winter adjustments, etc.)
-        ndvi = features_dict['ndvi']
-        evi = features_dict['evi']
-        month = features_dict['month']
-        
-        # Winter adjustment
-        if month in [11, 12, 1, 2] and evi < 0.8 and ndvi < 0.3:
-            bloom_probability = bloom_probability * 0.5
-            logger.info("❄️ Applied winter adjustment")
-        
-        # Confidence calculation
-        if bloom_probability > 0.75 or bloom_probability < 0.25:
-            confidence = 'HIGH'
-        elif bloom_probability > 0.6 or bloom_probability < 0.4:
-            confidence = 'MEDIUM'
-        else:
-            confidence = 'LOW'
-        
+        img = ee.Image(ELEV_IMAGE_ID)
+        pt = ee.Geometry.Point([float(lon), float(lat)])
+        rr = img.reduceRegion(ee.Reducer.first(), pt, scale=30, maxPixels=1e6)
+        if rr is None:
+            return None
+        try:
+            val = rr.get("elevation").getInfo()
+            return float(val) if val is not None else None
+        except Exception:
+            keys = rr.keys().getInfo()
+            for k in keys:
+                v = rr.get(k).getInfo()
+                if isinstance(v, (int, float)):
+                    return float(v)
+            return None
+    except Exception as e:
+        print("❌ get_elevation_from_ee error:", e)
+        return None
+
+# ------------------------------
+# Satellite retrieval (Landsat L2)
+# ------------------------------
+def get_single_date_satellite_data(lat, lon, date_str, satellite, buffer_meters, area):
+    collection_id = "LANDSAT/LC09/C02/T1_L2" if satellite == "Landsat-9" else "LANDSAT/LC08/C02/T1_L2"
+    try:
+        filtered = (ee.ImageCollection(collection_id)
+                    .filterBounds(area)
+                    .filterDate(date_str, f"{date_str}T23:59:59")
+                    .sort("CLOUD_COVER")
+                    .limit(1))
+        size = int(filtered.size().getInfo())
+        if size == 0:
+            return None
+        image = ee.Image(filtered.first())
+        info = image.getInfo().get("properties", {})
+        cloud_cover = float(info.get("CLOUD_COVER", 100.0))
+        if cloud_cover > 80:
+            return None
+
+        ndvi = image.normalizedDifference(["SR_B5", "SR_B4"]).rename("NDVI")
+        ndwi = image.normalizedDifference(["SR_B3", "SR_B5"]).rename("NDWI")
+        evi = image.expression(
+            "2.5 * ((NIR - RED) / (NIR + 6 * RED - 7.5 * BLUE + 1))",
+            {"NIR": image.select("SR_B5"), "RED": image.select("SR_B4"), "BLUE": image.select("SR_B2")},
+        ).rename("EVI")
+        lst = image.select("ST_B10").multiply(0.00341802).add(149.0).subtract(273.15).rename("LST")
+
+        composite = ndvi.addBands([ndwi, evi, lst])
+        stats = composite.reduceRegion(
+            reducer=ee.Reducer.mean(), geometry=area, scale=30, maxPixels=1e6, bestEffort=True
+        ).getInfo()
+        ndvi_val = stats.get("NDVI")
+        if ndvi_val is None:
+            return None
+        ndwi_val = stats.get("NDWI")
+        evi_val = stats.get("EVI")
+        lst_val = stats.get("LST")
+        current_dt = datetime.strptime(date_str, "%Y-%m-%d")
         return {
-            'bloom_probability': round(float(bloom_probability * 100), 2),
-            'prediction': 'BLOOM' if prediction == 1 else 'NO_BLOOM',
-            'confidence': confidence,
+            "ndvi": float(ndvi_val),
+            "ndwi": float(ndwi_val) if ndwi_val is not None else None,
+            "evi": float(evi_val) if evi_val is not None else None,
+            "lst": float(lst_val) if lst_val is not None else None,
+            "cloud_cover": float(cloud_cover),
+            "month": current_dt.month,
+            "day_of_year": current_dt.timetuple().tm_yday,
+            "satellite": satellite,
+            "date": date_str,
+            "buffer_size": buffer_meters,
         }
-        
     except Exception as e:
-        logger.error(f"❌ Prediction error: {e}")
-        raise
+        print("❌ get_single_date_satellite_data error:", e)
+        return None
 
-@app.on_event("startup")
-async def startup_event():
-    """Load ML model when the app starts"""
-    load_ml_model()
+def get_satellite_data_with_fallback(lat, lon, target_dt, satellite, buffer_meters, area, max_days_back=MAX_DAYS_BACK):
+    for days_back in range(0, max_days_back + 1):
+        current_date = (target_dt - timedelta(days=days_back)).strftime("%Y-%m-%d")
+        data = get_single_date_satellite_data(lat, lon, current_date, satellite, buffer_meters, area)
+        if data and data.get("ndvi") is not None:
+            data["original_request_date"] = target_dt.strftime("%Y-%m-%d")
+            data["actual_data_date"] = current_date
+            data["days_offset"] = days_back
+            return data
+    return None
 
-@app.get("/")
-async def root():
-    return {
-        "message": "Bloom Prediction ML API",
-        "status": "active",
-        "model_loaded": ML_MODEL is not None
-    }
+def get_essential_vegetation_data(lat, lon, target_date, buffer_meters=BUFFER_METERS, max_days_back=MAX_DAYS_BACK):
+    point = ee.Geometry.Point([float(lon), float(lat)])
+    area = point.buffer(buffer_meters)
+    target_dt = datetime.strptime(target_date, "%Y-%m-%d")
+    data = get_satellite_data_with_fallback(lat, lon, target_dt, "Landsat-9", buffer_meters, area, max_days_back)
+    if not data:
+        data = get_satellite_data_with_fallback(lat, lon, target_dt, "Landsat-8", buffer_meters, area, max_days_back)
+    return data
 
-@app.get("/health")
-async def health():
-    return {
-        "status": "healthy",
-        "model_loaded": ML_MODEL is not None
-    }
+# ------------------------------
+# ML prediction wrapper
+# ------------------------------
+def predict_bloom_with_ml(features_dict):
+    ndvi = features_dict.get("ndvi", 0.0) or 0.0
+    evi = features_dict.get("evi", 0.0) or 0.0
+    if ndvi < 0.05:
+        return {"bloom_probability": 8.0, "prediction": "NO_BLOOM", "confidence": "HIGH"}
+    if evi < 0.1 and ndvi < 0.1:
+        return {"bloom_probability": 10.0, "prediction": "NO_BLOOM", "confidence": "HIGH"}
+
+    if ML_MODEL is not None and SCALER is not None:
+        try:
+            features_array = np.array(
+                [
+                    [
+                        float(features_dict.get("ndvi", 0.0)),
+                        float(features_dict.get("ndwi", 0.0) or 0.0),
+                        float(features_dict.get("evi", 0.0) or 0.0),
+                        float(features_dict.get("lst", 0.0) or 0.0),
+                        float(features_dict.get("cloud_cover", 0.0) or 0.0),
+                        float(features_dict.get("month", 0) or 0),
+                        float(features_dict.get("day_of_year", 0) or 0),
+                    ]
+                ],
+                dtype=np.float64,
+            )
+            features_scaled = SCALER.transform(features_array)
+            probabilities = ML_MODEL.predict_proba(features_scaled)
+            bloom_prob = probabilities[0, 1] if probabilities.shape[1] == 2 else probabilities[0, 0]
+            prediction = ML_MODEL.predict(features_scaled)[0]
+            bloom_prob_pct = round(float(bloom_prob * 100.0), 2)
+            if bloom_prob_pct > 75 or bloom_prob_pct < 25:
+                conf = "HIGH"
+            elif bloom_prob_pct > 60 or bloom_prob_pct < 40:
+                conf = "MEDIUM"
+            else:
+                conf = "LOW"
+            return {"bloom_probability": bloom_prob_pct, "prediction": "BLOOM" if prediction == 1 else "NO_BLOOM", "confidence": conf}
+        except Exception as e:
+            print("❌ ML model error:", e)
+    return predict_bloom_fallback(features_dict)
+
+def predict_bloom_fallback(features_dict):
+    ndvi = float(features_dict.get("ndvi") or 0.0)
+    ndwi = float(features_dict.get("ndwi") or 0.0)
+    evi = float(features_dict.get("evi") or 0.0)
+    lst = float(features_dict.get("lst") or 0.0)
+    month = int(features_dict.get("month") or 1)
+    score = 0.0
+    if evi > 0.7:
+        score += 50
+    elif evi > 0.5:
+        score += 35
+    elif evi > 0.3:
+        score += 20
+    if ndvi > 0.5:
+        score += 25
+    elif ndvi > 0.3:
+        score += 15
+    if -0.2 < ndwi < 0.05:
+        score += 15
+    if 12 < lst < 32:
+        score += 12
+    if month in [3, 4, 5]:
+        score += 15
+    if month in [11, 12, 1, 2]:
+        score -= 3
+    prob = min(90, max(8, score))
+    if prob > 52:
+        pred = "BLOOM"
+        conf = "MEDIUM" if prob > 65 else "LOW"
+    else:
+        pred = "NO_BLOOM"
+        conf = "MEDIUM" if prob < 25 else "LOW"
+    return {"bloom_probability": round(prob, 2), "prediction": pred, "confidence": conf}
+
+# ------------------------------
+# Species stats builder / predictor
+# ------------------------------
+def load_or_build_species_stats():
+    global PHENO_FILE, SPECIES_STATS_FILE
+    if SPECIES_STATS_FILE.exists():
+        df = pd.read_csv(SPECIES_STATS_FILE)
+        doy_map = {}
+        for s in df["species"].tolist():
+            doy_map[s] = np.ones(DOY_BINS) / DOY_BINS
+        return df, doy_map
+    if PHENO_FILE.exists():
+        ph = pd.read_csv(PHENO_FILE, low_memory=False)
+        if "phenophaseStatus" in ph.columns:
+            ph["phenophaseStatus"] = ph["phenophaseStatus"].astype(str).str.strip().str.lower()
+            ph_yes = ph[ph["phenophaseStatus"].str.startswith("y")].copy()
+        else:
+            ph_yes = ph.copy()
+        ph_yes = ph_yes.dropna(subset=["elevation"])
+        if "dayOfYear" in ph_yes.columns:
+            ph_yes["dayOfYear"] = pd.to_numeric(ph_yes["dayOfYear"], errors="coerce").dropna().astype(int).clip(1, 366)
+        rows = []
+        doy_map = {}
+        grouped = ph_yes.groupby("scientificName")
+        for name, g in grouped:
+            cnt = len(g)
+            mean_elev = float(g["elevation"].dropna().mean()) if cnt > 0 else np.nan
+            std_elev = float(g["elevation"].dropna().std(ddof=0)) if cnt > 0 else EPS_STD
+            std_elev = max(std_elev if not np.isnan(std_elev) else 0.0, EPS_STD)
+            rows.append({"species": name, "count": cnt, "mean_elev": mean_elev, "std_elev": std_elev})
+            if "dayOfYear" in g.columns:
+                doy_map[name] = circular_histogram(g["dayOfYear"].to_numpy(dtype=int))
+            else:
+                doy_map[name] = np.ones(DOY_BINS) / DOY_BINS
+        species_df = pd.DataFrame(rows)
+        total = species_df["count"].sum()
+        species_df["prior"] = species_df["count"] / total if total > 0 else 1.0 / max(1, len(species_df))
+        rare = species_df[species_df["count"] < MIN_COUNT_FOR_SPECIES]
+        frequent = species_df[species_df["count"] >= MIN_COUNT_FOR_SPECIES]
+        final_rows = frequent.to_dict("records")
+        if len(rare) > 0:
+            rare_names = rare["species"].tolist()
+            rare_obs = ph_yes[ph_yes["scientificName"].isin(rare_names)]
+            total_rare = len(rare_obs)
+            if total_rare > 0:
+                mean_other = float(rare_obs["elevation"].dropna().mean())
+                std_other = float(rare_obs["elevation"].dropna().std(ddof=0)) if total_rare > 1 else EPS_STD
+                std_other = max(std_other if not np.isnan(std_other) else 0.0, EPS_STD)
+                final_rows.append(
+                    {
+                        "species": "OTHER",
+                        "count": int(total_rare),
+                        "mean_elev": mean_other,
+                        "std_elev": std_other,
+                        "prior": int(total_rare) / total if total > 0 else int(total_rare),
+                    }
+                )
+                doy_map["OTHER"] = circular_histogram(rare_obs["dayOfYear"].to_numpy(dtype=int)) if "dayOfYear" in rare_obs.columns else np.ones(DOY_BINS) / DOY_BINS
+        final_df = pd.DataFrame(final_rows).fillna(0)
+        if "prior" not in final_df.columns:
+            t2 = final_df["count"].sum()
+            final_df["prior"] = final_df["count"] / t2 if t2 > 0 else 1.0 / len(final_df)
+        return final_df, doy_map
+    return pd.DataFrame(columns=["species", "count", "mean_elev", "std_elev", "prior"]), {}
+
+def predict_species_by_elevation(elevation, doy=None, top_k=TOP_K_SPECIES):
+    global SPECIES_STATS_DF, DOY_HIST_MAP
+    if SPECIES_STATS_DF is None or SPECIES_STATS_DF.empty:
+        return []
+    species = SPECIES_STATS_DF["species"].tolist()
+    priors = SPECIES_STATS_DF["prior"].to_numpy(dtype=float)
+    means = SPECIES_STATS_DF["mean_elev"].to_numpy(dtype=float)
+    stds = SPECIES_STATS_DF["std_elev"].to_numpy(dtype=float)
+    x = np.array([float(elevation)]) if elevation is not None else np.array([np.nan])
+    like = np.array([gaussian_pdf(x, means[i], stds[i])[0] for i in range(len(species))])
+    post = priors * like
+    if post.sum() == 0:
+        post = np.ones(len(species)) / len(species)
+    else:
+        post = post / post.sum()
+    if doy is not None and not np.isnan(doy):
+        doy_idx = int(doy) - 1
+        doy_probs = np.array([DOY_HIST_MAP.get(s, np.ones(DOY_BINS) / DOY_BINS)[doy_idx] for s in species])
+        combined = post * doy_probs
+        if combined.sum() > 0:
+            combined = combined / combined.sum()
+            post = combined
+    order = np.argsort(-post)
+    top = []
+    for i in order[:top_k]:
+        top.append((species[i], float(post[i])))
+    return top
+
+# ------------------------------
+# Lifespan to load models and init EE
+# ------------------------------
+@asynccontextmanager
+async def lifespan(app):
+    global ML_MODEL, SCALER, FEATURE_COLUMNS, SPECIES_STATS_DF, DOY_HIST_MAP
+    if MODEL_FILE.exists():
+        try:
+            ML_MODEL = joblib.load(MODEL_FILE)
+            print("✅ MIL model loaded.")
+        except Exception as e:
+            print("❌ MIL model load error:", e)
+    if SCALER_FILE.exists():
+        try:
+            SCALER = joblib.load(SCALER_FILE)
+            print("✅ Scaler loaded.")
+        except Exception as e:
+            print("❌ Scaler load error:", e)
+    if FEATURES_FILE.exists():
+        try:
+            FEATURE_COLUMNS = joblib.load(FEATURES_FILE)
+            print("✅ Features list loaded.")
+        except Exception as e:
+            print("❌ Features list load error:", e)
+
+    ok = initialize_ee_from_env()
+    if not ok:
+        raise RuntimeError("Earth Engine initialization failed. Set CLIENT_ID, CLIENT_SECRET, REFRESH_TOKEN env vars in Space secrets.")
 
-@app.post("/predict")
-async def predict(request: PredictionRequest):
-    """
-    Main prediction endpoint called by the backend
-    """
     try:
-        logger.info(f"📊 Received prediction request with features: {request.features}")
-        
-        # Perform ML prediction
-        prediction_result = predict_bloom(request.features)
-        
-        response = PredictionResponse(
-            success=True,
-            bloom_probability=prediction_result['bloom_probability'],
-            prediction=prediction_result['prediction'],
-            confidence=prediction_result['confidence'],
-            message="Prediction completed successfully"
-        )
-        
-        logger.info(f"✅ Prediction completed: {prediction_result['bloom_probability']}%")
-        return response
-        
+        SPECIES_STATS_DF, DOY_HIST_MAP = load_or_build_species_stats()
+        print("✅ Species stats ready. species count:", len(SPECIES_STATS_DF))
     except Exception as e:
-        logger.error(f"❌ Prediction failed: {e}")
-        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")
+        print("⚠️ Species stats build error:", e)
+        SPECIES_STATS_DF = pd.DataFrame()
+        DOY_HIST_MAP = {}
+
+    yield
+    print("🔄 Shutting down")
+
+# ------------------------------
+# App + endpoints
+# ------------------------------
+app = FastAPI(title="Bloom Prediction (HF Space)", lifespan=lifespan)
+
+@app.get("/")
+async def root():
+    return {"message": "Bloom Prediction API (HF Space)", "model_loaded": ML_MODEL is not None}
+
+@app.post("/predict", response_model=BloomPredictionResponse)
+async def predict_bloom(req: BloomPredictionRequest):
+    start = time.time()
+    try:
+        req_dt = datetime.strptime(req.date, "%Y-%m-%d")
+    except ValueError:
+        raise HTTPException(status_code=400, detail="date must be YYYY-MM-DD")
+
+    elevation = get_elevation_from_ee(req.lat, req.lon)
+    year = req_dt.year
+    monthly_results = []
+    for month in range(1, 13):
+        sample_dt = date(year, month, 15)
+        sample_date_str = sample_dt.strftime("%Y-%m-%d")
+        point = ee.Geometry.Point([float(req.lon), float(req.lat)])
+        area = point.buffer(BUFFER_METERS)
+        sat_data = get_essential_vegetation_data(req.lat, req.lon, sample_date_str)
+        result = {
+            "month": month,
+            "sample_date": sample_date_str,
+            "ml_bloom_probability": None,
+            "ml_prediction": None,
+            "ml_confidence": None,
+            "species_top": None,
+            "species_probs": None,
+            "elevation_m": elevation,
+            "data_quality": None,
+            "satellite": None,
+            "note": None,
+        }
+        if sat_data is None:
+            result["note"] = f"No satellite data within {MAX_DAYS_BACK} days for {sample_date_str}"
+            monthly_results.append(MonthlyResult(**result))
+            continue
+
+        ml_out = predict_bloom_with_ml(sat_data)
+        result["ml_bloom_probability"] = float(ml_out.get("bloom_probability", 0.0))
+        result["ml_prediction"] = ml_out.get("prediction")
+        result["ml_confidence"] = ml_out.get("confidence")
+        result["data_quality"] = {
+            "satellite": sat_data.get("satellite"),
+            "cloud_cover": sat_data.get("cloud_cover"),
+            "days_offset": sat_data.get("days_offset"),
+            "buffer_radius_m": sat_data.get("buffer_size"),
+        }
+        result["satellite"] = sat_data.get("satellite")
+
+        try:
+            bloom_bool = (result["ml_prediction"] == "BLOOM") or (result["ml_bloom_probability"] >= 50.0)
+            if bloom_bool:
+                doy = sat_data.get("day_of_year", None)
+                top_species = predict_species_by_elevation(elevation, doy=doy, top_k=TOP_K_SPECIES)
+                result["species_top"] = [(s, round(p * 100.0, 2)) for s, p in top_species]
+
+                species_probs = {}
+                if (SPECIES_STATS_DF is not None) and (not SPECIES_STATS_DF.empty):
+                    all_species = SPECIES_STATS_DF["species"].tolist()
+                    priors = SPECIES_STATS_DF["prior"].to_numpy(dtype=float)
+                    means = SPECIES_STATS_DF["mean_elev"].to_numpy(dtype=float)
+                    stds = SPECIES_STATS_DF["std_elev"].to_numpy(dtype=float)
+                    x = np.array([float(elevation)]) if elevation is not None else np.array([np.nan])
+                    like = np.array([gaussian_pdf(x, means[i], stds[i])[0] for i in range(len(all_species))])
+                    post = priors * like
+                    if post.sum() == 0:
+                        post = np.ones(len(all_species)) / len(all_species)
+                    else:
+                        post = post / post.sum()
+                    if doy is not None and not np.isnan(doy):
+                        doy_idx = int(doy) - 1
+                        doy_probs = np.array([DOY_HIST_MAP.get(s, np.ones(DOY_BINS) / DOY_BINS)[doy_idx] for s in all_species])
+                        combined = post * doy_probs
+                        if combined.sum() > 0:
+                            combined = combined / combined.sum()
+                            post = combined
+                    for s, p in zip(all_species, post):
+                        species_probs[s] = round(float(p * 100.0), 6)
+                result["species_probs"] = species_probs
+            else:
+                result["species_top"] = []
+                result["species_probs"] = {}
+        except Exception as e:
+            print("❌ species prediction error:", e)
+            result["species_top"] = []
+            result["species_probs"] = {}
+            result["note"] = (result.get("note", "") + " ; species_pred_error") if result.get("note") else "species_pred_error"
+
+        monthly_results.append(MonthlyResult(**result))
+
+    proc_time = round(time.time() - start, 2)
+    resp = {
+        "success": True,
+        "analysis_date": datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "requested_date": req.date,
+        "monthly_results": monthly_results,
+        "processing_time": proc_time,
+    }
+    return BloomPredictionResponse(**resp)
 
-# For Hugging Face Spaces deployment
+# Run locally if invoked directly (not used by Docker CMD)
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run("app:app", host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))