Update app.py

app.py

@@ -1,9 +1,8 @@
 import json
-import random
-import difflib
 import os
 import csv
-import datetime
+import re
+from difflib import SequenceMatcher
 import gradio as gr
 
 # -----------------------------
@@ -11,136 +10,175 @@ import gradio as gr
 # -----------------------------
 DATA_PATH = "quotes.json"
 
-if os.path.exists(DATA_PATH):
-    with open(DATA_PATH, "r") as f:
-        dataset = json.load(f)
-else:
-    dataset = {"staged_responses": []}
+def load_dataset():
+    if os.path.exists(DATA_PATH):
+        with open(DATA_PATH, "r") as f:
+            data = json.load(f)
+            print(f"Loaded dataset from {DATA_PATH} with {len(data.keys())} categories.")
+            for cat, quotes in data.items():
+                print(f" - {cat}: {len(quotes)} entries")
+            return data
+    else:
+        print("No dataset found, starting with empty structure")
+        return {"staged_responses": []}
 
+dataset = load_dataset()
 
 # -----------------------------
-# Helpers
+# Matching logic
 # -----------------------------
-def find_best_quotes(category, user_input, top_n=3, threshold=0.4):
-    """Find top_n most similar quotes for a category or return fallback if none match well"""
+def normalize_text(s: str) -> str:
+    return re.sub(r'\W+', ' ', (s or "").lower()).strip()
+
+def tokens(s: str):
+    return set(t for t in normalize_text(s).split() if t)
+
+def find_best_quotes(category, user_input, top_n=3, threshold=0.15):
     if category not in dataset or not dataset[category]:
         return [f"No data about {user_input} (unknown)."]
 
-    quotes = [q["quote"] for q in dataset[category]]
-    scores = [difflib.SequenceMatcher(None, user_input.lower(), q.lower()).ratio() for q in quotes]
+    user_toks = tokens(user_input)
+    scored = []
+
+    for entry in dataset[category]:
+        qtext = entry.get("quote", "")
+        q_toks = tokens(qtext)
+
+        # Token overlap match
+        overlap = len(user_toks & q_toks)
+        if overlap > 0:
+            score = 1.0 + (overlap / max(1, len(q_toks)))
+        else:
+            # Fuzzy fallback
+            score = SequenceMatcher(None, user_input.lower(), qtext.lower()).ratio()
+
+        scored.append((score, qtext))
 
-    # Pair scores with quotes and sort
-    scored_quotes = sorted(zip(scores, quotes), key=lambda x: x[0], reverse=True)
+    scored.sort(key=lambda x: x[0], reverse=True)
+    best_score = scored[0][0] if scored else 0.0
 
-    best_score = scored_quotes[0][0] if scored_quotes else 0
     if best_score < threshold:
         return [f"No data about {user_input} (unknown)."]
 
-    return [q for _, q in scored_quotes[:top_n]]
+    return [q for _s, q in scored[:top_n]]
 
+# -----------------------------
+# Response generation
+# -----------------------------
+def generate_response(category, user_input):
+    best_quotes = find_best_quotes(category, user_input, top_n=3)
 
-def save_conversation_to_staged(messages, category):
-    """Stage conversation under chosen category in dataset (downloadable)"""
-    if not messages:
-        return "No conversation to stage."
+    if len(best_quotes) == 1 and best_quotes[0].startswith("No data"):
+        return (
+            f"Summary: {best_quotes[0]}",
+            f"Fusion: {best_quotes[0]}",
+            f"Reference: None"
+        )
 
-    convo_text = " ".join([msg["content"] for msg in messages if msg["role"] == "user" or msg["role"] == "assistant"])
+    # 1. Summary
+    summary = f"Summary: This is what people say about {category.lower()}."
 
-    if category not in dataset:
-        dataset[category] = []
+    # 2. Fusion
+    fusion = "Fusion: " + " ".join(best_quotes)
 
-    dataset[category].append({"quote": convo_text})
-    return f"Conversation staged under {category}."
+    # 3. Reference
+    reference = f"Reference: Example article about {category.lower()} - https://example.com/{category.lower()}"
 
+    return summary, fusion, reference
 
-def export_conversation_csv(messages):
-    """Export current conversation as CSV and return filename"""
-    if not messages:
-        return None
+# -----------------------------
+# Gradio logic
+# -----------------------------
+conversation_history = []
 
-    filename = f"conversation_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
-    with open(filename, "w", newline="", encoding="utf-8") as f:
-        writer = csv.writer(f)
-        writer.writerow(["role", "content"])
-        for msg in messages:
-            writer.writerow([msg["role"], msg["content"]])
-    return filename
+def chat(user_input, category):
+    summary, fusion, reference = generate_response(category, user_input)
 
+    # 3-fold response
+    bot_response = f"{summary}\n\n{fusion}\n\n{reference}"
 
-def download_dataset():
-    """Save dataset to a JSON file and return filename"""
-    filename = f"quotes_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-    with open(filename, "w", encoding="utf-8") as f:
-        json.dump(dataset, f, indent=2, ensure_ascii=False)
-    return filename
+    conversation_history.append({"role": "user", "content": user_input})
+    conversation_history.append({"role": "assistant", "content": bot_response})
+
+    return conversation_history
 
+def clear_conversation():
+    conversation_history.clear()
+    return conversation_history
 
 # -----------------------------
-# Chatbot core
+# CSV Export
 # -----------------------------
-def chatbot_reply(user_input, history, category):
-    """Handle user query and return chatbot response with updated history"""
-    if not user_input.strip():
-        return history, history
-
-    # Find 3-fold response
-    responses = find_best_quotes(category, user_input, top_n=3)
-
-    # Format assistant reply
-    reply = "\n---\n".join(responses)
+def export_conversation():
+    if not conversation_history:
+        return None
+    filename = "conversation.csv"
+    with open(filename, "w", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(["role", "content"])
+        for msg in conversation_history:
+            writer.writerow([msg["role"], msg["content"]])
+    return filename
 
-    # Append to history
-    history.append({"role": "user", "content": user_input})
-    history.append({"role": "assistant", "content": reply})
+# -----------------------------
+# Save staged responses
+# -----------------------------
+def stage_conversation(category):
+    if not conversation_history:
+        return None
 
-    return history, history
+    if "staged_responses" not in dataset:
+        dataset["staged_responses"] = []
 
+    staged_entry = {
+        "category": category,
+        "conversation": conversation_history.copy()
+    }
+    dataset["staged_responses"].append(staged_entry)
 
-def clear_conversation():
-    return [], []
+    # Save to file for download
+    staged_file = "staged_responses.json"
+    with open(staged_file, "w") as f:
+        json.dump(dataset, f, indent=2)
 
+    return staged_file
 
 # -----------------------------
 # UI
 # -----------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("# 🎓 Campus Life Chatbot")
+    gr.Markdown("## Campus Life Chatbot")
 
     with gr.Row():
-        with gr.Column():
-            category_dropdown = gr.Dropdown(
-                choices=list(dataset.keys()),
-                value="Food" if "Food" in dataset else None,
-                label="Select Category",
-            )
-
-            chatbot = gr.Chatbot(label="Conversation", height=360, type="messages")
-            user_input = gr.Textbox(
-                placeholder="Type your message and press Enter",
-                show_label=False,
-            )
-            send_btn = gr.Button("Send")
-            clear_btn = gr.Button("Clear")
-
-            export_csv_btn = gr.Button("📤 Export Conversation to CSV")
-            stage_btn = gr.Button("Stage Conversation to Category")
-            download_json_btn = gr.Button("💾 Download Current Dataset")
-
-            export_status = gr.Label(label="Status", value="")
-
-    # Events
-    send_btn.click(chatbot_reply, [user_input, chatbot, category_dropdown], [chatbot, chatbot])
-    user_input.submit(chatbot_reply, [user_input, chatbot, category_dropdown], [chatbot, chatbot])
+        category = gr.Dropdown(
+            choices=list(dataset.keys()),
+            label="Select Category",
+            value=list(dataset.keys())[0] if dataset else None
+        )
 
-    clear_btn.click(clear_conversation, outputs=[chatbot, chatbot])
+    chatbot = gr.Chatbot(label="Conversation", height=360, type="messages")
 
-    export_csv_btn.click(export_conversation_csv, [chatbot], outputs=export_status)
-    stage_btn.click(save_conversation_to_staged, [chatbot, category_dropdown], outputs=export_status)
-    download_json_btn.click(download_dataset, outputs=export_status)
+    with gr.Row():
+        user_input = gr.Textbox(
+            label="Type your message",
+            placeholder="Ask about food, housing, professors...",
+            scale=4
+        )
+        send_btn = gr.Button("Send", scale=1)
 
+    with gr.Row():
+        clear_btn = gr.Button("Clear")
+        export_btn = gr.Button("Export Conversation to CSV")
+        stage_btn = gr.Button("Stage Conversation to Category")
+        download_btn = gr.Button("Download Updated Dataset")
+
+    # Event wiring
+    send_btn.click(chat, [user_input, category], chatbot)
+    user_input.submit(chat, [user_input, category], chatbot)
+    clear_btn.click(clear_conversation, None, chatbot)
+    export_btn.click(export_conversation, None, gr.File())
+    stage_btn.click(stage_conversation, category, gr.File())
+    download_btn.click(lambda: DATA_PATH, None, gr.File())
 
-# -----------------------------
-# Launch
-# -----------------------------
 if __name__ == "__main__":
     demo.launch()