Update app.py

app.py

@@ -1,203 +1,146 @@
 import json
 import random
-import re
-import string
-import os
-import datetime
 import difflib
+import os
 import csv
+import datetime
 import gradio as gr
-import tempfile
-import shutil
 
 # -----------------------------
 # Config / data loading
 # -----------------------------
 DATA_PATH = "quotes.json"
 
-def load_quotes():
-    if os.path.exists(DATA_PATH):
-        try:
-            with open(DATA_PATH, "r", encoding="utf-8") as f:
-                data = json.load(f)
-            if isinstance(data, dict):
-                print(f"Loaded dataset from {DATA_PATH} with {len(data)} categories.")
-                return data
-        except Exception as e:
-            print(f"Failed to load {DATA_PATH}: {e}")
-    print("No dataset file found. Upload one via the UI.")
-    return {}
-
-QUOTES = load_quotes()
+if os.path.exists(DATA_PATH):
+    with open(DATA_PATH, "r") as f:
+        dataset = json.load(f)
+else:
+    dataset = {"staged_responses": []}
+
 
 # -----------------------------
-# Text helpers
+# Helpers
 # -----------------------------
-STOPWORDS = {
-    "the","a","an","and","or","but","if","then","so","than","to","of","in","on","at","for",
-    "is","are","was","were","be","being","been","it","that","this","these","those","with",
-    "as","by","from","about","into","over","after","before","up","down","out"
-}
+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"""
+    if category not in dataset or not dataset[category]:
+        return [f"No data about {user_input} (unknown)."]
 
-POS_HINTS = {"good","great","love","like","enjoy","awesome","amazing","nice","positive","best","fantastic","excellent"}
-NEG_HINTS = {"bad","hate","dislike","worst","awful","terrible","negative","poor","meh","gross","unsafe","hard","difficult"}
+    quotes = [q["quote"] for q in dataset[category]]
+    scores = [difflib.SequenceMatcher(None, user_input.lower(), q.lower()).ratio() for q in quotes]
 
-punct_re = re.compile(f"[{re.escape(string.punctuation)}]")
+    # Pair scores with quotes and sort
+    scored_quotes = sorted(zip(scores, quotes), key=lambda x: x[0], reverse=True)
 
-def normalize(text: str) -> str:
-    return punct_re.sub(" ", (text or "").lower())
+    best_score = scored_quotes[0][0] if scored_quotes else 0
+    if best_score < threshold:
+        return [f"No data about {user_input} (unknown)."]
 
-def tokenize(text: str):
-    return [t for t in normalize(text).split() if t and t not in STOPWORDS]
+    return [q for _, q in scored_quotes[:top_n]]
 
-def infer_sentiment(user_text: str) -> str:
-    tl = normalize(user_text)
-    has_pos = any(w in tl for w in POS_HINTS)
-    has_neg = any(w in tl for w in NEG_HINTS)
-    if has_pos and not has_neg:
-        return "positive"
-    if has_neg and not has_pos:
-        return "negative"
-    return "positive"
 
-# -----------------------------
-# Retrieval
-# -----------------------------
-def best_match_quote(category: str, user_text: str) -> str:
-    """Pick the quote with highest keyword overlap; fallback to random."""
-    if category not in QUOTES:
-        return f"No quotes found for category '{category}'."
-    pool = QUOTES[category]
-    if not pool:
-        return f"No quotes available in '{category}'."
-
-    q_tokens = set(tokenize(user_text))
-    best_score = -1
-    best_quote = None
-
-    for entry in pool:
-        quote = entry["quote"]
-        qtoks = set(tokenize(quote))
-        score = len(q_tokens & qtoks)
-        if score > best_score:
-            best_score = score
-            best_quote = quote
-
-    if best_quote is None or best_score == 0:
-        return random.choice([entry["quote"] for entry in pool])
-    return best_quote
+def save_conversation_to_staged(messages, category):
+    """Stage conversation under chosen category in dataset (downloadable)"""
+    if not messages:
+        return "No conversation to stage."
 
-# -----------------------------
-# Gradio callbacks
-# -----------------------------
-def respond(message, history, category):
-    if not QUOTES:
-        bot = "No dataset loaded. Please upload a JSON file first."
-        history.append({"role":"user","content":message})
-        history.append({"role":"assistant","content":bot})
-        return "", history
-
-    if not category:
-        bot = "Please select a category."
-        history.append({"role":"user","content":message})
-        history.append({"role":"assistant","content":bot})
-        return "", history
-
-    # 3-fold response
-    quote = best_match_quote(category, message)
-    summary = f"Summary: The user question seems related to '{category}'."
-    fusion = f"Details: {quote}"
-    link = "Reference: [No link provided]"
-
-    response = f"{summary}\n{fusion}\n{link}"
-    history.append({"role":"user","content":message})
-    history.append({"role":"assistant","content":response})
-    return "", history
-
-def clear_chat():
-    return []
-
-def upload_json(filepath):
-    """Accept a file path, load it into memory, and update category dropdown."""
-    global QUOTES, DATA_PATH
-    try:
-        with open(filepath, "r", encoding="utf-8") as f:
-            data = json.load(f)
-        if not isinstance(data, dict):
-            return gr.update(value="Upload failed: JSON root must be an object."), gr.update(choices=[])
-        QUOTES = data
-        DATA_PATH = os.path.basename(filepath)
-        cats = sorted(list(QUOTES.keys()))
-        status = f"Loaded {len(cats)} categories from {DATA_PATH}."
-        return status, gr.update(choices=cats, value=(cats[0] if cats else None))
-    except Exception as e:
-        return f"Error loading file: {e}", gr.update(choices=[])
-
-def download_current_csv(history):
-    if not history:
+    convo_text = " ".join([msg["content"] for msg in messages if msg["role"] == "user" or msg["role"] == "assistant"])
+
+    if category not in dataset:
+        dataset[category] = []
+
+    dataset[category].append({"quote": convo_text})
+    return f"Conversation staged under {category}."
+
+
+def export_conversation_csv(messages):
+    """Export current conversation as CSV and return filename"""
+    if not messages:
         return None
-    tmpdir = tempfile.mkdtemp()
-    filepath = os.path.join(tmpdir, "conversation_export.csv")
-    with open(filepath, "w", newline="", encoding="utf-8") as f:
+
+    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 history:
+        writer.writerow(["role", "content"])
+        for msg in messages:
             writer.writerow([msg["role"], msg["content"]])
-    return filepath
+    return filename
+
+
+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
+
+
+# -----------------------------
+# Chatbot core
+# -----------------------------
+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)
+
+    # Append to history
+    history.append({"role": "user", "content": user_input})
+    history.append({"role": "assistant", "content": reply})
+
+    return history, history
+
+
+def clear_conversation():
+    return [], []
 
-def download_current_json():
-    tmpdir = tempfile.mkdtemp()
-    filepath = os.path.join(tmpdir, "quotes_export.json")
-    with open(filepath, "w", encoding="utf-8") as f:
-        json.dump(QUOTES, f, indent=2, ensure_ascii=False)
-    return filepath
 
 # -----------------------------
 # UI
 # -----------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("## 🎓 College Life Chatbot — 3-Fold Response")
-
-    initial_categories = sorted(list(QUOTES.keys()))
+    gr.Markdown("# 🎓 Campus Life Chatbot")
 
     with gr.Row():
-        category = gr.Dropdown(
-            label="Category",
-            choices=initial_categories,
-            value=(initial_categories[0] if initial_categories else None)
-        )
+        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")
-    msg = gr.Textbox(label="Your message", placeholder="Ask something like: 'Is food good in college?'", autofocus=True)
-    send = gr.Button("Send")
-    clear = gr.Button("Clear")
+            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")
 
-    with gr.Row():
-        download_csv_btn = gr.Button("Export conversation to CSV")
-        download_csv_file = gr.File(label="Download CSV", interactive=False)
+            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="")
 
-        download_json_btn = gr.Button("Download current dataset")
-        download_json_file = gr.File(label="Download JSON", interactive=False)
+    # 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])
 
-        uploader = gr.File(label="Upload dataset (.json)", file_types=[".json"], type="filepath")
-        upload_status = gr.Textbox(label="Upload status", interactive=False)
+    clear_btn.click(clear_conversation, outputs=[chatbot, chatbot])
 
-    # Wire events
-    msg.submit(respond, [msg, chatbot, category], [msg, chatbot])
-    send.click(respond, [msg, chatbot, category], [msg, chatbot])
-    clear.click(clear_chat, None, chatbot, queue=False)
+    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)
 
-    uploader.upload(upload_json, uploader, [upload_status, category])
-    download_csv_btn.click(download_current_csv, inputs=chatbot, outputs=download_csv_file)
-    download_json_btn.click(download_current_json, outputs=download_json_file)
 
 # -----------------------------
-# Startup log
+# Launch
 # -----------------------------
-print(f"===== Application Startup at {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')} =====")
-if QUOTES:
-    for cat, entries in QUOTES.items():
-        print(f" - {cat}: {len(entries)} entries")
-
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch()