Upload 6 files

app.py

@@ -4,113 +4,192 @@ import sqlite3
 import json
 import re
 import PyPDF2
-import io
 import numpy as np
-from transformers import pipeline
+from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
 from sklearn.metrics.pairwise import cosine_similarity
 
+# Local imports
 from database1 import create_db
 from first1 import pdf_query
-from q_generator1 import QGenerator
+
 from ans_generator1 import AnswerGenerator
 
-# Models and tools
+import sqlite3, json
+from q_generator1 import QGenerator
+from transformers import pipeline
+# Initialize models
 qgen = QGenerator()
 ansgen = AnswerGenerator()
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 
+# Load FLAN-T5 model
 tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-base", use_fast=False)
 model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-base")
 qa_model = pipeline("text2text-generation", model=model, tokenizer=tokenizer)
 
 
-# ✅ Upload PDF and store to SQLite
-def upload_pdf(file):
+# ✅ Upload and process PDF
+# ✅ Updated version – supports multiple PDF files
+def upload_pdf(files):
     try:
-        filename = file.name
-        token = str(uuid.uuid4())
+        messages = []
 
-        pdf_reader = PyPDF2.PdfReader(file)
-        text = "".join([page.extract_text() or "" for page in pdf_reader.pages])
-        chunks = [text[i:i+500] for i in range(0, len(text), 500)]
+        for file in files:
+            filename = file.name
+            token = str(uuid.uuid4())
+
+            pdf_reader = PyPDF2.PdfReader(file)
+            text = "".join([page.extract_text() or "" for page in pdf_reader.pages])
+            chunks = [text[i:i + 500] for i in range(0, len(text), 500)]
+
+            create_db(token, chunks, filename, text)
+            messages.append(f"✅ Uploaded and stored: {filename} (Token: {token})")
+
+        return "\n".join(messages)
 
-        create_db(token, chunks, filename, text)
-        return f"✅ Uploaded and stored: {filename} (Token: {token})"
     except Exception as e:
         return f"❌ Error: {str(e)}"
 
-# ✅ Generate Q&A from filename
-def generate_qa(filename):
+
+
+# Load QG and QA once
+qgen = QGenerator()
+qa_model = pipeline("text2text-generation", model="google/flan-t5-base")
+def generate_qa(token):
     try:
+        if not token:
+            return "⚠️ Please provide a token."
+
+        print("📥 Received Token:", token)
+
+        # Load chunk_data using token
         with sqlite3.connect("my_database.db") as conn:
             cursor = conn.cursor()
-            cursor.execute("SELECT chunk_data FROM token_data WHERE filename = ?", (filename,))
+            cursor.execute("SELECT chunk_data FROM token_data WHERE token_id = ?", (token,))
             row = cursor.fetchone()
 
         if not row:
-            return "❌ No data found for this filename."
+            print("❌ No data found for token in DB.")
+            return "❌ No data found for this token."
 
         chunks = json.loads(row[0])
+        if not chunks:
+            print("⚠️ Chunk data is empty.")
+            return "⚠️ No content available in database for this PDF."
+
         qa_pairs = []
 
-        for chunk in chunks:
+        for i, chunk in enumerate(chunks):
+            print(f"\n🔹 Processing chunk {i+1}/{len(chunks)}")
             questions = qgen.generate(chunk)
+            print(f"🧠 Questions generated: {questions}")
+
             if not questions:
+                print("⚠️ No questions generated for this chunk.")
                 continue
-            question = questions[0]
-            prompt = f"Context: {chunk}\n\nQuestion: {question}\n\nAnswer:"
-            result = qa_model(prompt, max_length=256, do_sample=False)
-            answer = result[0]["generated_text"].strip()
-            qa_pairs.append(f"Q: {question}\nA: {answer}")
+
+            for question in questions[:2]:  # Max 2 Qs per chunk
+                prompt = f"Context: {chunk}\n\nQuestion: {question}\n\nAnswer:"
+                print(f"➡️ Prompt:\n{prompt}")
+
+                try:
+                    result = qa_model(prompt, max_length=256, do_sample=False)
+                    print(f"⬅️ Raw model output: {result}")
+
+                    if isinstance(result, list) and "generated_text" in result[0]:
+                        answer = result[0]["generated_text"].strip()
+                    elif isinstance(result, dict) and "answer" in result:
+                        answer = result["answer"].strip()
+                    else:
+                        answer = "N/A"
+
+                    print(f"✅ Final Answer: {answer}")
+                    qa_pairs.append(f"Q: {question}\nA: {answer}")
+
+                except Exception as e:
+                    print(f"❌ QA model failed: {e}")
+                    continue
+
+        if not qa_pairs:
+            print("⚠️ No Q&A pairs generated.")
+            return "⚠️ No Q&A pairs generated."
+
+        print("✅ Final Q&A generated successfully.")
         return "\n\n".join(qa_pairs)
+
     except Exception as e:
+        print(f"🔥 Exception in generate_qa(): {e}")
         return f"❌ Error: {str(e)}"
 
-# ✅ Ask a question using token (semantic similarity)
+
+# ✅ Ask question using token (semantic similarity)
 def ask_question(token, question):
     try:
         with sqlite3.connect("my_database.db") as conn:
             cursor = conn.cursor()
             cursor.execute("SELECT chunk_data FROM token_data WHERE token_id = ?", (token,))
             row = cursor.fetchone()
+
         if not row:
             return "❌ Token not found."
 
         chunks = json.loads(row[0])
         processor = pdf_query()
         model = processor.model
-        chunk_embeddings = model.encode(chunks)
+
+        clean_chunks = [re.sub(r'\s+', ' ', c.strip()) for c in chunks if c.strip()]
+        if not clean_chunks:
+            return "⚠️ No valid content found in PDF."
+
+        chunk_embeddings = model.encode(clean_chunks)
         q_embedding = model.encode([question])
         scores = cosine_similarity(q_embedding, chunk_embeddings)[0]
+
         top_index = int(np.argmax(scores))
         top_score = float(scores[top_index])
-        best_text = re.sub(r'\s+', ' ', chunks[top_index].strip())
+        best_text = clean_chunks[top_index]
+
+        return f"Q: {question}\nA: {best_text}\nScore: {round(top_score, 3)}"
 
-        if top_score >= 0.5:
-            return f"Q: {question}\nA: {best_text}\nScore: {round(top_score, 3)}"
-        else:
-            return "⚠️ No relevant answer found (score too low)."
     except Exception as e:
         return f"❌ Error: {str(e)}"
 
-# ✅ Gradio UI
-with gr.Blocks() as demo:
-    gr.Markdown("# 📄 PDF QA System")
 
-    with gr.Tab("1. Upload PDF"):
-        file = gr.File(label="Upload a PDF")
-        upload_out = gr.Textbox(label="Upload Result")
+
+
+
+
+# ✅ Gradio UI
+with gr.Blocks(theme="default") as demo:
+    gr.Markdown(
+        """
+        <div style='text-align: center; padding: 1rem;'>
+            <h1 style='color: #3b82f6;'>📄 AI-Powered PDF Q&A System</h1>
+            <p style='font-size: 1.1rem;'>Upload your PDFs, generate smart questions, and get intelligent answers.</p>
+        </div>
+        """
+    )
+
+    with gr.Tab("📤 1. Upload PDF"):
+        gr.Markdown("### 🗂 Upload a PDF File")
+        file = gr.File(label="Upload one or more PDFs", file_types=[".pdf"], file_count="multiple")
+
+        upload_out = gr.Textbox(label="Upload Result", interactive=False)
         file.change(fn=upload_pdf, inputs=file, outputs=upload_out)
 
-    with gr.Tab("2. Generate Q&A"):
-        fname = gr.Textbox(label="Enter uploaded filename")
-        qa_result = gr.Textbox(label="Q&A Output", lines=10)
-        gr.Button("Generate Q&A").click(fn=generate_qa, inputs=fname, outputs=qa_result)
+    with gr.Blocks(title="PDF Q&A Generator") as demo:
+        with gr.Tab("🧠 2. Generate Questions & Answers"):
+            gr.Markdown("### 🤖 Generate Questions and Answers from Uploaded PDF")
+            fname = gr.Textbox(label="📄 Enter Uploaded Filename", placeholder="example.pdf")
+            output_box = gr.Textbox(label="📝 Generated Q&A", lines=15, interactive=False)
+            gr.Button("🚀 Generate Q&A").click(fn=generate_qa, inputs=fname, outputs=output_box)
+
+    with gr.Tab("❓ 3. Ask a Question"):
+        gr.Markdown("### 💬 Ask a question based on uploaded PDF")
+        token_box = gr.Textbox(label="Token ID", placeholder="e.g., 123e4567-e89b-12d3-a456...")
+        question_box = gr.Textbox(label="Type your question", placeholder="What is the main topic discussed?")
+        answer_result = gr.Textbox(label="Answer Output", lines=6, interactive=False)
+        gr.Button("🎯 Get Answer").click(fn=ask_question, inputs=[token_box, question_box], outputs=answer_result)
 
-    with gr.Tab("3. Ask a Question"):
-        token_box = gr.Textbox(label="Enter Token ID")
-        question_box = gr.Textbox(label="Your Question")
-        answer_result = gr.Textbox(label="Answer", lines=5)
-        gr.Button("Ask").click(fn=ask_question, inputs=[token_box, question_box], outputs=answer_result)
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)
 
-demo.launch()

database1.py

@@ -6,7 +6,6 @@ class create_db:
         conn = sqlite3.connect('my_database.db')
         cursor = conn.cursor()
 
-        # Only store into this table
         cursor.execute("""
             CREATE TABLE IF NOT EXISTS token_data (
                 token_id TEXT PRIMARY KEY,
@@ -24,9 +23,9 @@ class create_db:
                 (token, chunk_json, filename, full_content)
             )
             conn.commit()
-            print({"message": "PDF uploaded and stored successfully"})
+            print({"message": f"✅ {filename} uploaded and stored successfully"})
         except sqlite3.IntegrityError:
-            print({"error": "Token already exists."})
+            print({"error": f"❌ Token already exists for: {filename}"})
 
         conn.close()
 
@@ -37,10 +36,4 @@ class create_db:
         cursor.execute("SELECT filename FROM token_data")
         rows = cursor.fetchall()
         conn.close()
-
-        if rows:
-            return {
-                "pdfs": [{"filename": row[0]} for row in rows]
-            }
-        else:
-            return {"pdfs": []}
+        return {"pdfs": [{"filename": row[0]} for row in rows]}

q_generator1.py

@@ -1,8 +1,8 @@
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, pipeline
+from transformers import T5Tokenizer, AutoModelForSeq2SeqLM, pipeline
 
 class QGenerator:
     def __init__(self):
-        tokenizer = AutoTokenizer.from_pretrained("valhalla/t5-small-qg-hl", use_fast=False)
+        tokenizer = T5Tokenizer.from_pretrained("valhalla/t5-small-qg-hl", use_fast=False)
         model = AutoModelForSeq2SeqLM.from_pretrained("valhalla/t5-small-qg-hl")
         self.qg = pipeline("text2text-generation", model=model, tokenizer=tokenizer)
 

requirements.txt

@@ -6,3 +6,8 @@ PyPDF2
 scikit-learn
 numpy
 uuid
+sentence_transformers
+sentencepiece
+tiktoken
+
+