Update app.py

app.py

@@ -1,8 +1,9 @@
 import json
 import random
+import re
+import string
 import os
 import datetime
-import csv
 import gradio as gr
 
 # -----------------------------
@@ -28,141 +29,168 @@ QUOTES = load_quotes()
 # -----------------------------
 # Text helpers
 # -----------------------------
-def simple_tokenize(text: str):
-    return set(text.lower().replace(".", "").replace(",", "").split())
+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"
 
-def best_match_quote(category: str, user_text: str) -> str:
-    if category not in QUOTES or not QUOTES[category]:
+# -----------------------------
+# Retrieval
+# -----------------------------
+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}'."
-    
-    pool = [q["quote"] for q in QUOTES[category] if "quote" in q]
+    if sentiment not in QUOTES[category]:
+        return f"No quotes found for sentiment '{sentiment}' in category '{category}'."
+
+    pool = QUOTES[category][sentiment]
     if not pool:
-        return f"No quotes available in category '{category}'."
-    
-    q_tokens = simple_tokenize(user_text)
+        return f"No quotes available in '{category}' → '{sentiment}'."
+
+    q_tokens = set(tokenize(user_text))
     best_score = -1
     best_quote = None
+
     for quote in pool:
-        qtoks = simple_tokenize(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:
-        best_quote = random.choice(pool)
+        return random.choice(pool)
     return best_quote
 
-def generate_three_fold_response(category: str, user_text: str):
-    quote_text = best_match_quote(category, user_text)
-    # Simple summary: first sentence
-    summary = quote_text.split(".")[0] + "."
-    # Fusion: merge similar sentences (naive)
-    fusion = " ".join(quote_text.split(".")[1:]).strip()
-    if not fusion:
-        fusion = summary
-    # URL placeholder
-    url = "No related URL available"
-    return summary, fusion, url
-
 # -----------------------------
 # Gradio callbacks
 # -----------------------------
-def respond(message, history, category):
-    if not message.strip():
+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
+
     if not category:
+        bot = "Please select a category."
+        history.append({"role":"user", "content":message})
+        history.append({"role":"assistant", "content":bot})
         return "", history
-    summary, fusion, url = generate_three_fold_response(category, message)
-    bot_message = [
-        ("Summary", summary),
-        ("What real people say", fusion),
-        ("Related URL", url)
-    ]
-    history.append((message, bot_message))
+
+    # Resolve sentiment
+    if sentiment_choice == "auto":
+        sent = infer_sentiment(message)
+    else:
+        sent = sentiment_choice  # "positive" or "negative"
+
+    bot = best_match_quote(category, sent, message)
+    history.append({"role":"user", "content":message})
+    history.append({"role":"assistant", "content":bot})
     return "", history
 
 def clear_chat():
     return None
 
-def stage_conversation(message, category):
-    if not message.strip() or not category:
-        return "Message is empty."
-    if "staged_responses" not in QUOTES:
-        QUOTES["staged_responses"] = []
-    QUOTES["staged_responses"].append({"quote": message})
-    return "Message staged for download."
-
 def upload_json(filepath):
-    global QUOTES
+    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 {filepath}."
+        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_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
-
-def download_conversation(history):
-    tmp = "conversation_export.csv"
-    with open(tmp, "w", newline="", encoding="utf-8") as f:
-        writer = csv.writer(f)
-        writer.writerow(["User", "Summary", "What real people say", "Related URL"])
-        for user_msg, bot_msgs in history:
-            summary = bot_msgs[0][1] if len(bot_msgs) > 0 else ""
-            fusion = bot_msgs[1][1] if len(bot_msgs) > 1 else ""
-            url = bot_msgs[2][1] if len(bot_msgs) > 2 else ""
-            writer.writerow([user_msg, summary, fusion, url])
-    return tmp
+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
 
 # -----------------------------
 # UI
 # -----------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("## 🎓 College Life Chatbot — 3-Fold Responses")
+    gr.Markdown("## 🎓 College Life Chatbot — Category-Aware, Similarity Matching")
 
     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)
-        )
+        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.)")
 
     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")
-        stage_status = gr.Textbox(label="Stage 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)
-        dataset_download = gr.File(label="Download current dataset")
-        convo_download = gr.File(label="Download conversation CSV")
+        downloader = gr.File(label="Download current dataset")
+        export_btn = gr.File(label="Export conversation to CSV")
 
     # Wire events
-    msg.submit(respond, [msg, chatbot, category], [msg, chatbot])
-    send.click(respond, [msg, chatbot, category], [msg, chatbot])
+    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_conversation, [msg, category], stage_status)
-
     uploader.upload(upload_json, uploader, [upload_status, category])
-    dataset_download.download(download_dataset)
-    convo_download.download(lambda history: download_conversation(history), inputs=chatbot)
+    downloader.download(download_current)
+    export_btn.download(lambda history: export_chat(history), inputs=chatbot)
 
 # -----------------------------
 # Startup log