Update app.py

app.py

@@ -1,11 +1,12 @@
 import gradio as gr
-import pdfplumber, docx, sqlite3, random
+import pdfplumber, docx, sqlite3, os, random
 from datetime import datetime
 import pandas as pd
 from sentence_transformers import SentenceTransformer, util
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
 import torch
 from duckduckgo_search import DDGS
+from fpdf import FPDF
 
 # -----------------------------
 # CONFIG
@@ -13,6 +14,7 @@ from duckduckgo_search import DDGS
 DB_NAME = "db.sqlite3"
 USERNAME = "aixbi"
 PASSWORD = "aixbi@123"
+MAX_SENTENCES_CHECK = 10
 
 # -----------------------------
 # DB INIT
@@ -43,39 +45,38 @@ model = AutoModelForSequenceClassification.from_pretrained("hello-simpleai/chatg
 # -----------------------------
 # FUNCTIONS
 # -----------------------------
-def extract_text(file_path):
-    """Extracts text from PDF, DOCX, or TXT files given a file path."""
-    filepath = str(file_path)
-    
-    if filepath.endswith(".pdf"):
-        with pdfplumber.open(filepath) as pdf:
+def extract_text(file_obj):
+    name = file_obj.name
+    if name.endswith(".pdf"):
+        with pdfplumber.open(file_obj.name) as pdf:
             return " ".join(page.extract_text() for page in pdf.pages if page.extract_text())
-    elif filepath.endswith(".docx"):
-        doc = docx.Document(filepath)
+    elif name.endswith(".docx"):
+        doc = docx.Document(file_obj.name)
         return " ".join([p.text for p in doc.paragraphs])
-    else:  # txt
-        with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
-            return f.read()
+    else:
+        return file_obj.read().decode("utf-8")
 
 def detect_ai_text(text):
     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 * 100  # return as percentage
+    return score  # probability of AI-generated
 
-def live_plagiarism_check(sentences, n_samples=3):
-    """Randomly samples sentences and checks them online."""
+def live_plagiarism_check(sentences):
     ddgs = DDGS()
-    if not sentences:
-        return 0
-    samples = random.sample(sentences, min(n_samples, len(sentences)))
+    samples = random.sample(sentences, min(MAX_SENTENCES_CHECK, len(sentences)))
+    suspicious_sentences = []
     plagiarism_hits = 0
+
     for sentence in samples:
         results = list(ddgs.text(sentence, max_results=2))
         if results:
             plagiarism_hits += 1
-    return (plagiarism_hits / len(samples)) * 100
+            suspicious_sentences.append(sentence)
+
+    score = (plagiarism_hits / len(samples)) * 100 if samples else 0
+    return score, suspicious_sentences
 
 def save_result(student_id, student_name, ai_score, plagiarism_score):
     conn = sqlite3.connect(DB_NAME)
@@ -91,6 +92,30 @@ def load_results():
     conn.close()
     return df
 
+def generate_pdf_report(student_name, student_id, ai_score, plagiarism_score, suspicious_sentences, output_path):
+    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)
+    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.")
+
+    pdf.output(output_path)
+
 # -----------------------------
 # APP LOGIC
 # -----------------------------
@@ -100,42 +125,35 @@ def login(user, pwd):
     else:
         return gr.update(), gr.update(), "Invalid username or password!"
 
-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
-    
-    text = extract_text(file_path)
-    sentences = [s for s in text.split(". ") if len(s) > 20]
+def analyze(student_name, student_id, file_obj):
+    if file_obj 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)
-    
-    # Local similarity check
-    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
-    else:
-        local_score = 0
+    ai_score = detect_ai_text(text) * 100
 
-    # Live web check
-    live_score = live_plagiarism_check(sentences)
-    plagiarism_score = max(local_score, live_score)
+    # Live plagiarism
+    plagiarism_score, suspicious_sentences = live_plagiarism_check(sentences)
 
     # Save to DB
     save_result(student_id, student_name, ai_score, plagiarism_score)
 
-    return f"Analysis Completed for {student_name} ({student_id})", round(ai_score,2), round(plagiarism_score,2)
+    # 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
 
 def show_dashboard():
     df = load_results()
     return df
 
-# -----------------------------
-# GRADIO INTERFACE
-# -----------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("# AIxBI - Plagiarism & AI Detection")
+    gr.Markdown("# AIxBI - Professional Thesis Checker")
 
     # Login Section
     login_box = gr.Group(visible=True)
@@ -151,18 +169,20 @@ 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"], type="filepath")
+            file_upload = gr.File(label="Upload Document", file_types=[".pdf",".docx",".txt"])
             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")
+            
         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])
+    analyze_btn.click(analyze, inputs=[student_name, student_id, file_upload], outputs=[status, ai_score, plagiarism_score, pdf_output, suspicious_text])
     dashboard_btn.click(show_dashboard, outputs=[dashboard])
 
 if __name__ == "__main__":