Update app.py

app.py

@@ -12,12 +12,109 @@ class GifChatBot:
         self.chat_history = []
         self.is_initialized = False
         self.session = requests.Session()
-        # Set a custom User-Agent to mimic a browser
-        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"
-        })
+        
+        # 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
+
+    def verify_gif_size(self, gif_url: str) -> bool:
+        """Verify if GIF meets size requirements"""
+        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
+            
+        except Exception as error:
+            print(f"Size verification error: {error}")
+            return False
+
+    def get_gif(self, search_query: str) -> Optional[str]:
+        """Get a GIF meeting size requirements with retries"""
+        for attempt in range(self.MAX_RETRIES):
+            try:
+                # Calculate offset based on attempt number to get different results
+                offset = attempt * 10
+                
+                params = {
+                    'api_key': self.giphy_key,
+                    'q': search_query,
+                    'limit': 10,
+                    'offset': offset,
+                    'rating': 'pg-13'
+                }
+                
+                response = self.session.get(
+                    "https://api.giphy.com/v1/gifs/search",
+                    params=params,
+                    timeout=5
+                )
+                
+                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:
+                        print("No GIFs found in search")
+                        break
+                        
+            except Exception as error:
+                print(f"Error in attempt {attempt + 1}: {error}")
+                continue
+        
+        # If we get here, try trending as last resort
+        return self._get_trending_gif()
+
+    def _get_trending_gif(self) -> Optional[str]:
+        """Get a trending GIF meeting size requirements"""
+        try:
+            params = {
+                'api_key': self.giphy_key,
+                'limit': 25,
+                'rating': 'pg-13'
+            }
+            
+            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["data"]:
+                    gifs = list(data["data"])
+                    random.shuffle(gifs)
+                    
+                    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
+                            
+        except Exception as error:
+            print(f"Trending GIF error: {error}")
+        return None
 
     def setup_keys(self, openai_key: str, giphy_key: str) -> str:
         """Initialize API clients with user's keys"""
@@ -36,8 +133,7 @@ class GifChatBot:
         """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},
-            timeout=5
+            params={"api_key": self.giphy_key, "limit": 1}
         )
         if response.status_code != 200:
             raise Exception("Invalid GIPHY API key")
@@ -53,127 +149,6 @@ 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 and not an error page.
-        It first uses a HEAD request (with redirects allowed) and, if necessary, falls back to a GET.
-        URLs returning HTML or very small content (e.g. < 10KB) are rejected.
-        """
-        try:
-            # Always attempt verification to filter out error pages.
-            response = self.session.head(gif_url, timeout=3, allow_redirects=True)
-            if response.status_code != 200:
-                response = self.session.get(gif_url, timeout=5, stream=True, allow_redirects=True)
-            if response.status_code == 200:
-                content_type = response.headers.get('content-type', '').lower()
-                # If the content type is HTML, this is likely an error page.
-                if 'text/html' in content_type:
-                    return False
-                # Optionally check content length (reject very small files)
-                content_length = response.headers.get('content-length')
-                if content_length:
-                    try:
-                        if int(content_length) < 10000:
-                            return False
-                    except Exception:
-                        pass
-                if 'gif' in content_type or 'image' in content_type:
-                    return True
-            return False
-        except Exception:
-            return False
-
-    def get_gif(self, search_query: str) -> Optional[str]:
-        """Search GIPHY with validation for working GIFs"""
-        try:
-            params = {
-                'api_key': self.giphy_key,
-                'q': search_query,
-                'limit': 25,
-                'rating': 'pg-13',
-                'bundle': 'messaging_non_clips'
-            }
-            
-            response = self.session.get(
-                "https://api.giphy.com/v1/gifs/search",
-                params=params,
-                timeout=5
-            )
-            
-            if response.status_code == 200:
-                data = response.json()
-                if data.get("data"):
-                    gifs = list(data["data"])
-                    random.shuffle(gifs)
-                    
-                    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
-                    
-                    # Fallback: try a trending GIF if none in search pass verification.
-                    return self._get_trending_gif()
-            return None
-            
-        except Exception as error:
-            return None
-
-    def _get_trending_gif(self) -> Optional[str]:
-        """Get a verified trending GIF as fallback"""
-        try:
-            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.get("data"):
-                    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:
-            pass
-        return None
-
-    def _is_good_quality_gif(self, gif: Dict) -> bool:
-        """Check if a GIF meets quality criteria: number of frames, maximum size, and minimum size (500 KB)"""
-        try:
-            original = gif.get("images", {}).get("original", {})
-            # Reject if too many frames (more than 50)
-            if int(original.get("frames", 50)) > 50:
-                return False
-            
-            # Reject if file size is above 2MB
-            size = int(original.get("size", 0))
-            if size > 2000000:
-                return False
-            
-            # New check: Accept only GIFs above 500 KB
-            if size < 500000:
-                return False
-            
-            if not original.get("url"):
-                return False
-            
-            return True
-        except:
-            return False
-
     def reset_chat(self) -> Tuple[List[Dict[str, str]], str]:
         """Reset the chat history"""
         self.chat_history = []
@@ -192,26 +167,30 @@ class GifChatBot:
             return message, history, ""
 
         try:
-            system_message = (
-                "You are a supportive, empathetic friend who uses GIFs naturally in conversation. \n"
-                "When using GIFs, keep search terms simple and contextual:\n\n"
-                "Examples:\n"
-                "- User feeling hungry -> [GIF: hungry]\n"
-                "- User feeling sad -> [GIF: comforting hug]\n"
-                "- User celebrating -> [GIF: celebration]\n"
-                "- User confused -> [GIF: confused]\n\n"
-                "Keep your responses:\n"
-                "1. Empathetic and natural\n"
-                "2. Context-aware\n"
-                "3. Use GIFs that match the emotion\n\n"
-                "Use 0-1 GIFs per message unless the moment really calls for more."
-            )
+            # 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:
+
+            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 natural
+            2. Context-aware (reference previous messages)
+            3. Use GIFs that match the emotion
+            
+            Use 0-1 GIFs per message unless the moment really calls for more."""
 
+            # 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,
@@ -219,6 +198,7 @@ class GifChatBot:
                 max_tokens=150
             )
 
+            # Process response and insert GIFs
             ai_message = response.choices[0].message.content
             final_response = ""
             
@@ -229,9 +209,11 @@ 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}")
                     gif_url = self.get_gif(gif_desc)
                     if gif_url:
                         final_response += f"\n![GIF]({gif_url})\n"
+                        print(f"Added GIF: {gif_url}")
                     final_response += part[gif_desc_end + 1:]
 
             history.append(self.format_message("user", message))
@@ -276,7 +258,7 @@ def create_interface():
             label="Chat",
             bubble_full_width=False,
             height=450,
-            type="messages"  # Use new message format
+            type="messages"
         )
         
         with gr.Row():
@@ -322,4 +304,4 @@ def create_interface():
 
 if __name__ == "__main__":
     demo = create_interface()
-    demo.launch()
+    demo.launch()