Upload 4 files

qtAnswering/app.py

@@ -0,0 +1,73 @@
+### ✅ app.py — Document QA Backend (Cleaned)
+from fastapi import FastAPI
+from fastapi.responses import FileResponse, JSONResponse
+import fitz  # PyMuPDF
+import easyocr
+import openpyxl
+import pptx
+import docx
+from transformers import pipeline
+from gtts import gTTS
+import tempfile
+import os
+
+app = FastAPI()
+
+qa_model = pipeline("question-answering", model="deepset/roberta-base-squad2")
+reader = easyocr.Reader(['en', 'fr'])
+
+def extract_text_from_pdf(pdf_file):
+    try:
+        with fitz.open(pdf_file) as doc:
+            return "\n".join(page.get_text("text") for page in doc)
+    except Exception as e:
+        return f"Error reading PDF: {e}"
+
+def extract_text_from_docx(docx_file):
+    doc = docx.Document(docx_file)
+    return "\n".join(p.text for p in doc.paragraphs if p.text.strip())
+
+def extract_text_from_pptx(pptx_file):
+    try:
+        prs = pptx.Presentation(pptx_file)
+        return "\n".join(shape.text for slide in prs.slides for shape in slide.shapes if hasattr(shape, "text"))
+    except Exception as e:
+        return f"Error reading PPTX: {e}"
+
+def extract_text_from_xlsx(xlsx_file):
+    try:
+        wb = openpyxl.load_workbook(xlsx_file)
+        return "\n".join(" ".join(str(cell) for cell in row if cell) for sheet in wb.sheetnames for row in wb[sheet].iter_rows(values_only=True))
+    except Exception as e:
+        return f"Error reading XLSX: {e}"
+
+def answer_question_from_doc(file, question):
+    ext = file.filename.split(".")[-1].lower()
+    file_path = f"/tmp/{file.filename}"
+
+    with open(file_path, "wb") as f:
+        f.write(file.read())
+
+    if ext == "pdf":
+        context = extract_text_from_pdf(file_path)
+    elif ext == "docx":
+        context = extract_text_from_docx(file_path)
+    elif ext == "pptx":
+        context = extract_text_from_pptx(file_path)
+    elif ext == "xlsx":
+        context = extract_text_from_xlsx(file_path)
+    else:
+        return "Unsupported file format.", None
+
+    if not context.strip():
+        return "No text found in the document.", None
+
+    try:
+        result = qa_model({"question": question, "context": context})
+        answer = result["answer"]
+        tts = gTTS(answer)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
+            tts.save(tmp.name)
+            return answer, tmp.name
+    except Exception as e:
+        return f"Error generating answer: {e}", None

qtAnswering/appImage.py

@@ -0,0 +1,60 @@
+
+from fastapi import FastAPI
+from fastapi.responses import RedirectResponse, JSONResponse, FileResponse
+import os
+from PIL import Image
+from transformers import ViltProcessor, ViltForQuestionAnswering, pipeline
+from gtts import gTTS
+import easyocr
+import torch
+import tempfile
+import numpy as np
+from io import BytesIO
+
+app = FastAPI()
+
+vqa_processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-finetuned-vqa")
+vqa_model = ViltForQuestionAnswering.from_pretrained("dandelin/vilt-b32-finetuned-vqa")
+captioner = pipeline("image-to-text", model="nlpconnect/vit-gpt2-image-captioning")
+reader = easyocr.Reader(['en', 'fr'])
+
+def classify_question(question: str):
+    q = question.lower()
+    if any(w in q for w in ["text", "say", "written", "read"]):
+        return "ocr"
+    if any(w in q for w in ["caption", "describe", "what is in the image"]):
+        return "caption"
+    return "vqa"
+
+def answer_question_from_image(image, question):
+    if image is None or not question.strip():
+        return "Please upload an image and ask a question.", None
+
+    mode = classify_question(question)
+
+    try:
+        if mode == "ocr":
+            result = reader.readtext(np.array(image))
+            answer = " ".join([entry[1] for entry in result]) or "No readable text found."
+
+        elif mode == "caption":
+            answer = captioner(image)[0]['generated_text']
+
+        else:
+            inputs = vqa_processor(image, question, return_tensors="pt")
+            with torch.no_grad():
+                outputs = vqa_model(**inputs)
+            predicted_id = outputs.logits.argmax(-1).item()
+            answer = vqa_model.config.id2label[predicted_id]
+
+        tts = gTTS(text=answer)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
+            tts.save(tmp.name)
+            return answer, tmp.name
+
+    except Exception as e:
+        return f"Error: {e}", None
+
+@app.get("/")
+def home():
+    return RedirectResponse(url="/templates/home.html")

qtAnswering/main.py

@@ -0,0 +1,72 @@
+from fastapi import FastAPI, UploadFile, Form, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+import shutil, os
+from tempfile import gettempdir
+
+app = FastAPI()
+
+# ✅ CORS to allow frontend access
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ✅ Static assets
+app.mount("/resources", StaticFiles(directory="resources"), name="resources")
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# ✅ Jinja2 Templates
+templates = Jinja2Templates(directory="templates")
+
+# ✅ Serve Homepage
+@app.get("/", response_class=HTMLResponse)
+async def serve_home(request: Request):
+    return templates.TemplateResponse("home.html", {"request": request})
+
+# ✅ Predict endpoint (handles image + document)
+@app.post("/predict")
+async def predict(question: str = Form(...), file: UploadFile = Form(...)):
+    try:
+        temp_path = f"temp_{file.filename}"
+        with open(temp_path, "wb") as f:
+            shutil.copyfileobj(file.file, f)
+
+        is_image = file.content_type.startswith("image/")
+
+        if is_image:
+            from appImage import answer_question_from_image
+            from PIL import Image
+            image = Image.open(temp_path).convert("RGB")
+            answer, audio_path = answer_question_from_image(image, question)
+
+        else:
+            from app import answer_question_from_doc
+            class NamedFile:
+                def __init__(self, name): self.filename = name
+                def read(self): return open(self.filename, "rb").read()
+            answer, audio_path = answer_question_from_doc(NamedFile(temp_path), question)
+
+        os.remove(temp_path)
+
+        if audio_path and os.path.exists(audio_path):
+            return JSONResponse({
+                "answer": answer,
+                "audio": f"/audio/{os.path.basename(audio_path)}"
+            })
+        else:
+            return JSONResponse({"answer": answer})
+
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+# ✅ Serve audio
+@app.get("/audio/{filename}")
+async def get_audio(filename: str):
+    filepath = os.path.join(gettempdir(), filename)
+    return FileResponse(filepath, media_type="audio/mpeg")

qtAnswering/requirements.txt

@@ -0,0 +1,23 @@
+fastapi
+uvicorn
+gradio==3.50.2
+pandas
+matplotlib
+seaborn
+transformers
+torch
+pdfplumber
+python-docx
+pydantic<2.0
+tools
+openpyxl
+pytesseract
+deep-translator
+frontend
+pillow
+easyocr
+python-pptx
+pymupdf
+tika
+hf_xet
+gTTS