""" FastAPI-sync + Gradio with AJAX (all route handlers are now synchronous with JSON responses) """ import logging import os import tempfile import traceback import uuid from pathlib import Path from typing import List, Dict, Any import gradio as gr from fastapi import FastAPI, File, HTTPException, Request, Response, UploadFile, status from fastapi.responses import HTMLResponse, RedirectResponse, FileResponse, JSONResponse from starlette.middleware.sessions import SessionMiddleware from starlette.responses import PlainTextResponse from werkzeug.utils import secure_filename # type: ignore try: from rag_document_viewer import RAG_DV except ImportError as err: print(f"Warning: Could not import RAG_DV: {err}") RAG_DV = None # --------------------------------------------------------------------------- # # Config / constants # # --------------------------------------------------------------------------- # SECRET_KEY = ( "a&VhLelkAo!dKXm9o5RRHQ@#BxoI3Q5378qwFP&aJKA#PLjO7TU*Aq5Kwg4OTdMI7N3%wFAmnwezlEbPUdEQKhGJD10E8@0gSrS" ) MAX_CONTENT_LENGTH = 16 * 1024 * 1024 # 16 MB ALLOWED_EXTENSIONS = { "txt", "pdf", "doc", "docx", "ppt", "pptx", "xls", "xlsx", "odt", "odp", "ods", } UPLOADS_DIR = ( Path(tempfile.gettempdir()) / "uploads" if os.getenv("SPACE_ID") else Path("uploads") ) UPLOADS_DIR.mkdir(exist_ok=True, parents=True) logging.basicConfig(level=logging.INFO) logger = logging.getLogger("rag_dv_demo") # --------------------------------------------------------------------------- # # Helpers # # --------------------------------------------------------------------------- # def _allowed_file(name: str) -> bool: return "." in name and name.rsplit(".", 1)[1].lower() in ALLOWED_EXTENSIONS def _json_response(success: bool = True, message: str = "", data: Dict[Any, Any] = None) -> JSONResponse: """Helper to create consistent JSON responses""" return JSONResponse({ "success": success, "message": message, "data": data or {} }) def _rewrite_html_urls(content: str, base_url: str, story_id: str) -> str: """Rewrite relative URLs in HTML content to use absolute URLs""" import re logger.info(f"Rewriting URLs with base: {base_url}, story_id: {story_id}") # Patterns to match various asset references patterns = [ # src="assets/..." -> src="[base_url]/..." (r'src="assets/', f'src="{base_url}/'), # href="assets/..." -> href="[base_url]/..." (r'href="assets/', f'href="{base_url}/'), # CSS url(assets/...) -> url([base_url]/...) (r'url\(assets/', f'url({base_url}/'), (r'url\("assets/', f'url("{base_url}/'), (r"url\('assets/", f"url('{base_url}/"), # Background images and other asset references (r'background-image:\s*url\(assets/', f'background-image: url({base_url}/'), (r'background:\s*url\(assets/', f'background: url({base_url}/'), # Script src (r']*src="assets/', f' """ template = Template(HTML_TEMPLATE) # --------------------------------------------------------------------------- # # FastAPI (synchronous with AJAX endpoints) # # --------------------------------------------------------------------------- # backend = FastAPI() backend.add_middleware( SessionMiddleware, secret_key=SECRET_KEY, same_site="none", # HF iframe needs SameSite=None https_only=True, ) @backend.get("/", name="index") def index(request: Request): return HTMLResponse(template.render()) @backend.get("/api/session") def get_session_info(request: Request): """Get current session information""" has_uploaded_file = "uploaded_file" in request.session filename = request.session.get("uploaded_file", "") original_filename = request.session.get("original_filename", "") return _json_response( success=True, data={ "has_uploaded_file": has_uploaded_file, "filename": filename, "original_filename": original_filename } ) @backend.post("/api/upload") def upload_file_ajax(request: Request, file: UploadFile = File(...)): if RAG_DV is None: return _json_response( success=False, message="RAG Document Viewer is not available. Please check installation." ) if not file.filename or not _allowed_file(file.filename): return _json_response( success=False, message="Invalid file type. Please upload a supported document." ) # Check file size file.file.seek(0, 2) # go to end size = file.file.tell() file.file.seek(0) if size > MAX_CONTENT_LENGTH: return _json_response( success=False, message="File is too large. Maximum size is 16MB." ) filename = secure_filename(file.filename) if not filename: return _json_response(success=False, message="Invalid filename") unique_filename = f"{uuid.uuid4()}_{filename}" dir_path = UPLOADS_DIR / Path(unique_filename).stem dir_path.mkdir(parents=True, exist_ok=True) filepath = dir_path / unique_filename # Save upload synchronously try: with open(filepath, "wb") as f_out: f_out.write(file.file.read()) except Exception as err: logger.error(f"Failed saving upload: {err}") return _json_response(success=False, message="Failed to save uploaded file") # RAG_DV processing out_path = filepath.parent / "rag_dv" try: RAG_DV(filepath, out_path) except Exception as err: logger.error(f"RAG_DV failed: {err}\n{traceback.format_exc()}") filepath.unlink(missing_ok=True) if not any(dir_path.iterdir()): dir_path.rmdir() return _json_response( success=False, message="Failed to process document. Please try again." ) if not (out_path / "index.html").exists(): return _json_response(success=False, message="Document processing incomplete.") request.session["uploaded_file"] = unique_filename request.session["original_filename"] = filename return _json_response( success=True, message="File successfully uploaded.", data={"filename": unique_filename, "original_filename": filename} ) @backend.post("/api/refresh") def refresh_session_ajax(request: Request): request.session.pop("uploaded_file", None) request.session.pop("original_filename", None) return _json_response(success=True, message="Started over successfully.") @backend.get("/load/{filename:path}") def load(request: Request, filename: str): if filename.startswith("assets"): asset_path = filename.replace("assets/", "") if "uploaded_file" not in request.session: logger.error("No active session for asset request") raise HTTPException(status_code=404, detail="No active session") # Log the request for debugging logger.info(f"Asset request: {asset_path}") logger.info(f"Uploaded file: {request.session.get('uploaded_file')}") uploaded_file = request.session["uploaded_file"] story_id = Path(uploaded_file).stem # This is our story_id base_dir = UPLOADS_DIR / story_id / "rag_dv" / "assets" # Construct the full file path file_path = base_dir / asset_path logger.info(f"Story ID: {story_id}") logger.info(f"Looking for asset at: {file_path}") logger.info(f"Base directory exists: {base_dir.exists()}") if base_dir.exists(): logger.info(f"Contents of assets dir: {list(base_dir.rglob('*'))}") if not file_path.exists() or not file_path.is_file(): logger.error(f"Asset not found: {file_path}") raise HTTPException(status_code=404, detail=f"Asset not found: {asset_path}") # Set appropriate content type based on file extension from mimetypes import guess_type content_type, _ = guess_type(str(file_path)) return FileResponse( file_path, media_type=content_type, headers={ "Cache-Control": "public, max-age=3600", # Cache for 1 hour "X-Story-ID": story_id # Custom header for debugging } ) else: filename = secure_filename(filename) filepath = UPLOADS_DIR / Path(filename).stem / filename idx_file = filepath.parent / "rag_dv" / "index.html" if not idx_file.exists(): raise HTTPException(status_code=404, detail="Document index not found.") logger.info(f"Loading document: {filename}") # Get the story_id (filename without extension and UUID prefix) story_id = Path(filename).stem # Construct base URL for assets base_url = str(request.base_url).rstrip('/') + f"/load" with open(idx_file, "r", encoding="utf-8") as f: content = f.read() # Rewrite URLs to use absolute paths # content = _rewrite_html_urls(content, base_url, story_id) logger.info(f"Document loaded with base URL: {base_url}") return HTMLResponse(content) # ----------------------------- Error handling ------------------------------ # @backend.exception_handler(HTTPException) def http_exception_handler(request: Request, exc: HTTPException): if exc.status_code == status.HTTP_413_REQUEST_ENTITY_TOO_LARGE: return _json_response( success=False, message="File is too large. Maximum size is 16MB." ) return JSONResponse( {"success": False, "message": str(exc.detail)}, status_code=exc.status_code ) @backend.exception_handler(Exception) def unhandled_exception(request: Request, exc: Exception): logger.error(f"Unhandled error: {exc}\n{traceback.format_exc()}") return _json_response( success=False, message="An unexpected error occurred. Please try again." ) # --------------------------------------------------------------------------- # # Gradio mounting (Blocks path = /gradio) # # --------------------------------------------------------------------------- # blocks = gr.Blocks() # no visual elements needed app = gr.mount_gradio_app(backend, blocks, path="/gradio") if __name__ == "__main__": import uvicorn uvicorn.run( "server:app", host="0.0.0.0", port=7860, reload=True, )