Update app.py

app.py

@@ -1,9 +1,8 @@
 import json
 import random
-import re
-import string
 import os
 import datetime
+import csv
 import gradio as gr
 
 # -----------------------------
@@ -29,128 +28,116 @@ QUOTES = load_quotes()
 # -----------------------------
 # 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"
-}
+def simple_tokenize(text: str):
+    return set(text.lower().replace(".", "").replace(",", "").split())
 
-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"
-    return "positive"  # default
-
-# -----------------------------
-# Retrieval
-# -----------------------------
 def best_match_quote(category: str, user_text: str) -> str:
-    if category not in QUOTES:
+    if category not in QUOTES or not QUOTES[category]:
         return f"No quotes found for category '{category}'."
-    pool = QUOTES[category]
+    
+    pool = [q["quote"] for q in QUOTES[category] if "quote" in q]
     if not pool:
-        return f"No quotes available in '{category}'."
+        return f"No quotes available in category '{category}'."
     
-    q_tokens = set(tokenize(user_text))
+    q_tokens = simple_tokenize(user_text)
     best_score = -1
     best_quote = None
-
-    for item in pool:
-        quote = item.get("quote", "")
-        qtoks = set(tokenize(quote))
+    for quote in pool:
+        qtoks = simple_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([item["quote"] for item in pool])
+        best_quote = 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 QUOTES:
-        bot = "No dataset loaded. Please upload a JSON file first."
-        history.append({"role": "user", "content": message})
-        history.append({"role": "assistant", "content": bot})
+    if not message.strip():
         return "", history
-
     if not category:
-        bot = "Please select a category."
-        history.append({"role": "user", "content": message})
-        history.append({"role": "assistant", "content": bot})
         return "", history
-
-    bot = best_match_quote(category, message)
-    history.append({"role": "user", "content": message})
-    history.append({"role": "assistant", "content": bot})
+    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))
     return "", history
 
 def clear_chat():
     return None
 
-def stage_conversation(msg_text, history):
-    if not msg_text:
+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"] = []
-    answer = history[-1]["content"] if history else ""
-    QUOTES["staged_responses"].append({"question": msg_text, "answer": answer})
-    return "Staged conversation added!"
-
-def download_staged_responses():
-    staged = QUOTES.get("staged_responses", [])
-    if not staged:
-        return None
-    filename = "staged_responses.json"
-    with open(filename, "w", encoding="utf-8") as f:
-        json.dump(staged, f, indent=2, ensure_ascii=False)
-    return filename
+    QUOTES["staged_responses"].append({"quote": message})
+    return "Message staged for download."
 
 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}."
+        status = f"Loaded {len(cats)} categories from {filepath}."
         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
+
 # -----------------------------
 # UI
 # -----------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("## 🎓 College Life Chatbot — Staged Responses with CSV/JSON Export")
+    gr.Markdown("## 🎓 College Life Chatbot — 3-Fold Responses")
 
     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)
+        )
+
     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")
@@ -158,30 +145,32 @@ with gr.Blocks() as demo:
 
     with gr.Row():
         stage_btn = gr.Button("Stage conversation to category")
-        download_staged = gr.File(label="Download staged responses")
+        stage_status = gr.Textbox(label="Stage status", interactive=False)
 
-    uploader = gr.File(label="Upload dataset (.json)", file_types=[".json"], type="filepath")
-    upload_status = gr.Textbox(label="Upload status", interactive=False)
-    download_dataset = gr.File(label="Download current dataset")
+    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")
 
     # 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)
-    
-    stage_btn.click(stage_conversation, [msg, chatbot], upload_status)
-    download_staged.download(download_staged_responses)
-    
+
+    stage_btn.click(stage_conversation, [msg, category], stage_status)
+
     uploader.upload(upload_json, uploader, [upload_status, category])
-    download_dataset.download(lambda: DATA_PATH if os.path.exists(DATA_PATH) else None)
+    dataset_download.download(download_dataset)
+    convo_download.download(lambda history: download_conversation(history), inputs=chatbot)
 
 # -----------------------------
 # Startup log
 # -----------------------------
 print(f"===== Application Startup at {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')} =====")
 if QUOTES:
-    for cat, items in QUOTES.items():
-        print(f" - {cat}: {len(items)} entries")
+    for cat, quotes in QUOTES.items():
+        print(f" - {cat}: {len(quotes)} entries")
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)