Update app.py

app.py

@@ -230,82 +230,79 @@ with gr.Blocks(title="AQI Intelligence Engine — HF ZeroGPU Edition", theme=gr.
                 """
             )
 
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
 from starlette.responses import JSONResponse
 from starlette.requests import Request
 
-# Initialize the Gradio queue — this creates the underlying FastAPI app object
-# MUST be called before registering REST routes on demo.app
-demo.queue()
-
+# Create the FastAPI app
+app = FastAPI(title="AQI Intelligence Engine API")
+
+# Configure CORS directly on the FastAPI app
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    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")
+        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)
 
-def register_api_routes(gradio_app):
-    """Register custom REST API endpoints on the Gradio FastAPI app."""
+@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)
+        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/health")
+@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",
+    })
 
-    @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}")
+# Initialize the Gradio queue — this creates the underlying FastAPI app object
+demo.queue()
 
-# Export Gradio demo as root app object for Hugging Face ZeroGPU SDK
-app = demo
+# Mount the Gradio app onto the FastAPI app at root path
+app = gr.mount_gradio_app(app, demo, path="/")
 
 if __name__ == "__main__":
+    import uvicorn
     # Local development only — on HF Spaces, uvicorn runs the app directly
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    uvicorn.run(app, host="0.0.0.0", port=7860)