Update app.py

app.py

@@ -34,16 +34,24 @@ from datetime import datetime, timezone
 try:
     import spaces
 except ImportError:
-    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
+    spaces = None
 
+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
@@ -98,9 +106,9 @@ async def _async_handle_forecast_ui(aqi_text_input: str, lat_val: str, lon_val:
         return f"❌ Execution Failed: {str(e)}", None, ""
 
 
-@spaces.GPU
+@gpu_decorator
 def handle_forecast_ui(aqi_text_input: str, lat_val: str, lon_val: str):
-    """Gradio handler for AQI Forecasting."""
+    """Gradio handler for AQI Forecasting wrapped with @gpu_decorator."""
     return asyncio.run(_async_handle_forecast_ui(aqi_text_input, lat_val, lon_val))
 
 
@@ -140,9 +148,9 @@ async def _async_handle_vision_ui(input_image):
         return f"❌ Analysis Failed: {str(e)}", ""
 
 
-@spaces.GPU
+@gpu_decorator
 def handle_vision_ui(input_image):
-    """Gradio handler for Satellite Vision."""
+    """Gradio handler for Satellite Vision wrapped with @gpu_decorator."""
     return asyncio.run(_async_handle_vision_ui(input_image))
 
 
@@ -211,8 +219,8 @@ 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**: `{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)"}`
+                - **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:
@@ -222,16 +230,18 @@ with gr.Blocks(title="AQI Intelligence Engine — HF ZeroGPU Edition", theme=gr.
                 """
             )
 
-from fastapi.middleware.cors import CORSMiddleware
 from starlette.responses import JSONResponse
 from starlette.requests import Request
 
-def register_api_routes(fastapi_app):
-    """Register custom REST API endpoints on the parent FastAPI app."""
+# Initialize the Gradio queue — this creates the underlying FastAPI app object
+# MUST be called before registering REST routes on demo.app
+demo.queue()
+
+
+def register_api_routes(gradio_app):
+    """Register custom REST API endpoints on the Gradio FastAPI app."""
 
-    @fastapi_app.post("/api/v1/forecast")
-    @fastapi_app.post("/api/forecast")
-    @fastapi_app.post("/forecast")
+    @gradio_app.post("/api/v1/forecast")
     async def api_forecast(request: Request):
         """REST API endpoint for historical AQI prediction."""
         try:
@@ -246,9 +256,7 @@ def register_api_routes(fastapi_app):
             logger.error(f"API Forecast error: {e}")
             return JSONResponse({"error": str(e)}, status_code=400)
 
-    @fastapi_app.post("/api/v1/analyze-image")
-    @fastapi_app.post("/api/analyze-image")
-    @fastapi_app.post("/analyze-image")
+    @gradio_app.post("/api/v1/analyze-image")
     async def api_analyze_image(request: Request):
         """REST API endpoint for satellite image pollution breakdown."""
         try:
@@ -268,9 +276,7 @@ def register_api_routes(fastapi_app):
             logger.error(f"API Vision error: {e}")
             return JSONResponse({"error": str(e)}, status_code=400)
 
-    @fastapi_app.get("/api/v1/health")
-    @fastapi_app.get("/api/health")
-    @fastapi_app.get("/health")
+    @gradio_app.get("/api/v1/health")
     async def api_health(request: Request):
         """Health check endpoint."""
         return JSONResponse({
@@ -280,36 +286,22 @@ def register_api_routes(fastapi_app):
             "version": "2.0.0",
         })
 
-# Save the original create_app method from Gradio
-_orig_create_app = demo.create_app
 
-def custom_create_app(*args, **kwargs):
-    """Intercept Gradio's app creation to inject custom middleware and REST routes."""
-    fastapi_app = _orig_create_app(*args, **kwargs)
-    
-    # Configure CORS on the FastAPI app
-    fastapi_app.add_middleware(
+# 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 our custom REST API routes
-    register_api_routes(fastapi_app)
-    
-    # Log the registered routes for debugging
-    routes = [route.path for route in fastapi_app.routes]
-    logger.info(f"Custom REST API routes successfully injected on Gradio FastAPI app: {routes}")
-    
-    return fastapi_app
-
-# Monkey-patch demo's create_app method
-demo.create_app = custom_create_app
-
-# Initialize the Gradio queue
-demo.queue()
+    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
@@ -317,5 +309,3 @@ app = demo
 if __name__ == "__main__":
     # Local development only — on HF Spaces, uvicorn runs the app directly
     demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
-
-