Update app.py

app.py

@@ -3,16 +3,6 @@ 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
@@ -44,24 +34,16 @@ from datetime import datetime, timezone
 try:
     import spaces
 except ImportError:
-    spaces = None
+    class spaces:
+        _is_mock = True
+        @staticmethod
+        def GPU(func_or_duration=None, **kwargs):
+            if callable(func_or_duration):
+                return func_or_duration
+            def decorator(func):
+                return func
+            return decorator
 
-def gpu_decorator(func=None, duration=None):
-    """ZeroGPU decorator wrapper that applies spaces.GPU on HF or identity on CPU."""
-    if spaces is not None:
-        try:
-            if func is None:
-                return spaces.GPU(duration=duration) if duration else spaces.GPU
-            if callable(func):
-                return spaces.GPU(func)
-            return spaces.GPU
-        except Exception:
-            pass
-    if func is None:
-        return lambda f: f
-    if callable(func):
-        return func
-    return lambda f: f
 
 from config import get_device, HAS_SPACES
 from services.forecast.service import forecast_aqi
@@ -79,7 +61,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]
@@ -116,9 +98,9 @@ async def _async_handle_forecast_ui(aqi_text_input: str, lat_val: str, lon_val:
         return f"❌ Execution Failed: {str(e)}", None, ""
 
 
-@gpu_decorator
+@spaces.GPU
 def handle_forecast_ui(aqi_text_input: str, lat_val: str, lon_val: str):
-    """Gradio handler for AQI Forecasting wrapped with @gpu_decorator."""
+    """Gradio handler for AQI Forecasting."""
     return asyncio.run(_async_handle_forecast_ui(aqi_text_input, lat_val, lon_val))
 
 
@@ -158,9 +140,9 @@ async def _async_handle_vision_ui(input_image):
         return f"❌ Analysis Failed: {str(e)}", ""
 
 
-@gpu_decorator
+@spaces.GPU
 def handle_vision_ui(input_image):
-    """Gradio handler for Satellite Vision wrapped with @gpu_decorator."""
+    """Gradio handler for Satellite Vision."""
     return asyncio.run(_async_handle_vision_ui(input_image))
 
 
@@ -229,108 +211,93 @@ with gr.Blocks(title="AQI Intelligence Engine — HF ZeroGPU Edition", theme=gr.
                 f"""
                 ### 🖥️ Active Deployment Info
                 - **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)"}`
-
+                - **HuggingFace `spaces` SDK Available**: `{not getattr(spaces, "_is_mock", False)}`
+                - **ZeroGPU Status**: `{"Active & Ready for dynamic GPU acceleration" if not getattr(spaces, "_is_mock", False) else "Running on standard CPU mode (Universal Compatibility)"}`
+                
                 ### 🔌 REST API Endpoints
-                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
+                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
                 """
             )
 
-
-# ---------------------------------------------------------------------------
-# 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
 
-app = FastAPI()
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-@app.post("/api/v1/forecast")
-async def api_forecast(request: Request):
-    """REST API endpoint for historical AQI prediction."""
-    try:
-        payload = await request.json()
-        aqi_hist = payload.get("aqi_history", [])
-        lat = payload.get("lat")
-        lon = payload.get("lon")
-        res = await forecast_aqi(aqi_hist, lat=lat, lon=lon)
-        return JSONResponse(res)
-    except Exception as e:
-        logger.error(f"API Forecast error: {e}")
-        return JSONResponse({"error": str(e)}, status_code=400)
-
-
-@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
-        base64_str = payload.get("image_base64", "")
-        if not base64_str:
-            return JSONResponse({"error": "No image_base64 provided"}, status_code=400)
-        if "," in base64_str:
-            base64_str = base64_str.split(",", 1)[1]
-        img_bytes = base64.b64decode(base64_str)
-        pil_img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
-        res = await detect_pollution_sources(pil_img)
-        return JSONResponse(res)
-    except Exception as e:
-        logger.error(f"API Vision error: {e}")
-        return JSONResponse({"error": str(e)}, status_code=400)
-
-
-@app.get("/api/v1/health")
-async def api_health():
-    """Health check endpoint."""
-    return JSONResponse({
-        "status": "ok",
-        "device": get_device(),
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "version": "2.0.0",
-    })
-
-
-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.
+# Initialize the Gradio queue — this creates the underlying FastAPI app object
+# MUST be called before registering REST routes on demo.app
 demo.queue()
 
-# 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])
+def register_api_routes(gradio_app):
+    """Register custom REST API endpoints on the Gradio FastAPI app."""
+
+    @gradio_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")
+            res = await forecast_aqi(aqi_hist, lat=lat, lon=lon)
+            return JSONResponse(res)
+        except Exception as e:
+            logger.error(f"API Forecast error: {e}")
+            return JSONResponse({"error": str(e)}, status_code=400)
+
+    @gradio_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)
+            if "," in base64_str:
+                base64_str = base64_str.split(",", 1)[1]
+            img_bytes = base64.b64decode(base64_str)
+            pil_img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
+            res = await detect_pollution_sources(pil_img)
+            return JSONResponse(res)
+        except Exception as e:
+            logger.error(f"API Vision error: {e}")
+            return JSONResponse({"error": str(e)}, status_code=400)
+
+    @gradio_app.get("/api/v1/health")
+    async def api_health(request: Request):
+        """Health check endpoint."""
+        return JSONResponse({
+            "status": "ok",
+            "device": get_device(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "version": "2.0.0",
+        })
+
+
+# Register REST API routes on the Gradio underlying FastAPI app
+try:
+    from fastapi.middleware.cors import CORSMiddleware
+    # Explicitly configure CORS on the underlying FastAPI app to allow direct requests from the browser
+    demo.app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    register_api_routes(demo.app)
+    logger.info("CORS middleware and REST API routes registered successfully on Gradio FastAPI app.")
+except Exception as e:
+    logger.warning(f"Could not register REST API routes or CORS (will be available via Gradio only): {e}")
 
+# Export Gradio demo as root app object for Hugging Face ZeroGPU SDK
+app = demo
 
 if __name__ == "__main__":
-    import uvicorn
-    # 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)))
+    # Local development only — on HF Spaces, uvicorn runs the app directly
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)