hagras commited on
Commit
e8a03a6
·
verified ·
1 Parent(s): 277f74b

Update server.py

Browse files
Files changed (1) hide show
  1. server.py +57 -121
server.py CHANGED
@@ -1,22 +1,7 @@
1
  """
2
- Flask → Gradio/FastAPI rewrite
3
- ==============================
4
-
5
- All behaviour (routes, template, file handling, max-size checks, RAG_DV
6
- processing, session refresh, etc.) is preserved. Only the underlying web
7
- framework changed – now driven by Gradio (which itself runs on FastAPI /
8
- Uvicorn).
9
-
10
- To install the few extra deps:
11
-
12
- pip install gradio==4.* fastapi jinja2 python-multipart
13
-
14
- If you used Flask’s built-in dev server before, you can still start this file
15
- with `python server.py`, or with `uvicorn server:app --reload`.
16
  """
17
 
18
- from __future__ import annotations
19
-
20
  import logging
21
  import os
22
  import tempfile
@@ -26,23 +11,12 @@ from pathlib import Path
26
  from typing import List
27
 
28
  import gradio as gr
29
- from fastapi import (
30
- FastAPI,
31
- File,
32
- HTTPException,
33
- Request,
34
- Response,
35
- UploadFile,
36
- status,
37
- )
38
  from fastapi.responses import HTMLResponse, RedirectResponse, FileResponse
39
  from starlette.middleware.sessions import SessionMiddleware
40
  from starlette.responses import PlainTextResponse
41
  from werkzeug.utils import secure_filename # type: ignore
42
 
43
- # --------------------------------------------------------------------------- #
44
- # Optional RAG import (kept exactly as before) #
45
- # --------------------------------------------------------------------------- #
46
  try:
47
  from rag_document_viewer import RAG_DV
48
  except ImportError as err:
@@ -50,7 +24,7 @@ except ImportError as err:
50
  RAG_DV = None
51
 
52
  # --------------------------------------------------------------------------- #
53
- # Constants & config #
54
  # --------------------------------------------------------------------------- #
55
  SECRET_KEY = (
56
  "a&VhLelkAo!dKXm9o5RRHQ@#BxoI3Q5378qwFP&aJKA#PLjO7TU*Aq5Kwg4OTdMI7N3%wFAmnwezlEbPUdEQKhGJD10E8@0gSrS"
@@ -70,47 +44,40 @@ ALLOWED_EXTENSIONS = {
70
  "ods",
71
  }
72
 
73
- if os.getenv("SPACE_ID"): # running inside a HF Space
74
- UPLOADS_DIR = Path(tempfile.gettempdir()) / "uploads"
75
- else:
76
- UPLOADS_DIR = Path("uploads")
 
77
  UPLOADS_DIR.mkdir(exist_ok=True, parents=True)
78
 
79
- # --------------------------------------------------------------------------- #
80
- # Logging #
81
- # --------------------------------------------------------------------------- #
82
  logging.basicConfig(level=logging.INFO)
83
  logger = logging.getLogger("rag_dv_demo")
84
 
85
  # --------------------------------------------------------------------------- #
86
- # Helper utilities #
87
  # --------------------------------------------------------------------------- #
88
  def _allowed_file(name: str) -> bool:
89
  return "." in name and name.rsplit(".", 1)[1].lower() in ALLOWED_EXTENSIONS
90
 
91
 
92
  def _flash(request: Request, message: str) -> None:
93
- """
94
- Store a flash message in the user’s server-side session.
95
- The template pulls them via get_flashed_messages().
96
- """
97
  request.session.setdefault("flash_messages", []).append(message)
98
 
99
 
100
- def _redirect_with_flash(
101
- request: Request, message: str, endpoint_name: str = "index"
102
- ) -> Response:
103
  _flash(request, message)
104
- url = request.url_for(endpoint_name)
105
- return RedirectResponse(url, status_code=status.HTTP_303_SEE_OTHER)
 
106
 
107
 
108
  # --------------------------------------------------------------------------- #
109
- # Jinja2 template (identical to original) #
110
  # --------------------------------------------------------------------------- #
111
- from jinja2 import Template # noqa: E402 (import after constant section)
112
 
113
- HTML_TEMPLATE = """
114
  <!DOCTYPE html>
115
  <html lang="en">
116
  <head>
@@ -502,56 +469,44 @@ HTML_TEMPLATE = """
502
  </html>
503
  """
504
 
505
- # The string was abbreviated above to keep this snippet short. Please replace
506
- # it with the *entire* HTML_TEMPLATE from your Flask application.
507
- # --------------------------------------------------------------------------- #
508
-
509
  template = Template(HTML_TEMPLATE)
510
 
511
- # --------------------------------------------------------------------------- #
512
- # FastAPI application (used by Gradio) #
513
- # --------------------------------------------------------------------------- #
514
- backend = FastAPI()
515
- backend.add_middleware(
516
- SessionMiddleware,
517
- secret_key=SECRET_KEY,
518
- same_site="none", # <-- allow cross-site requests (iframe)
519
- https_only=True # <-- required when SameSite=None
520
- )
521
-
522
 
523
- # ───────────────────── change ONLY this helper ──────────────────────
524
  def render_template(request: Request, **ctx) -> HTMLResponse:
525
- """
526
- Render the stored Jinja2 template, exposing:
527
- • session – for {{ session.* }}
528
- • get_flashed_messages – like Flask
529
- • url_for – so {{ url_for('load', …) }} keeps working
530
- """
531
-
532
- def _get_flashed_messages() -> list[str]:
533
  return request.session.pop("flash_messages", [])
534
 
535
  rendered = template.render(
536
  session=request.session,
537
  get_flashed_messages=_get_flashed_messages,
538
- url_for=request.url_for, # ← add this line
539
  **ctx,
540
  )
541
  return HTMLResponse(rendered)
542
 
543
- # ------------------------------ ROUTES ------------------------------------ #
 
 
 
 
 
 
 
 
 
 
 
 
544
  @backend.get("/", name="index")
545
- def index(request: Request) -> Response:
546
  return render_template(request)
547
 
548
 
549
  @backend.post("/upload")
550
- def upload_file(request: Request, file: UploadFile = File(...)) -> Response:
551
- # -- validations (mostly identical to Flask version) --------------------- #
552
  if RAG_DV is None:
553
  return _redirect_with_flash(
554
- request, "RAG Document Viewer is not available. Please check the installation."
555
  )
556
 
557
  if not file.filename or not _allowed_file(file.filename):
@@ -559,7 +514,12 @@ def upload_file(request: Request, file: UploadFile = File(...)) -> Response:
559
  request, "Invalid file type. Please upload a supported document."
560
  )
561
 
562
- if file.size and file.size > MAX_CONTENT_LENGTH:
 
 
 
 
 
563
  return _redirect_with_flash(
564
  request, "File is too large. Maximum size is 16MB."
565
  )
@@ -569,20 +529,19 @@ def upload_file(request: Request, file: UploadFile = File(...)) -> Response:
569
  return _redirect_with_flash(request, "Invalid filename")
570
 
571
  unique_filename = f"{uuid.uuid4()}_{filename}"
572
- dir_name = Path(unique_filename).stem
573
- dir_path = UPLOADS_DIR / dir_name
574
  dir_path.mkdir(parents=True, exist_ok=True)
575
  filepath = dir_path / unique_filename
576
 
577
- # Save the file
578
  try:
579
- with open(filepath, "wb") as fout:
580
- fout.write(file.read())
581
  except Exception as err:
582
  logger.error(f"Failed saving upload: {err}")
583
  return _redirect_with_flash(request, "Failed to save uploaded file")
584
 
585
- # RAG_DV processing ------------------------------------------------------ #
586
  out_path = filepath.parent / "rag_dv"
587
  try:
588
  RAG_DV(filepath, out_path)
@@ -596,9 +555,7 @@ def upload_file(request: Request, file: UploadFile = File(...)) -> Response:
596
  )
597
 
598
  if not (out_path / "index.html").exists():
599
- return _redirect_with_flash(
600
- request, "Document processing incomplete. Please try again."
601
- )
602
 
603
  request.session["uploaded_file"] = unique_filename
604
  request.session["original_filename"] = filename
@@ -606,15 +563,14 @@ def upload_file(request: Request, file: UploadFile = File(...)) -> Response:
606
 
607
 
608
  @backend.get("/refresh")
609
- def refresh_session(request: Request) -> Response:
610
  request.session.pop("uploaded_file", None)
611
  request.session.pop("original_filename", None)
612
- url = request.url_for("index")
613
- return RedirectResponse(url, status_code=status.HTTP_303_SEE_OTHER)
614
 
615
 
616
  @backend.get("/load/{filename:path}")
617
- def load(request: Request, filename: str) -> Response:
618
  filename = secure_filename(filename)
619
  filepath = UPLOADS_DIR / Path(filename).stem / filename
620
  idx_file = filepath.parent / "rag_dv" / "index.html"
@@ -623,18 +579,11 @@ def load(request: Request, filename: str) -> Response:
623
  return _redirect_with_flash(request, "Document index not found.")
624
 
625
  with open(idx_file, "r", encoding="utf-8") as f:
626
- html = f.read()
627
-
628
- print(filename)
629
- print(html)
630
-
631
- return HTMLResponse(html)
632
 
633
 
634
  @backend.get("/load/assets/{asset_type}/{file_name:path}")
635
- def load_assets(
636
- request: Request, asset_type: str, file_name: str
637
- ) -> Response:
638
  if "uploaded_file" not in request.session:
639
  return _redirect_with_flash(request, "No active session")
640
 
@@ -648,7 +597,6 @@ def load_assets(
648
  / asset_type
649
  )
650
  file_path = base / file_name
651
-
652
  if not file_path.exists():
653
  return _redirect_with_flash(request, "Asset not found")
654
 
@@ -656,12 +604,12 @@ def load_assets(
656
 
657
 
658
  @backend.get("/file_size_error")
659
- def file_size_error(request: Request) -> Response:
660
  _flash(request, "File size too large. Please upload a file smaller than 16MB.")
661
  return RedirectResponse(request.url_for("index"), status_code=303)
662
 
663
 
664
- # ----------------------------- ERROR HANDLING ----------------------------- #
665
  @backend.exception_handler(HTTPException)
666
  def http_exception_handler(request: Request, exc: HTTPException):
667
  if exc.status_code == status.HTTP_413_REQUEST_ENTITY_TOO_LARGE:
@@ -680,24 +628,12 @@ def unhandled_exception(request: Request, exc: Exception):
680
 
681
 
682
  # --------------------------------------------------------------------------- #
683
- # Gradio mounting #
684
  # --------------------------------------------------------------------------- #
685
- blocks = gr.Blocks()
686
-
687
- with blocks:
688
- gr.HTML(
689
- value='<iframe src="/" style="width:100%;height:100vh;border:none;"></iframe>'
690
- )
691
-
692
- app = gr.mount_gradio_app(
693
- backend,
694
- blocks,
695
- path="/" # now Gradio owns "/" but simply iframes
696
- # your FastAPI index, so behaviour is the same
697
- )
698
 
699
- # Launch via `python server.py` or `uvicorn server:app --reload`
700
  if __name__ == "__main__":
701
  import uvicorn
702
 
703
- uvicorn.run("server:app", host="0.0.0.0", port=7860, reload=True)
 
1
  """
2
+ FastAPI-sync + Gradio (all route handlers are now synchronous)
 
 
 
 
 
 
 
 
 
 
 
 
 
3
  """
4
 
 
 
5
  import logging
6
  import os
7
  import tempfile
 
11
  from typing import List
12
 
13
  import gradio as gr
14
+ from fastapi import FastAPI, File, HTTPException, Request, Response, UploadFile, status
 
 
 
 
 
 
 
 
15
  from fastapi.responses import HTMLResponse, RedirectResponse, FileResponse
16
  from starlette.middleware.sessions import SessionMiddleware
17
  from starlette.responses import PlainTextResponse
18
  from werkzeug.utils import secure_filename # type: ignore
19
 
 
 
 
20
  try:
21
  from rag_document_viewer import RAG_DV
22
  except ImportError as err:
 
24
  RAG_DV = None
25
 
26
  # --------------------------------------------------------------------------- #
27
+ # Config / constants #
28
  # --------------------------------------------------------------------------- #
29
  SECRET_KEY = (
30
  "a&VhLelkAo!dKXm9o5RRHQ@#BxoI3Q5378qwFP&aJKA#PLjO7TU*Aq5Kwg4OTdMI7N3%wFAmnwezlEbPUdEQKhGJD10E8@0gSrS"
 
44
  "ods",
45
  }
46
 
47
+ UPLOADS_DIR = (
48
+ Path(tempfile.gettempdir()) / "uploads"
49
+ if os.getenv("SPACE_ID")
50
+ else Path("uploads")
51
+ )
52
  UPLOADS_DIR.mkdir(exist_ok=True, parents=True)
53
 
 
 
 
54
  logging.basicConfig(level=logging.INFO)
55
  logger = logging.getLogger("rag_dv_demo")
56
 
57
  # --------------------------------------------------------------------------- #
58
+ # Helpers #
59
  # --------------------------------------------------------------------------- #
60
  def _allowed_file(name: str) -> bool:
61
  return "." in name and name.rsplit(".", 1)[1].lower() in ALLOWED_EXTENSIONS
62
 
63
 
64
  def _flash(request: Request, message: str) -> None:
 
 
 
 
65
  request.session.setdefault("flash_messages", []).append(message)
66
 
67
 
68
+ def _redirect_with_flash(request: Request, message: str, endpoint: str = "index"):
 
 
69
  _flash(request, message)
70
+ return RedirectResponse(
71
+ request.url_for(endpoint), status_code=status.HTTP_303_SEE_OTHER
72
+ )
73
 
74
 
75
  # --------------------------------------------------------------------------- #
76
+ # Template #
77
  # --------------------------------------------------------------------------- #
78
+ from jinja2 import Template # noqa
79
 
80
+ HTML_TEMPLATE = HTML_TEMPLATE = """
81
  <!DOCTYPE html>
82
  <html lang="en">
83
  <head>
 
469
  </html>
470
  """
471
 
 
 
 
 
472
  template = Template(HTML_TEMPLATE)
473
 
 
 
 
 
 
 
 
 
 
 
 
474
 
 
475
  def render_template(request: Request, **ctx) -> HTMLResponse:
476
+ def _get_flashed_messages() -> List[str]:
 
 
 
 
 
 
 
477
  return request.session.pop("flash_messages", [])
478
 
479
  rendered = template.render(
480
  session=request.session,
481
  get_flashed_messages=_get_flashed_messages,
482
+ url_for=request.url_for, # make url_for available
483
  **ctx,
484
  )
485
  return HTMLResponse(rendered)
486
 
487
+
488
+ # --------------------------------------------------------------------------- #
489
+ # FastAPI (synchronous) #
490
+ # --------------------------------------------------------------------------- #
491
+ backend = FastAPI()
492
+ backend.add_middleware(
493
+ SessionMiddleware,
494
+ secret_key=SECRET_KEY,
495
+ same_site="none", # HF iframe needs SameSite=None
496
+ https_only=True,
497
+ )
498
+
499
+
500
  @backend.get("/", name="index")
501
+ def index(request: Request):
502
  return render_template(request)
503
 
504
 
505
  @backend.post("/upload")
506
+ def upload_file(request: Request, file: UploadFile = File(...)):
 
507
  if RAG_DV is None:
508
  return _redirect_with_flash(
509
+ request, "RAG Document Viewer is not available. Please check installation."
510
  )
511
 
512
  if not file.filename or not _allowed_file(file.filename):
 
514
  request, "Invalid file type. Please upload a supported document."
515
  )
516
 
517
+ # FastAPI already enforces MAX_CONTENT_LENGTH for UploadFile objects only
518
+ # when reading them. We do the check manually:
519
+ file.file.seek(0, 2) # go to end
520
+ size = file.file.tell()
521
+ file.file.seek(0)
522
+ if size > MAX_CONTENT_LENGTH:
523
  return _redirect_with_flash(
524
  request, "File is too large. Maximum size is 16MB."
525
  )
 
529
  return _redirect_with_flash(request, "Invalid filename")
530
 
531
  unique_filename = f"{uuid.uuid4()}_{filename}"
532
+ dir_path = UPLOADS_DIR / Path(unique_filename).stem
 
533
  dir_path.mkdir(parents=True, exist_ok=True)
534
  filepath = dir_path / unique_filename
535
 
536
+ # Save upload synchronously
537
  try:
538
+ with open(filepath, "wb") as f_out:
539
+ f_out.write(file.file.read())
540
  except Exception as err:
541
  logger.error(f"Failed saving upload: {err}")
542
  return _redirect_with_flash(request, "Failed to save uploaded file")
543
 
544
+ # RAG_DV processing
545
  out_path = filepath.parent / "rag_dv"
546
  try:
547
  RAG_DV(filepath, out_path)
 
555
  )
556
 
557
  if not (out_path / "index.html").exists():
558
+ return _redirect_with_flash(request, "Document processing incomplete.")
 
 
559
 
560
  request.session["uploaded_file"] = unique_filename
561
  request.session["original_filename"] = filename
 
563
 
564
 
565
  @backend.get("/refresh")
566
+ def refresh_session(request: Request):
567
  request.session.pop("uploaded_file", None)
568
  request.session.pop("original_filename", None)
569
+ return RedirectResponse(request.url_for("index"), status_code=303)
 
570
 
571
 
572
  @backend.get("/load/{filename:path}")
573
+ def load(request: Request, filename: str):
574
  filename = secure_filename(filename)
575
  filepath = UPLOADS_DIR / Path(filename).stem / filename
576
  idx_file = filepath.parent / "rag_dv" / "index.html"
 
579
  return _redirect_with_flash(request, "Document index not found.")
580
 
581
  with open(idx_file, "r", encoding="utf-8") as f:
582
+ return HTMLResponse(f.read())
 
 
 
 
 
583
 
584
 
585
  @backend.get("/load/assets/{asset_type}/{file_name:path}")
586
+ def load_assets(request: Request, asset_type: str, file_name: str):
 
 
587
  if "uploaded_file" not in request.session:
588
  return _redirect_with_flash(request, "No active session")
589
 
 
597
  / asset_type
598
  )
599
  file_path = base / file_name
 
600
  if not file_path.exists():
601
  return _redirect_with_flash(request, "Asset not found")
602
 
 
604
 
605
 
606
  @backend.get("/file_size_error")
607
+ def file_size_error(request: Request):
608
  _flash(request, "File size too large. Please upload a file smaller than 16MB.")
609
  return RedirectResponse(request.url_for("index"), status_code=303)
610
 
611
 
612
+ # ----------------------------- Error handling ------------------------------ #
613
  @backend.exception_handler(HTTPException)
614
  def http_exception_handler(request: Request, exc: HTTPException):
615
  if exc.status_code == status.HTTP_413_REQUEST_ENTITY_TOO_LARGE:
 
628
 
629
 
630
  # --------------------------------------------------------------------------- #
631
+ # Gradio mounting (Blocks path = /gradio) #
632
  # --------------------------------------------------------------------------- #
633
+ blocks = gr.Blocks() # no visual elements needed
634
+ app = gr.mount_gradio_app(backend, blocks, path="/gradio")
 
 
 
 
 
 
 
 
 
 
 
635
 
 
636
  if __name__ == "__main__":
637
  import uvicorn
638
 
639
+ uvicorn.run(app, host="0.0.0.0", port=7860, reload=True)