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):
@@ -13,46 +14,68 @@ class GifChatBot:
         self.is_initialized = False
         self.session = requests.Session()
         
-        # Define size constraints
-        self.MINIMUM_FILE_SIZE = 500 * 1024  # 500KB in bytes
-        self.MAXIMUM_FILE_SIZE = 5 * 1024 * 1024  # 5MB in bytes
-        self.MAX_RETRIES = 10  # Maximum number of retries for finding a good GIF
+        # Configure session for better performance
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        })
 
-    def verify_gif_size(self, gif_url: str) -> bool:
-        """Verify if GIF meets size requirements"""
+    def setup_keys(self, openai_key: str, giphy_key: str) -> str:
+        """Initialize API clients with user's keys"""
         try:
-            # Do HEAD request to get content length
-            response = self.session.head(gif_url, timeout=3)
-            if response.status_code != 200:
-                return False
-            
-            # Get content length
-            content_length = response.headers.get('content-length')
-            if not content_length:
-                return False
-            
-            file_size = int(content_length)
-            return self.MINIMUM_FILE_SIZE <= file_size <= self.MAXIMUM_FILE_SIZE
-            
+            self.openai_client = OpenAI(api_key=openai_key)
+            self.giphy_key = giphy_key
+            # Test both keys
+            self._test_giphy_key()
+            self._test_openai_key()
+            self.is_initialized = True
+            return "✅ Setup successful! Let's chat!"
         except Exception as error:
-            print(f"Size verification error: {error}")
-            return False
+            self.is_initialized = False
+            return f"❌ Error setting up: {str(error)}"
+
+    def _test_giphy_key(self):
+        """Test if GIPHY key is valid"""
+        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:
+            self.openai_client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": "test"}],
+                max_tokens=5
+            )
+        except Exception:
+            raise Exception("Invalid OpenAI API key")
 
     def get_gif(self, search_query: str) -> Optional[str]:
-        """Get a GIF meeting size requirements with retries"""
-        for attempt in range(self.MAX_RETRIES):
+        """Search for a GIF with strict size requirements"""
+        total_attempts = 0
+        max_total_attempts = 3  # Maximum pagination attempts
+        minimum_size_bytes = 500000  # 500KB in bytes
+        
+        print(f"\nSearching for GIF: {search_query}")
+        
+        while total_attempts < max_total_attempts:
             try:
-                # Calculate offset based on attempt number to get different results
-                offset = attempt * 10
+                # Calculate offset for pagination
+                offset = total_attempts * 25
                 
                 params = {
                     'api_key': self.giphy_key,
                     'q': search_query,
-                    'limit': 10,
+                    'limit': 25,
                     'offset': offset,
                     'rating': 'pg-13'
                 }
                 
+                print(f"Attempt {total_attempts + 1} with offset {offset}")
+                
                 response = self.session.get(
                     "https://api.giphy.com/v1/gifs/search",
                     params=params,
@@ -61,32 +84,52 @@ class GifChatBot:
                 
                 if response.status_code == 200:
                     data = response.json()
-                    if data["data"]:
-                        # Shuffle results for variety
-                        gifs = list(data["data"])
-                        random.shuffle(gifs)
-                        
-                        # Try each GIF until we find one meeting size requirements
-                        for gif in gifs:
-                            gif_url = gif["images"]["original"]["url"]
-                            if self.verify_gif_size(gif_url):
-                                print(f"Found valid GIF on attempt {attempt + 1}")
-                                return gif_url
-                            
-                        print(f"No valid GIFs found in attempt {attempt + 1}, retrying...")
-                    else:
+                    if not data.get("data"):
                         print("No GIFs found in search")
                         break
-                        
+                    
+                    print(f"Found {len(data['data'])} GIFs, filtering by size...")
+                    
+                    # Filter GIFs by size first
+                    valid_gifs = []
+                    for gif in data["data"]:
+                        try:
+                            # Get size from original image data
+                            size_str = gif["images"]["original"]["size"]
+                            if size_str and size_str.isdigit():
+                                size_bytes = int(size_str)
+                                if size_bytes >= minimum_size_bytes:
+                                    valid_gifs.append(gif)
+                                    print(f"Found valid GIF: {size_bytes / 1024:.2f}KB")
+                        except (KeyError, ValueError) as e:
+                            print(f"Size parsing error for GIF: {e}")
+                            continue
+                    
+                    if valid_gifs:
+                        # Randomly select from valid GIFs
+                        chosen_gif = random.choice(valid_gifs)
+                        url = chosen_gif["images"]["original"]["url"]
+                        size = int(chosen_gif["images"]["original"]["size"])
+                        print(f"Selected GIF URL: {url}")
+                        print(f"Selected GIF size: {size / 1024:.2f}KB")
+                        return url
+                    
+                    print(f"No GIFs >= 500KB found in attempt {total_attempts + 1}")
+                
+                total_attempts += 1
+                
             except Exception as error:
-                print(f"Error in attempt {attempt + 1}: {error}")
-                continue
+                print(f"Error in attempt {total_attempts + 1}: {error}")
+                total_attempts += 1
         
         # If we get here, try trending as last resort
+        print("No suitable GIFs found in search, trying trending...")
         return self._get_trending_gif()
 
     def _get_trending_gif(self) -> Optional[str]:
-        """Get a trending GIF meeting size requirements"""
+        """Get a trending GIF with size verification"""
+        minimum_size_bytes = 500000  # 500KB in bytes
+        
         try:
             params = {
                 'api_key': self.giphy_key,
@@ -94,6 +137,8 @@ class GifChatBot:
                 'rating': 'pg-13'
             }
             
+            print("Fetching trending GIFs...")
+            
             response = self.session.get(
                 "https://api.giphy.com/v1/gifs/trending",
                 params=params,
@@ -102,53 +147,39 @@ class GifChatBot:
             
             if response.status_code == 200:
                 data = response.json()
-                if data["data"]:
-                    gifs = list(data["data"])
-                    random.shuffle(gifs)
+                if data.get("data"):
+                    print(f"Found {len(data['data'])} trending GIFs, filtering by size...")
+                    
+                    # Filter by size first
+                    valid_gifs = []
+                    for gif in data["data"]:
+                        try:
+                            size_str = gif["images"]["original"]["size"]
+                            if size_str and size_str.isdigit():
+                                size_bytes = int(size_str)
+                                if size_bytes >= minimum_size_bytes:
+                                    valid_gifs.append(gif)
+                                    print(f"Found valid trending GIF: {size_bytes / 1024:.2f}KB")
+                        except (KeyError, ValueError) as e:
+                            print(f"Size parsing error for trending GIF: {e}")
+                            continue
+                    
+                    if valid_gifs:
+                        chosen_gif = random.choice(valid_gifs)
+                        url = chosen_gif["images"]["original"]["url"]
+                        size = int(chosen_gif["images"]["original"]["size"])
+                        print(f"Selected trending GIF URL: {url}")
+                        print(f"Selected trending GIF size: {size / 1024:.2f}KB")
+                        return url
                     
-                    for gif in gifs:
-                        gif_url = gif["images"]["original"]["url"]
-                        if self.verify_gif_size(gif_url):
-                            print("Found valid trending GIF")
-                            return gif_url
-                            
+                    print("No valid trending GIFs found")
+                        
         except Exception as error:
             print(f"Trending GIF error: {error}")
+        
+        print("Failed to find any suitable GIFs")
         return None
 
-    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
-            self._test_giphy_key()
-            self._test_openai_key()
-            self.is_initialized = True
-            return "✅ Setup successful! Let's chat!"
-        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 = 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:
-            self.openai_client.chat.completions.create(
-                model="gpt-4o-mini",
-                messages=[{"role": "user", "content": "test"}],
-                max_tokens=5
-            )
-        except Exception:
-            raise Exception("Invalid OpenAI API key")
-
     def reset_chat(self) -> Tuple[List[Dict[str, str]], str]:
         """Reset the chat history"""
         self.chat_history = []
@@ -167,7 +198,7 @@ class GifChatBot:
             return message, history, ""
 
         try:
-            # System message emphasizing natural GIF usage
+            # System message for the AI
             system_message = """You are a supportive, empathetic friend who uses GIFs naturally in conversation. 
             When using GIFs, keep search terms simple and contextual:
 
@@ -179,10 +210,11 @@ class GifChatBot:
             
             Keep your responses:
             1. Empathetic and natural
-            2. Context-aware (reference previous messages)
-            3. Use GIFs that match the emotion
+            2. Context-aware (reference previous messages when relevant)
+            3. Use GIFs that match the emotional context
             
-            Use 0-1 GIFs per message unless the moment really calls for more."""
+            Use 0-1 GIFs per message unless the moment really calls for more.
+            Keep search terms simple and universal for better GIF matching."""
 
             # Prepare conversation history
             messages = [{"role": "system", "content": system_message}]
@@ -202,6 +234,7 @@ class GifChatBot:
             ai_message = response.choices[0].message.content
             final_response = ""
             
+            # Split by GIF markers and process
             parts = ai_message.split("[GIF:")
             final_response += parts[0]
             
@@ -209,19 +242,23 @@ class GifChatBot:
                 gif_desc_end = part.find("]")
                 if gif_desc_end != -1:
                     gif_desc = part[:gif_desc_end].strip()
-                    print(f"Searching for GIF: {gif_desc}")
+                    print(f"\nProcessing GIF request: {gif_desc}")
                     gif_url = self.get_gif(gif_desc)
                     if gif_url:
                         final_response += f"\n![GIF]({gif_url})\n"
-                        print(f"Added GIF: {gif_url}")
+                        print(f"Successfully added GIF: {gif_url}")
+                    else:
+                        print("Failed to find suitable GIF")
                     final_response += part[gif_desc_end + 1:]
 
+            # Update history with new messages
             history.append(self.format_message("user", message))
             history.append(self.format_message("assistant", final_response))
             return "", history, ""
 
         except Exception as error:
             error_message = f"Oops! Something went wrong: {str(error)}"
+            print(f"Chat error: {error}")
             return message, history, error_message
 
 def create_interface():
@@ -258,7 +295,7 @@ def create_interface():
             label="Chat",
             bubble_full_width=False,
             height=450,
-            type="messages"
+            type="messages"  # Use new message format
         )
         
         with gr.Row():
@@ -298,6 +335,8 @@ def create_interface():
         - 💭 The conversation is context-aware
         - 🎯 GIFs are chosen to match the emotion
         - 🔄 Use 'Clear Chat' to start fresh
+        
+        Note: GIFs are carefully validated to ensure quality (minimum 500KB size).
         """)
     
     return interface