feat: Major optimizations - Quiz dynamic fonts, TTS 1.2x speed, Video stream copy (10x faster), Single API call, Fact Image dynamic fonts, Text Story position fix

modules/fact_image/services/text_overlay.py

@@ -77,23 +77,33 @@ class TextOverlay:
         
         return self._font_cache[cache_key]
     
-    def _wrap_text(self, text: str, max_words_per_line: int = 4) -> str:
+    def _wrap_text(self, text: str, max_words_per_line: int = 4, max_chars_per_line: int = 25) -> str:
         """
         Wrap text for optimal display.
         
         Rules:
-        - Max 4-5 words per line
+        - Max characters per line to prevent overflow
+        - Max words per line for readability
         - Natural line breaks
         """
         words = text.split()
         lines = []
         current_line = []
+        current_char_count = 0
         
         for word in words:
-            current_line.append(word)
-            if len(current_line) >= max_words_per_line:
+            word_len = len(word)
+            # Check if adding this word would exceed limits
+            new_char_count = current_char_count + word_len + (1 if current_line else 0)
+            
+            if (len(current_line) >= max_words_per_line or 
+                new_char_count > max_chars_per_line) and current_line:
                 lines.append(' '.join(current_line))
-                current_line = []
+                current_line = [word]
+                current_char_count = word_len
+            else:
+                current_line.append(word)
+                current_char_count = new_char_count
         
         if current_line:
             lines.append(' '.join(current_line))
@@ -177,17 +187,59 @@ class TextOverlay:
         overlay = Image.new('RGBA', img.size, (0, 0, 0, 0))
         draw = ImageDraw.Draw(overlay)
         
-        # Get fonts (both bold now)
-        heading_font = self._get_font(self.HEADING_FONT_SIZE, bold=True)
-        text_font = self._get_font(self.TEXT_FONT_SIZE, bold=True)  # Fact text also bold
-        
-        # Calculate max width
+        # Calculate max width (with padding on sides)
         max_width = self.TARGET_WIDTH - (2 * self.PADDING_X)
         
-        # Prepare wrapped text
-        wrapped_text = self._wrap_text(text)
+        # Dynamic font size for HEADING based on text length
+        heading_text_length = len(heading) if heading else 0
+        if heading_text_length <= 15:
+            heading_font_size = 80  # Large for short heading
+        elif heading_text_length <= 25:
+            heading_font_size = 70
+        elif heading_text_length <= 35:
+            heading_font_size = 60
+        elif heading_text_length <= 50:
+            heading_font_size = 50
+        else:
+            heading_font_size = 42  # Minimum for very long heading
+        
+        # Dynamic font size for FACT TEXT based on text length
+        text_length = len(text)
+        if text_length <= 50:
+            text_font_size = 60  # Large for short text
+        elif text_length <= 100:
+            text_font_size = 52
+        elif text_length <= 150:
+            text_font_size = 46
+        elif text_length <= 200:
+            text_font_size = 40
+        elif text_length <= 300:
+            text_font_size = 36
+        else:
+            text_font_size = 32  # Minimum for very long text
+        
+        # Get fonts with dynamic sizes (both bold)
+        heading_font = self._get_font(heading_font_size, bold=True)
+        text_font = self._get_font(text_font_size, bold=True)
+        
+        # Word wrap text with dynamic font to fit max_width
+        words = text.split()
+        lines = []
+        current_line = ""
+        for word in words:
+            test_line = current_line + " " + word if current_line else word
+            bbox = draw.textbbox((0, 0), test_line, font=text_font)
+            if bbox[2] - bbox[0] <= max_width:
+                current_line = test_line
+            else:
+                if current_line:
+                    lines.append(current_line)
+                current_line = word
+        if current_line:
+            lines.append(current_line)
+        wrapped_text = "\n".join(lines)
         
-        # Calculate text dimensions
+        # Calculate text dimensions with wrapped text
         text_bbox = draw.multiline_textbbox((0, 0), wrapped_text, font=text_font)
         text_width = text_bbox[2] - text_bbox[0]
         text_height = text_bbox[3] - text_bbox[1]

modules/quiz_reel/router.py

@@ -79,7 +79,7 @@ async def generate_quiz_video(job_id: str, quizzes: list, voice: str):
             question_audio_path = os.path.join(temp_dir, f"question_{i}.wav")
             
             logger.info(f"Generating TTS for question {i+1}: {question_text[:30]}...")
-            audio_bytes, duration = await tts_client.generate(text=question_text, voice=voice)
+            audio_bytes, duration = await tts_client.generate(text=question_text, voice=voice, speed=1.2)
             with open(question_audio_path, "wb") as f:
                 f.write(audio_bytes)
             
@@ -90,7 +90,7 @@ async def generate_quiz_video(job_id: str, quizzes: list, voice: str):
             answer_audio_path = os.path.join(temp_dir, f"answer_{i}.wav")
             
             logger.info(f"Generating TTS for answer {i+1}: {answer_text[:30]}...")
-            audio_bytes, duration = await tts_client.generate(text=answer_text, voice=voice)
+            audio_bytes, duration = await tts_client.generate(text=answer_text, voice=voice, speed=1.2)
             with open(answer_audio_path, "wb") as f:
                 f.write(audio_bytes)
             

modules/quiz_reel/services/quiz_frame.py

@@ -182,13 +182,37 @@ class QuizFrameGenerator:
         img = self._create_gradient_background()
         draw = ImageDraw.Draw(img)
         
-        # Hook text with background box
+        # Hook text with background box and dynamic font sizing
         if hook:
             hook_text = hook.upper()
             hook_y = int(self.HEIGHT * self.HOOK_Y)
             
-            # Calculate hook text dimensions
-            bbox = draw.textbbox((0, 0), hook_text, font=self.font_hook)
+            # Calculate dynamic font size based on text length
+            text_length = len(hook_text)
+            if text_length <= 10:
+                hook_font_size = 72  # Default large
+            elif text_length <= 15:
+                hook_font_size = 60
+            elif text_length <= 20:
+                hook_font_size = 50
+            elif text_length <= 30:
+                hook_font_size = 40
+            else:
+                hook_font_size = 32  # Minimum size
+            
+            # Load hook font with calculated size
+            hook_font = self.font_hook
+            for path in ["C:/Windows/Fonts/arial.ttf", "C:/Windows/Fonts/ArialBD.ttf",
+                         "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"]:
+                if os.path.exists(path):
+                    try:
+                        hook_font = ImageFont.truetype(path, hook_font_size)
+                        break
+                    except:
+                        pass
+            
+            # Calculate hook text dimensions with dynamic font
+            bbox = draw.textbbox((0, 0), hook_text, font=hook_font)
             text_width = bbox[2] - bbox[0]
             text_height = bbox[3] - bbox[1]
             
@@ -204,9 +228,11 @@ class QuizFrameGenerator:
             self._draw_rounded_rect(draw, (box_x1, box_y1, box_x2, box_y2), 
                                    self.HOOK_BG_COLOR, radius=25)
             
-            # Draw hook text centered in box
-            self._draw_text_centered(draw, hook_text, hook_y, 
-                                     self.font_hook, self.HOOK_COLOR)
+            # Draw hook text centered in box with dynamic font
+            bbox = draw.textbbox((0, 0), hook_text, font=hook_font)
+            text_width = bbox[2] - bbox[0]
+            x = (self.WIDTH - text_width) // 2
+            draw.text((x, hook_y), hook_text, fill=self.HOOK_COLOR, font=hook_font)
         
         # Question card
         card_x1 = int(self.WIDTH * 0.05)
@@ -277,9 +303,10 @@ class QuizFrameGenerator:
             x = (self.WIDTH - text_width) // 2
             draw.text((x, text_start_y + i * line_height), line, fill=self.QUESTION_TEXT, font=question_font)
         
-        # Options
+        # Options - with dynamic font sizing
         option_width = int(self.WIDTH * 0.85)
         option_x = (self.WIDTH - option_width) // 2
+        max_option_text_width = option_width - 60  # Leave padding
         
         for i, (key, value) in enumerate(options.items()):
             y_pos = int(self.HEIGHT * (self.OPTIONS_START + i * self.OPTIONS_GAP))
@@ -289,12 +316,37 @@ class QuizFrameGenerator:
                 (option_x, y_pos, option_x + option_width, y_pos + self.OPTION_HEIGHT),
                 self.OPTION_DEFAULT_BG, radius=50)
             
-            # Option text
+            # Option text with dynamic font size (like question)
             option_text = f"{key}. {value}"
-            bbox = draw.textbbox((0, 0), option_text, font=self.font_option)
+            text_length = len(option_text)
+            
+            # Calculate optimal font size based on text length
+            if text_length <= 20:
+                font_size = 36  # Default size
+            elif text_length <= 35:
+                font_size = 32
+            elif text_length <= 50:
+                font_size = 28
+            elif text_length <= 70:
+                font_size = 24
+            else:
+                font_size = 20  # Minimum size
+            
+            # Load font with calculated size
+            option_font = self.font_option
+            for path in ["C:/Windows/Fonts/arial.ttf", "C:/Windows/Fonts/ArialBD.ttf",
+                         "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"]:
+                if os.path.exists(path):
+                    try:
+                        option_font = ImageFont.truetype(path, font_size)
+                        break
+                    except:
+                        pass
+            
+            bbox = draw.textbbox((0, 0), option_text, font=option_font)
             text_height = bbox[3] - bbox[1]
             text_y = y_pos + (self.OPTION_HEIGHT - text_height) // 2
-            draw.text((option_x + 30, text_y), option_text, fill=self.OPTION_TEXT, font=self.font_option)
+            draw.text((option_x + 30, text_y), option_text, fill=self.OPTION_TEXT, font=option_font)
         
         # Bottom right removed (was sparkle icon)
         
@@ -492,7 +544,7 @@ class QuizFrameGenerator:
                 checkmark_y = y_pos + self.OPTION_HEIGHT // 2
                 self._draw_checkmark(draw, (checkmark_x, checkmark_y))
         
-        # Explain section with heading
+        # Explain section with heading and white background box
         if explain:
             # Options end at approximately 67% (OPTIONS_START + 3*OPTIONS_GAP + OPTION_HEIGHT)
             # Explain text at EXPLAIN_Y (72%)
@@ -502,7 +554,6 @@ class QuizFrameGenerator:
             heading_y = (options_end_y + explain_text_y) // 2  # Midpoint
             
             # "Explanation" heading (bold, bigger font, different color - cyan/teal)
-            heading_color = (56, 189, 248)  # Sky blue #38BDF8
             heading_text = "Explanation"
             
             # Load 52px font for heading
@@ -516,12 +567,76 @@ class QuizFrameGenerator:
                     except:
                         pass
             
-            # Draw heading centered
-            self._draw_text_centered(draw, heading_text, heading_y, heading_font, heading_color)
+            # Dynamic font size for explain text based on length
+            explain_length = len(explain)
+            if explain_length <= 30:
+                explain_font_size = 44  # Large for short text
+            elif explain_length <= 60:
+                explain_font_size = 38
+            elif explain_length <= 100:
+                explain_font_size = 32
+            elif explain_length <= 150:
+                explain_font_size = 28
+            else:
+                explain_font_size = 24  # Minimum for very long text
+            
+            # Load explain font with calculated size
+            explain_font = self.font_explain
+            for path in ["C:/Windows/Fonts/arial.ttf", "C:/Windows/Fonts/ArialBD.ttf",
+                         "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"]:
+                if os.path.exists(path):
+                    try:
+                        explain_font = ImageFont.truetype(path, explain_font_size)
+                        break
+                    except:
+                        pass
+            
+            # Word wrap explain text to fit in box
+            max_explain_width = int(self.WIDTH * 0.8)
+            words = explain.split()
+            lines = []
+            current_line = ""
+            for word in words:
+                test_line = current_line + " " + word if current_line else word
+                bbox = draw.textbbox((0, 0), test_line, font=explain_font)
+                if bbox[2] - bbox[0] <= max_explain_width:
+                    current_line = test_line
+                else:
+                    if current_line:
+                        lines.append(current_line)
+                    current_line = word
+            if current_line:
+                lines.append(current_line)
+            
+            wrapped_explain = "\n".join(lines)
+            
+            # Calculate wrapped text dimensions
+            explain_bbox = draw.multiline_textbbox((0, 0), wrapped_explain, font=explain_font)
+            explain_width = explain_bbox[2] - explain_bbox[0]
+            explain_height = explain_bbox[3] - explain_bbox[1]
+            
+            # Fixed box size (relative to screen width)
+            box_width = int(self.WIDTH * 0.9)
+            box_padding_x = 40
+            box_padding_y = 25
+            box_x1 = (self.WIDTH - box_width) // 2
+            box_x2 = box_x1 + box_width
+            box_y1 = heading_y - 20  # Above heading
+            box_y2 = explain_text_y + 30 + explain_height + box_padding_y + 20  # Below explain text
+            
+            # Draw white rounded rectangle background
+            self._draw_rounded_rect(draw, (box_x1, box_y1, box_x2, box_y2), 
+                                   (255, 255, 255), radius=20)
+            
+            # Draw heading centered (now on white bg, use darker color)
+            heading_color_on_white = (30, 100, 150)  # Darker blue for white bg
+            self._draw_text_centered(draw, heading_text, heading_y, heading_font, heading_color_on_white)
             
-            # Explain text at original position
-            self._draw_text_centered(draw, explain, explain_text_y + 30, self.font_explain, 
-                                    self.EXPLAIN_COLOR, max_width=int(self.WIDTH * 0.85))
+            # Draw wrapped explain text centered (use dark text on white bg)
+            explain_text_color = (50, 50, 50)  # Dark gray for visibility
+            text_x = (self.WIDTH - explain_width) // 2
+            draw.multiline_text((text_x, explain_text_y + 30), wrapped_explain, 
+                               fill=explain_text_color, font=explain_font, align="center")
         
         # Bottom right removed (was sparkle icon)
         

modules/text_story/router.py

@@ -310,7 +310,7 @@ OUTPUT FORMAT (strict JSON):
         {{"sender": "A", "text": "What's up?"}},
         ...
     ],
-    "ending_text": "To be continued..."
+    "ending_text": ""
 }}
 
 Only output valid JSON, nothing else."""

modules/text_story/services/renderer.py

@@ -26,7 +26,7 @@ CANVAS_HEIGHT = 1920
 # - Small avatar next to other person's messages
 
 LAYOUT = {
-    "top_margin": 670,            # 35% from top (1920 * 0.35)
+    "top_margin": 500,            # 26% from top (moved up 8-10% from original 35%)
     "side_margin": 50,            # More side margin (left/right)
     "chat_box_width": 980,        # Narrower card (1080 - 50*2)
     "chat_box_radius": 35,        # Rounded corners

modules/video_creator/services/libraries/ffmpeg_utils.py

@@ -135,6 +135,8 @@ class FFmpegUtils:
     def cut_video(input_path: Path, output_path: Path, start_time: float, duration: float):
         """
         Cut a segment from a video file using FFmpeg.
+        Uses stream copy for 10x faster cutting (no re-encoding).
+        Audio is removed since TTS is used separately.
         
         Args:
             input_path: Source video
@@ -145,12 +147,11 @@ class FFmpegUtils:
         try:
             cmd = [
                 "ffmpeg",
-                "-ss", str(start_time),
+                "-ss", str(start_time),   # Seek to start (before -i for fast seeking)
                 "-i", str(input_path),
                 "-t", str(duration),
-                "-c:v", "libx264",
-                "-preset", "fast",
-                "-c:a", "aac",
+                "-c:v", "copy",           # Stream copy - no re-encode (10x faster!)
+                "-an",                    # Remove audio (TTS is used)
                 "-y",
                 str(output_path)
             ]

modules/video_creator/services/libraries/tts_client.py

@@ -19,20 +19,21 @@ class TTSClient:
         self.api_url = api_url.rstrip('/')
         logger.info(f"Using cloud TTS API at {self.api_url}")
     
-    async def generate(self, text: str, voice: str) -> Tuple[bytes, float]:
+    async def generate(self, text: str, voice: str, speed: float = 1.0) -> Tuple[bytes, float]:
         """
         Generate speech from text
         
         Args:
             text: Text to convert to speech
             voice: Voice identifier (e.g., 'af_heart', 'am_adam')
+            speed: Speech speed multiplier (0.5-2.0, default 1.0)
         
         Returns:
             Tuple of (audio_bytes, duration_seconds)
         """
         endpoint = f"{self.api_url}/v1/audio/speech"
         
-        logger.debug(f"Generating audio with voice={voice}, text_length={len(text)}")
+        logger.debug(f"Generating audio with voice={voice}, speed={speed}, text_length={len(text)}")
         
         async with aiohttp.ClientSession() as session:
             async with session.post(
@@ -40,7 +41,8 @@ class TTSClient:
                 json={
                     "model": "kokoro",
                     "input": text,
-                    "voice": voice
+                    "voice": voice,
+                    "speed": speed
                 },
                 headers={"Content-Type": "application/json"},
                 timeout=aiohttp.ClientTimeout(total=120)

modules/video_creator/services/short_creator.py

@@ -197,66 +197,47 @@ class ShortCreator:
                 # Ensure keywords is a list for find_video
                 search_keywords = keywords if isinstance(keywords, list) else [keywords]
                 
-                # Search BOTH platforms (if configured) - pick best result
-                pexels_video = None
-                pixabay_video = None
+                # PRIORITY: Try ONE platform only to save API quota
+                # Priority: Pexels first, Pixabay as fallback
                 selected_video = None
-                video_source = None  # Track which platform we use
+                video_source = None
                 
-                # Try Pexels (if configured)
+                # Try Pexels FIRST (if configured)
                 if self.pexels:
                     try:
                         logger.debug(f"Searching Pexels for: {search_keywords}")
-                        pexels_video = self.pexels.find_video(
+                        selected_video = self.pexels.find_video(
                             search_keywords,
                             search_duration,
                             exclude_video_ids,
                             orientation
                         )
+                        if selected_video:
+                            video_source = "Pexels"
+                            logger.info(f"Found video on Pexels for '{keyword}'")
                     except Exception as e:
                         logger.warning(f"Pexels search failed: {e}")
                 
-                # Try Pixabay (if configured) - ALWAYS try both
-                if self.pixabay:
+                # FALLBACK: Try Pixabay ONLY if Pexels didn't find anything
+                if not selected_video and self.pixabay:
                     try:
-                        logger.debug(f"Searching Pixabay for: {search_keywords}")
-                        pixabay_video = self.pixabay.find_video(
+                        logger.debug(f"Searching Pixabay (fallback) for: {search_keywords}")
+                        selected_video = self.pixabay.find_video(
                             search_keywords,
                             search_duration,
                             exclude_video_ids,
                             orientation
                         )
+                        if selected_video:
+                            video_source = "Pixabay"
+                            logger.info(f"Found video on Pixabay for '{keyword}'")
                     except Exception as e:
                         logger.warning(f"Pixabay search failed: {e}")
                 
-                # Smart Selection: Pick best video based on duration match
-                if pexels_video and pixabay_video:
-                    # Both found - pick the one closer to required duration
-                    pexels_dur_diff = abs(pexels_video.get("duration", 0) - search_duration)
-                    pixabay_dur_diff = abs(pixabay_video.get("duration", 0) - search_duration)
-                    
-                    if pexels_dur_diff <= pixabay_dur_diff:
-                        selected_video = pexels_video
-                        video_source = "Pexels"
-                    else:
-                        selected_video = pixabay_video
-                        video_source = "Pixabay"
-                        
-                    logger.info(f"Both APIs found videos - selected {video_source} (better duration match)")
-                    
-                elif pexels_video:
-                    selected_video = pexels_video
-                    video_source = "Pexels"
-                    logger.info(f"Found video on Pexels for '{keyword}'")
-                    
-                elif pixabay_video:
-                    selected_video = pixabay_video
-                    video_source = "Pixabay"
-                    logger.info(f"Found video on Pixabay for '{keyword}'")
-                
                 # If no video found on either platform
                 if not selected_video:
                     raise Exception(f"No video found for {search_keywords} on any platform")
+
                 
                 video_path = self.config.temp_dir_path / f"{temp_vid_id}.mp4"
                 temp_files.append(video_path)