Update app.py

app.py

@@ -1,6 +1,5 @@
 import os
 import time
-import json
 import requests
 import gradio as gr
 import google.generativeai as genai
@@ -25,9 +24,9 @@ gemini_model = genai.GenerativeModel("gemini-2.5-flash")
 # Simple in-memory chat memory
 # -----------------------
 class SimpleMemory:
-    def __init__(self, max_messages=20):
+    def __init__(self, max_messages=40):
         self.max_messages = max_messages
-        self.history = []  # list of tuples (role, text) with role in {"user","bot"}
+        self.history = []  # list of tuples (role, text) where role in {"user","bot"}
 
     def add(self, role, text):
         self.history.append((role, text))
@@ -43,7 +42,7 @@ class SimpleMemory:
                 lines.append(f"Chatbot: {txt}")
         return "\n".join(lines)
 
-memory = SimpleMemory(max_messages=20)
+memory = SimpleMemory(max_messages=40)
 
 # -----------------------
 # Prompt template
@@ -54,14 +53,14 @@ User: {user_message}
 Chatbot:"""
 
 # -----------------------
-# Robust Gemini generator (tries multiple message formats)
+# Robust Gemini generator (tries several message formats)
 # Returns: (text_or_None, error_message_or_None)
 # -----------------------
 def generate_text_with_gemini(user_message):
     chat_history_text = memory.as_prompt_text()
     full_prompt = PROMPT_TEMPLATE.format(chat_history=chat_history_text, user_message=user_message)
 
-    # 1) Try the simplest call (raw prompt)
+    # 1) Try raw prompt string
     try:
         resp = gemini_model.generate_content(full_prompt)
         text = getattr(resp, "text", None)
@@ -69,10 +68,10 @@ def generate_text_with_gemini(user_message):
             text = str(resp)
         return text, None
     except ResourceExhausted as e:
-        print("Gemini quota exhausted (raw prompt):", e)
+        print("Gemini quota exhausted (raw):", e)
         return None, "Gemini quota exceeded. Please try again later."
     except Exception as e1:
-        print("generate_content(raw) failed, will retry with messages format:", repr(e1))
+        print("generate_content(raw) failed, will try messages:", repr(e1))
 
     # 2) Try messages with content as plain string
     try:
@@ -89,9 +88,9 @@ def generate_text_with_gemini(user_message):
         print("Gemini quota exhausted (messages):", e)
         return None, "Gemini quota exceeded. Please try again later."
     except Exception as e2:
-        print("generate_content(messages) failed, will retry with typed content:", repr(e2))
+        print("generate_content(messages) failed, will try typed content:", repr(e2))
 
-    # 3) Try messages where content is a list of typed chunks
+    # 3) Try messages where content is list of typed parts
     try:
         messages2 = [
             {"role": "system", "content": [{"type": "text", "text": "You are a helpful assistant."}]},
@@ -106,11 +105,11 @@ def generate_text_with_gemini(user_message):
         print("Gemini quota exhausted (messages2):", e)
         return None, "Gemini quota exceeded. Please try again later."
     except Exception as efinal:
-        print("Gemini generate_content all attempts failed:", repr(efinal))
+        print("Gemini all attempts failed:", repr(efinal))
         return None, f"Gemini error: {repr(efinal)}"
 
 # -----------------------
-# ElevenLabs HTTP TTS (fallback, robust)
+# ElevenLabs HTTP TTS
 # Returns: (output_path_or_empty, error_or_empty)
 # -----------------------
 def generate_audio_elevenlabs_http(text):
@@ -156,71 +155,65 @@ def generate_audio_elevenlabs_http(text):
         print(err)
         return "", err
 
+# -----------------------
+# Convert memory -> messages list (dicts) for Gradio
+# Each message is {"role":"user"/"assistant", "content": "..."}
+# -----------------------
+def convert_memory_to_messages(history):
+    messages = []
+    for role, msg in history:
+        role_out = "assistant" if role == "bot" else "user"
+        messages.append({"role": role_out, "content": msg})
+    return messages
+
 # -----------------------
 # Combined workflow
+# Returns: (messages_list, audio_path, error_message)
 # -----------------------
 def process_user_message(user_message):
-    # 1) Generate text (robust)
+    # 1) generate text
     text, gen_err = generate_text_with_gemini(user_message)
     if gen_err:
         # safe fallback: store user and friendly message
         memory.add("user", user_message)
         fallback = "Sorry — the assistant is temporarily unavailable: " + gen_err
         memory.add("bot", fallback)
-        history_pairs = convert_memory_to_pairs(memory.history)
-        return history_pairs, "", gen_err
+        return convert_memory_to_messages(memory.history), "", gen_err
 
     # 2) update memory
     memory.add("user", user_message)
     memory.add("bot", text)
 
-    # 3) try audio (HTTP fallback)
+    # 3) generate audio (optional)
     audio_path, audio_err = generate_audio_elevenlabs_http(text)
     if audio_err:
         print("Audio generation error:", audio_err)
 
-    history_pairs = convert_memory_to_pairs(memory.history)
-    return history_pairs, audio_path or "", audio_err or ""
-
-def convert_memory_to_pairs(history):
-    """
-    Convert memory list of tuples into chat pairs for gr.Chatbot.
-    memory.history is [(role, text), ...] where roles alternate.
-    Returns list of (user_text, bot_text) pairs.
-    """
-    pairs = []
-    temp_user = None
-    for role, msg in history:
-        if role == "user":
-            temp_user = msg
-        else:  # bot
-            pairs.append((temp_user or "", msg))
-            temp_user = None
-    return pairs
+    return convert_memory_to_messages(memory.history), audio_path or "", audio_err or ""
 
 # -----------------------
-# Gradio UI
+# Gradio UI (Blocks)
 # -----------------------
 with gr.Blocks() as demo:
     gr.Markdown("## 🤖 Gemini + ElevenLabs Chatbot (Text + Audio replies)")
-    chatbot = gr.Chatbot()
+    chatbot = gr.Chatbot()  # expects messages as dicts with role/content
     with gr.Row():
         txt = gr.Textbox(show_label=False, placeholder="Type your message and press Enter")
         send_btn = gr.Button("Send")
     audio_player = gr.Audio(label="Last reply audio (if available)", visible=False)
 
     def submit_message(message):
-        # Run the combined workflow
-        pairs, audio_path, err = process_user_message(message)
-        # The chat UI expects list of pairs (user, bot)
+        messages, audio_path, err = process_user_message(message)
+        # Return messages list (dicts) for the chatbot; audio shown if available
         if audio_path:
-            return pairs, gr.update(value=audio_path, visible=True)
+            return messages, gr.update(value=audio_path, visible=True)
         else:
-            return pairs, gr.update(value=None, visible=False)
+            return messages, gr.update(value=None, visible=False)
 
     send_btn.click(fn=submit_message, inputs=[txt], outputs=[chatbot, audio_player])
     txt.submit(fn=submit_message, inputs=[txt], outputs=[chatbot, audio_player])
 
 # Launch app
 if __name__ == "__main__":
+    # debug=True recommended while testing
     demo.launch(debug=True)