Update app.py

app.py

@@ -4,8 +4,6 @@ import requests
 import json
 from typing import List, Dict, Optional, Tuple
 import random
-import time
-from datetime import datetime
 
 class GifChatBot:
     def __init__(self):
@@ -14,182 +12,106 @@ class GifChatBot:
         self.chat_history = []
         self.is_initialized = False
         self.session = requests.Session()
-        
-        # 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'
-        })
-        
-        # Parameters for GIF quality checking
-        self.minimum_gif_size = 10000  # 10KB minimum
-        self.maximum_gif_size = 2000000  # 2MB maximum
-        self.minimum_dimension = 200
-        self.maximum_dimension = 1000
-        self.maximum_frames = 50
 
-    def verify_gif_url(self, gif_url: str) -> bool:
-        """Verify GIF URL with relaxed validation for GIPHY URLs"""
+    def setup_keys(self, openai_key: str, giphy_key: str) -> str:
+        """Initialize API clients with user's keys"""
         try:
-            # Special handling for GIPHY URLs: assume they are valid if they come from giphy.com/media
-            if "giphy.com/media" in gif_url or "giphy.gif" in gif_url:
-                return True
-
-            # Use HEAD request with allow_redirects to properly follow URL redirects
-            head_response = self.session.head(gif_url, timeout=3, allow_redirects=True)
-            if head_response.status_code != 200:
-                print(f"HEAD request failed with status {head_response.status_code}")
-                return False
-
-            content_type = head_response.headers.get('content-type', '').lower()
-            if not ('gif' in content_type or 'image' in content_type):
-                print("Invalid content type:", content_type)
-                return False
-
-            return True
-
+            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:
-            print(f"GIF validation error: {error}")
-            # Be more lenient if the URL is from GIPHY
-            return "giphy.com/media" in gif_url
-
-    def _is_good_quality_gif(self, gif: Dict) -> bool:
-        """Comprehensive quality check for GIFs"""
-        try:
-            # Check required attributes
-            if not gif.get("images") or not gif.get("images").get("original"):
-                print("Missing image data")
-                return False
-
-            original = gif.get("images").get("original")
-
-            # Check dimensions
-            try:
-                width = int(original.get("width", 0))
-                height = int(original.get("height", 0))
-                
-                if width < self.minimum_dimension or height < self.minimum_dimension:
-                    print("GIF too small:", width, height)
-                    return False
-                if width > self.maximum_dimension or height > self.maximum_dimension:
-                    print("GIF too large:", width, height)
-                    return False
-            except (ValueError, TypeError):
-                print("Invalid dimensions")
-                return False
-
-            # Check frame count
-            try:
-                frames = int(original.get("frames", self.maximum_frames))
-                if frames > self.maximum_frames:
-                    print("Too many frames:", frames)
-                    return False
-            except (ValueError, TypeError):
-                print("Invalid frame count")
-                return False
+            self.is_initialized = False
+            return f"❌ Error setting up: {str(error)}"
 
-            # Check file size
-            try:
-                size = int(original.get("size", 0))
-                if size < self.minimum_gif_size or size > self.maximum_gif_size:
-                    print("Invalid size:", size)
-                    return False
-            except (ValueError, TypeError):
-                print("Invalid size data")
-                return False
+    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")
 
-            # Check if it's a newer GIF (longer ID generally means newer)
-            gif_id = gif.get("id", "")
-            if len(gif_id) < 10:
-                print("Old GIF (short ID)")
-                return False
+    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")
 
-            # Check trending status
-            if gif.get("is_trending"):
-                print("Currently trending")
+    def verify_gif_url(self, gif_url: str) -> bool:
+        """Verify if a GIF URL is accessible"""
+        try:
+            # Assume URLs from GIPHY are valid.
+            if "giphy.com/media" in gif_url or "giphy.gif" in gif_url:
                 return True
 
-            # Check recent trending status
-            trending_datetime = gif.get("trending_datetime")
-            if trending_datetime and trending_datetime != "0000-00-00 00:00:00":
-                try:
-                    trending_date = datetime.strptime(trending_datetime, "%Y-%m-%d %H:%M:%S")
-                    days_ago = (datetime.now() - trending_date).days
-                    if days_ago < 90:  # Recently trending
-                        print("Recently trending")
-                        return True
-                except:
-                    pass
+            # First try a HEAD request with redirects allowed.
+            response = self.session.head(gif_url, timeout=3, allow_redirects=True)
+            if response.status_code == 200:
+                content_type = response.headers.get('content-type', '').lower()
+                if 'gif' in content_type or 'image' in content_type:
+                    return True
 
-            return True
+            # If HEAD did not succeed, try a GET request with streaming.
+            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 'gif' in content_type or 'image' in content_type:
+                    return True
 
-        except Exception as error:
-            print(f"Quality check error: {error}")
+            return False
+        except Exception:
             return False
 
     def get_gif(self, search_query: str) -> Optional[str]:
-        """Search and validate GIPHY GIFs"""
+        """Search GIPHY with validation for working GIFs"""
         try:
-            print(f"Searching for GIF: {search_query}")
-            
-            # Search parameters
-            parameters = {
+            params = {
                 'api_key': self.giphy_key,
                 'q': search_query,
                 'limit': 25,
                 'rating': 'pg-13',
-                'bundle': 'messaging_non_clips',
-                'sort': 'relevant'
+                'bundle': 'messaging_non_clips'
             }
             
             response = self.session.get(
                 "https://api.giphy.com/v1/gifs/search",
-                params=parameters,
+                params=params,
                 timeout=5
             )
             
             if response.status_code == 200:
                 data = response.json()
-                if data.get("data"):
-                    # Sort by ID length (newer GIFs first)
-                    gifs = sorted(
-                        data["data"],
-                        key=lambda x: len(x.get("id", "")),
-                        reverse=True
-                    )
-                    
-                    print(f"Found {len(gifs)} GIFs, testing quality...")
+                if data["data"]:
+                    gifs = list(data["data"])
+                    random.shuffle(gifs)
                     
-                    # Try each GIF 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"]
-                        print(f"Testing GIF URL: {gif_url}")
-                        
                         if self.verify_gif_url(gif_url):
-                            print("Found good GIF!")
                             return gif_url
-                        else:
-                            print("GIF validation failed")
                     
-                    print("No good GIFs found, trying trending...")
                     return self._get_trending_gif()
-                else:
-                    print("No GIFs found in search")
-            else:
-                print(f"Search failed with status {response.status_code}")
-            
             return None
             
         except Exception as error:
-            print(f"GIPHY search error: {error}")
+            print(f"GIPHY error: {error}")
             return None
 
     def _get_trending_gif(self) -> Optional[str]:
-        """Get a verified trending GIF"""
+        """Get a verified trending GIF as fallback"""
         try:
-            print("Fetching trending GIF...")
             response = self.session.get(
                 "https://api.giphy.com/v1/gifs/trending",
                 params={
@@ -203,63 +125,34 @@ class GifChatBot:
             
             if response.status_code == 200:
                 data = response.json()
-                if data.get("data"):
+                if data["data"]:
                     gifs = list(data["data"])
                     random.shuffle(gifs)
                     
-                    print(f"Testing {len(gifs)} trending GIFs...")
                     for gif in gifs:
-                        if not self._is_good_quality_gif(gif):
-                            continue
-                            
                         gif_url = gif["images"]["original"]["url"]
-                        print(f"Testing trending GIF: {gif_url}")
-                        
                         if self.verify_gif_url(gif_url):
-                            print("Found good trending GIF!")
                             return gif_url
-                        else:
-                            print("Trending GIF validation failed")
-            
-            print("No good trending GIFs found")
-            return None
                             
         except Exception as error:
             print(f"Error getting trending GIF: {error}")
-            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")
+        return None
 
-    def _test_openai_key(self):
-        """Test if OpenAI key is valid"""
+    def _is_good_quality_gif(self, gif: Dict) -> bool:
+        """Check if a GIF meets quality criteria"""
         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")
+            if int(gif.get("images", {}).get("original", {}).get("frames", 50)) > 50:
+                return False
+            
+            if int(gif.get("images", {}).get("original", {}).get("size", 0)) > 2000000:
+                return False
+            
+            if not gif.get("images", {}).get("original", {}).get("url"):
+                return False
+            
+            return True
+        except:
+            return False
 
     def reset_chat(self) -> Tuple[List[Dict[str, str]], str]:
         """Reset the chat history"""
@@ -279,20 +172,26 @@ class GifChatBot:
             return message, history, ""
 
         try:
-            # System message for the AI
             system_message = (
-                "You are a supportive, empathetic friend who uses GIFs naturally and proactively in conversation regardless of "
-                "whether the user requests it or not. When using GIFs, deduce what type of terms or keywords may be used to search "
-                "for the GIF and pick a reliable one randomly."
+                "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."
             )
 
-            # 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,
@@ -300,7 +199,6 @@ class GifChatBot:
                 max_tokens=150
             )
 
-            # Process response and insert GIFs
             ai_message = response.choices[0].message.content
             final_response = ""
             
@@ -311,23 +209,17 @@ class GifChatBot:
                 gif_desc_end = part.find("]")
                 if gif_desc_end != -1:
                     gif_desc = part[:gif_desc_end].strip()
-                    print(f"Looking 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}")
-                    else:
-                        print("No suitable GIF found")
                     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():
@@ -337,7 +229,7 @@ def create_interface():
     with gr.Blocks(theme=gr.themes.Soft()) as interface:
         gr.Markdown("""
         # 🎭 Friendly Chat Bot with GIFs
-        Chat with an empathetic AI friend who expresses themselves through GIFs that are verified to work! 
+        Chat with an empathetic AI friend who expresses themselves through GIFs! 
         Enter your API keys below to start.
         """)
         
@@ -400,7 +292,10 @@ def create_interface():
         
         gr.Markdown("""
         ### Tips:
-        - Always check whether the GIF is broken or not before sending. Only non-broken GIFs will be used.
+        - 🤝 Share how you're feeling - the AI responds empathetically
+        - 💭 The conversation is context-aware
+        - 🎯 GIFs are chosen to match the emotion
+        - 🔄 Use 'Clear Chat' to start fresh
         """)
     
     return interface