Update app.py

app.py

@@ -1,13 +1,13 @@
 import json
-import random
-import re
-import string
 import os
 import datetime
+import random
+import difflib
 import gradio as gr
+import csv
 
 # -----------------------------
-# Config / data loading
+# Config / Data Loading
 # -----------------------------
 DATA_PATH = "quotes.json"
 
@@ -21,176 +21,141 @@ def load_quotes():
                 return data
         except Exception as e:
             print(f"Failed to load {DATA_PATH}: {e}")
-    print("No dataset file found. Upload one via the UI.")
+    print("No dataset found. Upload one via the UI.")
     return {}
 
 QUOTES = load_quotes()
+STAGED_RESPONSES = []
 
 # -----------------------------
-# Text 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"
-}
-
-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"}
-
-punct_re = re.compile(f"[{re.escape(string.punctuation)}]")
-
-def normalize(text: str) -> str:
-    return punct_re.sub(" ", (text or "").lower())
-
-def tokenize(text: str):
-    return [t for t in normalize(text).split() if t and t not in STOPWORDS]
-
-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"
-    # tie or unknown → default to positive
-    return "positive"
-
-# -----------------------------
-# Retrieval
+# Utility Functions
 # -----------------------------
-def best_match_quote(category: str, sentiment: str, user_text: str) -> str:
-    if category not in QUOTES:
-        return f"No quotes found for category '{category}'."
-    if sentiment not in QUOTES[category]:
-        return f"No quotes found for sentiment '{sentiment}' in category '{category}'."
+def best_match_quote(category, user_text):
+    if category not in QUOTES or not QUOTES[category]:
+        return "No quotes available for this category."
 
-    pool = QUOTES[category][sentiment]
-    if not pool:
-        return f"No quotes available in '{category}' → '{sentiment}'."
-
-    q_tokens = set(tokenize(user_text))
-    best_score = -1
+    pool = QUOTES[category]
+    q_tokens = set(user_text.lower().split())
     best_quote = None
-
-    for quote in pool:
-        qtoks = set(tokenize(quote))
+    best_score = -1
+    for entry in pool:
+        quote = entry.get("quote", "")
+        qtoks = set(quote.lower().split())
         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(pool)
+    if best_score == 0:
+        best_quote = random.choice(pool).get("quote", "")
     return best_quote
 
-# -----------------------------
-# Gradio callbacks
-# -----------------------------
-def respond(message, history, category, sentiment_choice):
-    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
+def generate_3fold_response(category, user_text):
+    # 1. Summary sentence (first line of best matching quote)
+    best_quote = best_match_quote(category, user_text)
+    summary = best_quote.split('.')[0] + '.'
 
-    if not category:
-        bot = "Please select a category."
-        history.append({"role":"user", "content":message})
-        history.append({"role":"assistant", "content":bot})
-        return "", history
+    # 2. Fusion of quotes in category
+    fused = " ".join([q.get("quote", "") for q in QUOTES.get(category, [])][:3])
+
+    # 3. Placeholder link (can be replaced with site search later)
+    link = f"https://www.google.com/search?q={category}+college+site:example.com"
 
-    # Resolve sentiment
-    if sentiment_choice == "auto":
-        sent = infer_sentiment(message)
-    else:
-        sent = sentiment_choice  # "positive" or "negative"
+    return [
+        f"Summary: \n{summary}",
+        f"What real people say: \n{fused}",
+        f"Related link: \n{link}"
+    ]
 
-    bot = best_match_quote(category, sent, message)
-    history.append({"role":"user", "content":message})
-    history.append({"role":"assistant", "content":bot})
+# -----------------------------
+# Gradio Callbacks
+# -----------------------------
+def respond(message, history, category, sentiment):
+    if not message.strip():
+        return "", history
+    responses = generate_3fold_response(category, message)
+    history.append((message, responses))
     return "", history
 
 def clear_chat():
     return None
 
+def stage_response(chat_history, category):
+    if not chat_history:
+        return gr.update(value="No conversation to stage.")
+    last_user, last_bot = chat_history[-1]
+    if category not in QUOTES:
+        QUOTES[category] = []
+    QUOTES[category].append({"quote": last_bot[1].replace("What real people say: \n","")})
+    STAGED_RESPONSES.append((last_user, last_bot))
+    return gr.update(value=f"Last message staged to category '{category}'.")
+
+def download_csv():
+    if not STAGED_RESPONSES:
+        return None
+    filename = "staged_conversation.csv"
+    with open(filename, "w", newline="", encoding="utf-8") as csvfile:
+        writer = csv.writer(csvfile)
+        writer.writerow(["User", "Summary", "What people say", "Link"])
+        for user_msg, bot_resp in STAGED_RESPONSES:
+            writer.writerow([user_msg] + bot_resp)
+    return filename
+
 def upload_json(filepath):
-    global QUOTES, DATA_PATH
+    global QUOTES
     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))
+        return f"Loaded {len(cats)} categories from {filepath}.", 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():
-    out_name = DATA_PATH or "quotes_export.json"
-    try:
-        if DATA_PATH and os.path.exists(DATA_PATH):
-            return DATA_PATH
-        tmp = "quotes_export.json"
-        with open(tmp, "w", encoding="utf-8") as f:
-            json.dump(QUOTES, f, indent=2, ensure_ascii=False)
-        return tmp
-    except Exception:
-        return None
-
-def export_chat(history):
-    """Export conversation as CSV"""
-    try:
-        tmp = "conversation_export.csv"
-        with open(tmp, "w", newline="", encoding="utf-8") as csvfile:
-            writer = csv.writer(csvfile)
-            writer.writerow(["role","message"])
-            for msg in history:
-                writer.writerow([msg["role"], msg["content"]])
-        return tmp
-    except Exception:
-        return None
+def download_dataset():
+    tmp = "quotes_export.json"
+    with open(tmp, "w", encoding="utf-8") as f:
+        json.dump(QUOTES, f, indent=2, ensure_ascii=False)
+    return tmp
 
 # -----------------------------
-# UI
+# Gradio UI
 # -----------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("## 🎓 College Life Chatbot — Category-Aware, Similarity Matching")
+    gr.Markdown("## 🎓 College Life Chatbot — 3-Fold Response + Staged Export")
 
     initial_categories = sorted(list(QUOTES.keys()))
 
     with gr.Row():
-        category = gr.Dropdown(label="Category",
-                               choices=initial_categories,
-                               value=(initial_categories[0] if initial_categories else None))
-        sentiment = gr.Dropdown(label="Sentiment",
-                                choices=["auto","positive","negative"],
-                                value="auto",
-                                info="Auto infers from your question (good/bad/etc.)")
+        category = gr.Dropdown(label="Category", choices=initial_categories, value=(initial_categories[0] if initial_categories else None))
+        sentiment = gr.Dropdown(label="Sentiment", choices=["auto", "positive", "negative"], value="auto")
 
     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")
 
+    with gr.Row():
+        stage_btn = gr.Button("Stage conversation to category")
+        staged_status = gr.Textbox(label="Staging status", interactive=False)
+
     with gr.Row():
         uploader = gr.File(label="Upload dataset (.json)", file_types=[".json"], type="filepath")
         upload_status = gr.Textbox(label="Upload status", interactive=False)
         downloader = gr.File(label="Download current dataset")
-        export_btn = gr.File(label="Export conversation to CSV")
+        download_csv_btn = gr.File(label="Download staged conversation CSV")
 
     # Wire events
     msg.submit(respond, [msg, chatbot, category, sentiment], [msg, chatbot])
     send.click(respond, [msg, chatbot, category, sentiment], [msg, chatbot])
     clear.click(clear_chat, None, chatbot, queue=False)
 
+    stage_btn.click(stage_response, [chatbot, category], staged_status)
     uploader.upload(upload_json, uploader, [upload_status, category])
-    downloader.download(download_current)
-    export_btn.download(lambda history: export_chat(history), inputs=chatbot)
+    downloader.download(download_dataset)
+    download_csv_btn.download(download_csv)
 
 # -----------------------------
 # Startup log