Create app.py

app.py

@@ -0,0 +1,157 @@
+import gradio as gr
+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
+
+# -----------------------------
+# CONFIG
+# -----------------------------
+DB_NAME = "db.sqlite3"
+USERNAME = "aixbi"
+PASSWORD = "aixbi@123"
+
+# -----------------------------
+# DB INIT
+# -----------------------------
+def init_db():
+    conn = sqlite3.connect(DB_NAME)
+    c = conn.cursor()
+    c.execute("""CREATE TABLE IF NOT EXISTS results (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    student_id TEXT,
+                    student_name TEXT,
+                    ai_score REAL,
+                    plagiarism_score REAL,
+                    timestamp TEXT
+                )""")
+    conn.commit()
+    conn.close()
+
+init_db()
+
+# -----------------------------
+# MODEL LOADING (only once)
+# -----------------------------
+embedder = SentenceTransformer('all-MiniLM-L6-v2')
+tokenizer = AutoTokenizer.from_pretrained("hello-simpleai/chatgpt-detector-roberta")
+model = AutoModelForSequenceClassification.from_pretrained("hello-simpleai/chatgpt-detector-roberta")
+
+# -----------------------------
+# FUNCTIONS
+# -----------------------------
+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 name.endswith(".docx"):
+        doc = docx.Document(file_obj.name)
+        return " ".join([p.text for p in doc.paragraphs])
+    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  # probability of AI-generated
+
+def live_plagiarism_check(sentences, n_samples=3):
+    ddgs = DDGS()
+    samples = random.sample(sentences, min(n_samples, len(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
+
+def save_result(student_id, student_name, ai_score, plagiarism_score):
+    conn = sqlite3.connect(DB_NAME)
+    c = conn.cursor()
+    c.execute("INSERT INTO results (student_id, student_name, ai_score, plagiarism_score, timestamp) VALUES (?,?,?,?,?)",
+              (student_id, student_name, ai_score, plagiarism_score, datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
+    conn.commit()
+    conn.close()
+
+def load_results():
+    conn = sqlite3.connect(DB_NAME)
+    df = pd.read_sql_query("SELECT * FROM results", conn)
+    conn.close()
+    return df
+
+# -----------------------------
+# APP LOGIC
+# -----------------------------
+def login(user, pwd):
+    if user == USERNAME and pwd == PASSWORD:
+        return gr.update(visible=False), gr.update(visible=True), ""
+    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:
+        return "Please fill all fields and upload a document.", None, None
+    
+    text = extract_text(file_obj)
+    sentences = [s for s in text.split(". ") if len(s) > 20]
+    
+    # AI Detection
+    ai_score = detect_ai_text(text) * 100
+    
+    # Local similarity
+    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 web check
+    live_score = live_plagiarism_check(sentences)
+    plagiarism_score = max(local_score, live_score)
+
+    # 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)
+
+def show_dashboard():
+    df = load_results()
+    return df
+
+with gr.Blocks() as demo:
+    gr.Markdown("# AIxBI - Plagiarism & AI Detection")
+
+    # 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_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"])
+            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 (%)")
+
+        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])
+    dashboard_btn.click(show_dashboard, outputs=[dashboard])
+
+if __name__ == "__main__":
+    demo.launch()