Update app.py

app.py

@@ -5,15 +5,23 @@ import json
 from typing import List, Dict, Optional, Tuple
 import random
 import time
+from datetime import datetime
 
 class GifChatBot:
     def __init__(self):
+        """Initialize the chatbot with necessary configurations"""
         self.openai_client = None
         self.giphy_key = None
         self.chat_history = []
         self.is_initialized = False
         self.session = requests.Session()
         
+        # Constants for GIF validation
+        self.MINIMUM_SIZE_KB = 500  # Strict 500KB minimum
+        self.MAXIMUM_SIZE_MB = 5    # 5MB maximum
+        self.MAX_SEARCH_ATTEMPTS = 5
+        self.RESULTS_PER_PAGE = 50
+        
         # 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'
@@ -24,7 +32,6 @@ class GifChatBot:
         try:
             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
@@ -53,28 +60,32 @@ class GifChatBot:
         except Exception:
             raise Exception("Invalid OpenAI API key")
 
+    def _verify_gif_url(self, url: str) -> bool:
+        """Verify GIF URL is accessible"""
+        try:
+            response = self.session.head(url, timeout=3)
+            return response.status_code == 200
+        except:
+            return False
+
     def get_gif(self, search_query: str) -> Optional[str]:
-        """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
+        """Persistently search for a GIF above 500KB"""
+        attempt = 0
+        offset = 0
         
         print(f"\nSearching for GIF: {search_query}")
         
-        while total_attempts < max_total_attempts:
+        while attempt < self.MAX_SEARCH_ATTEMPTS:
             try:
-                # Calculate offset for pagination
-                offset = total_attempts * 25
-                
                 params = {
                     'api_key': self.giphy_key,
                     'q': search_query,
-                    'limit': 25,
+                    'limit': self.RESULTS_PER_PAGE,
                     'offset': offset,
                     'rating': 'pg-13'
                 }
                 
-                print(f"Attempt {total_attempts + 1} with offset {offset}")
+                print(f"Attempt {attempt + 1} with offset {offset}")
                 
                 response = self.session.get(
                     "https://api.giphy.com/v1/gifs/search",
@@ -85,97 +96,113 @@ class GifChatBot:
                 if response.status_code == 200:
                     data = response.json()
                     if not data.get("data"):
-                        print("No GIFs found in search")
+                        print("No GIFs found, modifying search...")
+                        # Try appending "reaction" to search query
+                        if "reaction" not in search_query.lower():
+                            search_query += " reaction"
+                            offset = 0
+                            attempt += 1
+                            continue
                         break
                     
-                    print(f"Found {len(data['data'])} GIFs, filtering by size...")
-                    
-                    # Filter GIFs by size first
+                    # First sort by size to try largest GIFs 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")
+                                size_kb = size_bytes / 1024
+                                if size_kb >= self.MINIMUM_SIZE_KB:
+                                    valid_gifs.append((size_kb, gif))
+                                    print(f"Found valid GIF: {size_kb:.2f}KB")
                         except (KeyError, ValueError) as e:
-                            print(f"Size parsing error for GIF: {e}")
                             continue
                     
+                    # Sort by size, largest first
+                    valid_gifs.sort(reverse=True, key=lambda x: x[0])
+                    
                     if valid_gifs:
-                        # Randomly select from valid GIFs
-                        chosen_gif = random.choice(valid_gifs)
+                        # Pick one of the top 5 largest GIFs randomly
+                        top_gifs = valid_gifs[:5]
+                        size_kb, chosen_gif = random.choice(top_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"Selected GIF size: {size_kb:.2f}KB")
+                        # Verify URL is accessible
+                        if self._verify_gif_url(url):
+                            return url
+                        print("GIF URL verification failed, continuing search...")
                     
-                    print(f"No GIFs >= 500KB found in attempt {total_attempts + 1}")
+                    # If we didn't find a valid GIF or URL verification failed
+                    offset += self.RESULTS_PER_PAGE
+                    attempt += 1
+                    continue
                 
-                total_attempts += 1
+                attempt += 1
                 
             except Exception as error:
-                print(f"Error in attempt {total_attempts + 1}: {error}")
-                total_attempts += 1
+                print(f"Error in attempt {attempt + 1}: {error}")
+                attempt += 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 with size verification"""
-        minimum_size_bytes = 500000  # 500KB in bytes
+        """Get a trending GIF ensuring 500KB minimum size"""
+        attempt = 0
         
-        try:
-            params = {
-                'api_key': self.giphy_key,
-                'limit': 25,
-                'rating': 'pg-13'
-            }
-            
-            print("Fetching trending GIFs...")
-            
-            response = self.session.get(
-                "https://api.giphy.com/v1/gifs/trending",
-                params=params,
-                timeout=5
-            )
-            
-            if response.status_code == 200:
-                data = response.json()
-                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
-                    
-                    print("No valid trending GIFs found")
+        while attempt < 3:  # Try up to 3 times with trending
+            try:
+                params = {
+                    'api_key': self.giphy_key,
+                    'limit': self.RESULTS_PER_PAGE,
+                    'rating': 'pg-13'
+                }
+                
+                print(f"Fetching trending GIFs (attempt {attempt + 1})...")
+                
+                response = self.session.get(
+                    "https://api.giphy.com/v1/gifs/trending",
+                    params=params,
+                    timeout=5
+                )
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    if data.get("data"):
+                        # Sort 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)
+                                    size_kb = size_bytes / 1024
+                                    if size_kb >= self.MINIMUM_SIZE_KB:
+                                        valid_gifs.append((size_kb, gif))
+                                        print(f"Found valid trending GIF: {size_kb:.2f}KB")
+                            except (KeyError, ValueError):
+                                continue
                         
-        except Exception as error:
-            print(f"Trending GIF error: {error}")
+                        # Sort by size, largest first
+                        valid_gifs.sort(reverse=True, key=lambda x: x[0])
+                        
+                        if valid_gifs:
+                            # Pick one of the top 5 largest GIFs randomly
+                            top_gifs = valid_gifs[:5]
+                            size_kb, chosen_gif = random.choice(top_gifs)
+                            url = chosen_gif["images"]["original"]["url"]
+                            if self._verify_gif_url(url):
+                                print(f"Selected trending GIF: {size_kb:.2f}KB")
+                                return url
+                
+                attempt += 1
+                
+            except Exception as error:
+                print(f"Trending GIF error: {error}")
+                attempt += 1
         
         print("Failed to find any suitable GIFs")
         return None
@@ -198,9 +225,10 @@ class GifChatBot:
             return message, history, ""
 
         try:
-            # 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:
+            # Enhanced system message emphasizing GIF requirements
+            system_message = """You are a supportive, empathetic friend who uses GIFs naturally in conversation.
+            IMPORTANT: All GIFs must be high quality (>500KB). If a suitable GIF isn't found, the system will 
+            keep searching until it finds one. Keep search terms simple and universal:
 
             Examples:
             - User feeling hungry -> [GIF: hungry]
@@ -210,19 +238,17 @@ class GifChatBot:
             
             Keep your responses:
             1. Empathetic and natural
-            2. Context-aware (reference previous messages when relevant)
-            3. Use GIFs that match the emotional context
+            2. Context-aware
+            3. Use GIFs that match the emotion
+            4. Simple search terms for better matches
             
-            Use 0-1 GIFs per message unless the moment really calls for more.
-            Keep search terms simple and universal for better GIF matching."""
+            The system will automatically ensure all GIFs meet quality requirements."""
 
-            # Prepare conversation history
             messages = [{"role": "system", "content": system_message}]
             for chat in history:
                 messages.append({"role": chat["role"], "content": chat["content"]})
             messages.append({"role": "user", "content": message})
 
-            # Get AI response
             response = self.openai_client.chat.completions.create(
                 model="gpt-4o-mini",
                 messages=messages,
@@ -230,11 +256,9 @@ class GifChatBot:
                 max_tokens=150
             )
 
-            # Process response and insert GIFs
             ai_message = response.choices[0].message.content
             final_response = ""
             
-            # Split by GIF markers and process
             parts = ai_message.split("[GIF:")
             final_response += parts[0]
             
@@ -243,15 +267,22 @@ class GifChatBot:
                 if gif_desc_end != -1:
                     gif_desc = part[:gif_desc_end].strip()
                     print(f"\nProcessing GIF request: {gif_desc}")
-                    gif_url = self.get_gif(gif_desc)
+                    gif_url = None
+                    
+                    # Keep trying until we get a valid GIF
+                    retry_count = 0
+                    while not gif_url and retry_count < 3:
+                        gif_url = self.get_gif(gif_desc)
+                        if not gif_url:
+                            print(f"Retrying GIF search (attempt {retry_count + 1})...")
+                            retry_count += 1
+                    
                     if gif_url:
                         final_response += f"\n![GIF]({gif_url})\n"
                         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, ""
@@ -295,7 +326,7 @@ def create_interface():
             label="Chat",
             bubble_full_width=False,
             height=450,
-            type="messages"  # Use new message format
+            type="messages"
         )
         
         with gr.Row():
@@ -336,7 +367,7 @@ def create_interface():
         - 🎯 GIFs are chosen to match the emotion
         - 🔄 Use 'Clear Chat' to start fresh
         
-        Note: GIFs are carefully validated to ensure quality (minimum 500KB size).
+        Note: All GIFs are strictly validated to be above 500KB for quality assurance.
         """)
     
     return interface