Update app.py

app.py

@@ -2,25 +2,29 @@ import gradio as gr
 from openai import OpenAI
 import requests
 import json
-from typing import List, Dict, Optional
+from typing import List, Dict, Optional, Tuple
+import random
 
 class GifChatBot:
     def __init__(self):
         self.openai_client = None
         self.giphy_key = None
         self.chat_history = []
-        
+        self.is_initialized = False
+
     def setup_keys(self, openai_key: str, giphy_key: str) -> str:
         """Initialize API clients with user's keys"""
         try:
             self.openai_client = OpenAI(api_key=openai_key)
             self.giphy_key = giphy_key
-            # Test the keys
+            # Test both keys
             self._test_giphy_key()
             self._test_openai_key()
+            self.is_initialized = True
             return "✅ Setup successful! Let's chat!"
-        except Exception as e:
-            return f"❌ Error setting up: {str(e)}"
+        except Exception as error:
+            self.is_initialized = False
+            return f"❌ Error setting up: {str(error)}"
     
     def _test_giphy_key(self):
         """Test if GIPHY key is valid"""
@@ -43,49 +47,116 @@ class GifChatBot:
             raise Exception("Invalid OpenAI API key")
 
     def get_gif(self, search_query: str) -> Optional[str]:
-        """Search GIPHY for a relevant GIF"""
+        """Search GIPHY with natural, contextual queries"""
         try:
+            # Keep the search query simple and contextual
+            params = {
+                'api_key': self.giphy_key,
+                'q': search_query,
+                'limit': 15,
+                'rating': 'pg-13',
+                'bundle': 'messaging_non_clips'
+            }
+            
             response = requests.get(
                 "https://api.giphy.com/v1/gifs/search",
+                params=params
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                if data["data"]:
+                    # Filter for good quality GIFs
+                    good_gifs = [
+                        gif for gif in data["data"]
+                        if self._is_good_quality_gif(gif)
+                    ]
+                    
+                    if good_gifs:
+                        return random.choice(good_gifs)["images"]["original"]["url"]
+                        
+            # Fallback to trending if no good matches
+            return self._get_trending_gif()
+            
+        except Exception as error:
+            print(f"GIPHY error: {error}")
+            return None
+
+    def _is_good_quality_gif(self, gif: Dict) -> bool:
+        """Check if a GIF meets quality criteria"""
+        try:
+            # Avoid very long GIFs
+            if int(gif.get("images", {}).get("original", {}).get("frames", 50)) > 50:
+                return False
+                
+            # Check if size is reasonable (under 2MB)
+            if int(gif.get("images", {}).get("original", {}).get("size", 0)) > 2000000:
+                return False
+                
+            return True
+        except:
+            return True
+
+    def _get_trending_gif(self) -> Optional[str]:
+        """Get a trending GIF as fallback"""
+        try:
+            response = requests.get(
+                "https://api.giphy.com/v1/gifs/trending",
                 params={
-                    "api_key": self.giphy_key,
-                    "q": search_query,
-                    "limit": 10,
-                    "rating": "pg-13"
+                    'api_key': self.giphy_key,
+                    'limit': 25,
+                    'rating': 'pg-13',
+                    'bundle': 'messaging_non_clips'
                 }
             )
+            
             if response.status_code == 200:
                 data = response.json()
                 if data["data"]:
-                    import random
-                    gif = random.choice(data["data"])
-                    return gif["images"]["original"]["url"]
-        except Exception as e:
-            print(f"GIPHY error: {e}")
+                    return random.choice(data["data"])["images"]["original"]["url"]
+        except Exception as error:
+            print(f"Error getting trending GIF: {error}")
         return None
 
-    def chat(self, message: str, history: List[List[str]]) -> tuple[str, List[List[str]]]:
-        """Main chat function with GIF support"""
-        if not self.openai_client or not self.giphy_key:
-            return "Please set up your API keys first!", history
+    def reset_chat(self) -> Tuple[str, List[List[str]]]:
+        """Reset the chat history"""
+        self.chat_history = []
+        return "", []
+
+    def chat(self, message: str, history: List[List[str]]) -> Tuple[str, List[List[str]], str]:
+        """Main chat function with natural GIF integration"""
+        if not self.is_initialized:
+            return message, history, "Please set up your API keys first!"
+
+        if not message.strip():
+            return message, history, ""
 
         try:
-            # Create the system message that encourages proactive GIF usage
-            system_message = """You are a fun, internet-savvy friend who loves expressing yourself through GIFs! 
-            You can and should proactively use GIFs when appropriate to make the conversation more engaging.
+            # System message emphasizing natural GIF search
+            system_message = """You are a supportive, empathetic friend who uses GIFs naturally in conversation. 
+            When using GIFs, keep search terms simple and contextual, like humans do:
+
+            Examples of natural GIF searches:
+            - When someone's hungry: [GIF: hungry]
+            - When comforting someone: [GIF: comforting hug]
+            - When celebrating: [GIF: celebration]
+            - When confused: [GIF: confused]
+            - When agreeing strongly: [GIF: absolutely yes]
             
-            To use a GIF, simply include [GIF: description] in your message where you want the GIF to appear. 
-            For example: "That's amazing! [GIF: mind blown explosion] I can't believe it!"
+            Keep your responses:
+            1. Empathetic and supportive
+            2. Context-aware (reference previous messages naturally)
+            3. Use GIFs that match the emotional context
             
-            Keep your responses conversational and natural, and use GIFs to enhance emotional expression or reactions.
-            Don't overuse GIFs - use them naturally like a real person would in chat."""
+            Use 0-1 GIFs per message unless the context really calls for more.
+            The GIF should enhance your message, not replace it."""
 
             # Prepare conversation history
             messages = [{"role": "system", "content": system_message}]
-            for h in history:
+            for chat in history:
                 messages.extend([
-                    {"role": "user", "content": h[0]},
-                    {"role": "assistant", "content": h[1]}
+                    {"role": "user", "content": chat[0]},
+                    {"role": "assistant", "content": chat[1]}
                 ])
             messages.append({"role": "user", "content": message})
 
@@ -115,48 +186,61 @@ class GifChatBot:
                     final_response += part[gif_desc_end + 1:]
 
             history.append([message, final_response])
-            return final_response, history
+            return "", history, ""
 
-        except Exception as e:
-            return f"Oops! Something went wrong: {str(e)}", history
+        except Exception as error:
+            error_message = f"Oops! Something went wrong: {str(error)}"
+            return message, history, error_message
 
-# Create Gradio interface
 def create_interface():
+    """Create the Gradio interface"""
     bot = GifChatBot()
     
-    with gr.Blocks() as interface:
+    with gr.Blocks(theme=gr.themes.Soft()) as interface:
         gr.Markdown("""
-        # Fun AI Friend with GIFs! 🎉
-        First, enter your API keys below to get started. Then chat away!
+        # 🎭 Friendly Chat Bot with GIFs
+        Chat with an empathetic AI friend who expresses themselves through GIFs! 
+        Enter your API keys below to start.
         """)
         
         with gr.Row():
-            openai_key = gr.Textbox(
-                label="OpenAI API Key",
-                placeholder="sk-...",
-                type="password"
-            )
-            giphy_key = gr.Textbox(
-                label="GIPHY API Key",
-                placeholder="Enter your GIPHY API key",
-                type="password"
-            )
+            with gr.Column(scale=1):
+                openai_key = gr.Textbox(
+                    label="OpenAI API Key",
+                    placeholder="sk-...",
+                    type="password",
+                    scale=2
+                )
+            with gr.Column(scale=1):
+                giphy_key = gr.Textbox(
+                    label="GIPHY API Key",
+                    placeholder="Enter your GIPHY API key",
+                    type="password",
+                    scale=2
+                )
         
-        setup_button = gr.Button("Set up Keys")
+        setup_button = gr.Button("Set up Keys", variant="primary")
         setup_status = gr.Textbox(label="Setup Status")
         
         chatbot = gr.Chatbot(
             label="Chat",
             bubble_full_width=False,
             show_label=False,
-            height=400
-        )
-        msg = gr.Textbox(
-            label="Type your message",
-            placeholder="Say something...",
-            show_label=False
+            height=450
         )
-        clear = gr.Button("Clear Chat")
+        
+        with gr.Row():
+            with gr.Column(scale=4):
+                message_box = gr.Textbox(
+                    label="Type your message",
+                    placeholder="Say something...",
+                    show_label=False,
+                    container=False
+                )
+            with gr.Column(scale=1):
+                clear_button = gr.Button("Clear Chat", variant="secondary")
+        
+        error_box = gr.Textbox(label="Error Messages", visible=True)
 
         # Set up event handlers
         setup_button.click(
@@ -165,24 +249,27 @@ def create_interface():
             outputs=setup_status
         )
         
-        msg.submit(
+        message_box.submit(
             bot.chat,
-            inputs=[msg, chatbot],
-            outputs=[msg, chatbot]
+            inputs=[message_box, chatbot],
+            outputs=[message_box, chatbot, error_box]
         )
         
-        clear.click(lambda: None, None, chatbot)
+        clear_button.click(
+            bot.reset_chat,
+            outputs=[message_box, chatbot]
+        )
         
         gr.Markdown("""
-        ### Notes:
-        - The AI will naturally use GIFs when appropriate in conversation
-        - Your API keys are never stored and are only used for this session
-        - Have fun chatting! 🎈
+        ### Tips:
+        - 🤝 Share how you're feeling - the AI will respond empathetically
+        - 💭 The conversation is context-aware
+        - 🎯 GIFs are chosen to match the emotional context
+        - 🔄 Use 'Clear Chat' to start fresh
         """)
     
     return interface
 
-# Launch the app
 if __name__ == "__main__":
     demo = create_interface()
     demo.launch()