Update app.py

app.py

@@ -14,7 +14,7 @@ import io
 import shutil
 from urllib.parse import quote
 import numpy as np
-from bs4 import BeautifulSoup
+from bs4 import BeautifulSoup # Keep import in case needed elsewhere, but not for search
 import base64
 from gtts import gTTS
 import gradio as gr
@@ -27,11 +27,10 @@ from moviepy.editor import (
     concatenate_videoclips, CompositeAudioClip
 )
 import moviepy.video.fx.all as vfx
-# No longer importing moviepy.config or calling change_settings for ImageMagick
 
-# Pydub imports (for potential gTTS fallback format conversion)
+# Pydub imports
 from pydub import AudioSegment
-from pydub.generators import Sine # Might not be needed if TTS works
+from pydub.generators import Sine
 
 # ---------------- Global Configuration ---------------- #
 # --- API Keys (Replace with your actual keys) ---
@@ -43,25 +42,24 @@ OUTPUT_VIDEO_FILENAME = "final_video.mp4"
 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"
 
 # --- Gradio Controlled Variables (with defaults) ---
-selected_voice = 'af_heart'  # Default voice (Kokoro American Female)
-voice_speed = 0.9          # Default voice speed
-font_size = 45             # Default caption font size
-video_clip_probability = 0.25 # Default probability for using video clips (25%)
-bg_music_volume = 0.08     # Default background music volume
-fps = 30                   # Default video frames per second
-preset = "veryfast"        # Default video export preset (faster, lower quality)
-caption_style_bg_color = 'rgba(0, 0, 0, 0.6)' # Background for captions
-caption_style_text_color = 'yellow' # Text color for captions
-caption_font = 'Arial-Bold' # Font for captions (ensure it's available)
+selected_voice = 'af_heart'
+voice_speed = 0.9
+font_size = 45
+video_clip_probability = 0.25 # Default 25%
+bg_music_volume = 0.08
+fps = 30
+preset = "veryfast"
+caption_style_bg_color = 'rgba(0, 0, 0, 0.6)'
+caption_style_text_color = 'yellow'
+caption_font = 'Arial-Bold'
 
 # --- Runtime Variables (set per execution) ---
-TARGET_RESOLUTION = None   # Will be set based on Gradio input (e.g., (1920, 1080))
-TEMP_FOLDER = None         # Will be created temporarily for each run
-USE_CAPTIONS = True        # Will be set based on Gradio input
+TARGET_RESOLUTION = None
+TEMP_FOLDER = None
+USE_CAPTIONS = True
 
 # ---------------- Kokoro TTS Initialization ---------------- #
 try:
-    # Initialize Kokoro TTS pipeline (using American English default)
     pipeline = KPipeline(lang_code='a')
     print("Kokoro TTS Pipeline initialized.")
 except Exception as e:
@@ -73,14 +71,14 @@ except Exception as e:
 
 def generate_script(user_input):
     """Generate documentary script using OpenRouter API."""
+    # --- Retain previous generate_script function ---
+    # (No changes needed here based on the request)
     headers = {
         'Authorization': f'Bearer {OPENROUTER_API_KEY}',
         'Content-Type': 'application/json',
-        # Optional but recommended:
         'HTTP-Referer': 'http://localhost:7860', # Or your app's URL
         'X-Title': 'AI Documentary Maker Gradio'
     }
-
     prompt = f"""Create a short, humorous, slightly negative, and conversational documentary-style script based on the following topic or instructions: '{user_input}'.
 
 Formatting Rules:
@@ -107,36 +105,30 @@ Subscribe now, or a cat will knock your coffee over.
 
 Now generate the script based on: {user_input}
 """
-
     data = {
         'model': OPENROUTER_MODEL,
         'messages': [{'role': 'user', 'content': prompt}],
-        'temperature': 0.6, # Slightly more creative for humor
-        'max_tokens': 600  # Adjust as needed
+        'temperature': 0.6,
+        'max_tokens': 600
     }
-
     try:
         response = requests.post(
             'https://openrouter.ai/api/v1/chat/completions',
             headers=headers,
             json=data,
-            timeout=45 # Increased timeout
+            timeout=45
         )
-
-        response.raise_for_status() # Raises HTTPError for bad responses (4xx or 5xx)
-
+        response.raise_for_status()
         response_data = response.json()
         if 'choices' in response_data and len(response_data['choices']) > 0:
             script_content = response_data['choices'][0]['message']['content']
-            # Basic cleaning: remove potential preamble/postamble if AI didn't follow instructions perfectly
-            script_content = re.sub(r"^.*?\n?\[", "[", script_content, flags=re.DOTALL) # Remove anything before the first bracket
+            script_content = re.sub(r"^.*?\n?\[", "[", script_content, flags=re.DOTALL)
             script_content = script_content.strip()
             print("Script generated successfully.")
             return script_content
         else:
             print(f"API Error: Unexpected response format: {response_data}")
             return None
-
     except requests.exceptions.Timeout:
         print("API Error: Request timed out.")
         return None
@@ -151,235 +143,179 @@ Now generate the script based on: {user_input}
         return None
 
 def parse_script(script_text):
-    """
-    Parse the generated script into a list of dictionaries,
-    each representing a segment with a visual prompt and narration.
-    """
+    """Parse the generated script into segments."""
+    # --- Retain previous parse_script function ---
+    # (No changes needed here based on the request)
     segments = []
     current_title = None
     current_narration = ""
-
     if not script_text:
         print("Error: Script text is empty.")
         return []
-
     lines = script_text.strip().splitlines()
-
     for line in lines:
         line = line.strip()
-        if not line:
-            continue
-
+        if not line: continue
         title_match = re.match(r'^\[(.*?)\](.*)', line)
-
         if title_match:
-            # If we were processing a previous title, save it
             if current_title is not None and current_narration.strip():
-                segments.append({
-                    "prompt": current_title,
-                    "narration": current_narration.strip()
-                })
-
-            # Start the new segment
+                segments.append({"prompt": current_title, "narration": current_narration.strip()})
             current_title = title_match.group(1).strip()
-            current_narration = title_match.group(2).strip() + " " # Add space for potential multi-line narration
+            current_narration = title_match.group(2).strip() + " "
         elif current_title is not None:
-            # Append to the current narration if it's not a new title line
             current_narration += line + " "
-
-    # Add the last segment
     if current_title is not None and current_narration.strip():
-        segments.append({
-            "prompt": current_title,
-            "narration": current_narration.strip()
-        })
-
+        segments.append({"prompt": current_title, "narration": current_narration.strip()})
     if not segments:
         print("Error: Could not parse any segments from the script.")
-        # Attempt a simpler parse if the strict format failed
         simple_segments = []
         for i, line in enumerate(lines):
-             if line.strip():
-                 simple_segments.append({"prompt": f"Scene {i+1}", "narration": line.strip()})
+             if line.strip(): simple_segments.append({"prompt": f"Scene {i+1}", "narration": line.strip()})
         if simple_segments:
              print("Warning: Using simplified script parsing.")
              return simple_segments
-        else:
-             return []
-
-
+        else: return []
     print(f"Parsed {len(segments)} segments from script.")
     return segments
 
+# --- MODIFIED: search_pexels Function ---
 def search_pexels(query, api_key, search_type="videos"):
-    """Search Pexels for videos or images."""
-    if not api_key:
-        print(f"Pexels API key not provided. Skipping Pexels {search_type} search.")
+    """Search Pexels for videos or images with improved error handling."""
+    if not api_key or api_key == 'YOUR_PEXELS_API_KEY':
+        print(f"Pexels API key not provided or is default. Skipping Pexels {search_type} search.")
         return None
 
     base_url = f"https://api.pexels.com/{search_type}/search"
     headers = {'Authorization': api_key}
     params = {"query": query, "per_page": 15, "orientation": "landscape"}
     if search_type == "videos":
-        params["size"] = "medium" # Request medium or large, HD might not always be available
+        params["size"] = "medium" # Request medium or large
 
     max_retries = 3
-    retry_delay = 1
+    retry_delay = 2 # Slightly longer initial delay
+    timeout_duration = 20 # Increased timeout
+
+    print(f"Searching Pexels {search_type} for '{query}'...")
 
     for attempt in range(max_retries):
         try:
-            response = requests.get(base_url, headers=headers, params=params, timeout=15)
-            response.raise_for_status() # Check for HTTP errors
+            response = requests.get(base_url, headers=headers, params=params, timeout=timeout_duration)
+
+            # Check for specific HTTP errors before raising general exception
+            if response.status_code == 401:
+                 print(f"Pexels API Error: Unauthorized (401). Check your API Key.")
+                 return None # Don't retry on auth errors
+            if response.status_code == 429:
+                 print(f"Pexels API Error: Rate limit hit (429) (attempt {attempt+1}/{max_retries}). Waiting {retry_delay*2}s...")
+                 time.sleep(retry_delay * 2) # Wait longer for rate limits
+                 retry_delay *= 2
+                 continue # Go to next attempt
+            if response.status_code == 522:
+                 print(f"Pexels API Error: Connection Timed Out (522) between Cloudflare and Pexels server (attempt {attempt+1}/{max_retries}). Retrying in {retry_delay}s...")
+                 # This error is external, retrying might help if temporary
+                 time.sleep(retry_delay)
+                 retry_delay *= 2
+                 continue # Go to next attempt
+
+            response.raise_for_status() # Raise exceptions for other 4xx/5xx errors
 
             data = response.json()
             items = data.get(search_type, [])
 
             if not items:
                 print(f"No Pexels {search_type} found for query: {query}")
-                return None
+                return None # No results found
 
+            # --- Filtering logic remains the same ---
             valid_items = []
             if search_type == "videos":
                 for video in items:
-                    # Prefer HD or Large, fallback to Medium
                     hd_link = next((f['link'] for f in video.get('video_files', []) if f.get('quality') == 'hd' and f.get('width', 0) >= 1080), None)
                     large_link = next((f['link'] for f in video.get('video_files', []) if f.get('quality') == 'large' and f.get('width', 0) >= 1080), None)
                     medium_link = next((f['link'] for f in video.get('video_files', []) if f.get('quality') == 'medium'), None)
                     link = hd_link or large_link or medium_link
-                    if link:
-                        valid_items.append(link)
+                    if link: valid_items.append(link)
             else: # images
                 for photo in items:
                     link = photo.get("src", {}).get("large2x") or photo.get("src", {}).get("original")
-                    if link:
-                        valid_items.append(link)
+                    if link: valid_items.append(link)
 
             if valid_items:
-                print(f"Found {len(valid_items)} Pexels {search_type} for '{query}'. Selecting one.")
+                print(f"Found {len(valid_items)} suitable Pexels {search_type} for '{query}'. Selecting one.")
                 return random.choice(valid_items)
             else:
                 print(f"No suitable quality Pexels {search_type} found for query: {query}")
                 return None
 
         except requests.exceptions.Timeout:
-            print(f"Pexels API timeout (attempt {attempt+1}/{max_retries})...")
+            print(f"Pexels API request timed out after {timeout_duration}s (attempt {attempt+1}/{max_retries}). Retrying in {retry_delay}s...")
             time.sleep(retry_delay)
             retry_delay *= 2
         except requests.exceptions.RequestException as e:
-            print(f"Pexels API error (attempt {attempt+1}/{max_retries}): {e}")
-            if response is not None and response.status_code == 429: # Rate limit
-                 print("Rate limit hit, waiting longer...")
-                 time.sleep(retry_delay * 2)
-                 retry_delay *= 2
-            else:
-                 time.sleep(retry_delay)
-                 retry_delay *= 2
+            print(f"Pexels API request error (attempt {attempt+1}/{max_retries}): {e}")
+            # Don't retry on general request errors unless specifically handled above
+            time.sleep(retry_delay)
+            retry_delay *= 2 # Still increase delay for next attempt if retrying
         except Exception as e:
             print(f"Unexpected error during Pexels search: {e}")
-            break # Don't retry on unexpected errors
+            break # Stop retrying on unexpected python errors
 
     print(f"Pexels {search_type} search failed for '{query}' after {max_retries} attempts.")
     return None
 
-def search_google_images(query):
-    """Search for images on Google Images (use sparingly and ethically)."""
-    print(f"Attempting Google Image search for: {query} (Use with caution)")
-    try:
-        # Using a simple search URL, might be fragile
-        search_url = f"https://www.google.com/search?q={quote(query)}&tbm=isch&safe=active"
-        headers = {"User-Agent": USER_AGENT}
-        response = requests.get(search_url, headers=headers, timeout=10)
-        response.raise_for_status()
-        soup = BeautifulSoup(response.text, "html.parser")
-
-        img_tags = soup.find_all("img")
-        image_urls = []
-
-        # Look for potential image URLs, prioritizing data-src or src containing http
-        for img in img_tags:
-            src = img.get("data-src") or img.get("src")
-            if src and src.startswith("http") and not "gstatic" in src and not src.startswith("data:image"):
-                 # Basic check for likely image file extensions
-                 if any(ext in src.lower() for ext in ['.jpg', '.jpeg', '.png', '.webp']):
-                    image_urls.append(src)
-
-        if image_urls:
-            # Return a random one from the first few results
-            print(f"Found {len(image_urls)} potential Google Images for '{query}'.")
-            return random.choice(image_urls[:min(len(image_urls), 10)])
-        else:
-            print(f"No suitable Google Images found for query: {query}")
-            return None
-    except requests.exceptions.RequestException as e:
-        print(f"Error during Google Images search request: {e}")
-        return None
-    except Exception as e:
-        print(f"Error parsing Google Images search results: {e}")
-        return None
+# --- REMOVED: search_google_images Function ---
+# def search_google_images(query):
+#     # ... function content removed ...
+#     pass
 
 def download_media(media_url, filename_prefix, target_folder):
     """Download media (image or video) from a URL."""
+    # --- Retain previous download_media function ---
+    # (No changes needed here based on the request, it handles Pexels URLs)
     try:
         headers = {"User-Agent": USER_AGENT}
         response = requests.get(media_url, headers=headers, stream=True, timeout=30)
         response.raise_for_status()
-
-        # Try to determine file extension from URL or Content-Type
-        content_type = response.headers.get('content-type')
+        content_type = response.headers.get('content-type', '').lower()
         file_extension = ".jpg" # Default
-        if 'video' in content_type:
-            file_extension = ".mp4"
-        elif 'image/jpeg' in content_type:
-            file_extension = ".jpg"
-        elif 'image/png' in content_type:
-            file_extension = ".png"
-        elif 'image/webp' in content_type:
-            file_extension = ".webp"
+        if 'video' in content_type: file_extension = ".mp4"
+        elif 'image/jpeg' in content_type: file_extension = ".jpg"
+        elif 'image/png' in content_type: file_extension = ".png"
+        elif 'image/webp' in content_type: file_extension = ".webp"
         else: # Guess from URL
-            if '.mp4' in media_url: file_extension = ".mp4"
-            elif '.mov' in media_url: file_extension = ".mov" # May need conversion later
-            elif '.jpg' in media_url or '.jpeg' in media_url: file_extension = ".jpg"
-            elif '.png' in media_url: file_extension = ".png"
-            elif '.webp' in media_url: file_extension = ".webp"
-
+            media_url_lower = media_url.lower()
+            if '.mp4' in media_url_lower: file_extension = ".mp4"
+            elif '.mov' in media_url_lower: file_extension = ".mov"
+            elif '.jpg' in media_url_lower or '.jpeg' in media_url_lower: file_extension = ".jpg"
+            elif '.png' in media_url_lower: file_extension = ".png"
+            elif '.webp' in media_url_lower: file_extension = ".webp"
 
         filename = os.path.join(target_folder, f"{filename_prefix}{file_extension}")
-
         with open(filename, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=8192):
-                f.write(chunk)
-
+            for chunk in response.iter_content(chunk_size=8192): f.write(chunk)
         print(f"Media downloaded successfully to: {filename}")
 
-        # Basic validation for images
         if file_extension in [".jpg", ".png", ".webp"]:
             try:
                 img = Image.open(filename)
-                img.verify() # Check if it's a valid image file
+                img.verify()
                 img.close()
-                 # Re-open and convert to RGB if necessary (MoviePy prefers RGB)
                 img = Image.open(filename)
                 if img.mode != 'RGB':
                     print(f"Converting image {filename} to RGB.")
                     rgb_img = img.convert('RGB')
-                    # Overwrite if JPG, save as JPG if PNG/WEBP for consistency
                     jpg_filename = os.path.join(target_folder, f"{filename_prefix}.jpg")
                     rgb_img.save(jpg_filename, "JPEG")
                     rgb_img.close()
                     img.close()
-                    if filename != jpg_filename: # Remove original if format changed
-                        os.remove(filename)
-                    return jpg_filename # Return path to the JPG
-                else:
-                    img.close()
-
+                    if filename != jpg_filename: os.remove(filename)
+                    return jpg_filename
+                else: img.close()
             except Exception as e_validate:
                 print(f"Downloaded file {filename} is not a valid image or conversion failed: {e_validate}")
                 if os.path.exists(filename): os.remove(filename)
                 return None
-
-        return filename # Return original path for videos or already RGB images
-
+        return filename
     except requests.exceptions.RequestException as e_download:
         print(f"Media download error from {media_url}: {e_download}")
         return None
@@ -387,114 +323,106 @@ def download_media(media_url, filename_prefix, target_folder):
         print(f"General error during media download/processing: {e_general}")
         return None
 
+# --- MODIFIED: generate_media Function ---
 def generate_media(prompt):
     """
     Find and download a visual asset (video or image) based on the prompt.
-    Prioritizes Pexels Video, then Pexels Image, then Google Image as fallback.
+    Prioritizes Pexels Video, then Pexels Image. NO Google Image fallback.
+    Uses a single generic Pexels image search as the final fallback.
     """
     safe_prompt = re.sub(r'[^\w\s-]', '', prompt).strip().replace(' ', '_')
-    filename_prefix = f"{safe_prompt}_{int(time.time())}" # Add timestamp for uniqueness
+    # Limit length of prompt in filename to avoid issues
+    safe_prompt = safe_prompt[:50]
+    filename_prefix = f"{safe_prompt}_{int(time.time())}"
 
     # 1. Try Pexels Video (if probability met)
     if random.random() < video_clip_probability:
-        print(f"Searching Pexels Video for: {prompt}")
         video_url = search_pexels(prompt, PEXELS_API_KEY, search_type="videos")
         if video_url:
             downloaded_path = download_media(video_url, filename_prefix + "_vid", TEMP_FOLDER)
             if downloaded_path:
+                print(f"Using Pexels video for '{prompt}'")
                 return {"path": downloaded_path, "asset_type": "video"}
         else:
-            print("Pexels video search failed or no suitable video found.")
+            print(f"Pexels video search failed or no suitable video found for '{prompt}'. Trying image...")
 
     # 2. Try Pexels Image
-    print(f"Searching Pexels Image for: {prompt}")
     image_url = search_pexels(prompt, PEXELS_API_KEY, search_type="photos")
     if image_url:
         downloaded_path = download_media(image_url, filename_prefix + "_img", TEMP_FOLDER)
         if downloaded_path:
+            print(f"Using Pexels image for '{prompt}'")
             return {"path": downloaded_path, "asset_type": "image"}
     else:
-        print("Pexels image search failed.")
-
-    # 3. Fallback: Try Google Images (especially for specific/newsy terms)
-    print(f"Falling back to Google Image search for: {prompt}")
-    google_image_url = search_google_images(prompt)
-    if google_image_url:
-        downloaded_path = download_media(google_image_url, filename_prefix + "_gimg", TEMP_FOLDER)
-        if downloaded_path:
-            return {"path": downloaded_path, "asset_type": "image"}
+        print(f"Pexels image search failed for '{prompt}'.")
+
+    # --- REMOVED GOOGLE IMAGE SEARCH ---
+    # print(f"Falling back to Google Image search for: {prompt}")
+    # google_image_url = search_google_images(prompt)
+    # ... (removed logic) ...
+
+    # 3. Absolute Fallback: Generic Pexels Image Search
+    #    Only use this if the specific prompt searches failed.
+    #    Avoid searching for problematic terms like "Subscribe CTA".
+    fallback_terms = ["technology", "abstract", "nature", "background"]
+    # Don't use fallback for prompts that are clearly instructions/CTAs
+    if "subscribe" not in prompt.lower() and "cta" not in prompt.lower():
+        fallback_term = random.choice(fallback_terms)
+        print(f"All specific searches failed for '{prompt}'. Using Pexels fallback term: '{fallback_term}'")
+        fallback_url = search_pexels(fallback_term, PEXELS_API_KEY, search_type="photos")
+        if fallback_url:
+            downloaded_path = download_media(fallback_url, filename_prefix + "_fallback", TEMP_FOLDER)
+            if downloaded_path:
+                print(f"Using Pexels fallback image '{fallback_term}' for '{prompt}'")
+                return {"path": downloaded_path, "asset_type": "image"}
+            else:
+                 print(f"Pexels fallback image download failed for term '{fallback_term}'.")
+        else:
+            print(f"Pexels fallback image search failed for term '{fallback_term}'.")
     else:
-        print("Google image search failed.")
+        print(f"Skipping fallback search for instructional prompt: '{prompt}'")
 
-    # 4. Absolute Fallback: Generic Image
-    print("All searches failed. Using absolute fallback: 'technology'")
-    fallback_url = search_pexels("technology", PEXELS_API_KEY, search_type="photos")
-    if fallback_url:
-        downloaded_path = download_media(fallback_url, filename_prefix + "_fallback", TEMP_FOLDER)
-        if downloaded_path:
-            return {"path": downloaded_path, "asset_type": "image"}
 
-    print(f"FATAL: Could not retrieve any media for prompt: {prompt}")
+    # 4. Final Failure
+    print(f"FATAL: Could not retrieve any suitable media for prompt: '{prompt}' after all attempts.")
     return None # Indicate failure
 
+
 def generate_tts(text, voice_id, speed):
-    """
-    Generate TTS audio using Kokoro, falling back to gTTS.
-    """
-    # Sanitize text for filename (simple approach)
+    """Generate TTS audio using Kokoro, falling back to gTTS."""
+    # --- Retain previous generate_tts function ---
     safe_text_prefix = re.sub(r'[^\w\s-]', '', text[:20]).strip().replace(' ', '_')
     output_filename = os.path.join(TEMP_FOLDER, f"tts_{safe_text_prefix}_{voice_id}.wav")
-
-    # --- Try Kokoro TTS First ---
-    if pipeline: # Check if Kokoro was initialized
+    if pipeline:
         try:
             print(f"Generating TTS with Kokoro (Voice: {voice_id}, Speed: {speed}) for: '{text[:30]}...'")
-            # Generate audio segment(s)
-            generator = pipeline(text, voice=voice_id, speed=speed) # Removed split_pattern for simplicity
+            generator = pipeline(text, voice=voice_id, speed=speed)
             audio_segments = []
-            # Kokoro's generator might yield differently depending on version/setup
-            # Assuming it yields tuples or directly the audio array
             for item in generator:
                 if isinstance(item, tuple) and len(item) > 0 and isinstance(item[-1], np.ndarray):
-                    audio_segments.append(item[-1]) # Assume audio is the last element
+                    audio_segments.append(item[-1])
                 elif isinstance(item, np.ndarray):
-                     audio_segments.append(item) # Assume it yields audio directly
-                # Add more checks if Kokoro's output structure is different
-
-            if not audio_segments:
-                 raise ValueError("Kokoro TTS returned no audio segments.")
-
-            # Concatenate if multiple segments
+                     audio_segments.append(item)
+            if not audio_segments: raise ValueError("Kokoro TTS returned no audio segments.")
             full_audio = np.concatenate(audio_segments) if len(audio_segments) > 0 else audio_segments[0]
-
-            # Ensure audio is float32 for soundfile if needed (Kokoro usually outputs float32)
             if full_audio.dtype != np.float32:
                 full_audio = full_audio.astype(np.float32)
-                # Normalize if necessary after type conversion
                 max_val = np.max(np.abs(full_audio))
-                if max_val > 1.0:
-                    full_audio /= max_val
-
-            sf.write(output_filename, full_audio, 24000) # Kokoro default sample rate
+                if max_val > 1.0: full_audio /= max_val
+            sf.write(output_filename, full_audio, 24000)
             print(f"Kokoro TTS audio saved to {output_filename}")
             return output_filename
         except Exception as e:
             print(f"Error with Kokoro TTS: {e}. Falling back to gTTS.")
-            # Fall through to gTTS block
-
-    # --- Fallback to gTTS ---
     try:
         print(f"Generating TTS with gTTS for: '{text[:30]}...'")
-        tts = gTTS(text=text, lang='en', slow= (speed < 0.9) ) # gTTS speed is boolean (slow/normal)
+        tts = gTTS(text=text, lang='en', slow= (speed < 0.9) )
         mp3_path = os.path.join(TEMP_FOLDER, f"tts_{safe_text_prefix}_gtts.mp3")
-        wav_path = output_filename # Reuse the intended output filename
+        wav_path = output_filename
         tts.save(mp3_path)
-
-        # Convert MP3 to WAV using pydub
         audio = AudioSegment.from_mp3(mp3_path)
         audio.export(wav_path, format="wav")
-        os.remove(mp3_path) # Clean up temporary mp3
-
+        os.remove(mp3_path)
         print(f"gTTS audio saved and converted to {wav_path}")
         return wav_path
     except ImportError:
@@ -504,577 +432,317 @@ def generate_tts(text, voice_id, speed):
         print(f"Error with gTTS fallback: {fallback_error}")
         return None
 
-
 def apply_kenburns_effect(clip, target_resolution, duration):
     """Apply a randomized Ken Burns effect (zoom/pan) to an image clip."""
+    # --- Retain previous apply_kenburns_effect function ---
     target_w, target_h = target_resolution
     img_w, img_h = clip.size
-
-    # Resize image slightly larger than target to allow movement
-    # Maintain aspect ratio, fit to cover target dimensions + margin
-    scale_factor = 1.2 # Zoom margin
+    scale_factor = 1.2
     scaled_w, scaled_h = img_w * scale_factor, img_h * scale_factor
-
-    # Determine resize dimensions to cover target + margin
     if scaled_w / scaled_h > target_w / target_h:
-        # Wider than target aspect ratio -> fit height
         final_h = target_h * scale_factor
         final_w = final_h * (img_w / img_h)
     else:
-        # Taller than target aspect ratio -> fit width
         final_w = target_w * scale_factor
         final_h = final_w * (img_h / img_w)
-
     final_w, final_h = int(final_w), int(final_h)
-
-    # Create a resized version for the animation base
-    # Using Pillow for resizing before passing to MoviePy might be more reliable for high-res
     try:
-        pil_img = Image.fromarray(clip.get_frame(0)) # Get frame as numpy array, convert to PIL
+        pil_img = Image.fromarray(clip.get_frame(0))
         resized_pil = pil_img.resize((final_w, final_h), Image.Resampling.LANCZOS)
         resized_clip = ImageClip(np.array(resized_pil)).set_duration(duration)
     except Exception as e:
         print(f"Warning: Error during high-quality resize for Ken Burns, using MoviePy default: {e}")
-        # Fallback to moviepy resize (might be lower quality for stills)
         resized_clip = clip.resize(newsize=(final_w, final_h)).set_duration(duration)
-
-
-    # Define start and end zoom/position parameters randomly
     max_move_x = final_w - target_w
     max_move_y = final_h - target_h
-
-    # Choose effect type
     effect = random.choice(['zoom_in', 'zoom_out', 'pan_lr', 'pan_rl', 'pan_td', 'pan_dt'])
-
-    if effect == 'zoom_in':
-        zoom_start, zoom_end = 1.0, scale_factor
-        x_start, x_end = max_move_x / 2, max_move_x / 2
-        y_start, y_end = max_move_y / 2, max_move_y / 2
-    elif effect == 'zoom_out':
-        zoom_start, zoom_end = scale_factor, 1.0
-        x_start, x_end = max_move_x / 2, max_move_x / 2
-        y_start, y_end = max_move_y / 2, max_move_y / 2
-    elif effect == 'pan_lr': # Pan Left to Right
-        zoom_start, zoom_end = scale_factor, scale_factor # Constant zoom while panning
-        x_start, x_end = 0, max_move_x
-        y_start, y_end = max_move_y / 2, max_move_y / 2 # Center vertically
-    elif effect == 'pan_rl': # Pan Right to Left
-        zoom_start, zoom_end = scale_factor, scale_factor
-        x_start, x_end = max_move_x, 0
-        y_start, y_end = max_move_y / 2, max_move_y / 2
-    elif effect == 'pan_td': # Pan Top to Down
-        zoom_start, zoom_end = scale_factor, scale_factor
-        x_start, x_end = max_move_x / 2, max_move_x / 2 # Center horizontally
-        y_start, y_end = 0, max_move_y
-    else: # Pan Down to Top
-        zoom_start, zoom_end = scale_factor, scale_factor
-        x_start, x_end = max_move_x / 2, max_move_x / 2
-        y_start, y_end = max_move_y, 0
-
-    # Define the function for fl_image
+    if effect == 'zoom_in': zoom_start, zoom_end = 1.0, scale_factor; x_start, x_end = max_move_x / 2, max_move_x / 2; y_start, y_end = max_move_y / 2, max_move_y / 2
+    elif effect == 'zoom_out': zoom_start, zoom_end = scale_factor, 1.0; x_start, x_end = max_move_x / 2, max_move_x / 2; y_start, y_end = max_move_y / 2, max_move_y / 2
+    elif effect == 'pan_lr': zoom_start, zoom_end = scale_factor, scale_factor; x_start, x_end = 0, max_move_x; y_start, y_end = max_move_y / 2, max_move_y / 2
+    elif effect == 'pan_rl': zoom_start, zoom_end = scale_factor, scale_factor; x_start, x_end = max_move_x, 0; y_start, y_end = max_move_y / 2, max_move_y / 2
+    elif effect == 'pan_td': zoom_start, zoom_end = scale_factor, scale_factor; x_start, x_end = max_move_x / 2, max_move_x / 2; y_start, y_end = 0, max_move_y
+    else: zoom_start, zoom_end = scale_factor, scale_factor; x_start, x_end = max_move_x / 2, max_move_x / 2; y_start, y_end = max_move_y, 0
     def make_frame(t):
-        # Linear interpolation for time
         interp = t / duration if duration else 0
-
-        # Interpolate zoom and position
         current_zoom = zoom_start + (zoom_end - zoom_start) * interp
         current_x = x_start + (x_end - x_start) * interp
         current_y = y_start + (y_end - y_start) * interp
-
-        # Calculate the crop box dimensions based on current zoom
-        # The size of the box to crop from the *resized_clip*
-        crop_w = target_w / (current_zoom / scale_factor) # Adjust target by zoom relative to initial scale
-        crop_h = target_h / (current_zoom / scale_factor)
-
-        # Ensure crop dimensions are valid
-        crop_w = max(1, int(crop_w))
-        crop_h = max(1, int(crop_h))
-
-        # Calculate the top-left corner of the crop box
-        # current_x/y is the center offset in the scaled image
-        # We need top-left corner (x1, y1)
-        x1 = current_x # Assume current_x/y are already top-left offsets
-        y1 = current_y
-
-        # Clamp coordinates to stay within bounds
-        x1 = max(0, min(x1, final_w - crop_w))
-        y1 = max(0, min(y1, final_h - crop_h))
-
-        # Get the frame from the *potentially pre-resized* clip
+        crop_w = target_w / (current_zoom / scale_factor); crop_h = target_h / (current_zoom / scale_factor)
+        crop_w = max(1, int(crop_w)); crop_h = max(1, int(crop_h))
+        x1 = current_x; y1 = current_y
+        x1 = max(0, min(x1, final_w - crop_w)); y1 = max(0, min(y1, final_h - crop_h))
         frame = resized_clip.get_frame(t)
-
-        # Crop the frame
-        # Note: MoviePy's crop uses x1,y1,x2,y2 or x_center, y_center, width, height
-        # Using numpy slicing might be easier here
         cropped_frame = frame[int(y1):int(y1 + crop_h), int(x1):int(x1 + crop_w)]
-
-        # Resize the cropped frame to the final target resolution
-        # Using OpenCV for potentially better resizing quality
         final_frame = cv2.resize(cropped_frame, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
-
         return final_frame
-
-    # Apply the transformation using fl
-    return resized_clip.fl(make_frame, apply_to=['mask']) # Apply to mask if exists
+    return resized_clip.fl(make_frame, apply_to=['mask'])
 
 def resize_to_fill(clip, target_resolution):
     """Resize and crop a video clip to fill the target resolution."""
+    # --- Retain previous resize_to_fill function ---
     target_w, target_h = target_resolution
     target_aspect = target_w / target_h
-
-    # Use MoviePy's resize and crop fx
-    # Resize to fit the smaller dimension to cover the target area
-    if clip.w / clip.h > target_aspect:
-        # Clip is wider than target -> resize based on height
-        resized_clip = clip.resize(height=target_h)
-    else:
-        # Clip is taller or equal aspect -> resize based on width
-        resized_clip = clip.resize(width=target_w)
-
-    # Crop the excess from the center
+    if clip.w / clip.h > target_aspect: resized_clip = clip.resize(height=target_h)
+    else: resized_clip = clip.resize(width=target_w)
     crop_x = max(0, (resized_clip.w - target_w) / 2)
     crop_y = max(0, (resized_clip.h - target_h) / 2)
-
     cropped_clip = resized_clip.crop(x1=crop_x, y1=crop_y, width=target_w, height=target_h)
     return cropped_clip
 
 def add_background_music(video_clip, music_file_path, volume):
     """Add background music, looping if necessary."""
+    # --- Retain previous add_background_music function ---
     if not music_file_path or not os.path.exists(music_file_path):
         print("No background music file found or provided. Skipping.")
         return video_clip
-
     try:
         print(f"Adding background music from: {music_file_path}")
         bg_music = AudioFileClip(music_file_path)
-
-        if bg_music.duration > video_clip.duration:
-            # Trim music to video duration
-            bg_music = bg_music.subclip(0, video_clip.duration)
+        if bg_music.duration > video_clip.duration: bg_music = bg_music.subclip(0, video_clip.duration)
         elif bg_music.duration < video_clip.duration:
-            # Loop music to fit video duration
             loops_needed = math.ceil(video_clip.duration / bg_music.duration)
             bg_music = concatenate_audioclips([bg_music] * loops_needed)
-            bg_music = bg_music.subclip(0, video_clip.duration) # Trim precisely
-
-        # Apply volume adjustment
+            bg_music = bg_music.subclip(0, video_clip.duration)
         bg_music = bg_music.volumex(volume)
-
-        # Combine with existing audio (if any)
-        final_audio = CompositeAudioClip([video_clip.audio, bg_music])
+        # Check if video_clip has audio before composing
+        if video_clip.audio:
+             final_audio = CompositeAudioClip([video_clip.audio, bg_music])
+        else:
+             # If original clip has no audio, just use the background music
+             final_audio = bg_music
         video_clip = video_clip.set_audio(final_audio)
         print("Background music added successfully.")
         return video_clip
-
     except Exception as e:
         print(f"Error adding background music: {e}. Skipping.")
-        return video_clip # Return original clip
-
+        return video_clip
 
 def create_segment_clip(media_info, tts_path, narration_text):
     """Create a single video segment (clip) with visuals, audio, and subtitles."""
+    # --- Retain previous create_segment_clip function ---
     try:
         media_path = media_info['path']
         asset_type = media_info['asset_type']
         print(f"Creating clip segment: Type={asset_type}, Media={os.path.basename(media_path)}")
-
-        # --- 1. Load Audio ---
-        if not os.path.exists(tts_path):
-            print(f"Error: TTS file not found: {tts_path}")
-            return None
+        if not os.path.exists(tts_path): print(f"Error: TTS file not found: {tts_path}"); return None
         audio_clip = AudioFileClip(tts_path)
-        # Add tiny silence buffer at start/end for transitions
-        segment_duration = audio_clip.duration + 0.3 # Add buffer
-
-        # --- 2. Create Visual Clip ---
+        segment_duration = audio_clip.duration + 0.3
         if asset_type == "video":
-            if not os.path.exists(media_path):
-                print(f"Error: Video file not found: {media_path}")
-                return None
+            if not os.path.exists(media_path): print(f"Error: Video file not found: {media_path}"); return None
             video_clip = VideoFileClip(media_path)
-            # Ensure video covers segment duration, looping if needed
             if video_clip.duration < segment_duration:
-                # Loop the video
                 loops = math.ceil(segment_duration / video_clip.duration)
-                video_clip = concatenate_videoclips([video_clip] * loops)
-            # Trim to exact segment duration
+                try:
+                     # Handle potential zero duration clips during looping
+                     if video_clip.duration > 0:
+                          video_clip = concatenate_videoclips([video_clip] * loops)
+                     else:
+                          print(f"Warning: Video clip has zero duration, cannot loop: {media_path}")
+                          # Create a short black clip instead? Or fail? Let's fail for now.
+                          return None
+                except Exception as loop_err:
+                     print(f"Error looping video {media_path}: {loop_err}")
+                     return None # Fail segment if looping fails
+
             video_clip = video_clip.subclip(0, segment_duration)
-            # Resize/crop to fit target resolution
             visual_clip = resize_to_fill(video_clip, TARGET_RESOLUTION)
-
         elif asset_type == "image":
-            if not os.path.exists(media_path):
-                 print(f"Error: Image file not found: {media_path}")
-                 return None
-            # Create ImageClip and apply Ken Burns
+            if not os.path.exists(media_path): print(f"Error: Image file not found: {media_path}"); return None
             img_clip = ImageClip(media_path).set_duration(segment_duration)
-            # Apply Ken Burns effect
             visual_clip = apply_kenburns_effect(img_clip, TARGET_RESOLUTION, segment_duration)
-            # Ensure final size is correct after effects
             visual_clip = visual_clip.resize(newsize=TARGET_RESOLUTION)
-
-        else:
-            print(f"Error: Unknown asset type: {asset_type}")
-            return None
-
-        # Add fade-in/out for smoother transitions between segments
+        else: print(f"Error: Unknown asset type: {asset_type}"); return None
         visual_clip = visual_clip.fadein(0.15).fadeout(0.15)
-
-        # --- 3. Add Subtitles (Chunk-based, No ImageMagick) ---
         subtitle_clips = []
         if USE_CAPTIONS and narration_text:
             words = narration_text.split()
-            # Simple chunking: group words, max ~5 per chunk or based on duration
-            max_words_per_chunk = 5
-            chunks = []
-            current_chunk = []
+            max_words_per_chunk = 5; chunks = []; current_chunk = []
             for word in words:
                 current_chunk.append(word)
-                if len(current_chunk) >= max_words_per_chunk:
-                    chunks.append(" ".join(current_chunk))
-                    current_chunk = []
-            if current_chunk: # Add any remaining words
-                chunks.append(" ".join(current_chunk))
-
-            if not chunks: # Handle empty narration case
-                 print("Warning: Narration text is empty, skipping subtitles for this segment.")
-
+                if len(current_chunk) >= max_words_per_chunk: chunks.append(" ".join(current_chunk)); current_chunk = []
+            if current_chunk: chunks.append(" ".join(current_chunk))
+            if not chunks: print("Warning: Narration text is empty, skipping subtitles.")
             else:
-                num_chunks = len(chunks)
-                chunk_duration = audio_clip.duration / num_chunks # Duration per text chunk
-                start_time = 0.1 # Small delay before first subtitle
-
+                num_chunks = len(chunks); chunk_duration = audio_clip.duration / num_chunks
+                start_time = 0.1
                 for i, chunk_text in enumerate(chunks):
-                    end_time = start_time + chunk_duration
-                    # Ensure end_time doesn't exceed the visual clip duration slightly
-                    end_time = min(end_time, segment_duration - 0.1)
-
-                    txt_clip = TextClip(
-                        txt=chunk_text,
-                        fontsize=font_size,
-                        font=caption_font, # Ensure this font is available or use default
-                        color=caption_style_text_color,
-                        bg_color=caption_style_bg_color, # Semi-transparent background
-                        method='label', # Use 'label' - simpler, less likely ImageMagick dependency
-                        align='center',
-                        size=(TARGET_RESOLUTION[0] * 0.8, None) # Width constraint
-                    )
-                    # Position: center horizontally, lower part of the screen
-                    txt_clip = txt_clip.set_position(('center', TARGET_RESOLUTION[1] * 0.80))
-                    txt_clip = txt_clip.set_start(start_time).set_duration(end_time - start_time)
-                    # txt_clip = txt_clip.fadein(0.1).fadeout(0.1) # Optional fade for text
-
-                    subtitle_clips.append(txt_clip)
-                    start_time = end_time # Next chunk starts where the last one ended
-
-        # --- 4. Combine Visuals, Audio, and Subtitles ---
-        if subtitle_clips:
-            final_clip = CompositeVideoClip([visual_clip] + subtitle_clips)
-        else:
-            final_clip = visual_clip # No subtitles
-
-        # Set the audio for the final segment clip
-        final_clip = final_clip.set_audio(audio_clip.set_start(0.15)) # Start audio slightly after visual fade-in
-
+                    end_time = min(start_time + chunk_duration, segment_duration - 0.1)
+                    try:
+                         txt_clip = TextClip(txt=chunk_text, fontsize=font_size, font=caption_font, color=caption_style_text_color,
+                                             bg_color=caption_style_bg_color, method='label', align='center',
+                                             size=(TARGET_RESOLUTION[0] * 0.8, None))
+                         txt_clip = txt_clip.set_position(('center', TARGET_RESOLUTION[1] * 0.80))
+                         txt_clip = txt_clip.set_start(start_time).set_duration(max(0.1, end_time - start_time)) # Ensure non-zero duration
+                         subtitle_clips.append(txt_clip)
+                         start_time = end_time
+                    except Exception as txt_err:
+                         print(f"ERROR creating TextClip for '{chunk_text}': {txt_err}. Skipping subtitle chunk.")
+                         # If one subtitle fails, continue without it
+
+        final_clip = CompositeVideoClip([visual_clip] + subtitle_clips) if subtitle_clips else visual_clip
+        final_clip = final_clip.set_audio(audio_clip.set_start(0.15))
         print(f"Clip segment created successfully. Duration: {final_clip.duration:.2f}s")
         return final_clip
-
     except Exception as e:
         print(f"Error creating clip segment: {e}")
         import traceback
-        traceback.print_exc() # Print detailed traceback for debugging
+        traceback.print_exc()
         return None
 
 # ---------------- Main Video Generation Function ---------------- #
 
 def generate_full_video(user_input, resolution_choice, caption_choice, music_file_info):
-    """
-    Main function orchestrating the video generation process.
-    Uses global variables set by Gradio for configuration.
-    """
+    """Main function orchestrating the video generation process."""
+    # --- Retain most of previous generate_full_video function ---
+    # (Ensure it handles None from generate_media correctly)
     global TARGET_RESOLUTION, TEMP_FOLDER, USE_CAPTIONS
-
-    print("\n--- Starting Video Generation ---")
-    start_time = time.time()
-
-    # 1. Setup Environment
-    if resolution_choice == "Short (9:16)":
-        TARGET_RESOLUTION = (1080, 1920)
-        print("Resolution set to: Short (1080x1920)")
-    else: # Default to Full HD
-        TARGET_RESOLUTION = (1920, 1080)
-        print("Resolution set to: Full HD (1920x1080)")
-
-    USE_CAPTIONS = (caption_choice == "Yes")
-    print(f"Captions Enabled: {USE_CAPTIONS}")
-
-    # Create unique temporary folder for this run
-    TEMP_FOLDER = tempfile.mkdtemp(prefix="aivideo_")
-    print(f"Temporary folder created: {TEMP_FOLDER}")
-
-    # Handle uploaded music file
+    print("\n--- Starting Video Generation ---"); start_time = time.time()
+    if resolution_choice == "Short (9:16)": TARGET_RESOLUTION = (1080, 1920); print("Resolution set to: Short (1080x1920)")
+    else: TARGET_RESOLUTION = (1920, 1080); print("Resolution set to: Full HD (1920x1080)")
+    USE_CAPTIONS = (caption_choice == "Yes"); print(f"Captions Enabled: {USE_CAPTIONS}")
+    TEMP_FOLDER = tempfile.mkdtemp(prefix="aivideo_"); print(f"Temporary folder created: {TEMP_FOLDER}")
     music_file_path = None
     if music_file_info is not None:
         try:
-            # Copy uploaded file to a predictable location (or use directly if safe)
-            # Using a fixed name in the temp folder is often easier
             music_file_path = os.path.join(TEMP_FOLDER, "background_music.mp3")
             shutil.copy(music_file_info.name, music_file_path)
             print(f"Background music copied to: {music_file_path}")
-        except Exception as e:
-            print(f"Error handling uploaded music file: {e}")
-            music_file_path = None # Ensure it's None if copy failed
-
+        except Exception as e: print(f"Error handling uploaded music file: {e}"); music_file_path = None
 
-    # --- No ImageMagick Fix Needed ---
-    # print("Skipping ImageMagick policy check as alternative subtitles are used.")
-
-
-    # 2. Generate Script
-    print("\nStep 1: Generating script...")
-    script_text = generate_script(user_input)
-    if not script_text:
-        print("ERROR: Failed to generate script. Aborting.")
-        shutil.rmtree(TEMP_FOLDER)
-        return None, "Error: Script generation failed. Check API keys and OpenRouter status." # Return error message for Gradio
+    print("\nStep 1: Generating script..."); script_text = generate_script(user_input)
+    if not script_text: print("ERROR: Failed to generate script. Aborting."); shutil.rmtree(TEMP_FOLDER); return None, "Error: Script generation failed."
     print("Script Generated:\n", script_text)
 
-
-    # 3. Parse Script
-    print("\nStep 2: Parsing script...")
-    segments = parse_script(script_text)
-    if not segments:
-        print("ERROR: Failed to parse script into segments. Aborting.")
-        shutil.rmtree(TEMP_FOLDER)
-        return None, "Error: Script parsing failed. Check script format."
+    print("\nStep 2: Parsing script..."); segments = parse_script(script_text)
+    if not segments: print("ERROR: Failed to parse script. Aborting."); shutil.rmtree(TEMP_FOLDER); return None, "Error: Script parsing failed."
     print(f"Successfully parsed {len(segments)} segments.")
 
-
-    # 4. Generate Media and TTS for each segment
     print("\nStep 3: Generating media and TTS for each segment...")
-    segment_clips = []
-    total_segments = len(segments)
+    segment_clips = []; total_segments = len(segments)
     for i, segment in enumerate(segments):
         print(f"\n--- Processing Segment {i+1}/{total_segments} ---")
         print(f"  Prompt: {segment['prompt']}")
         print(f"  Narration: {segment['narration']}")
 
-        # Generate Media
         media_info = generate_media(segment['prompt'])
+        # --- Crucial Check ---
         if not media_info:
-            print(f"Warning: Failed to get media for segment {i+1}. Skipping segment.")
-            continue # Skip this segment if media fails
+            print(f"Warning: Failed to get media for segment {i+1} ('{segment['prompt']}'). Skipping this segment.")
+            continue # Skip segment if media generation failed
 
-        # Generate TTS
         tts_path = generate_tts(segment['narration'], selected_voice, voice_speed)
         if not tts_path:
             print(f"Warning: Failed to generate TTS for segment {i+1}. Skipping segment.")
-            # Clean up downloaded media if TTS failed
             if media_info and os.path.exists(media_info['path']):
-                 try: os.remove(media_info['path'])
+                 try: os.remove(media_info['path']); print(f"Cleaned up unused media: {media_info['path']}")
                  except OSError: pass
-            continue # Skip this segment if TTS fails
+            continue
 
-        # Create the actual MoviePy clip for this segment
         clip = create_segment_clip(media_info, tts_path, segment['narration'])
         if clip:
             segment_clips.append(clip)
         else:
             print(f"Warning: Failed to create video clip for segment {i+1}. Skipping.")
-            # Clean up files for this failed segment
             if media_info and os.path.exists(media_info['path']):
-                 try: os.remove(media_info['path'])
+                 try: os.remove(media_info['path']); print(f"Cleaned up media for failed clip: {media_info['path']}")
                  except OSError: pass
             if tts_path and os.path.exists(tts_path):
-                 try: os.remove(tts_path)
+                 try: os.remove(tts_path); print(f"Cleaned up TTS for failed clip: {tts_path}")
                  except OSError: pass
 
-
     if not segment_clips:
         print("ERROR: No video clips were successfully created. Aborting.")
         shutil.rmtree(TEMP_FOLDER)
-        return None, "Error: Failed to create any video segments. Check logs."
-
+        return None, "Error: Failed to create any video segments. Check logs for media/TTS issues."
 
-    # 5. Concatenate Clips
-    print("\nStep 4: Concatenating video segments...")
+    print("\nStep 4: Concatenating video segments...");
     try:
-        final_video = concatenate_videoclips(segment_clips, method="compose")
+        # Filter out potential None values just in case, although the loop should prevent them
+        valid_clips = [c for c in segment_clips if c is not None]
+        if not valid_clips:
+             raise ValueError("No valid clips remained after processing.")
+        final_video = concatenate_videoclips(valid_clips, method="compose")
         print("Segments concatenated successfully.")
     except Exception as e:
-        print(f"ERROR: Failed to concatenate video clips: {e}")
-        shutil.rmtree(TEMP_FOLDER)
-        return None, f"Error: Concatenation failed: {e}"
-
-
-    # 6. Add Background Music
-    print("\nStep 5: Adding background music...")
-    final_video = add_background_music(final_video, music_file_path, bg_music_volume)
+        print(f"ERROR: Failed to concatenate video clips: {e}"); shutil.rmtree(TEMP_FOLDER); return None, f"Error: Concatenation failed: {e}"
 
+    print("\nStep 5: Adding background music..."); final_video = add_background_music(final_video, music_file_path, bg_music_volume)
 
-    # 7. Export Final Video
-    print(f"\nStep 6: Exporting final video to '{OUTPUT_VIDEO_FILENAME}'...")
+    print(f"\nStep 6: Exporting final video to '{OUTPUT_VIDEO_FILENAME}'..."); export_success = False
     try:
-        final_video.write_videofile(
-            OUTPUT_VIDEO_FILENAME,
-            codec='libx264',    # Good balance of quality/compatibility
-            audio_codec='aac', # Standard audio codec
-            fps=fps,
-            preset=preset,      # Controls encoding speed vs compression
-            threads=4,          # Use multiple threads for faster encoding
-            logger='bar'        # Show progress bar
-        )
+        final_video.write_videofile(OUTPUT_VIDEO_FILENAME, codec='libx264', audio_codec='aac', fps=fps, preset=preset, threads=4, logger='bar')
         print(f"Final video saved successfully as {OUTPUT_VIDEO_FILENAME}")
         export_success = True
     except Exception as e:
-        print(f"ERROR: Failed to write final video file: {e}")
-        import traceback
-        traceback.print_exc()
-        export_success = False
-
-
-    # 8. Cleanup
-    print("\nStep 7: Cleaning up temporary files...")
-    try:
-        shutil.rmtree(TEMP_FOLDER)
-        print(f"Temporary folder {TEMP_FOLDER} removed.")
-    except Exception as e:
-        print(f"Warning: Failed to remove temporary folder {TEMP_FOLDER}: {e}")
+        print(f"ERROR: Failed to write final video file: {e}"); import traceback; traceback.print_exc()
 
+    print("\nStep 7: Cleaning up temporary files...");
+    try: shutil.rmtree(TEMP_FOLDER); print(f"Temporary folder {TEMP_FOLDER} removed.")
+    except Exception as e: print(f"Warning: Failed to remove temporary folder {TEMP_FOLDER}: {e}")
 
-    end_time = time.time()
-    total_time = end_time - start_time
-    print(f"\n--- Video Generation Finished ---")
-    print(f"Total time: {total_time:.2f} seconds")
-
-    if export_success:
-        return OUTPUT_VIDEO_FILENAME, f"Video generation complete! Time: {total_time:.2f}s"
-    else:
-        return None, f"Error: Video export failed. Check logs. Time: {total_time:.2f}s"
+    end_time = time.time(); total_time = end_time - start_time
+    print(f"\n--- Video Generation Finished ---"); print(f"Total time: {total_time:.2f} seconds")
+    if export_success: return OUTPUT_VIDEO_FILENAME, f"Video generation complete! Time: {total_time:.2f}s"
+    else: return None, f"Error: Video export failed. Check logs. Time: {total_time:.2f}s"
 
 
 # ---------------- Gradio Interface Definition ---------------- #
-
-# Kokoro Voice Choices (Example subset, add more as needed)
+# --- Retain previous Gradio Interface code ---
 VOICE_CHOICES = {
-    # American English
-    'Emma (US Female)': 'af_heart',
-    'Bella (US Female)': 'af_bella',
-    'Nicole (US Female)': 'af_nicole',
-    'Sarah (US Female)': 'af_sarah',
-    'Michael (US Male)': 'am_michael',
-    'Eric (US Male)': 'am_eric',
-    'Adam (US Male)': 'am_adam',
-    # British English
-    'Emma (UK Female)': 'bf_emma',
-    'Alice (UK Female)': 'bf_alice',
-    'George (UK Male)': 'bm_george',
-    'Daniel (UK Male)': 'bm_daniel',
+    'Emma (US Female)': 'af_heart', 'Bella (US Female)': 'af_bella', 'Nicole (US Female)': 'af_nicole',
+    'Sarah (US Female)': 'af_sarah', 'Michael (US Male)': 'am_michael', 'Eric (US Male)': 'am_eric',
+    'Adam (US Male)': 'am_adam', 'Emma (UK Female)': 'bf_emma', 'Alice (UK Female)': 'bf_alice',
+    'George (UK Male)': 'bm_george', 'Daniel (UK Male)': 'bm_daniel',
 }
-
-def gradio_interface_handler(
-    user_prompt, resolution, captions, bg_music,
-    voice_name, video_prob, music_vol, video_fps, export_preset,
-    tts_speed, caption_size):
-    """Wrapper function to connect Gradio inputs to the main generation logic."""
-
+def gradio_interface_handler(user_prompt, resolution, captions, bg_music, voice_name, video_prob, music_vol, video_fps, export_preset, tts_speed, caption_size):
     print("\n--- Received Request from Gradio ---")
-    print(f"Prompt: {user_prompt[:50]}...")
-    print(f"Resolution: {resolution}")
-    print(f"Captions: {captions}")
-    print(f"Music File: {'Provided' if bg_music else 'None'}")
-    print(f"Voice: {voice_name}")
-    print(f"Video Probability: {video_prob}%")
-    print(f"Music Volume: {music_vol}")
-    print(f"FPS: {video_fps}")
-    print(f"Preset: {export_preset}")
-    print(f"TTS Speed: {tts_speed}")
-    print(f"Caption Size: {caption_size}")
-
-    # Update global settings based on Gradio inputs
+    print(f"Prompt: {user_prompt[:50]}...") # Print inputs for debugging
+    # ... (print other inputs) ...
     global selected_voice, voice_speed, font_size, video_clip_probability, bg_music_volume, fps, preset
-    selected_voice = VOICE_CHOICES.get(voice_name, 'af_heart') # Get voice ID from name
-    voice_speed = tts_speed
-    font_size = caption_size
-    video_clip_probability = video_prob / 100.0 # Convert percentage to probability
-    bg_music_volume = music_vol
-    fps = video_fps
-    preset = export_preset
-
-    # Call the main video generation function
+    selected_voice = VOICE_CHOICES.get(voice_name, 'af_heart')
+    voice_speed = tts_speed; font_size = caption_size; video_clip_probability = video_prob / 100.0
+    bg_music_volume = music_vol; fps = video_fps; preset = export_preset
     video_path, status_message = generate_full_video(user_prompt, resolution, captions, bg_music)
-
     print(f"Gradio Handler Status: {status_message}")
-
-    # Return the video path (or None if failed) and the status message
     return video_path, status_message
 
-
-# Create Gradio Interface
 with gr.Blocks(theme=gr.themes.Soft()) as iface:
     gr.Markdown("# 🎬 AI Documentary Video Generator")
-    gr.Markdown("Enter a topic or detailed instructions, customize settings, and generate a short documentary-style video. Uses AI for script, TTS, and finds relevant stock footage.")
-
+    gr.Markdown("Enter a topic or detailed instructions, customize settings, and generate a short documentary-style video.")
     with gr.Row():
         with gr.Column(scale=2):
-            prompt_input = gr.Textbox(
-                label="Video Concept / Topic / Script",
-                placeholder="e.g., 'The history of coffee', 'Top 5 strangest animals', or paste a full script following the format.",
-                lines=4
-            )
+            prompt_input = gr.Textbox(label="Video Concept / Topic / Script", placeholder="e.g., 'The history of coffee'...", lines=4)
             submit_button = gr.Button("Generate Video", variant="primary")
             status_output = gr.Textbox(label="Status", interactive=False)
-
-        with gr.Column(scale=1):
-            video_output = gr.Video(label="Generated Video")
-
-
+        with gr.Column(scale=1): video_output = gr.Video(label="Generated Video")
     with gr.Accordion("⚙️ Advanced Settings", open=False):
         gr.Markdown("### Video & Audio Settings")
         with gr.Row():
             resolution_dd = gr.Dropdown(["Full HD (16:9)", "Short (9:16)"], label="Resolution", value="Full HD (16:9)")
             caption_dd = gr.Radio(["Yes", "No"], label="Generate Captions", value="Yes")
             music_upload = gr.File(label="Upload Background Music (MP3)", file_types=[".mp3"])
-
         gr.Markdown("### Voice & Narration")
         with gr.Row():
             voice_dd = gr.Dropdown(choices=list(VOICE_CHOICES.keys()), label="Narration Voice", value="Emma (US Female)")
             speed_slider = gr.Slider(0.5, 1.5, value=0.9, step=0.05, label="Voice Speed")
-
         gr.Markdown("### Visuals & Style")
         with gr.Row():
             video_prob_slider = gr.Slider(0, 100, value=35, step=5, label="Video Clip % (vs. Images)")
             caption_size_slider = gr.Slider(20, 80, value=45, step=1, label="Caption Font Size")
-
         gr.Markdown("### Export Settings")
         with gr.Row():
             music_vol_slider = gr.Slider(0.0, 1.0, value=0.08, step=0.01, label="Background Music Volume")
             fps_slider = gr.Slider(15, 60, value=30, step=1, label="Video FPS")
-            preset_dd = gr.Dropdown(
-                choices=["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow"],
-                value="veryfast", label="Export Quality/Speed Preset"
-            )
-
-    # Connect components
-    submit_button.click(
-        fn=gradio_interface_handler,
-        inputs=[
-            prompt_input, resolution_dd, caption_dd, music_upload,
-            voice_dd, video_prob_slider, music_vol_slider, fps_slider, preset_dd,
-            speed_slider, caption_size_slider
-        ],
-        outputs=[video_output, status_output]
-    )
+            preset_dd = gr.Dropdown(choices=["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow"], value="veryfast", label="Export Quality/Speed Preset")
+    submit_button.click(fn=gradio_interface_handler, inputs=[prompt_input, resolution_dd, caption_dd, music_upload, voice_dd, video_prob_slider, music_vol_slider, fps_slider, preset_dd, speed_slider, caption_size_slider], outputs=[video_output, status_output])
 
 # Launch the interface
 if __name__ == "__main__":
     print("Launching Gradio Interface...")
-    # Make sure to replace API keys at the top before running!
     if PEXELS_API_KEY == 'YOUR_PEXELS_API_KEY' or OPENROUTER_API_KEY == 'YOUR_OPENROUTER_API_KEY':
         print("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
         print("!!! WARNING: API Keys not set in the script.         !!!")
         print("!!! Please replace 'YOUR_PEXELS_API_KEY' and         !!!")
         print("!!! 'YOUR_OPENROUTER_API_KEY' with your actual keys. !!!")
         print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n")
-
-    iface.launch(share=True, debug=True) # Share=True for public link, Debug=True for more logs
+    iface.launch(share=True, debug=True)