Spaces:

dataera2013
/

podcraft_web_app

Sleeping

App Files Files Community

Nagesh Muralidhar commited on Mar 20

Commit

2784e84

1 Parent(s): fee9ffa

addin app.py

Browse files

Files changed (1) hide show

app.py +50 -94

app.py CHANGED Viewed

@@ -46,17 +46,34 @@ 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 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,
@@ -64,32 +81,19 @@ frontend_app.add_middleware(
     allow_headers=["*"],
 )
-# 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()}")
-if static_path.exists():
-    logger.info(f"Static directory contents: {os.listdir(static_path)}")
-    logger.info(f"Static index exists: {index_path.exists()}")
-# Root route handler - must come before mounting static files
-@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"}
-# Serve specific file types with correct Content-Type
-@frontend_app.get("/assets/{file_path:path}")
 async def serve_assets(file_path: str):
     file_full_path = static_path / "assets" / file_path
@@ -113,75 +117,27 @@ async def serve_assets(file_path: str):
     logger.info(f"Serving asset: {file_path} with content-type: {content_type}")
     return FileResponse(file_full_path, media_type=content_type)
-# Now mount the static directory AFTER defining the root handler
 if static_path.exists():
-    frontend_app.mount("/static", StaticFiles(directory=str(static_path)), name="static")
-# Catch-all route to serve index.html for client-side routing
-@frontend_app.get("/{full_path:path}")
-async def catch_all(full_path: str):
-    # Skip API paths
-    if full_path.startswith("api/") or full_path.startswith("docs") or full_path.startswith("openapi.json"):
-        raise HTTPException(status_code=404, detail="Not found")
-    logger.info(f"Catch-all route hit for path: {full_path}, serving index.html")
-    # For any other path, serve index.html to support client-side routing
-    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)
-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 CORS middleware
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=["*"],
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
-    # Include the backend app routes
-    # This imports all routes from the backend_app into our main app
-    from fastapi import APIRouter
-    backend_router = APIRouter()
-    # Import all routes from backend_app
-    for route in backend_app.routes:
-        backend_router.routes.append(route)
-    # Add the backend routes
-    app.include_router(backend_router)
-    # Mount the frontend app at the root - this should be last
-    # so that API routes take precedence but frontend handles all other routes
-    app.mount("/", frontend_app)
-    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__":
@@ -191,4 +147,4 @@ if __name__ == "__main__":
     host = os.environ.get("HOST", "0.0.0.0")
     logger.info(f"Starting server on {host}:{port}")
-    uvicorn.run(app_to_run, host=host, port=port)

 os.environ["MONGODB_CONNECT_TIMEOUT_MS"] = "5000"  # 5 seconds timeout
 os.environ["MONGODB_SERVER_SELECTION_TIMEOUT_MS"] = "5000"  # 5 seconds timeout
+# Import FastAPI and related modules
+from fastapi import FastAPI, Request, HTTPException, Depends
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse, Response, RedirectResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
+# Function to read index.html content
+def get_index_html():
+    if index_path.exists():
+        with open(index_path, "r") as f:
+            return f.read()
+    else:
+        return "<html><body><h1>Index file not found</h1></body></html>"
+try:
+    # Try to import the backend app but don't use it directly
+    import backend.app.main
+    logger.info("Backend module imported successfully")
+    backend_available = True
+except Exception as e:
+    logger.error(f"Error importing backend module: {str(e)}")
+    backend_available = False
+# Create the main application
+app = FastAPI(title="PodCraft")
 # Add CORS middleware
+app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
     allow_credentials=True,
     allow_headers=["*"],
 )
+# Define the root route that directly serves index.html
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    logger.info("Root route accessed, serving index.html")
+    return HTMLResponse(content=get_index_html())
 # API status endpoint
+@app.get("/api/status")
 async def status():
     return {"status": "ok", "message": "PodCraft API is running"}
+# Serve static assets directory with correct content types
+@app.get("/assets/{file_path:path}")
 async def serve_assets(file_path: str):
     file_full_path = static_path / "assets" / file_path
     logger.info(f"Serving asset: {file_path} with content-type: {content_type}")
     return FileResponse(file_full_path, media_type=content_type)
+# Mount the static directory for other static files
 if static_path.exists():
+    app.mount("/static", StaticFiles(directory=str(static_path)), name="static")
+# Catch-all route for client-side routing in the React app
+@app.get("/{full_path:path}")
+async def catch_all(full_path: str, request: Request):
+    # Skip API paths and redirect them to the backend
+    if full_path.startswith("api/") or full_path == "docs" or full_path == "openapi.json":
+        if backend_available:
+            # Use the backend.app.main module's routes
+            return backend.app.main.app.get(full_path)
+        else:
+            return {"error": "Backend API not available"}
+    # Skip static file paths
+    if full_path.startswith("static/") or full_path.startswith("assets/"):
+        raise HTTPException(status_code=404, detail="Not found")
+    logger.info(f"Catch-all route hit for path: {full_path}, serving index.html for client-side routing")
+    return HTMLResponse(content=get_index_html())
 # For Hugging Face Spaces - expose the app
 if __name__ == "__main__":
     host = os.environ.get("HOST", "0.0.0.0")
     logger.info(f"Starting server on {host}:{port}")
+    uvicorn.run(app, host=host, port=port)