update;

quote_generator_gemini.py

@@ -8,16 +8,18 @@ import json
 import time
 from typing import List, Optional
 
+
 class QuoteGenerator:
     """
     Gemini-powered quote generator with built-in variety tracking.
-    Prevents repetitive quotes by maintaining history in persistent storage.
+    Prevents repetitive quotes by maintaining history in persistent storage,
+    tracked per niche.
     """
-    
+
     def __init__(self, api_key: Optional[str] = None, history_file: str = "/data/quote_history.json"):
         """
         Initialize with Gemini API.
-        
+
         Args:
             api_key: Gemini API key (defaults to GEMINI_API_KEY env var)
             history_file: Path to persistent quote history storage
@@ -25,33 +27,34 @@ class QuoteGenerator:
         api_key = api_key or os.getenv("GEMINI_API_KEY")
         if not api_key:
             raise ValueError("GEMINI_API_KEY not found in environment variables")
-        
+
         genai.configure(api_key=api_key)
-        self.model = genai.GenerativeModel('gemini-1.5-flash')  # Updated model name
-        
+        # You can switch to "gemini-1.5-pro" if you want higher quality
+        self.model = genai.GenerativeModel("gemini-1.5-flash")
+
         # Persistent storage for quote history - PER NICHE
         self.history_file = history_file
-        self.quotes_by_niche = self._load_history()  # Returns dict
+        self.quotes_by_niche = self._load_history()  # dict: niche -> list[str]
         self.max_history = 100  # Keep last 100 quotes PER NICHE
-        
+
     def _load_history(self) -> dict:
         """Load quote history from persistent storage - organized by niche"""
         try:
             if os.path.exists(self.history_file):
-                with open(self.history_file, 'r') as f:
+                with open(self.history_file, "r") as f:
                     data = json.load(f)
                     # Support both old format (list) and new format (dict)
-                    if 'quotes_by_niche' in data:
+                    if "quotes_by_niche" in data:
                         print(f"📖 Loaded history for {len(data['quotes_by_niche'])} niches")
-                        return data['quotes_by_niche']
-                    elif 'quotes' in data:
-                        # Old format - migrate
-                        print("📖 Migrating to per-niche tracking")
-                        return {"General": data['quotes']}
+                        return data["quotes_by_niche"]
+                    elif "quotes" in data:
+                        # Old format - migrate to a default niche
+                        print("📖 Migrating to per-niche tracking (General)")
+                        return {"General": data["quotes"]}
         except Exception as e:
             print(f"Could not load history: {e}")
         return {}
-    
+
     def _save_history(self):
         """Save quote history to persistent storage"""
         try:
@@ -60,125 +63,142 @@ class QuoteGenerator:
             trimmed_data = {}
             for niche, quotes in self.quotes_by_niche.items():
                 trimmed_data[niche] = quotes[-self.max_history:]
-            
-            with open(self.history_file, 'w') as f:
-                json.dump({'quotes_by_niche': trimmed_data}, f, indent=2)
+
+            with open(self.history_file, "w") as f:
+                json.dump({"quotes_by_niche": trimmed_data}, f, indent=2)
         except Exception as e:
             print(f"Could not save history: {e}")
-    
+
     def generate_quote(self, niche: str, style: str) -> str:
         """
-        Generate a unique quote using Gemini with variety enforcement.
-        
+        Generate a unique, SHORT quote using Gemini with variety enforcement.
+
         Args:
             niche: Quote category (Motivation, Business, etc.)
             style: Visual style (Cinematic, Nature, etc.)
-        
+
         Returns:
-            A unique quote string
+            A unique quote string.
         """
-        
-        # Get this niche's history
+        # Ensure niche bucket exists
         if niche not in self.quotes_by_niche:
             self.quotes_by_niche[niche] = []
-        
+
         recent_quotes = self.quotes_by_niche[niche]
-        
+
         # Get recent quotes to avoid (last 30 for better variety)
         recent_quotes_text = ""
         if recent_quotes:
-            recent_quotes_text = f"\n\n❌ PREVIOUSLY GENERATED {niche.upper()} QUOTES (YOU MUST AVOID THESE - DO NOT REPEAT OR PARAPHRASE):\n"
-            for i, quote in enumerate(recent_quotes[-30:], 1):  # Last 30
+            recent_quotes_text = (
+                f"\n\nPREVIOUSLY GENERATED {niche.upper()} QUOTES "
+                f"(DO NOT REPEAT OR PARAPHRASE ANY OF THESE):\n"
+            )
+            for i, quote in enumerate(recent_quotes[-30:], 1):
                 recent_quotes_text += f"{i}. {quote}\n"
-            
-            print(f"📊 {niche} history: {len(recent_quotes)} total quotes, showing last 30 to avoid")
+
+            print(
+                f"📊 {niche} history: {len(recent_quotes)} total quotes, "
+                f"showing last {min(30, len(recent_quotes))} to avoid"
+            )
         else:
             print(f"📊 No {niche} history yet - generating first quote for this niche")
-        
-        # Build prompt with VERY strong variety instructions
-        prompt = f"""Generate a COMPLETELY UNIQUE and powerful {niche} quote suitable for an Instagram/TikTok video.
 
-Visual Style: {style}
+        # Build prompt with strong variety + length control
+        prompt = f"""
+Generate a COMPLETELY UNIQUE and SHORT {niche} quote suitable for an Instagram/TikTok video overlay.
 
-CRITICAL REQUIREMENTS - READ CAREFULLY:
-- 2-4 sentences maximum (can be longer if deeply meaningful)
-- Must be RADICALLY DIFFERENT from all previously generated quotes below
-- Inspirational and impactful
-- Deep and meaningful insights  
-- Fresh perspective that viewers haven't heard before
-- Unexpected wisdom or unique angle
-- DO NOT use clichés or overused phrases
-- AVOID common motivational phrases like "success is", "believe in yourself", "the only limit"
+Visual style / mood context: {style}
 
-{recent_quotes_text}
+STRICT FORMAT:
+- 1–2 short sentences ONLY (NO paragraphs)
+- Maximum 22 words total
+- The quote must be self-contained and readable in one quick glance on screen
 
-IMPORTANT: Your quote must be COMPLETELY ORIGINAL in:
-- Core message and theme (different life area or concept)
-- Wording and phrasing (no similar sentences)
-- Perspective and angle (unique viewpoint)
-- Examples or metaphors used (creative analogies)
+STYLE REQUIREMENTS:
+- Sharp, specific, and emotionally or philosophically strong
+- NO clichés (avoid things like "believe in yourself", "follow your dreams", "the only limit", "trust the process")
+- NO generic motivational filler, no long poetic rambling
+- Avoid starting with bland openers like "Sometimes", "In life", "When you", "If you", "Success is"
 
-Generate something viewers have NEVER seen before.
+VARIETY REQUIREMENTS:
+- Must be RADICALLY DIFFERENT from all previously generated quotes below
+- Do NOT reuse the same metaphors, structure, or idea as earlier quotes
+- New angle, new imagery, new insight
 
-Return ONLY the quote text, nothing else. No quotation marks, no attribution."""
+{recent_quotes_text}
+
+Return ONLY the quote text, nothing else:
+- No quotation marks
+- No author name
+- No emojis
+- No extra commentary
+"""
 
         try:
-            # Add timestamp-based variation
-            seed_value = int(time.time() * 1000) % 10000
-            
-            # Generate with high temperature for maximum variety
+            # Generate with moderate temperature and low token limit to keep it tight
             response = self.model.generate_content(
                 prompt,
                 generation_config={
-                    "temperature": 1.0,  # Maximum creativity
-                    "top_p": 0.95,
-                    "top_k": 64,
-                    "max_output_tokens": 200,
-                }
+                    "temperature": 0.7,
+                    "top_p": 0.9,
+                    "top_k": 40,
+                    "max_output_tokens": 60,  # keeps it short
+                },
             )
-            
+
             quote = response.text.strip()
             quote = quote.strip('"').strip("'").strip()
-            
-            # Check if this quote already exists in THIS niche
+
+            # If for some reason it's still long, hard-trim by words
+            words = quote.split()
+            if len(words) > 22:
+                quote = " ".join(words[:22])
+
+            # Check if this exact quote already exists in THIS niche
             if quote in recent_quotes:
-                print(f"⚠️ WARNING: Generated duplicate {niche} quote! Trying again with higher temperature...")
-                # Try one more time with even higher temperature
-                response = self.model.generate_content(
+                print(f"⚠️ WARNING: Generated duplicate {niche} quote! Retrying once with higher temperature...")
+                retry_response = self.model.generate_content(
                     prompt,
                     generation_config={
-                        "temperature": 1.2,  # Even higher
-                        "top_p": 0.98,
-                        "top_k": 80,
-                        "max_output_tokens": 200,
-                    }
+                        "temperature": 0.9,
+                        "top_p": 0.95,
+                        "top_k": 60,
+                        "max_output_tokens": 60,
+                    },
                 )
-                quote = response.text.strip().strip('"').strip("'").strip()
-            
-            # Add to this niche's history and save
+                quote_retry = retry_response.text.strip().strip('"').strip("'").strip()
+                words_retry = quote_retry.split()
+                if len(words_retry) > 22:
+                    quote_retry = " ".join(words_retry[:22])
+                quote = quote_retry
+
+            # Store in this niche's history and persist
             self.quotes_by_niche[niche].append(quote)
             self._save_history()
-            
-            print(f"✅ Generated unique {niche} quote #{len(self.quotes_by_niche[niche])}")
-            print(f"💾 Saved to: {self.history_file}")
-            
+
+            print(f"✅ Generated {niche} quote #{len(self.quotes_by_niche[niche])}")
+            print(f"💾 History file: {self.history_file}")
+
             return quote
-        
+
         except Exception as e:
             raise Exception(f"Gemini quote generation failed: {str(e)}")
-    
+
     def get_stats(self) -> dict:
         """Get statistics about quote generation - per niche"""
         total_quotes = sum(len(quotes) for quotes in self.quotes_by_niche.values())
         return {
             "total_quotes_generated": total_quotes,
-            "quotes_by_niche": {niche: len(quotes) for niche, quotes in self.quotes_by_niche.items()},
-            "niches_tracked": len(self.quotes_by_niche)
+            "quotes_by_niche": {
+                niche: len(quotes) for niche, quotes in self.quotes_by_niche.items()
+            },
+            "niches_tracked": len(self.quotes_by_niche),
         }
-    
+
     def clear_history(self, niche: Optional[str] = None):
-        """Clear quote history (use with caution)
-        
+        """
+        Clear quote history (use with caution).
+
         Args:
             niche: If provided, clear only this niche. Otherwise clear all.
         """
@@ -194,19 +214,18 @@ Return ONLY the quote text, nothing else. No quotation marks, no attribution."""
 class HybridQuoteGenerator:
     """
     Hybrid system using Gemini as primary, OpenAI as fallback.
-    Maximizes prize eligibility while ensuring reliability.
     """
-    
-    def __init__(self, gemini_key: Optional[str] = None, openai_client = None):
+
+    def __init__(self, gemini_key: Optional[str] = None, openai_client=None):
         """
         Initialize hybrid generator.
-        
+
         Args:
             gemini_key: Gemini API key
             openai_client: OpenAI client instance (for fallback)
         """
         self.openai_client = openai_client
-        
+
         try:
             self.gemini_generator = QuoteGenerator(api_key=gemini_key)
             self.gemini_available = True
@@ -214,20 +233,19 @@ class HybridQuoteGenerator:
         except Exception as e:
             self.gemini_available = False
             print(f"⚠️ Gemini not available: {e}")
-    
+
     def generate_quote(self, niche: str, style: str, prefer_gemini: bool = True) -> dict:
         """
         Generate quote with automatic fallback.
-        
+
         Args:
             niche: Quote category
             style: Visual style
             prefer_gemini: Try Gemini first if True
-        
+
         Returns:
-            Dict with quote, source, and metadata
+            Dict with quote, source, and metadata.
         """
-        
         # Try Gemini first
         if prefer_gemini and self.gemini_available:
             try:
@@ -237,11 +255,11 @@ class HybridQuoteGenerator:
                     "quote": quote,
                     "source": "gemini",
                     "stats": stats,
-                    "success": True
+                    "success": True,
                 }
             except Exception as e:
                 print(f"⚠️ Gemini failed, falling back to OpenAI: {e}")
-        
+
         # Fallback to OpenAI
         if self.openai_client:
             try:
@@ -250,53 +268,64 @@ class HybridQuoteGenerator:
                     "quote": quote,
                     "source": "openai",
                     "stats": None,
-                    "success": True
+                    "success": True,
                 }
             except Exception as e:
                 return {
                     "quote": None,
                     "source": None,
                     "error": f"Both generators failed: {str(e)}",
-                    "success": False
+                    "success": False,
                 }
-        
+
         return {
             "quote": None,
             "source": None,
             "error": "No generator available",
-            "success": False
+            "success": False,
         }
-    
+
     def _generate_openai(self, niche: str, style: str) -> str:
-        """OpenAI fallback generator"""
-        prompt = f"""Generate a UNIQUE and powerful {niche} quote suitable for an Instagram/TikTok video.
+        """OpenAI fallback generator (short quote version)"""
+        prompt = f"""
+Generate a UNIQUE, SHORT {niche} quote for an Instagram/TikTok video overlay.
 
-Style: {style}
+Style / mood: {style}
 
 Requirements:
-- 2-4 sentences (can be longer)
-- Inspirational and impactful
-- Deep and meaningful
-- Should resonate deeply with viewers
-- Must be DIFFERENT from typical motivational quotes
-- Add unexpected wisdom or fresh perspective
-
-Return ONLY the quote text, nothing else."""
-        
+- 1–2 short sentences ONLY
+- Maximum 22 words
+- Inspirational or insightful, but NOT generic
+- Avoid clichés like "believe in yourself", "follow your dreams", "the only limit", "trust the process"
+- No paragraphs, no long explanations
+
+Return ONLY the quote text, nothing else (no quotes, no author, no emojis).
+"""
+
         seed = int(time.time() * 1000) % 1000
-        
+
         response = self.openai_client.chat.completions.create(
             model="gpt-4o-mini",
             messages=[
-                {"role": "system", "content": f"You are a quote generator. Seed: {seed}"},
-                {"role": "user", "content": prompt}
+                {
+                    "role": "system",
+                    "content": f"You are a concise, original quote generator. Seed: {seed}",
+                },
+                {"role": "user", "content": prompt},
             ],
-            max_tokens=150,
-            temperature=0.9
+            max_tokens=60,
+            temperature=0.7,
         )
-        
+
         quote = response.choices[0].message.content.strip()
-        return quote.strip('"').strip("'")
+        quote = quote.strip('"').strip("'").strip()
+
+        # Hard trim in case model gets wordy
+        words = quote.split()
+        if len(words) > 22:
+            quote = " ".join(words[:22])
+
+        return quote
 
 
 # Integration function for smolagents tool
@@ -307,32 +336,28 @@ def create_hybrid_generator(openai_client):
     """
     return HybridQuoteGenerator(
         gemini_key=os.getenv("GEMINI_API_KEY"),
-        openai_client=openai_client
+        openai_client=openai_client,
     )
 
 
 # Example usage and testing
 if __name__ == "__main__":
-    # Test Gemini generator
-    print("Testing Gemini Quote Generator with Variety Tracking\n")
-    print("="*60)
-    
+    print("Testing Gemini Quote Generator with Variety Tracking (short quotes)\n")
+    print("=" * 60)
+
     try:
         generator = QuoteGenerator()
-        
-        # Generate 5 quotes to show variety
-        print("\nGenerating 5 quotes about Motivation/Cinematic:\n")
+
+        print("\nGenerating 5 short quotes about Motivation/Cinematic:\n")
         for i in range(5):
             quote = generator.generate_quote("Motivation", "Cinematic")
             print(f"{i+1}. {quote}\n")
-        
-        # Show stats
+
         stats = generator.get_stats()
         print("\nStats:")
         print(f"  Total generated: {stats['total_quotes_generated']}")
         print(f"  Niches tracked: {stats['niches_tracked']}")
         print(f"  Per niche: {stats['quotes_by_niche']}")
-        
     except Exception as e:
         print(f"Error: {e}")
-        print("\nMake sure GEMINI_API_KEY is set in environment variables")
+        print("\nMake sure GEMINI_API_KEY is set in environment variables")