Update app.py

app.py

@@ -1,5 +1,5 @@
 import gradio as gr
-import pdfplumber, docx, sqlite3, os, random
+import pdfplumber, docx, sqlite3, random, os
 from datetime import datetime
 import pandas as pd
 from sentence_transformers import SentenceTransformer, util
@@ -7,14 +7,19 @@ from transformers import AutoTokenizer, AutoModelForSequenceClassification
 import torch
 from duckduckgo_search import DDGS
 from fpdf import FPDF
+import qrcode
+from PIL import Image
 
 # -----------------------------
 # CONFIG
 # -----------------------------
 DB_NAME = "db.sqlite3"
+REPORT_DIR = "reports"
+LOGO_PATH = "aixbi.jpg"  # Place your uploaded logo in the root
 USERNAME = "aixbi"
 PASSWORD = "aixbi@123"
-MAX_SENTENCES_CHECK = 10
+
+os.makedirs(REPORT_DIR, exist_ok=True)
 
 # -----------------------------
 # DB INIT
@@ -45,38 +50,38 @@ model = AutoModelForSequenceClassification.from_pretrained("hello-simpleai/chatg
 # -----------------------------
 # FUNCTIONS
 # -----------------------------
-def extract_text(file_obj):
-    name = file_obj.name
-    if name.endswith(".pdf"):
-        with pdfplumber.open(file_obj.name) as pdf:
+def extract_text(file_path: str):
+    filepath = str(file_path)
+    if filepath.endswith(".pdf"):
+        with pdfplumber.open(filepath) as pdf:
             return " ".join(page.extract_text() for page in pdf.pages if page.extract_text())
-    elif name.endswith(".docx"):
-        doc = docx.Document(file_obj.name)
+    elif filepath.endswith(".docx"):
+        doc = docx.Document(filepath)
         return " ".join([p.text for p in doc.paragraphs])
-    else:
-        return file_obj.read().decode("utf-8")
+    else:  # txt
+        with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
+            return f.read()
 
-def detect_ai_text(text):
+def detect_ai_text(text: str):
     inputs = tokenizer(text[:512], return_tensors="pt", truncation=True)
     with torch.no_grad():
         outputs = model(**inputs)
     score = torch.softmax(outputs.logits, dim=1)[0][1].item()
-    return score  # probability of AI-generated
+    return score * 100
 
-def live_plagiarism_check(sentences):
+def live_plagiarism_check(sentences, n_samples=3):
     ddgs = DDGS()
-    samples = random.sample(sentences, min(MAX_SENTENCES_CHECK, len(sentences)))
-    suspicious_sentences = []
+    if not sentences:
+        return 0, []
+    samples = random.sample(sentences, min(n_samples, len(sentences)))
     plagiarism_hits = 0
-
+    top_sentences = []
     for sentence in samples:
         results = list(ddgs.text(sentence, max_results=2))
         if results:
             plagiarism_hits += 1
-            suspicious_sentences.append(sentence)
-
-    score = (plagiarism_hits / len(samples)) * 100 if samples else 0
-    return score, suspicious_sentences
+            top_sentences.append(sentence)
+    return (plagiarism_hits / len(samples)) * 100, top_sentences
 
 def save_result(student_id, student_name, ai_score, plagiarism_score):
     conn = sqlite3.connect(DB_NAME)
@@ -92,29 +97,51 @@ def load_results():
     conn.close()
     return df
 
-def generate_pdf_report(student_name, student_id, ai_score, plagiarism_score, suspicious_sentences, output_path):
+def generate_pdf_report(student_name, student_id, ai_score, plagiarism_score, top_sentences):
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    verdict = "Likely Original"
+    if ai_score > 70 or plagiarism_score > 50:
+        verdict = "⚠ High AI/Plagiarism Risk"
+    elif ai_score > 40 or plagiarism_score > 30:
+        verdict = "Moderate Risk"
+
+    filename = f"{REPORT_DIR}/Report_{student_id}_{int(datetime.now().timestamp())}.pdf"
+    
     pdf = FPDF()
     pdf.add_page()
-    pdf.set_font("Arial", size=12)
 
-    pdf.cell(200, 10, txt="AIxBI - Student Thesis Analysis Report", ln=True, align='C')
-    pdf.ln(10)
-    pdf.cell(200, 10, txt=f"Student: {student_name} ({student_id})", ln=True)
-    pdf.cell(200, 10, txt=f"AI Probability: {ai_score:.2f}%", ln=True)
-    pdf.cell(200, 10, txt=f"Plagiarism Score: {plagiarism_score:.2f}%", ln=True)
-    pdf.cell(200, 10, txt=f"Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", ln=True)
+    # Add Logo
+    if os.path.exists(LOGO_PATH):
+        pdf.image(LOGO_PATH, 10, 8, 33)
+
+    pdf.set_font("Arial", "B", 18)
+    pdf.cell(200, 20, "AIxBI - Thesis Analysis Report", ln=True, align="C")
+    pdf.ln(20)
+
+    pdf.set_font("Arial", size=12)
+    pdf.cell(200, 10, f"Student Name: {student_name}", ln=True)
+    pdf.cell(200, 10, f"Student ID: {student_id}", ln=True)
+    pdf.cell(200, 10, f"AI Probability: {ai_score:.2f}%", ln=True)
+    pdf.cell(200, 10, f"Plagiarism Score: {plagiarism_score:.2f}%", ln=True)
+    pdf.cell(200, 10, f"Verdict: {verdict}", ln=True)
+    pdf.cell(200, 10, f"Analysis Date: {timestamp}", ln=True)
     pdf.ln(10)
 
-    pdf.multi_cell(0, 10, txt="Suspicious Sentences (Possible Plagiarism or AI-generated):")
-    pdf.ln(5)
-    if suspicious_sentences:
-        for s in suspicious_sentences:
-            pdf.multi_cell(0, 10, f"- {s}")
-            pdf.ln(2)
-    else:
-        pdf.multi_cell(0, 10, "None detected.")
+    # Highlight top plagiarized sentences
+    if top_sentences:
+        pdf.set_text_color(255, 0, 0)
+        pdf.multi_cell(0, 10, "Top Plagiarized Sentences:\n" + "\n\n".join(top_sentences))
+        pdf.set_text_color(0, 0, 0)
+
+    # Generate QR Code
+    qr_data = f"AIxBI Verification\nID:{student_id}\nAI:{ai_score:.2f}% Plag:{plagiarism_score:.2f}%\nTime:{timestamp}"
+    qr_img = qrcode.make(qr_data)
+    qr_path = "qr_temp.png"
+    qr_img.save(qr_path)
+    pdf.image(qr_path, x=160, y=230, w=40)
 
-    pdf.output(output_path)
+    pdf.output(filename)
+    return filename
 
 # -----------------------------
 # APP LOGIC
@@ -125,35 +152,38 @@ def login(user, pwd):
     else:
         return gr.update(), gr.update(), "Invalid username or password!"
 
-def analyze(student_name, student_id, file_obj):
-    if file_obj is None or not student_name or not student_id:
+def analyze(student_name, student_id, file_path):
+    if file_path is None or not student_name or not student_id:
         return "Please fill all fields and upload a document.", None, None, None
     
-    text = extract_text(file_obj)
-    sentences = [s.strip() for s in text.split(". ") if len(s) > 30]
-
-    # AI Detection
-    ai_score = detect_ai_text(text) * 100
+    text = extract_text(file_path)
+    sentences = [s for s in text.split(". ") if len(s) > 20]
+    
+    ai_score = detect_ai_text(text)
+    local_score = 0
+    if sentences:
+        embeddings = embedder.encode(sentences, convert_to_tensor=True)
+        cosine_scores = util.cos_sim(embeddings, embeddings)
+        local_score = (cosine_scores > 0.95).float().mean().item() * 100
 
-    # Live plagiarism
-    plagiarism_score, suspicious_sentences = live_plagiarism_check(sentences)
+    live_score, top_sentences = live_plagiarism_check(sentences)
+    plagiarism_score = max(local_score, live_score)
 
-    # Save to DB
     save_result(student_id, student_name, ai_score, plagiarism_score)
+    pdf_path = generate_pdf_report(student_name, student_id, ai_score, plagiarism_score, top_sentences)
 
-    # Generate PDF Report
-    output_pdf = f"{student_id}_report.pdf"
-    generate_pdf_report(student_name, student_id, ai_score, plagiarism_score, suspicious_sentences, output_pdf)
-
-    highlighted_text = "\n\n".join([f"⚠️ {s}" for s in suspicious_sentences]) if suspicious_sentences else "No suspicious sentences found."
-    return f"Analysis Completed for {student_name} ({student_id})", round(ai_score,2), round(plagiarism_score,2), output_pdf, highlighted_text
+    return f"Analysis Completed for {student_name} ({student_id})", round(ai_score,2), round(plagiarism_score,2), pdf_path
 
 def show_dashboard():
     df = load_results()
     return df
 
+# -----------------------------
+# GRADIO INTERFACE
+# -----------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("# AIxBI - Professional Thesis Checker")
+    gr.Image(LOGO_PATH, label="AIxBI", show_label=False)
+    gr.Markdown("# AIxBI - Plagiarism & AI Detection with PDF Reports")
 
     # Login Section
     login_box = gr.Group(visible=True)
@@ -169,20 +199,19 @@ with gr.Blocks() as demo:
         with gr.Tab("Check Thesis"):
             student_name = gr.Textbox(label="Student Name")
             student_id = gr.Textbox(label="Student ID")
-            file_upload = gr.File(label="Upload Document", file_types=[".pdf",".docx",".txt"])
+            file_upload = gr.File(label="Upload Document", file_types=[".pdf",".docx",".txt"], type="filepath")
             analyze_btn = gr.Button("Analyze Document")
             status = gr.Textbox(label="Status")
             ai_score = gr.Number(label="AI Probability (%)")
             plagiarism_score = gr.Number(label="Plagiarism Score (%)")
-            suspicious_text = gr.Textbox(label="Suspicious Sentences Highlight", lines=10)
-            pdf_output = gr.File(label="Download PDF Report")
-            
+            pdf_report = gr.File(label="Download PDF Report")
+
         with gr.Tab("Summary Dashboard"):
             dashboard_btn = gr.Button("Refresh Dashboard")
             dashboard = gr.Dataframe(headers=["id","student_id","student_name","ai_score","plagiarism_score","timestamp"])
 
     login_btn.click(login, inputs=[user, pwd], outputs=[login_box, app_box, login_msg])
-    analyze_btn.click(analyze, inputs=[student_name, student_id, file_upload], outputs=[status, ai_score, plagiarism_score, pdf_output, suspicious_text])
+    analyze_btn.click(analyze, inputs=[student_name, student_id, file_upload], outputs=[status, ai_score, plagiarism_score, pdf_report])
     dashboard_btn.click(show_dashboard, outputs=[dashboard])
 
 if __name__ == "__main__":