Update app.py

app.py

@@ -3,6 +3,16 @@ AQI Intelligence Engine — Hugging Face Gradio + ZeroGPU Main Application Entry
 
 Supports both standalone Gradio Web Interface and REST API backend.
 Runs seamlessly on Hugging Face ZeroGPU spaces as well as standard CPU fallback.
+
+FIX (2026-07-15): Custom REST routes (/api/v1/forecast, /api/v1/analyze-image,
+/api/v1/health) were previously registered on `demo.app`, which does not exist
+yet at import time (Gradio only builds it inside `.launch()`). That meant the
+routes were silently never attached, and `demo.launch()` built a brand-new
+FastAPI app internally that had never seen them — hence 404/405 in production.
+
+Fix: build our own `FastAPI()` instance up front, register the routes on it,
+mount the Gradio Blocks app into it with `gr.mount_gradio_app`, and serve that
+combined app directly with uvicorn instead of calling `demo.launch()`.
 """
 
 import os
@@ -69,7 +79,7 @@ async def _async_handle_forecast_ui(aqi_text_input: str, lat_val: str, lon_val:
     try:
         if not aqi_text_input or not aqi_text_input.strip():
             return "❌ Error: Please provide at least 24 hourly AQI readings.", None, ""
-        
+
         # Parse CSV string into list of floats
         raw_vals = [x.strip() for x in aqi_text_input.split(",") if x.strip()]
         aqi_series = [float(x) for x in raw_vals]
@@ -221,24 +231,32 @@ with gr.Blocks(title="AQI Intelligence Engine — HF ZeroGPU Edition", theme=gr.
                 - **Primary Compute Hardware**: `{device_active}`
                 - **HuggingFace `spaces` SDK Available**: `{spaces is not None}`
                 - **ZeroGPU Status**: `{"Active & Ready for dynamic GPU acceleration" if spaces is not None else "Running on standard CPU mode (Universal Compatibility)"}`
-                
+
                 ### 🔌 REST API Endpoints
-                When deployed on Hugging Face Spaces, you can query REST endpoints directly:
-                - `POST /forecast`: Direct historical AQI prediction payload
-                - `POST /analyze-image`: Satellite base64 image breakdown
-                - `GET /health`: Core server state & device telemetry
+                Query REST endpoints directly at this Space's root URL:
+                - `POST /api/v1/forecast`: Direct historical AQI prediction payload
+                - `POST /api/v1/analyze-image`: Satellite base64 image breakdown
+                - `GET /api/v1/health`: Core server state & device telemetry
                 """
             )
 
+
+# ---------------------------------------------------------------------------
+# REST API — built on our OWN FastAPI instance, not on `demo.app`.
+#
+# `demo.app` does not exist until Gradio's `.launch()` builds it internally,
+# so registering routes on it here (before launch) is a no-op that silently
+# fails. Instead we own the FastAPI app from the start and mount Gradio's UI
+# into it, so there is exactly one app object and it has everything on it.
+# ---------------------------------------------------------------------------
+
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from starlette.responses import JSONResponse
 from starlette.requests import Request
 
-# Create the FastAPI app
-app = FastAPI(title="AQI Intelligence Engine API")
+app = FastAPI()
 
-# Configure CORS directly on the FastAPI app
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -247,14 +265,12 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Register REST API routes on the FastAPI app
-@app.post("/api/forecast")
+
 @app.post("/api/v1/forecast")
 async def api_forecast(request: Request):
     """REST API endpoint for historical AQI prediction."""
     try:
         payload = await request.json()
-        from services.forecast.service import forecast_aqi
         aqi_hist = payload.get("aqi_history", [])
         lat = payload.get("lat")
         lon = payload.get("lon")
@@ -264,14 +280,13 @@ async def api_forecast(request: Request):
         logger.error(f"API Forecast error: {e}")
         return JSONResponse({"error": str(e)}, status_code=400)
 
-@app.post("/api/analyze-image")
+
 @app.post("/api/v1/analyze-image")
 async def api_analyze_image(request: Request):
     """REST API endpoint for satellite image pollution breakdown."""
     try:
         payload = await request.json()
         import base64
-        from services.vision.service import detect_pollution_sources
         base64_str = payload.get("image_base64", "")
         if not base64_str:
             return JSONResponse({"error": "No image_base64 provided"}, status_code=400)
@@ -285,9 +300,9 @@ async def api_analyze_image(request: Request):
         logger.error(f"API Vision error: {e}")
         return JSONResponse({"error": str(e)}, status_code=400)
 
-@app.get("/api/health")
+
 @app.get("/api/v1/health")
-async def api_health(request: Request):
+async def api_health():
     """Health check endpoint."""
     return JSONResponse({
         "status": "ok",
@@ -296,13 +311,26 @@ async def api_health(request: Request):
         "version": "2.0.0",
     })
 
-# Initialize the Gradio queue — this creates the underlying FastAPI app object
+
+logger.info("Custom REST API routes registered: /api/v1/forecast, /api/v1/analyze-image, /api/v1/health")
+
+# Enable Gradio's internal event queue (needed for streaming/progress updates
+# in the Blocks UI) before mounting.
 demo.queue()
 
-# Mount the Gradio app onto the FastAPI app at root path
+# Mount the Gradio Blocks UI onto our FastAPI app at root ("/"). From this
+# point on, `app` is the single combined ASGI application — it carries both
+# the Gradio UI and the custom /api/v1/* routes above.
 app = gr.mount_gradio_app(app, demo, path="/")
 
+# Log every route at startup so a misconfiguration is visible immediately in
+# the Space logs rather than discovered later via a 404 in the browser.
+logger.info("Registered routes: %s", [getattr(r, "path", r) for r in app.routes])
+
+
 if __name__ == "__main__":
     import uvicorn
-    # Local development only — on HF Spaces, uvicorn runs the app directly
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    # Serve our combined `app` object directly. Do NOT call `demo.launch()`
+    # here — that would build a second, separate FastAPI app internally that
+    # never saw the routes registered above, which was the original bug.
+    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))