Spaces:

dataera2013
/

podcraft_web_app

Sleeping

App Files Files Community

Nagesh Muralidhar commited on Mar 20

Commit

1700fb6

1 Parent(s): 2251ba3

Fix frontend HTML serving with improved app architecture

Browse files

Files changed (1) hide show

app.py +60 -95

app.py CHANGED Viewed

@@ -46,12 +46,45 @@ if not index_path.exists():
 os.environ["MONGODB_CONNECT_TIMEOUT_MS"] = "5000"  # 5 seconds timeout
 os.environ["MONGODB_SERVER_SELECTION_TIMEOUT_MS"] = "5000"  # 5 seconds timeout
-# Create a FastAPI app - either the main one or an error one
-from fastapi import FastAPI, Request
-from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
 # Check if static directory exists with index.html
 static_index_exists = static_path.exists() and index_path.exists()
 logger.info(f"Static path exists: {static_path.exists()}")
@@ -60,8 +93,14 @@ if static_path.exists():
     logger.info(f"Static index exists: {index_path.exists()}")
 try:
-    # Try to import the main app
-    from backend.app.main import app
     # Add CORS middleware
     app.add_middleware(
@@ -72,102 +111,28 @@ try:
         allow_headers=["*"],
     )
-    # Add an index route to check if the API is accessible
-    @app.get("/api/status")
-    async def status():
-        return {"status": "ok", "message": "PodCraft API is running"}
-    # Override the root route to serve the frontend
-    @app.get("/", response_class=HTMLResponse)
-    async def read_root():
-        # If index.html exists, return it directly using FileResponse
-        if index_path.exists():
-            logger.info(f"Serving index.html from {index_path}")
-            return FileResponse(index_path)
-        else:
-            logger.warning("index.html not found, returning fallback HTML")
-            return """
-            <html>
-                <head>
-                    <title>PodCraft API</title>
-                    <style>
-                        body { font-family: Arial, sans-serif; margin: 0; padding: 0; display: flex; justify-content: center; align-items: center; height: 100vh; background-color: #f8f9fa; }
-                        .container { max-width: 800px; padding: 2rem; background-color: white; border-radius: 0.5rem; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); }
-                        h1 { color: #6366F1; }
-                        pre { background-color: #f5f5f5; padding: 1rem; border-radius: 0.25rem; overflow: auto; }
-                    </style>
-                </head>
-                <body>
-                    <div class="container">
-                        <h1>PodCraft API</h1>
-                        <p>The PodCraft API is running, but the frontend static files were not found.</p>
-                        <p>Static directory: <code>./static</code></p>
-                        <p>Static directory exists: <code>{static_path.exists()}</code></p>
-                        <p>If you need to access the API directly, you can use the following endpoints:</p>
-                        <ul>
-                            <li><code>/api/status</code> - Check API status</li>
-                            <li><code>/docs</code> - API documentation</li>
-                        </ul>
-                    </div>
-                </body>
-            </html>
-            """
-    # Mount static files
-    # First, make sure we're not serving the root path via StaticFiles
-    @app.get("/static/{path:path}")
-    async def serve_static(path: str):
-        file_path = static_path / path
-        if file_path.exists() and file_path.is_file():
-            return FileResponse(file_path)
-        return {"error": "File not found"}
     app_to_run = app
-    logger.info("Using main application")
 except Exception as e:
-    # If there's an error, create a minimal FastAPI app
-    logger.error(f"Error initializing main app: {str(e)}")
-    error_app = FastAPI()
-    @error_app.get("/", response_class=HTMLResponse)
-    async def root():
-        return f"""
-        <html>
-            <head>
-                <title>PodCraft - Error</title>
-                <style>
-                    body {{ font-family: Arial, sans-serif; margin: 0; padding: 0; display: flex; justify-content: center; align-items: center; height: 100vh; background-color: #f8f9fa; }}
-                    .container {{ max-width: 800px; padding: 2rem; background-color: white; border-radius: 0.5rem; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); }}
-                    h1 {{ color: #d32f2f; }}
-                    pre {{ background-color: #f5f5f5; padding: 1rem; border-radius: 0.25rem; overflow: auto; }}
-                </style>
-            </head>
-            <body>
-                <div class="container">
-                    <h1>PodCraft Error</h1>
-                    <p>An error occurred while starting the application:</p>
-                    <pre>{str(e)}</pre>
-                    <p>Please check your environment variables and configuration.</p>
-                    <p>MongoDB URL format should be: <code>mongodb+srv://username:[email protected]/...</code></p>
-                    <p>API keys should be properly formatted and valid.</p>
-                    <p>Static directory exists: <code>{static_path.exists()}</code></p>
-                    {f"<p>Static directory contents: <code>{os.listdir(static_path)}</code></p>" if static_path.exists() else ""}
-                    <p>Static index exists: <code>{static_index_exists}</code></p>
-                </div>
-            </body>
-        </html>
-        """
-    @error_app.get("/static/{path:path}")
-    async def serve_static(path: str):
-        file_path = static_path / path
-        if file_path.exists() and file_path.is_file():
-            return FileResponse(file_path)
-        return {"error": "File not found"}
-    app_to_run = error_app
-    logger.info("Using error application")
 # For Hugging Face Spaces - expose the app
 if __name__ == "__main__":

 os.environ["MONGODB_CONNECT_TIMEOUT_MS"] = "5000"  # 5 seconds timeout
 os.environ["MONGODB_SERVER_SELECTION_TIMEOUT_MS"] = "5000"  # 5 seconds timeout
+# Create our own FastAPI app first
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse, Response
 from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
+# Create our own app that will handle frontend routes
+frontend_app = FastAPI(title="PodCraft Frontend")
+# Add CORS middleware
+frontend_app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+# Mount static directory
+if static_path.exists():
+    frontend_app.mount("/static", StaticFiles(directory=str(static_path)), name="static")
+# Root route handler
+@frontend_app.get("/", response_class=HTMLResponse)
+async def read_root():
+    logger.info(f"Serving index.html from {index_path}")
+    # Read the file contents directly
+    if index_path.exists():
+        with open(index_path, "r") as f:
+            content = f.read()
+            return HTMLResponse(content=content)
+    else:
+        return HTMLResponse(content="Index file not found", status_code=404)
+# API status endpoint
+@frontend_app.get("/api/status")
+async def status():
+    return {"status": "ok", "message": "PodCraft API is running"}
 # Check if static directory exists with index.html
 static_index_exists = static_path.exists() and index_path.exists()
 logger.info(f"Static path exists: {static_path.exists()}")
     logger.info(f"Static index exists: {index_path.exists()}")
 try:
+    # Try to import the backend app
+    from backend.app.main import app as backend_app
+    # Now create a merged app that prioritizes frontend routes
+    app = FastAPI(title="PodCraft")
+    # Add frontend app routes to the main app
+    app.mount("/", frontend_app)
     # Add CORS middleware
     app.add_middleware(
         allow_headers=["*"],
     )
+    # Forward specific backend API routes
+    @app.get("/api/{path:path}")
+    async def api_route(request: Request, path: str):
+        return await backend_app.handle_request(request)
     app_to_run = app
+    logger.info("Using merged application (frontend + backend)")
 except Exception as e:
+    # If there's an error, use just the frontend app
+    logger.error(f"Error initializing backend app: {str(e)}")
+    # Add error handler to frontend app
+    @frontend_app.get("/api/{path:path}")
+    async def api_error(path: str):
+        return {
+            "error": "Backend API not available",
+            "message": str(e)
+        }
+    app_to_run = frontend_app
+    logger.info("Using frontend application only due to backend error")
 # For Hugging Face Spaces - expose the app
 if __name__ == "__main__":