Update app.py

app.py

@@ -1,136 +1,117 @@
 import json
+import random
 import os
 import datetime
-import random
-import difflib
 import gradio as gr
-import csv
 
 # -----------------------------
-# Config / Data Loading
+# 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 found. Upload one via the UI.")
+        with open(DATA_PATH, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        print(f"Loaded dataset from {DATA_PATH} with {len(data)} categories.")
+        return data
+    print("No dataset found. Please upload a JSON file via the UI.")
     return {}
 
 QUOTES = load_quotes()
-STAGED_RESPONSES = []
 
 # -----------------------------
-# Utility Functions
+# Helper functions
 # -----------------------------
-def best_match_quote(category, user_text):
-    if category not in QUOTES or not QUOTES[category]:
-        return "No quotes available for this category."
+def tokenize(text):
+    return set(text.lower().split())
 
+def best_match_quote(category, user_text):
+    """Find the quote with the most token overlap."""
+    if category not in QUOTES:
+        return None
     pool = QUOTES[category]
-    q_tokens = set(user_text.lower().split())
-    best_quote = None
+    if not pool:
+        return None
+
+    q_tokens = tokenize(user_text)
     best_score = -1
+    best_quote = None
+
     for entry in pool:
-        quote = entry.get("quote", "")
-        qtoks = set(quote.lower().split())
-        score = len(q_tokens & qtoks)
+        quote_tokens = tokenize(entry["quote"])
+        score = len(q_tokens & quote_tokens)
         if score > best_score:
             best_score = score
-            best_quote = quote
+            best_quote = entry["quote"]
 
-    if best_score == 0:
-        best_quote = random.choice(pool).get("quote", "")
-    return best_quote
+    # fallback
+    if not best_quote:
+        best_quote = random.choice(pool)["quote"]
 
-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] + '.'
+    return best_quote
 
-    # 2. Fusion of quotes in category
-    fused = " ".join([q.get("quote", "") for q in QUOTES.get(category, [])][:3])
+def generate_response(category, user_text):
+    """Produce 3-fold response based on category quotes."""
+    if category not in QUOTES:
+        return ["No quotes found for this category.", "", ""]
 
-    # 3. Placeholder link (can be replaced with site search later)
-    link = f"https://www.google.com/search?q={category}+college+site:example.com"
+    pool = QUOTES[category]
+    if not pool:
+        return ["No quotes available.", "", ""]
 
-    return [
-        f"Summary: \n{summary}",
-        f"What real people say: \n{fused}",
-        f"Related link: \n{link}"
-    ]
+    # For simplicity, pick up to 2-3 quotes for summary
+    sampled = random.sample(pool, min(2, len(pool)))
+    summary = " ".join([s["quote"].split(".")[0] + "." for s in sampled])  # first sentence
+    details = " ".join([s["quote"] for s in sampled])
+    suggested_url = "https://www.example.com/search?q=" + category.replace(" ", "+")
+    return [summary, details, suggested_url]
 
 # -----------------------------
-# Gradio Callbacks
+# Gradio callbacks
 # -----------------------------
-def respond(message, history, category, sentiment):
+def respond(message, history, category):
     if not message.strip():
         return "", history
-    responses = generate_3fold_response(category, message)
-    history.append((message, responses))
+
+    summary, details, suggested_url = generate_response(category, message)
+
+    # Append messages in Gradio "messages" format
+    history.append({"role": "user", "content": message})
+    history.append({"role": "assistant", "content": f"Summary:\n{summary}"})
+    history.append({"role": "assistant", "content": f"What real people say:\n{details}"})
+    history.append({"role": "assistant", "content": f"Suggested URL:\n{suggested_url}"})
+
     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
-    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
-        cats = sorted(list(QUOTES.keys()))
-        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_dataset():
-    tmp = "quotes_export.json"
-    with open(tmp, "w", encoding="utf-8") as f:
-        json.dump(QUOTES, f, indent=2, ensure_ascii=False)
+def download_current_csv(history):
+    """Export current conversation to CSV."""
+    import csv
+    tmp = "conversation_export.csv"
+    with open(tmp, "w", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f)
+        writer.writerow(["role", "content"])
+        for msg in history:
+            writer.writerow([msg["role"], msg["content"]])
     return tmp
 
 # -----------------------------
-# Gradio UI
+# UI
 # -----------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("## 🎓 College Life Chatbot — 3-Fold Response + Staged 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))
-        sentiment = gr.Dropdown(label="Sentiment", choices=["auto", "positive", "negative"], value="auto")
+        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)
@@ -138,24 +119,13 @@ with gr.Blocks() as demo:
     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")
-        download_csv_btn = gr.File(label="Download staged conversation CSV")
+        download_csv = gr.File(label="Export conversation to CSV")
 
     # Wire events
-    msg.submit(respond, [msg, chatbot, category, sentiment], [msg, chatbot])
-    send.click(respond, [msg, chatbot, category, sentiment], [msg, chatbot])
+    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_response, [chatbot, category], staged_status)
-    uploader.upload(upload_json, uploader, [upload_status, category])
-    downloader.download(download_dataset)
-    download_csv_btn.download(download_csv)
+    download_csv.download(lambda h: download_current_csv(h), chatbot, download_csv)
 
 # -----------------------------
 # Startup log