vibe coding the fix now basically added more logs and timeouts

Dockerfile

@@ -69,7 +69,5 @@ WORKDIR /home/user/app/backend
 # Expose port for FastAPI on Hugging Face
 EXPOSE 7860
 
-# Start the FastAPI server
-# CMD ["python", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
-# Update this line in your Dockerfile
-CMD ["python", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--proxy-headers", "--forwarded-allow-ips=*"]
+# Start the FastAPI server with optimized settings for Hugging Face Spaces
+CMD ["python", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--proxy-headers", "--forwarded-allow-ips=*", "--timeout-keep-alive", "75"]

backend/main.py

@@ -34,32 +34,50 @@ from aimakerspace.utils.session_manager import SessionManager
 from dotenv import load_dotenv
 load_dotenv()
 
-app = FastAPI()
+app = FastAPI(
+    title="RAG Application",
+    description="Retrieval Augmented Generation with FastAPI and React",
+    version="0.1.0",
+    root_path="",  # Important for proxy environments
+)
 
-# For deployment on Hugging Face Spaces, add a middleware to handle HTTPS
+# More robust middleware for handling HTTPS
 from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import RedirectResponse, JSONResponse
 
-class HTTPSRedirectMiddleware(BaseHTTPMiddleware):
+class ProxyMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request, call_next):
-        # Check for X-Forwarded-Proto header and ensure it's HTTPS
-        if request.headers.get("X-Forwarded-Proto") == "http":
-            logger.info("Redirecting to HTTPS")
-            url = request.url.replace(scheme="https")
-            return RedirectResponse(url=str(url), status_code=307)
-        return await call_next(request)
+        # Log request details for debugging
+        logger.info(f"Request path: {request.url.path}")
+        logger.info(f"Request headers: {request.headers}")
+        
+        # Validate request before processing
+        try:
+            start_time = time.time()
+            response = await call_next(request)
+            process_time = time.time() - start_time
+            response.headers["X-Process-Time"] = str(process_time)
+            return response
+        except Exception as e:
+            logger.error(f"Request failed: {str(e)}")
+            logger.error(traceback.format_exc())
+            return JSONResponse(
+                status_code=500,
+                content={"detail": f"Internal server error: {str(e)}"}
+            )
 
-# Add the HTTPS middleware
-from starlette.responses import RedirectResponse
-app.add_middleware(HTTPSRedirectMiddleware)
+# Add custom middleware
+app.add_middleware(ProxyMiddleware)
 
-# Configure CORS - allow all origins explicitly for development
+# Configure CORS - more specific configuration for Hugging Face
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # This will allow all origins
+    allow_origins=["*"],  # In production, you should restrict this
     allow_credentials=True,
-    allow_methods=["*"],  # Allow all methods
-    allow_headers=["*"],  # Allow all headers
-    expose_headers=["*"]
+    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    allow_headers=["*"],
+    expose_headers=["Content-Length", "X-Process-Time"],
+    max_age=600,  # 10 minutes cache for preflight requests
 )
 
 # Initialize session manager
@@ -167,6 +185,11 @@ async def process_file_background(temp_path: str, filename: str, session_id: str
 async def upload_file(background_tasks: BackgroundTasks, file: UploadFile = File(...)):
     try:
         logger.info(f"Received upload request for file: {file.filename}")
+        logger.info(f"Content type: {file.content_type}")
+        
+        # Create a unique ID for this upload
+        upload_id = str(uuid.uuid4())
+        logger.info(f"Assigned upload ID: {upload_id}")
         
         # Check file size first
         file_size = 0
@@ -174,20 +197,32 @@ async def upload_file(background_tasks: BackgroundTasks, file: UploadFile = File
         contents = bytearray()
         
         # Read file in chunks to avoid memory issues
-        while True:
-            chunk = await file.read(chunk_size)
-            if not chunk:
-                break
-            file_size += len(chunk)
-            contents.extend(chunk)
-            
-            # Check size limit
-            if file_size > FILE_SIZE_LIMIT:
-                logger.warning(f"File too large: {file_size/1024/1024:.2f}MB exceeds limit of {FILE_SIZE_LIMIT/1024/1024}MB")
-                return HTTPException(
-                    status_code=413, 
-                    detail=f"File too large. Maximum size is {FILE_SIZE_LIMIT/1024/1024}MB"
-                )
+        try:
+            while True:
+                chunk = await asyncio.wait_for(file.read(chunk_size), timeout=60.0)
+                if not chunk:
+                    break
+                file_size += len(chunk)
+                contents.extend(chunk)
+                
+                # Check size limit
+                if file_size > FILE_SIZE_LIMIT:
+                    logger.warning(f"File too large: {file_size/1024/1024:.2f}MB exceeds limit of {FILE_SIZE_LIMIT/1024/1024}MB")
+                    return HTTPException(
+                        status_code=413, 
+                        detail=f"File too large. Maximum size is {FILE_SIZE_LIMIT/1024/1024}MB"
+                    )
+                
+                # Log progress for large files
+                if file_size % (5 * 1024 * 1024) == 0:  # Log every 5MB
+                    logger.info(f"Upload progress: {file_size/1024/1024:.2f}MB read so far...")
+                    
+        except asyncio.TimeoutError:
+            logger.error(f"Timeout reading file: {file.filename}")
+            raise HTTPException(
+                status_code=408,
+                detail="Request timeout while reading file. Please try again."
+            )
         
         logger.info(f"File size: {file_size/1024/1024:.2f}MB")
         
@@ -214,7 +249,7 @@ async def upload_file(background_tasks: BackgroundTasks, file: UploadFile = File
             session_id
         )
         
-        return {"session_id": session_id, "message": "File uploaded and processing started"}
+        return {"session_id": session_id, "message": "File uploaded and processing started", "upload_id": upload_id}
     
     except Exception as e:
         logger.error(f"Error processing upload: {str(e)}")

frontend/src/App.js

@@ -197,9 +197,16 @@ function FileUploader({ onFileUpload }) {
           headers: {
             'Content-Type': 'multipart/form-data',
           },
+          timeout: 180000, // 3 minutes timeout for large files
+          maxContentLength: Infinity,
+          maxBodyLength: Infinity,
           onUploadProgress: (progressEvent) => {
             const percentCompleted = Math.round((progressEvent.loaded * 100) / progressEvent.total);
             setUploadProgress(percentCompleted);
+          },
+          // Add retry logic for network errors
+          validateStatus: function (status) {
+            return status >= 200 && status < 500; // Handle 4xx errors in our own logic
           }
         });