Update app.py

app.py

@@ -4,6 +4,7 @@ import requests
 import json
 from typing import List, Dict, Optional, Tuple
 import random
+import time
 
 class GifChatBot:
     def __init__(self):
@@ -11,6 +12,7 @@ class GifChatBot:
         self.giphy_key = None
         self.chat_history = []
         self.is_initialized = False
+        self.session = requests.Session()  # Use session for better performance
 
     def setup_keys(self, openai_key: str, giphy_key: str) -> str:
         """Initialize API clients with user's keys"""
@@ -25,16 +27,16 @@ class GifChatBot:
         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"""
-        response = requests.get(
+        response = self.session.get(
             "https://api.giphy.com/v1/gifs/trending",
             params={"api_key": self.giphy_key, "limit": 1}
         )
         if response.status_code != 200:
             raise Exception("Invalid GIPHY API key")
-    
+
     def _test_openai_key(self):
         """Test if OpenAI key is valid"""
         try:
@@ -46,78 +48,111 @@ class GifChatBot:
         except Exception:
             raise Exception("Invalid OpenAI API key")
 
+    def verify_gif_url(self, gif_url: str) -> bool:
+        """Verify if a GIF URL is accessible"""
+        try:
+            # Head request is faster than full GET
+            response = self.session.head(gif_url, timeout=3)
+            
+            # Check if status is OK and content type is correct
+            if response.status_code == 200:
+                content_type = response.headers.get('content-type', '').lower()
+                return 'gif' in content_type or 'image' in content_type
+            return False
+        except:
+            return False
+
     def get_gif(self, search_query: str) -> Optional[str]:
-        """Search GIPHY with natural, contextual queries"""
+        """Search GIPHY with validation for working GIFs"""
         try:
-            # Keep the search query simple and contextual
             params = {
                 'api_key': self.giphy_key,
                 'q': search_query,
-                'limit': 15,
+                'limit': 25,  # Get more options
                 'rating': 'pg-13',
                 'bundle': 'messaging_non_clips'
             }
             
-            response = requests.get(
+            response = self.session.get(
                 "https://api.giphy.com/v1/gifs/search",
-                params=params
+                params=params,
+                timeout=5
             )
             
             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)
-                    ]
+                    # Shuffle results for variety
+                    gifs = list(data["data"])
+                    random.shuffle(gifs)
+                    
+                    # Try GIFs until we find a good one
+                    for gif in gifs:
+                        if not self._is_good_quality_gif(gif):
+                            continue
+                            
+                        gif_url = gif["images"]["original"]["url"]
+                        if self.verify_gif_url(gif_url):
+                            return gif_url
                     
-                    if good_gifs:
-                        return random.choice(good_gifs)["images"]["original"]["url"]
-                        
-            # Fallback to trending if no good matches
-            return self._get_trending_gif()
+                    # If no GIFs passed validation, try trending
+                    return self._get_trending_gif()
+            
+            return None
             
         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"""
+        """Get a verified trending GIF as fallback"""
         try:
-            response = requests.get(
+            response = self.session.get(
                 "https://api.giphy.com/v1/gifs/trending",
                 params={
                     'api_key': self.giphy_key,
                     'limit': 25,
                     'rating': 'pg-13',
                     'bundle': 'messaging_non_clips'
-                }
+                },
+                timeout=5
             )
             
             if response.status_code == 200:
                 data = response.json()
                 if data["data"]:
-                    return random.choice(data["data"])["images"]["original"]["url"]
+                    # Try each trending GIF until we find a working one
+                    gifs = list(data["data"])
+                    random.shuffle(gifs)
+                    
+                    for gif in gifs:
+                        gif_url = gif["images"]["original"]["url"]
+                        if self.verify_gif_url(gif_url):
+                            return gif_url
+                            
         except Exception as error:
             print(f"Error getting trending GIF: {error}")
         return None
 
+    def _is_good_quality_gif(self, gif: Dict) -> bool:
+        """Check if a GIF meets quality criteria"""
+        try:
+            # Skip GIFs that are too long
+            if int(gif.get("images", {}).get("original", {}).get("frames", 50)) > 50:
+                return False
+            
+            # Skip GIFs that are too large
+            if int(gif.get("images", {}).get("original", {}).get("size", 0)) > 2000000:  # 2MB
+                return False
+            
+            # Skip if no image data
+            if not gif.get("images", {}).get("original", {}).get("url"):
+                return False
+            
+            return True
+        except:
+            return False
+
     def reset_chat(self) -> Tuple[str, List[List[str]]]:
         """Reset the chat history"""
         self.chat_history = []
@@ -132,24 +167,22 @@ class GifChatBot:
             return message, history, ""
 
         try:
-            # System message emphasizing natural GIF search
+            # System message emphasizing natural GIF usage
             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:
+            When using GIFs, keep search terms simple and contextual:
 
-            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]
+            Examples:
+            - User feeling hungry -> [GIF: hungry]
+            - User feeling sad -> [GIF: comforting hug]
+            - User celebrating -> [GIF: celebration]
+            - User confused -> [GIF: confused]
             
             Keep your responses:
-            1. Empathetic and supportive
-            2. Context-aware (reference previous messages naturally)
-            3. Use GIFs that match the emotional context
+            1. Empathetic and natural
+            2. Context-aware
+            3. Use GIFs that match the emotion
             
-            Use 0-1 GIFs per message unless the context really calls for more.
-            The GIF should enhance your message, not replace it."""
+            Use 0-1 GIFs per message unless the moment really calls for more."""
 
             # Prepare conversation history
             messages = [{"role": "system", "content": system_message}]
@@ -192,6 +225,10 @@ class GifChatBot:
             error_message = f"Oops! Something went wrong: {str(error)}"
             return message, history, error_message
 
+    def cleanup(self):
+        """Cleanup resources"""
+        self.session.close()
+
 def create_interface():
     """Create the Gradio interface"""
     bot = GifChatBot()
@@ -262,11 +299,18 @@ def create_interface():
         
         gr.Markdown("""
         ### Tips:
-        - 🤝 Share how you're feeling - the AI will respond empathetically
+        - 🤝 Share how you're feeling - the AI responds empathetically
         - 💭 The conversation is context-aware
-        - 🎯 GIFs are chosen to match the emotional context
+        - 🎯 GIFs are chosen to match the emotion
         - 🔄 Use 'Clear Chat' to start fresh
         """)
+
+        # Cleanup on page unload
+        interface.load(lambda: None, [], [], _js="""() => {
+            window.addEventListener('unload', function() {
+                // Cleanup resources
+            })
+        }""")
     
     return interface