Update app.py

app.py

@@ -1,25 +1,21 @@
 import gradio as gr
-import pdfplumber, docx, sqlite3, random, os
+import pdfplumber, docx, sqlite3, os, random
 from datetime import datetime
 import pandas as pd
-from sentence_transformers import SentenceTransformer, util
+from sentence_transformers import SentenceTransformer
 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"
-
-os.makedirs(REPORT_DIR, exist_ok=True)
+MAX_SENTENCES_CHECK = 10
+LOGO_PATH = "aixbi.jpg"  # Place your logo here
 
 # -----------------------------
 # DB INIT
@@ -44,44 +40,52 @@ init_db()
 # MODEL LOADING
 # -----------------------------
 embedder = SentenceTransformer('all-MiniLM-L6-v2')
-tokenizer = AutoTokenizer.from_pretrained("hello-simpleai/chatgpt-detector-roberta")
-model = AutoModelForSequenceClassification.from_pretrained("hello-simpleai/chatgpt-detector-roberta")
+tokenizer = AutoTokenizer.from_pretrained("SuperAnnotate/ai-detector")
+model = AutoModelForSequenceClassification.from_pretrained("SuperAnnotate/ai-detector")
 
 # -----------------------------
-# FUNCTIONS
+# SAFE TEXT EXTRACTION
 # -----------------------------
-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 filepath.endswith(".docx"):
-        doc = docx.Document(filepath)
-        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()
-
-def detect_ai_text(text: str):
+def extract_text(file_obj):
+    try:
+        name = file_obj.name
+        if name.endswith(".pdf"):
+            with pdfplumber.open(file_obj.name) as pdf:
+                text = " ".join(page.extract_text() or "" for page in pdf.pages)
+                return text.strip() if text else None
+        elif name.endswith(".docx"):
+            doc = docx.Document(file_obj.name)
+            text = " ".join([p.text for p in doc.paragraphs])
+            return text.strip() if text else None
+        elif name.endswith(".txt"):
+            text = file_obj.read().decode("utf-8", errors="ignore")
+            return text.strip() if text else None
+        else:
+            return None
+    except Exception:
+        return None
+
+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 score  # probability of AI-generated
 
-def live_plagiarism_check(sentences, n_samples=3):
+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
-    top_sentences = []
+
     for sentence in samples:
         results = list(ddgs.text(sentence, max_results=2))
         if results:
             plagiarism_hits += 1
-            top_sentences.append(sentence)
-    return (plagiarism_hits / len(samples)) * 100, top_sentences
+            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)
@@ -97,51 +101,54 @@ def load_results():
     conn.close()
     return df
 
-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 REPORT WITH LOGO & COLORS
+# -----------------------------
+class HighlightPDF(FPDF):
+    def add_highlighted_sentence(self, sentence, color):
+        self.set_fill_color(*color)
+        self.multi_cell(0, 10, sentence, fill=True)
+        self.ln(1)
+
+def generate_pdf_report(student_name, student_id, ai_score, plagiarism_score, suspicious_sentences, sample_text, output_path):
+    pdf = HighlightPDF()
     pdf.add_page()
 
-    # Add Logo
+    # Add logo
     if os.path.exists(LOGO_PATH):
-        pdf.image(LOGO_PATH, 10, 8, 33)
+        pdf.image(LOGO_PATH, 10, 8, 20, 20)
 
-    pdf.set_font("Arial", "B", 18)
-    pdf.cell(200, 20, "AIxBI - Thesis Analysis Report", ln=True, align="C")
+    pdf.set_font("Arial", style='B', size=14)
+    pdf.cell(200, 10, txt="AIxBI - Ultimate Document Plagiarism 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.multi_cell(0, 10, txt=f"Student: {student_name} ({student_id})")
+    pdf.multi_cell(0, 10, txt=f"AI Probability: {ai_score:.2f}%")
+    pdf.multi_cell(0, 10, txt=f"Plagiarism Score: {plagiarism_score:.2f}%")
+    pdf.multi_cell(0, 10, txt=f"Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
     pdf.ln(10)
 
-    # 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)
+    pdf.multi_cell(0, 10, txt="Suspicious Sentences Detected:")
+    if suspicious_sentences:
+        for s in suspicious_sentences:
+            pdf.add_highlighted_sentence(f"- {s}", (255, 200, 200))  # Red for suspicious
+    else:
+        pdf.multi_cell(0, 10, "None detected.")
+    pdf.ln(10)
 
-    # 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.multi_cell(0, 10, txt="Sample Detected Text (AI/Plagiarized Excerpt):")
+    pdf.add_highlighted_sentence(sample_text, (255, 230, 200))  # Orange
+    pdf.ln(10)
 
-    pdf.output(filename)
-    return filename
+    pdf.multi_cell(0, 10, txt="Recommendations for Student:")
+    recommendations = """1. Rewrite detected sentences in your own words.
+2. Add citations for any copied or referenced material.
+3. Avoid using AI content directly—use as guidance, not verbatim.
+4. Use plagiarism tools and proofread before submission."""
+    pdf.multi_cell(0, 10, recommendations)
+
+    pdf.output(output_path)
 
 # -----------------------------
 # APP LOGIC
@@ -152,66 +159,80 @@ 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, None
-    
-    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
+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, None
+
+    text = extract_text(file_obj)
+    if not text:
+        return "Error: Could not read the file. Please upload a valid PDF, DOCX, or TXT.", None, None, None, None
+
+    sentences = [s.strip() for s in text.split(". ") if len(s) > 30]
 
-    live_score, top_sentences = live_plagiarism_check(sentences)
-    plagiarism_score = max(local_score, live_score)
+    # AI Detection
+    ai_score = detect_ai_text(text) * 100
 
+    # Live plagiarism
+    plagiarism_score, suspicious_sentences = live_plagiarism_check(sentences)
+
+    # Pick a sample suspicious excerpt for report
+    sample_text = suspicious_sentences[0] if suspicious_sentences else text[:200]
+
+    # 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)
 
-    return f"Analysis Completed for {student_name} ({student_id})", round(ai_score,2), round(plagiarism_score,2), pdf_path
+    # Generate PDF Report
+    output_pdf = f"{student_id}_report.pdf"
+    generate_pdf_report(
+        student_name, student_id, ai_score, plagiarism_score,
+        suspicious_sentences, sample_text, 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
+# GRADIO UI (LIGHT THEME & LOGO)
 # -----------------------------
-with gr.Blocks() as demo:
-    gr.Image(LOGO_PATH, label="AIxBI", show_label=False)
-    gr.Markdown("# AIxBI - Plagiarism & AI Detection with PDF Reports")
+with gr.Blocks(theme="default") as demo:
+    with gr.Row():
+        if os.path.exists(LOGO_PATH):
+            gr.Image(LOGO_PATH, elem_id="logo", show_label=False, scale=0.2)
+        gr.Markdown("## **AIxBI - Ultimate Document Plagiarism Software**\n#### Professional Thesis & AI Content Detector", elem_id="title")
 
     # Login Section
     login_box = gr.Group(visible=True)
     with login_box:
         user = gr.Textbox(label="Username")
         pwd = gr.Textbox(label="Password", type="password")
-        login_btn = gr.Button("Login")
+        login_btn = gr.Button("Login", variant="primary")
         login_msg = gr.Markdown("")
     
     # Main App
     app_box = gr.Group(visible=False)
     with app_box:
         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")
-            analyze_btn = gr.Button("Analyze Document")
+            with gr.Row():
+                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"])
+            analyze_btn = gr.Button("Analyze Document", variant="primary")
             status = gr.Textbox(label="Status")
             ai_score = gr.Number(label="AI Probability (%)")
             plagiarism_score = gr.Number(label="Plagiarism Score (%)")
-            pdf_report = gr.File(label="Download PDF Report")
-
+            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_btn = gr.Button("Refresh Dashboard", variant="secondary")
             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_report])
+    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__":