Update app.py

app.py

@@ -1,187 +1,245 @@
+
+
 # Import necessary libraries
-from kokoro import KPipeline # Assuming kokoro is installed and working
+from kokoro import KPipeline
 
 import soundfile as sf
 import torch
+
+import soundfile as sf
 import os
+from moviepy.editor import VideoFileClip, AudioFileClip, ImageClip
+from PIL import Image
 import tempfile
 import random
+import cv2
 import math
-import time
-import re
-import requests
-import io
-import shutil
-from urllib.parse import quote # Needed for search_google_images
-import numpy as np
-from bs4 import BeautifulSoup # Needed for search_google_images
-import base64
-from gtts import gTTS
-import gradio as gr
-from PIL import Image, ImageDraw, ImageFont
-import cv2 # OpenCV for image processing in Ken Burns
-
-# MoviePy imports
+import os, requests, io, time, re, random
 from moviepy.editor import (
-    VideoFileClip, AudioFileClip, ImageClip, CompositeVideoClip, TextClip,
-    concatenate_videoclips, CompositeAudioClip
+    VideoFileClip, concatenate_videoclips, AudioFileClip, ImageClip,
+    CompositeVideoClip, TextClip, CompositeAudioClip
 )
+import gradio as gr
+import shutil
+import os
 import moviepy.video.fx.all as vfx
-
-# Pydub imports
+import moviepy.config as mpy_config
 from pydub import AudioSegment
 from pydub.generators import Sine
 
+from PIL import Image, ImageDraw, ImageFont
+import numpy as np
+from bs4 import BeautifulSoup
+import base64
+from urllib.parse import quote
+import pysrt
+from gtts import gTTS
+import gradio as gr  # Import Gradio
+
+# Initialize Kokoro TTS pipeline (using American English)
+pipeline = KPipeline(lang_code='a')  # Use voice 'af_heart' for American English
+# Ensure ImageMagick binary is set
+mpy_config.change_settings({"IMAGEMAGICK_BINARY": "/usr/bin/convert"})
+
 # ---------------- Global Configuration ---------------- #
 PEXELS_API_KEY = 'BhJqbcdm9Vi90KqzXKAhnEHGsuFNv4irXuOjWtT761U49lRzo03qBGna'
 OPENROUTER_API_KEY = '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'
 OPENROUTER_MODEL = "mistralai/mistral-small-3.1-24b-instruct:free"
 OUTPUT_VIDEO_FILENAME = "final_video.mp4"
-# --- Web Request Settings ---
 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'
-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) ---
+
+
+# Additional global variables needed for the Gradio interface
+selected_voice = 'af_heart'  # Default voice
+voice_speed = 0.9  # Default voice speed
+font_size = 45  # Default font size
+video_clip_probability = 0.25  # Default probability for video clips
+bg_music_volume = 0.08  # Default background music volume
+fps = 30  # Default FPS
+preset = "veryfast"  # Default preset
 TARGET_RESOLUTION = None
+CAPTION_COLOR = None
 TEMP_FOLDER = None
-USE_CAPTIONS = True
 
-# ---------------- Kokoro TTS Initialization ---------------- #
-try:
-    pipeline = KPipeline(lang_code='a')
-    print("Kokoro TTS Pipeline initialized.")
-except Exception as e:
-    print(f"Warning: Failed to initialize Kokoro TTS Pipeline: {e}")
-    print("TTS generation will rely on gTTS.")
-    pipeline = None
 
 # ---------------- Helper Functions ---------------- #
+# (Your existing helper functions remain unchanged: generate_script, parse_script,
+# search_pexels_videos, search_pexels_images, search_google_images, download_image,
+# download_video, generate_media, generate_tts, apply_kenburns_effect,
+# resize_to_fill, find_mp3_files, add_background_music, create_clip,
+# fix_imagemagick_policy)
+
+# Define these globally as they were in your original code but will be set per run
+TARGET_RESOLUTION = None
+CAPTION_COLOR = None
+TEMP_FOLDER = None
 
 def generate_script(user_input):
-    """Generate documentary script using OpenRouter API."""
-    # (Retained from previous versions)
+    """Generate documentary script with proper OpenRouter handling."""
     headers = {
         'Authorization': f'Bearer {OPENROUTER_API_KEY}',
-        'Content-Type': 'application/json',
-        'HTTP-Referer': 'http://localhost:7860', # Or your app's URL
-        'X-Title': 'AI Documentary Maker Gradio'
+        'HTTP-Referer': 'https://your-domain.com',
+        'X-Title': 'AI Documentary Maker'
     }
-    prompt = f"""Create a short, humorous, slightly negative, and conversational documentary-style script based on the following topic or instructions: '{user_input}'.
 
+    prompt = f"""Short Documentary Script GeneratorInstructions:
+
+If I say "use this," just output the script exactly as I gave it.
+If I only give topics, generate a script based on them.
+If I provide a full script, rewrite it without any changes. Make everything short simple and humarous funny and act as serious but humarous. And don't say anything off topic. Also alway say a funny statement to subscribe based on the video topic at the end. Use normal conversational text like a normal person talking and avoid AI phase make the statements humanize and normal conversational
+And always talk negative views don't really wants any positive statement and the full script will be one video about one topic so keep in mind
 Formatting Rules:
-1. Start each distinct visual scene/idea with a title in square brackets `[Like This]`. This title will be used for searching visuals. Keep titles concise (1-3 words).
-2. After the bracketed title, write 1-2 short sentences (5-15 words total) of narration for that scene.
-3. Keep the narration casual, funny, maybe a bit sarcastic or critical, and human-like. Avoid sounding like a robotic AI.
-4. Do NOT use any other formatting like bold, italics, or bullet points.
-5. Ensure search terms in brackets are general enough for stock footage searches (e.g., use "[Technology]" instead of "[Quantum Supercomputer]").
-6. End the *entire* script with a funny, topic-related call to subscribe, also enclosed in brackets like `[Subscribe CTA]`.
-7. Focus on one core topic for the entire script.
-8. Output *only* the formatted script, nothing else.
-
-Example:
-[Cats]
-So, you think cats are cute? Let's investigate.
-[Sleeping]
-They spend 90% of their lives asleep. Lazy, much?
-[Judgment]
-The other 10%? Judging your life choices. Harsh.
-[Boxes]
-Their obsession with boxes remains unexplained. Weirdos.
-[Subscribe CTA]
-Subscribe now, or a cat will knock your coffee over.
-
-Now generate the script based on: {user_input}
+
+
+Title in Square Brackets:
+
+
+Each section starts with a one-word title inside [ ] (max two words if necessary).
+This title will be used as a search term for Pexels footage.
+
+
+
+Casual & Funny Narration:
+
+
+Each section has 5-10 words of narration.
+Keep it natural, funny, and unpredictable (not robotic, poetic, or rhythmic).
+
+
+
+No Special Formatting:
+
+
+No bold, italics, or special characters. You are a assistant AI your task is to create script. You aren't a chatbot. So, don't write extra text
+
+
+
+Generalized Search Terms:
+
+
+If a term is too specific, make it more general for Pexels search.
+
+
+
+Scene-Specific Writing:
+
+
+Each section describes only what should be shown in the video.
+
+
+
+Output Only the Script, and also make it funny and humarous and helirous and also add to subscribe with a funny statement like subscribe now or .....
+
+
+No extra text, just the script.
+
+
+
+Example Output:
+[North Korea]
+
+Top 5 unknown facts about North Korea.
+
+[Invisibility]
+
+North Korea’s internet speed is so fast… it doesn’t exist.
+
+[Leadership]
+
+Kim Jong-un once won an election with 100% votes… against himself.
+
+[Magic]
+
+North Korea discovered time travel. That’s why their news is always from the past.
+
+[Warning]
+
+Subscribe now, or Kim Jong-un will send you a free one-way ticket… to North Korea.
+
+[Freedom]
+
+North Korean citizens can do anything… as long as it's government-approved.
+Now here is the Topic/scrip: {user_input}
 """
+
     data = {
         'model': OPENROUTER_MODEL,
         'messages': [{'role': 'user', 'content': prompt}],
-        'temperature': 0.6,
-        'max_tokens': 600
+        'temperature': 0.4,
+        'max_tokens': 5000
     }
+
     try:
         response = requests.post(
             'https://openrouter.ai/api/v1/chat/completions',
             headers=headers,
             json=data,
-            timeout=45
+            timeout=30
         )
-        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']
-            script_content = re.sub(r"^.*?\n?\[", "[", script_content, flags=re.DOTALL)
-            script_content = script_content.strip()
-            print("Script generated successfully.")
-            return script_content
+
+        if response.status_code == 200:
+            response_data = response.json()
+            if 'choices' in response_data and len(response_data['choices']) > 0:
+                return response_data['choices'][0]['message']['content']
+            else:
+                print("Unexpected response format:", response_data)
+                return None
         else:
-            print(f"API Error: Unexpected response format: {response_data}")
+            print(f"API Error {response.status_code}: {response.text}")
             return None
-    except requests.exceptions.Timeout:
-        print("API Error: Request timed out.")
-        return None
-    except requests.exceptions.RequestException as e:
-        print(f"API Error: Request failed: {e}")
-        if hasattr(e, 'response') and e.response is not None:
-            print(f"API Response Status Code: {e.response.status_code}")
-            print(f"API Response Text: {e.response.text}")
-        return None
+
     except Exception as e:
-        print(f"Error during script generation: {str(e)}")
+        print(f"Request failed: {str(e)}")
         return None
 
 def parse_script(script_text):
-    """Parse the generated script into segments."""
-    # (Retained from previous versions)
-    segments = []
+    """
+    Parse the generated script into a list of elements.
+    For each section, create two elements:
+      - A 'media' element using the section title as the visual prompt.
+      - A 'tts' element with the narration text, voice info, and computed duration.
+    """
+    sections = {}
     current_title = None
-    current_narration = ""
-    if not script_text:
-        print("Error: Script text is empty.")
+    current_text = ""
+
+    try:
+        for line in script_text.splitlines():
+            line = line.strip()
+            if line.startswith("[") and "]" in line:
+                bracket_start = line.find("[")
+                bracket_end = line.find("]", bracket_start)
+                if bracket_start != -1 and bracket_end != -1:
+                    if current_title is not None:
+                        sections[current_title] = current_text.strip()
+                    current_title = line[bracket_start+1:bracket_end]
+                    current_text = line[bracket_end+1:].strip()
+            elif current_title:
+                current_text += line + " "
+
+        if current_title:
+            sections[current_title] = current_text.strip()
+
+        elements = []
+        for title, narration in sections.items():
+            if not title or not narration:
+                continue
+
+            media_element = {"type": "media", "prompt": title, "effects": "fade-in"}
+            words = narration.split()
+            duration = max(3, len(words) * 0.5)
+            tts_element = {"type": "tts", "text": narration, "voice": "en", "duration": duration}
+            elements.append(media_element)
+            elements.append(tts_element)
+
+        return elements
+    except Exception as e:
+        print(f"Error parsing script: {e}")
         return []
-    lines = script_text.strip().splitlines()
-    for line in lines:
-        line = line.strip()
-        if not line: continue
-        title_match = re.match(r'^\[(.*?)\](.*)', line)
-        if title_match:
-            if current_title is not None and current_narration.strip():
-                segments.append({"prompt": current_title, "narration": current_narration.strip()})
-            current_title = title_match.group(1).strip()
-            current_narration = title_match.group(2).strip() + " "
-        elif current_title is not None:
-            current_narration += line + " "
-    if current_title is not None and 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.")
-        simple_segments = []
-        for i, line in enumerate(lines):
-             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 []
-    print(f"Parsed {len(segments)} segments from script.")
-    return segments
-
-# --- Start: User Provided Functions ---
 
 def search_pexels_videos(query, pexels_api_key):
     """Search for a video on Pexels by query and return a random HD video."""
-    if not pexels_api_key or pexels_api_key == 'YOUR_PEXELS_API_KEY':
-        print(f"Pexels API key not provided or is default. Skipping Pexels video search.")
-        return None
     headers = {'Authorization': pexels_api_key}
     base_url = "https://api.pexels.com/videos/search"
     num_pages = 3
@@ -189,990 +247,726 @@ def search_pexels_videos(query, pexels_api_key):
 
     max_retries = 3
     retry_delay = 1
-    timeout_duration = 15 # Increased timeout slightly
 
     search_query = query
     all_videos = []
-    print(f"Searching Pexels videos for '{query}' (up to {num_pages} pages)...")
 
     for page in range(1, num_pages + 1):
-        print(f" Pexels Video Search: Page {page}")
         for attempt in range(max_retries):
             try:
-                params = {"query": search_query, "per_page": videos_per_page, "page": page, "orientation": "landscape"}
-                response = requests.get(base_url, headers=headers, params=params, timeout=timeout_duration)
+                params = {"query": search_query, "per_page": videos_per_page, "page": page}
+                response = requests.get(base_url, headers=headers, params=params, timeout=10)
 
                 if response.status_code == 200:
                     data = response.json()
                     videos = data.get("videos", [])
 
                     if not videos:
-                        print(f" No videos found on page {page} for '{query}'.")
-                        # Don't break inner loop immediately, maybe next page has results
-                        # Break outer loop if no videos found on *this* page attempt
-                        break # Break attempt loop for this page
+                        print(f"No videos found on page {page}.")
+                        break
 
-                    found_on_page = 0
                     for video in videos:
                         video_files = video.get("video_files", [])
-                        # Prioritize HD, then large, then medium
-                        hd_link = next((f['link'] for f in video_files if f.get('quality') == 'hd' and f.get('width', 0) >= 1080), None)
-                        large_link = next((f['link'] for f in video_files if f.get('quality') == 'large' and f.get('width', 0) >= 1080), None)
-                        medium_link = next((f['link'] for f in video_files if f.get('quality') == 'medium'), None) # Fallback if no HD/Large
-                        link_to_add = hd_link or large_link or medium_link
-
-                        if link_to_add:
-                            all_videos.append(link_to_add)
-                            found_on_page += 1
-                            # Don't break inner loop, collect all suitable videos from the page
-
-                    print(f" Found {found_on_page} suitable videos on page {page}.")
-                    break # Break attempt loop successfully after processing page
-
-                elif response.status_code == 401:
-                     print(f" Pexels API Error: Unauthorized (401). Check your API Key.")
-                     return None # Stop searching if key is bad
+                        for file in video_files:
+                            if file.get("quality") == "hd":
+                                all_videos.append(file.get("link"))
+                                break
+
+                    break
+
                 elif response.status_code == 429:
-                    print(f" Rate limit hit (attempt {attempt+1}/{max_retries}). Retrying in {retry_delay} seconds...")
+                    print(f"Rate limit hit (attempt {attempt+1}/{max_retries}). Retrying in {retry_delay} seconds...")
                     time.sleep(retry_delay)
                     retry_delay *= 2
-                elif response.status_code == 522:
-                     print(f" Pexels API Error: Connection Timed Out (522) (attempt {attempt+1}/{max_retries}). Retrying in {retry_delay} seconds...")
-                     time.sleep(retry_delay)
-                     retry_delay *= 2
                 else:
-                    print(f" Error fetching videos: {response.status_code} {response.text}")
+                    print(f"Error fetching videos: {response.status_code} {response.text}")
                     if attempt < max_retries - 1:
-                        print(f" Retrying in {retry_delay} seconds...")
+                        print(f"Retrying in {retry_delay} seconds...")
                         time.sleep(retry_delay)
                         retry_delay *= 2
                     else:
-                        print(f" Max retries reached for page {page}.")
-                        break # Break attempt loop for this page after max retries
+                        break
 
-            except requests.exceptions.Timeout:
-                print(f" Request timed out (attempt {attempt+1}/{max_retries}). Retrying in {retry_delay} seconds...")
-                time.sleep(retry_delay)
-                retry_delay *= 2
             except requests.exceptions.RequestException as e:
-                print(f" Request exception: {e}")
+                print(f"Request exception: {e}")
                 if attempt < max_retries - 1:
-                    print(f" Retrying in {retry_delay} seconds...")
+                    print(f"Retrying in {retry_delay} seconds...")
                     time.sleep(retry_delay)
                     retry_delay *= 2
                 else:
-                    print(f" Max retries reached for page {page} due to request exception.")
-                    break # Break attempt loop for this page
-
-        # Reset retry delay for the next page
-        retry_delay = 1
+                    break
 
     if all_videos:
         random_video = random.choice(all_videos)
-        print(f"Selected random video from {len(all_videos)} suitable videos found across pages.")
+        print(f"Selected random video from {len(all_videos)} HD videos")
         return random_video
     else:
-        print(f"No suitable videos found for '{query}' after searching {num_pages} pages.")
+        print("No suitable videos found after searching all pages.")
         return None
 
 def search_pexels_images(query, pexels_api_key):
     """Search for an image on Pexels by query."""
-    if not pexels_api_key or pexels_api_key == 'YOUR_PEXELS_API_KEY':
-        print(f"Pexels API key not provided or is default. Skipping Pexels image search.")
-        return None
     headers = {'Authorization': pexels_api_key}
     url = "https://api.pexels.com/v1/search"
-    # Fetch more results to increase chance of finding good ones
-    params = {"query": query, "per_page": 15, "orientation": "landscape"}
+    params = {"query": query, "per_page": 5, "orientation": "landscape"}
 
     max_retries = 3
     retry_delay = 1
-    timeout_duration = 15 # Increased timeout slightly
-
-    print(f"Searching Pexels images for '{query}'...")
 
     for attempt in range(max_retries):
         try:
-            response = requests.get(url, headers=headers, params=params, timeout=timeout_duration)
+            response = requests.get(url, headers=headers, params=params, timeout=10)
 
             if response.status_code == 200:
                 data = response.json()
                 photos = data.get("photos", [])
                 if photos:
-                    # Select from all returned photos, preferring larger sizes
-                    valid_photos = []
-                    for photo in photos:
-                         # Prefer large2x or original, fallback to large
-                         large2x_url = photo.get("src", {}).get("large2x")
-                         original_url = photo.get("src", {}).get("original")
-                         large_url = photo.get("src", {}).get("large")
-                         img_url = large2x_url or original_url or large_url
-                         if img_url:
-                              valid_photos.append(img_url)
-
-                    if valid_photos:
-                         selected_photo = random.choice(valid_photos)
-                         print(f"Selected random image from {len(valid_photos)} suitable images found.")
-                         return selected_photo
-                    else:
-                         print(f"No suitable image URLs found in results for query: {query}")
-                         return None # Found photos but no usable URLs
+                    photo = random.choice(photos[:min(5, len(photos))])
+                    img_url = photo.get("src", {}).get("original")
+                    return img_url
                 else:
                     print(f"No images found for query: {query}")
-                    return None # API returned empty 'photos' list
+                    return None
 
-            elif response.status_code == 401:
-                 print(f" Pexels API Error: Unauthorized (401). Check your API Key.")
-                 return None # Stop searching if key is bad
             elif response.status_code == 429:
-                print(f" Rate limit hit (attempt {attempt+1}/{max_retries}). Retrying in {retry_delay} seconds...")
+                print(f"Rate limit hit (attempt {attempt+1}/{max_retries}). Retrying in {retry_delay} seconds...")
                 time.sleep(retry_delay)
                 retry_delay *= 2
-            elif response.status_code == 522:
-                 print(f" Pexels API Error: Connection Timed Out (522) (attempt {attempt+1}/{max_retries}). Retrying in {retry_delay} seconds...")
-                 time.sleep(retry_delay)
-                 retry_delay *= 2
             else:
-                print(f" Error fetching images: {response.status_code} {response.text}")
+                print(f"Error fetching images: {response.status_code} {response.text}")
                 if attempt < max_retries - 1:
-                    print(f" Retrying in {retry_delay} seconds...")
+                    print(f"Retrying in {retry_delay} seconds...")
                     time.sleep(retry_delay)
                     retry_delay *= 2
-                else:
-                     break # Max retries for other errors
 
-        except requests.exceptions.Timeout:
-            print(f" Request timed out (attempt {attempt+1}/{max_retries}). Retrying in {retry_delay} seconds...")
-            time.sleep(retry_delay)
-            retry_delay *= 2
         except requests.exceptions.RequestException as e:
-            print(f" Request exception: {e}")
+            print(f"Request exception: {e}")
             if attempt < max_retries - 1:
-                print(f" Retrying in {retry_delay} seconds...")
+                print(f"Retrying in {retry_delay} seconds...")
                 time.sleep(retry_delay)
                 retry_delay *= 2
-            else:
-                break # Max retries after request exception
 
     print(f"No Pexels images found for query: {query} after all attempts")
     return None
 
-# Added back search_google_images as it's used in the provided generate_media
 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)")
+    """Search for images on Google Images (for news-related queries)"""
     try:
-        search_url = f"https://www.google.com/search?q={quote(query)}&tbm=isch&safe=active"
+        search_url = f"https://www.google.com/search?q={quote(query)}&tbm=isch"
         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 = []
         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"):
-                 if any(ext in src.lower() for ext in ['.jpg', '.jpeg', '.png', '.webp']):
-                    image_urls.append(src)
+            src = img.get("src", "")
+            if src.startswith("http") and "gstatic" not in src:
+                image_urls.append(src)
 
         if image_urls:
-            print(f"Found {len(image_urls)} potential Google Images for '{query}'.")
-            # Select randomly from top 10 potential URLs
-            return random.choice(image_urls[:min(len(image_urls), 10)])
+            return random.choice(image_urls[:5]) if len(image_urls) >= 5 else image_urls[0]
         else:
-            print(f"No suitable Google Images found for query: {query}")
+            print(f"No 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}")
+        print(f"Error in Google Images search: {e}")
         return None
 
-
 def download_image(image_url, filename):
     """Download an image from a URL to a local file with enhanced error handling."""
     try:
         headers = {"User-Agent": USER_AGENT}
         print(f"Downloading image from: {image_url} to {filename}")
-        response = requests.get(image_url, headers=headers, stream=True, timeout=20) # Increased timeout
+        response = requests.get(image_url, headers=headers, stream=True, timeout=15)
         response.raise_for_status()
 
-        # Ensure the target directory exists
-        os.makedirs(os.path.dirname(filename), exist_ok=True)
-
         with open(filename, 'wb') as f:
             for chunk in response.iter_content(chunk_size=8192):
                 f.write(chunk)
 
-        print(f" Image downloaded successfully to: {filename}")
+        print(f"Image downloaded successfully to: {filename}")
 
-        # Validate and convert image
         try:
             img = Image.open(filename)
-            img.verify() # Check if it's a valid image file format
-            img.close() # Close file handle after verify
-
-            # Re-open to check mode and convert if needed
+            img.verify()
             img = Image.open(filename)
             if img.mode != 'RGB':
-                print(f" Converting image {os.path.basename(filename)} to RGB.")
-                # Ensure conversion doesn't create an empty file on error
-                try:
-                    rgb_img = img.convert('RGB')
-                    # Save to a temporary file first, then replace original
-                    temp_filename = filename + ".tmp.jpg"
-                    rgb_img.save(temp_filename, "JPEG")
-                    rgb_img.close()
-                    img.close()
-                    os.replace(temp_filename, filename) # Atomic replace if possible
-                    print(f" Image successfully converted and saved as {os.path.basename(filename)}")
-                except Exception as e_convert:
-                    print(f" Error converting image to RGB: {e_convert}")
-                    img.close() # Close original image handle
-                    if os.path.exists(filename): os.remove(filename) # Remove partially converted/original
-                    if os.path.exists(temp_filename): os.remove(temp_filename) # Clean up temp
-                    return None
-            else:
-                img.close() # Close if already RGB
-                print(f" Image {os.path.basename(filename)} validated (already RGB).")
-
-            # Final check if file exists after processing
-            if os.path.exists(filename) and os.path.getsize(filename) > 0:
-                 return filename
-            else:
-                 print(f" Image file {os.path.basename(filename)} missing or empty after processing.")
-                 return None
-
-        except (IOError, SyntaxError, Image.UnidentifiedImageError) as e_validate:
-            print(f" Downloaded file {os.path.basename(filename)} is not a valid image or corrupted: {e_validate}")
-            if os.path.exists(filename): os.remove(filename)
+                img = img.convert('RGB')
+                img.save(filename)
+            print(f"Image validated and processed: {filename}")
+            return filename
+        except Exception as e_validate:
+            print(f"Downloaded file is not a valid image: {e_validate}")
+            if os.path.exists(filename):
+                os.remove(filename)
             return None
-        except Exception as e_general_process:
-             print(f" Unexpected error during image processing: {e_general_process}")
-             if os.path.exists(filename): os.remove(filename)
-             return None
-
 
     except requests.exceptions.RequestException as e_download:
-        print(f" Image download error: {e_download}")
-        # Don't remove file here, might not exist or be partial
+        print(f"Image download error: {e_download}")
+        if os.path.exists(filename):
+            os.remove(filename)
         return None
-    except Exception as e_general_download:
-        print(f" General error during image download request: {e_general_download}")
+    except Exception as e_general:
+        print(f"General error during image processing: {e_general}")
+        if os.path.exists(filename):
+            os.remove(filename)
         return None
 
 def download_video(video_url, filename):
     """Download a video from a URL to a local file."""
     try:
-        headers = {"User-Agent": USER_AGENT} # Add User-Agent
-        print(f"Downloading video from: {video_url} to {filename}")
-        response = requests.get(video_url, headers=headers, stream=True, timeout=60) # Longer timeout for videos
+        response = requests.get(video_url, stream=True, timeout=30)
         response.raise_for_status()
-
-        # Ensure the target directory exists
-        os.makedirs(os.path.dirname(filename), exist_ok=True)
-
         with open(filename, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=1024*1024): # Larger chunk size for videos
+            for chunk in response.iter_content(chunk_size=8192):
                 f.write(chunk)
-        print(f" Video downloaded successfully to: {filename}")
-        # Basic check: file exists and has size > 0
-        if os.path.exists(filename) and os.path.getsize(filename) > 0:
-            return filename
-        else:
-            print(f" Video file {os.path.basename(filename)} missing or empty after download.")
-            if os.path.exists(filename): os.remove(filename) # Clean up empty file
-            return None
-    except requests.exceptions.RequestException as e:
+        print(f"Video downloaded successfully to: {filename}")
+        return filename
+    except Exception as e:
         print(f"Video download error: {e}")
-        # Don't remove file here, might not exist or be partial
+        if os.path.exists(filename):
+            os.remove(filename)
         return None
-    except Exception as e_general:
-         print(f"General error during video download: {e_general}")
-         return None
 
 def generate_media(prompt, user_image=None, current_index=0, total_segments=1):
     """
-    Generate a visual asset using user-provided functions.
-    Checks for "news", tries Pexels video/image, falls back to generic Pexels image.
+    Generate a visual asset by first searching for a video or using a specific search strategy.
+    For news-related queries, use Google Images.
+    Returns a dict: {'path': <file_path>, 'asset_type': 'video' or 'image'}.
     """
-    # Sanitize prompt for filename
-    safe_prompt_base = re.sub(r'[^\w\s-]', '', prompt).strip().replace(' ', '_')
-    safe_prompt_base = safe_prompt_base[:50] # Limit length
-    # Add timestamp for uniqueness within the temp folder
-    safe_prompt = f"{safe_prompt_base}_{int(time.time())}"
+    safe_prompt = re.sub(r'[^\w\s-]', '', prompt).strip().replace(' ', '_')
 
-    # --- News Check (Uses Google Images) ---
     if "news" in prompt.lower():
-        print(f"News-related query detected: '{prompt}'. Trying Google Images...")
+        print(f"News-related query detected: {prompt}. Using Google Images...")
         image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_news.jpg")
-        image_url = search_google_images(prompt) # Use the added back function
+        image_url = search_google_images(prompt)
         if image_url:
             downloaded_image = download_image(image_url, image_file)
             if downloaded_image:
-                print(f" Using Google Image news asset: {os.path.basename(downloaded_image)}")
+                print(f"News image saved to {downloaded_image}")
                 return {"path": downloaded_image, "asset_type": "image"}
-            else:
-                print(f" Google Image download failed for: {image_url}")
         else:
-            print(f" Google Images search failed for prompt: '{prompt}'. Proceeding with Pexels.")
-        # Fall through to Pexels if Google fails
+            print(f"Google Images search failed for prompt: {prompt}")
 
-    # --- Pexels Video Attempt ---
     if random.random() < video_clip_probability:
-        print(f"Attempting Pexels video search for: '{prompt}'")
         video_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_video.mp4")
         video_url = search_pexels_videos(prompt, PEXELS_API_KEY)
         if video_url:
             downloaded_video = download_video(video_url, video_file)
             if downloaded_video:
-                print(f" Using Pexels video asset: {os.path.basename(downloaded_video)}")
+                print(f"Video asset saved to {downloaded_video}")
                 return {"path": downloaded_video, "asset_type": "video"}
-            else:
-                 print(f" Pexels video download failed for: {video_url}")
         else:
-            print(f" Pexels video search yielded no results for '{prompt}'.")
-    else:
-         print(f"Skipping Pexels video search based on probability for '{prompt}'.")
+            print(f"Pexels video search failed for prompt: {prompt}")
 
-
-    # --- Pexels Image Attempt ---
-    print(f"Attempting Pexels image search for: '{prompt}'")
-    image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_image.jpg")
+    image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}.jpg")
     image_url = search_pexels_images(prompt, PEXELS_API_KEY)
     if image_url:
         downloaded_image = download_image(image_url, image_file)
         if downloaded_image:
-            print(f" Using Pexels image asset: {os.path.basename(downloaded_image)}")
+            print(f"Image asset saved to {downloaded_image}")
             return {"path": downloaded_image, "asset_type": "image"}
         else:
-            print(f" Pexels image download failed for: {image_url}")
-    else:
-        print(f" Pexels image search yielded no results for '{prompt}'.")
-
-    # --- Fallback Pexels Image Attempt ---
-    # Avoid fallback for instructional prompts
-    if "subscribe" not in prompt.lower() and "cta" not in prompt.lower():
-        fallback_terms = ["technology", "abstract", "nature", "background", "texture"]
-        term = random.choice(fallback_terms)
-        print(f"All specific searches failed for '{prompt}'. Trying Pexels fallback term: '{term}'")
-        fallback_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_fallback_{term}.jpg")
+            print(f"Pexels image download failed for prompt: {prompt}")
+
+    fallback_terms = ["nature", "people", "landscape", "technology", "business"]
+    for term in fallback_terms:
+        print(f"Trying fallback image search with term: {term}")
+        fallback_file = os.path.join(TEMP_FOLDER, f"fallback_{term}.jpg")
         fallback_url = search_pexels_images(term, PEXELS_API_KEY)
         if fallback_url:
             downloaded_fallback = download_image(fallback_url, fallback_file)
             if downloaded_fallback:
-                print(f" Using Pexels fallback image asset: {os.path.basename(downloaded_fallback)}")
+                print(f"Fallback image saved to {downloaded_fallback}")
                 return {"path": downloaded_fallback, "asset_type": "image"}
             else:
-                print(f" Pexels fallback image download failed for term: '{term}'")
+                print(f"Fallback image download failed for term: {term}")
         else:
-            print(f" Pexels fallback image search failed for term: '{term}'")
-    else:
-         print(f"Skipping fallback search for instructional prompt: '{prompt}'")
-
+            print(f"Fallback image search failed for term: {term}")
 
-    # --- Final Failure ---
-    print(f"FATAL: Failed to generate any visual asset for prompt: '{prompt}'")
+    print(f"Failed to generate visual asset for prompt: {prompt}")
     return None
 
-# --- End: User Provided Functions ---
+def generate_silent_audio(duration, sample_rate=24000):
+    """Generate a silent WAV audio file lasting 'duration' seconds."""
+    num_samples = int(duration * sample_rate)
+    silence = np.zeros(num_samples, dtype=np.float32)
+    silent_path = os.path.join(TEMP_FOLDER, f"silent_{int(time.time())}.wav")
+    sf.write(silent_path, silence, sample_rate)
+    print(f"Silent audio generated: {silent_path}")
+    return silent_path
 
+def generate_tts(text, voice):
+    """
+    Generate TTS audio using Kokoro, falling back to gTTS or silent audio if needed.
+    """
+    safe_text = re.sub(r'[^\w\s-]', '', text[:10]).strip().replace(' ', '_')
+    file_path = os.path.join(TEMP_FOLDER, f"tts_{safe_text}.wav")
+
+    if os.path.exists(file_path):
+        print(f"Using cached TTS for text '{text[:10]}...'")
+        return file_path
 
-def generate_tts(text, voice_id, speed):
-    """Generate TTS audio using Kokoro, falling back to gTTS."""
-    # (Retained from previous versions)
-    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")
-    if pipeline:
-        try:
-            print(f"Generating TTS with Kokoro (Voice: {voice_id}, Speed: {speed}) for: '{text[:30]}...'")
-            generator = pipeline(text, voice=voice_id, speed=speed)
-            audio_segments = []
-            for item in generator:
-                if isinstance(item, tuple) and len(item) > 0 and isinstance(item[-1], np.ndarray):
-                    audio_segments.append(item[-1])
-                elif isinstance(item, np.ndarray):
-                     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]
-            if full_audio.dtype != np.float32:
-                full_audio = full_audio.astype(np.float32)
-                max_val = np.max(np.abs(full_audio))
-                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.")
     try:
-        print(f"Generating TTS with gTTS for: '{text[:30]}...'")
-        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
-        tts.save(mp3_path)
-        audio = AudioSegment.from_mp3(mp3_path)
-        # Ensure target directory exists for export
-        os.makedirs(os.path.dirname(wav_path), exist_ok=True)
-        audio.export(wav_path, format="wav")
-        os.remove(mp3_path)
-        print(f"gTTS audio saved and converted to {wav_path}")
-        # Check if file exists and has size
-        if os.path.exists(wav_path) and os.path.getsize(wav_path) > 0:
-            return wav_path
-        else:
-            print(f"Error: gTTS output file missing or empty: {wav_path}")
-            return None
-    except ImportError:
-        print("Error: gTTS or pydub might not be installed. Cannot use gTTS fallback.")
-        return None
-    except Exception as fallback_error:
-        print(f"Error with gTTS fallback: {fallback_error}")
-        return None
+        kokoro_voice = selected_voice if voice == 'en' else voice
+        generator = pipeline(text, voice=kokoro_voice, speed=voice_speed, split_pattern=r'\n+')
+        audio_segments = []
+        for i, (gs, ps, audio) in enumerate(generator):
+            audio_segments.append(audio)
+        full_audio = np.concatenate(audio_segments) if len(audio_segments) > 1 else audio_segments[0]
+        sf.write(file_path, full_audio, 24000)
+        print(f"TTS audio saved to {file_path} (Kokoro)")
+        return file_path
+    except Exception as e:
+        print(f"Error with Kokoro TTS: {e}")
+        try:
+            print("Falling back to gTTS...")
+            tts = gTTS(text=text, lang='en')
+            mp3_path = os.path.join(TEMP_FOLDER, f"tts_{safe_text}.mp3")
+            tts.save(mp3_path)
+            audio = AudioSegment.from_mp3(mp3_path)
+            audio.export(file_path, format="wav")
+            os.remove(mp3_path)
+            print(f"Fallback TTS saved to {file_path} (gTTS)")
+            return file_path
+        except Exception as fallback_error:
+            print(f"Both TTS methods failed: {fallback_error}")
+            return generate_silent_audio(duration=max(3, len(text.split()) * 0.5))
+
+def apply_kenburns_effect(clip, target_resolution, effect_type=None):
+    """Apply a smooth Ken Burns effect with a single movement pattern."""
+    target_w, target_h = target_resolution
+    clip_aspect = clip.w / clip.h
+    target_aspect = target_w / target_h
 
-def apply_kenburns_effect(clip, target_resolution, duration):
-    """Apply a randomized Ken Burns effect (zoom/pan) to an image clip."""
-    # (Retained from previous versions)
+    if clip_aspect > target_aspect:
+        new_height = target_h
+        new_width = int(new_height * clip_aspect)
+    else:
+        new_width = target_w
+        new_height = int(new_width / clip_aspect)
+
+    clip = clip.resize(newsize=(new_width, new_height))
+    base_scale = 1.15
+    new_width = int(new_width * base_scale)
+    new_height = int(new_height * base_scale)
+    clip = clip.resize(newsize=(new_width, new_height))
+
+    max_offset_x = new_width - target_w
+    max_offset_y = new_height - target_h
+
+    available_effects = ["zoom-in", "zoom-out", "pan-left", "pan-right", "up-left"]
+    if effect_type is None or effect_type == "random":
+        effect_type = random.choice(available_effects)
+
+    if effect_type == "zoom-in":
+        start_zoom = 0.9
+        end_zoom = 1.1
+        start_center = (new_width / 2, new_height / 2)
+        end_center = start_center
+    elif effect_type == "zoom-out":
+        start_zoom = 1.1
+        end_zoom = 0.9
+        start_center = (new_width / 2, new_height / 2)
+        end_center = start_center
+    elif effect_type == "pan-left":
+        start_zoom = 1.0
+        end_zoom = 1.0
+        start_center = (max_offset_x + target_w / 2, (max_offset_y // 2) + target_h / 2)
+        end_center = (target_w / 2, (max_offset_y // 2) + target_h / 2)
+    elif effect_type == "pan-right":
+        start_zoom = 1.0
+        end_zoom = 1.0
+        start_center = (target_w / 2, (max_offset_y // 2) + target_h / 2)
+        end_center = (max_offset_x + target_w / 2, (max_offset_y // 2) + target_h / 2)
+    elif effect_type == "up-left":
+        start_zoom = 1.0
+        end_zoom = 1.0
+        start_center = (max_offset_x + target_w / 2, max_offset_y + target_h / 2)
+        end_center = (target_w / 2, target_h / 2)
+    else:
+        raise ValueError(f"Unsupported effect_type: {effect_type}")
+
+    def transform_frame(get_frame, t):
+        frame = get_frame(t)
+        ratio = t / clip.duration if clip.duration > 0 else 0
+        ratio = 0.5 - 0.5 * math.cos(math.pi * ratio)
+        current_zoom = start_zoom + (end_zoom - start_zoom) * ratio
+        crop_w = int(target_w / current_zoom)
+        crop_h = int(target_h / current_zoom)
+        current_center_x = start_center[0] + (end_center[0] - start_center[0]) * ratio
+        current_center_y = start_center[1] + (end_center[1] - start_center[1]) * ratio
+        min_center_x = crop_w / 2
+        max_center_x = new_width - crop_w / 2
+        min_center_y = crop_h / 2
+        max_center_y = new_height - crop_h / 2
+        current_center_x = max(min_center_x, min(current_center_x, max_center_x))
+        current_center_y = max(min_center_y, min(current_center_y, max_center_y))
+        cropped_frame = cv2.getRectSubPix(frame, (crop_w, crop_h), (current_center_x, current_center_y))
+        resized_frame = cv2.resize(cropped_frame, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
+        return resized_frame
+
+    return clip.fl(transform_frame)
+
+def resize_to_fill(clip, target_resolution):
+    """Resize and crop a clip to fill the target resolution while maintaining aspect ratio."""
     target_w, target_h = target_resolution
-    try: # Add try-except around accessing clip properties
-        img_w, img_h = clip.size
-    except Exception as e:
-        print(f"Error accessing image clip size: {e}")
-        # Cannot apply effect if size is unknown, return original clip resized
-        return clip.resize(newsize=target_resolution).set_duration(duration)
-
-    scale_factor = 1.2
-    # Handle potential division by zero if img_h is 0
-    if img_h == 0: img_h = 1
-    img_aspect = img_w / img_h
+    clip_aspect = clip.w / clip.h
     target_aspect = target_w / target_h
 
-    # Resize logic
-    if img_aspect > target_aspect:
-        final_h = target_h * scale_factor
-        final_w = final_h * img_aspect
+    if clip_aspect > target_aspect:
+        clip = clip.resize(height=target_h)
+        crop_amount = (clip.w - target_w) / 2
+        clip = clip.crop(x1=crop_amount, x2=clip.w - crop_amount, y1=0, y2=clip.h)
     else:
-        final_w = target_w * scale_factor
-        final_h = final_w / img_aspect # Use img_aspect here
+        clip = clip.resize(width=target_w)
+        crop_amount = (clip.h - target_h) / 2
+        clip = clip.crop(x1=0, x2=clip.w, y1=crop_amount, y2=clip.h - crop_amount)
+
+    return clip
+
+def find_mp3_files():
+    """Search for any MP3 files in the current directory and subdirectories."""
+    mp3_files = []
+    for root, dirs, files in os.walk('.'):
+        for file in files:
+            if file.endswith('.mp3'):
+                mp3_path = os.path.join(root, file)
+                mp3_files.append(mp3_path)
+                print(f"Found MP3 file: {mp3_path}")
+    return mp3_files[0] if mp3_files else None
+
+def add_background_music(final_video, bg_music_volume=0.10):
+    """Add background music to the final video using any MP3 file found."""
+    try:
+        bg_music_path = "music.mp3"
+        if bg_music_path and os.path.exists(bg_music_path):
+            print(f"Adding background music from: {bg_music_path}")
+            bg_music = AudioFileClip(bg_music_path)
+            if bg_music.duration < final_video.duration:
+                loops_needed = math.ceil(final_video.duration / bg_music.duration)
+                bg_segments = [bg_music] * loops_needed
+                bg_music = concatenate_audioclips(bg_segments)
+            bg_music = bg_music.subclip(0, final_video.duration)
+            bg_music = bg_music.volumex(bg_music_volume)
+            video_audio = final_video.audio
+            mixed_audio = CompositeAudioClip([video_audio, bg_music])
+            final_video = final_video.set_audio(mixed_audio)
+            print("Background music added successfully")
+        else:
+            print("No MP3 files found, skipping background music")
+        return final_video
+    except Exception as e:
+        print(f"Error adding background music: {e}")
+        print("Continuing without background music")
+        return final_video
+
+def create_clip(media_path, asset_type, tts_path, duration=None, effects=None, narration_text=None, segment_index=0):
+    """Create a video clip with synchronized subtitles and narration."""
+    try:
+        print(f"Creating clip #{segment_index} with asset_type: {asset_type}, media_path: {media_path}")
+        if not os.path.exists(media_path) or not os.path.exists(tts_path):
+            print("Missing media or TTS file")
+            return None
 
-    final_w, final_h = int(final_w), int(final_h)
-    # Ensure final dimensions are not zero
-    if final_w <= 0: final_w = 1
-    if final_h <= 0: final_h = 1
+        audio_clip = AudioFileClip(tts_path).audio_fadeout(0.2)
+        audio_duration = audio_clip.duration
+        target_duration = audio_duration + 0.2
+
+        if asset_type == "video":
+            clip = VideoFileClip(media_path)
+            clip = resize_to_fill(clip, TARGET_RESOLUTION)
+            if clip.duration < target_duration:
+                clip = clip.loop(duration=target_duration)
+            else:
+                clip = clip.subclip(0, target_duration)
+        elif asset_type == "image":
+            img = Image.open(media_path)
+            if img.mode != 'RGB':
+                with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as temp:
+                    img.convert('RGB').save(temp.name)
+                    media_path = temp.name
+                img.close()
+            clip = ImageClip(media_path).set_duration(target_duration)
+            clip = apply_kenburns_effect(clip, TARGET_RESOLUTION)
+            clip = clip.fadein(0.3).fadeout(0.3)
+        else:
+            return None
+
+        if narration_text and CAPTION_COLOR != "transparent":
+            try:
+                words = narration_text.split()
+                chunks = []
+                current_chunk = []
+                for word in words:
+                    current_chunk.append(word)
+                    if len(current_chunk) >= 5:
+                        chunks.append(' '.join(current_chunk))
+                        current_chunk = []
+                if current_chunk:
+                    chunks.append(' '.join(current_chunk))
+
+                chunk_duration = audio_duration / len(chunks)
+                subtitle_clips = []
+                subtitle_y_position = int(TARGET_RESOLUTION[1] * 0.70)
 
+                for i, chunk_text in enumerate(chunks):
+                    start_time = i * chunk_duration
+                    end_time = (i + 1) * chunk_duration
+                    txt_clip = TextClip(
+                        chunk_text,
+                        fontsize=45,
+                        font='Arial-Bold',
+                        color=CAPTION_COLOR,
+                        bg_color='rgba(0, 0, 0, 0.25)',
+                        method='caption',
+                        align='center',
+                        stroke_width=2,
+                        stroke_color=CAPTION_COLOR,
+                        size=(TARGET_RESOLUTION[0] * 0.8, None)
+                    ).set_start(start_time).set_end(end_time)
+                    txt_clip = txt_clip.set_position(('center', subtitle_y_position))
+                    subtitle_clips.append(txt_clip)
+
+                clip = CompositeVideoClip([clip] + subtitle_clips)
+            except Exception as sub_error:
+                print(f"Subtitle error: {sub_error}")
+                txt_clip = TextClip(
+                    narration_text,
+                    fontsize=font_size,
+                    color=CAPTION_COLOR,
+                    align='center',
+                    size=(TARGET_RESOLUTION[0] * 0.7, None)
+                ).set_position(('center', int(TARGET_RESOLUTION[1] / 3))).set_duration(clip.duration)
+                clip = CompositeVideoClip([clip, txt_clip])
+
+        clip = clip.set_audio(audio_clip)
+        print(f"Clip created: {clip.duration:.1f}s")
+        return clip
+    except Exception as e:
+        print(f"Error in create_clip: {str(e)}")
+        return None
+
+def fix_imagemagick_policy():
+    """Fix ImageMagick security policies."""
     try:
-        # Use MoviePy's resize for ImageClip directly before applying fl
-        resized_clip = clip.resize(newsize=(final_w, final_h)).set_duration(duration)
-        # pil_img = Image.fromarray(clip.get_frame(0)) # Avoid get_frame here
-        # resized_pil = pil_img.resize((final_w, final_h), Image.Resampling.LANCZOS)
-        # resized_clip = ImageClip(np.array(resized_pil)).set_duration(duration)
+        print("Attempting to fix ImageMagick security policies...")
+        policy_paths = [
+            "/etc/ImageMagick-6/policy.xml",
+            "/etc/ImageMagick-7/policy.xml",
+            "/etc/ImageMagick/policy.xml",
+            "/usr/local/etc/ImageMagick-7/policy.xml"
+        ]
+        found_policy = next((path for path in policy_paths if os.path.exists(path)), None)
+        if not found_policy:
+            print("No policy.xml found. Using alternative subtitle method.")
+            return False
+        print(f"Modifying policy file at {found_policy}")
+        os.system(f"sudo cp {found_policy} {found_policy}.bak")
+        os.system(f"sudo sed -i 's/rights=\"none\"/rights=\"read|write\"/g' {found_policy}")
+        os.system(f"sudo sed -i 's/<policy domain=\"path\" pattern=\"@\*\"[^>]*>/<policy domain=\"path\" pattern=\"@*\" rights=\"read|write\"/g' {found_policy}")
+        os.system(f"sudo sed -i 's/<policy domain=\"coder\" rights=\"none\" pattern=\"PDF\"[^>]*>/<!-- <policy domain=\"coder\" rights=\"none\" pattern=\"PDF\"> -->/g' {found_policy}")
+        print("ImageMagick policies updated successfully.")
+        return True
     except Exception as e:
-        print(f"Warning: Error during resize for Ken Burns, using MoviePy default: {e}")
-        try:
-            # Fallback resize
-            resized_clip = clip.resize(newsize=(final_w, final_h)).set_duration(duration)
-        except Exception as resize_err:
-             print(f"FATAL error during fallback resize for Ken Burns: {resize_err}")
-             # Return original clip resized to target as last resort
-             return clip.resize(newsize=target_resolution).set_duration(duration)
-
-
-    max_move_x = final_w - target_w
-    max_move_y = final_h - target_h
-    # Ensure max_move is not negative if resizing failed slightly
-    max_move_x = max(0, max_move_x)
-    max_move_y = max(0, max_move_y)
-
-    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': 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):
-        # Protect against duration being zero
-        interp = t / duration if duration > 0 else 0
-
-        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
-
-        # Avoid division by zero for zoom
-        if current_zoom <= 0: current_zoom = 1e-6 # Small positive number
-
-        # Calculate crop box dimensions based on current zoom relative to the base scale_factor
-        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))
-
-        # Calculate top-left corner (x1, y1)
-        x1 = current_x; y1 = current_y
-        x1 = max(0, min(x1, final_w - crop_w)); y1 = max(0, min(y1, final_h - crop_h))
-
-        # Get frame from the *resized* clip
-        frame = resized_clip.get_frame(t)
-
-        # Crop using numpy slicing
-        try:
-            # Ensure indices are integers and within bounds
-            y1_int, y2_int = int(y1), int(y1 + crop_h)
-            x1_int, x2_int = int(x1), int(x1 + crop_w)
-            # Clamp coordinates to frame dimensions BEFORE slicing
-            y1_int = max(0, min(y1_int, frame.shape[0] - 1))
-            y2_int = max(y1_int + 1, min(y2_int, frame.shape[0])) # Ensure y2 > y1
-            x1_int = max(0, min(x1_int, frame.shape[1] - 1))
-            x2_int = max(x1_int + 1, min(x2_int, frame.shape[1])) # Ensure x2 > x1
+        print(f"Error fixing policies: {e}")
+        return False
+
+
+
+
 
-            # Check if dimensions are valid after clamping
-            if y2_int <= y1_int or x2_int <= x1_int:
-                 print(f"Warning: Invalid crop dimensions after clamping ({y1_int}:{y2_int}, {x1_int}:{x2_int}). Returning uncropped frame.")
-                 # Resize original frame to target as fallback for this frame
-                 return cv2.resize(frame, (target_w, target_h), interpolation=cv2.INTER_AREA)
 
 
-            cropped_frame = frame[y1_int:y2_int, x1_int:x2_int]
 
-             # Check if cropped frame is empty
-            if cropped_frame.size == 0:
-                 print(f"Warning: Cropped frame is empty ({y1_int}:{y2_int}, {x1_int}:{x2_int}). Returning uncropped frame.")
-                 return cv2.resize(frame, (target_w, target_h), interpolation=cv2.INTER_AREA)
 
 
-            # Resize cropped frame to target
-            final_frame = cv2.resize(cropped_frame, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
-        except IndexError as ie:
-             print(f"Error during frame cropping/resizing: {ie}. Frame shape: {frame.shape}, Crop: y={y1_int}:{y2_int}, x={x1_int}:{x2_int}")
-             # Fallback: return the original frame resized
-             final_frame = cv2.resize(frame, (target_w, target_h), interpolation=cv2.INTER_AREA)
-        except Exception as crop_resize_err:
-             print(f"Unexpected error during frame cropping/resizing: {crop_resize_err}")
-             final_frame = cv2.resize(frame, (target_w, target_h), interpolation=cv2.INTER_AREA)
 
 
-        return final_frame
 
-    # Apply the transformation using fl
-    try:
-        return resized_clip.fl(make_frame, apply_to=['mask'])
-    except Exception as fl_err:
-        print(f"Error applying Ken Burns effect via fl: {fl_err}")
-        # Return the resized clip without the effect as fallback
-        return resized_clip.resize(newsize=target_resolution)
 
 
-def resize_to_fill(clip, target_resolution):
-    """Resize and crop a video clip to fill the target resolution."""
-    # (Retained from previous versions)
-    target_w, target_h = target_resolution
-    try:
-         # Ensure clip dimensions are valid
-         if clip.w <= 0 or clip.h <= 0:
-              print(f"Warning: Invalid clip dimensions ({clip.w}x{clip.h}). Cannot resize/crop.")
-              # Return a black clip of target size? Or fail? Let's return black.
-              from moviepy.editor import ColorClip
-              return ColorClip(size=target_resolution, color=(0,0,0), duration=clip.duration)
 
-         target_aspect = target_w / target_h
-         clip_aspect = clip.w / clip.h
 
-         if clip_aspect > target_aspect: resized_clip = clip.resize(height=target_h)
-         else: resized_clip = clip.resize(width=target_w)
 
-         # Ensure resized dimensions are valid
-         if resized_clip.w <= 0 or resized_clip.h <= 0:
-              print(f"Warning: Invalid resized clip dimensions ({resized_clip.w}x{resized_clip.h}).")
-              from moviepy.editor import ColorClip
-              return ColorClip(size=target_resolution, color=(0,0,0), duration=clip.duration)
 
 
-         crop_x = max(0, (resized_clip.w - target_w) / 2)
-         crop_y = max(0, (resized_clip.h - target_h) / 2)
 
-         # Use integer coordinates for cropping
-         cropped_clip = resized_clip.crop(x1=int(crop_x), y1=int(crop_y), width=target_w, height=target_h)
-         return cropped_clip
-    except Exception as e:
-         print(f"Error during resize_to_fill: {e}")
-         # Fallback: try simple resize to target resolution
-         try:
-              return clip.resize(newsize=target_resolution)
-         except Exception as fallback_e:
-              print(f"Fallback resize also failed: {fallback_e}")
-              # Last resort: return black clip
-              from moviepy.editor import ColorClip
-              return ColorClip(size=target_resolution, color=(0,0,0), duration=clip.duration)
-
-
-def add_background_music(video_clip, music_file_path, volume):
-    """Add background music, looping if necessary."""
-    # (Retained from previous versions)
-    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)
-        # Check for valid duration
-        if not bg_music or bg_music.duration is None or bg_music.duration <= 0:
-             print("Warning: Background music file is invalid or has zero duration. Skipping.")
-             return video_clip
-        if not video_clip or video_clip.duration is None or video_clip.duration <=0:
-             print("Warning: Video clip has invalid duration. Cannot add music.")
-             # Return original clip without audio modification
-             return video_clip
-
-
-        if bg_music.duration > video_clip.duration: bg_music = bg_music.subclip(0, video_clip.duration)
-        elif bg_music.duration < video_clip.duration:
-            loops_needed = math.ceil(video_clip.duration / bg_music.duration)
-            # Ensure bg_music can be concatenated
-            try:
-                 bg_music = concatenate_audioclips([bg_music] * loops_needed)
-                 bg_music = bg_music.subclip(0, video_clip.duration)
-            except Exception as concat_err:
-                 print(f"Error looping background music: {concat_err}. Skipping music.")
-                 return video_clip # Return original video if looping fails
-
-        bg_music = bg_music.volumex(volume)
-
-        if video_clip.audio:
-             # Ensure video audio is valid
-             if video_clip.audio.duration is None or video_clip.audio.duration <= 0:
-                  print("Warning: Video clip audio has invalid duration. Replacing with background music.")
-                  final_audio = bg_music
-             else:
-                  # Make durations match exactly before composing
-                  try:
-                       video_audio_adjusted = video_clip.audio.set_duration(video_clip.duration)
-                       bg_music_adjusted = bg_music.set_duration(video_clip.duration)
-                       final_audio = CompositeAudioClip([video_audio_adjusted, bg_music_adjusted])
-                  except Exception as audio_comp_err:
-                       print(f"Error composing audio clips: {audio_comp_err}. Skipping music.")
-                       return video_clip # Return original video
-        else:
-             final_audio = bg_music # If original clip has no audio
 
-        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
 
-def create_segment_clip(media_info, tts_path, narration_text):
-    """Create a single video segment (clip) with visuals, audio, and subtitles."""
-    # (Retained from previous versions, with minor stability checks)
-    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)}")
-        if not os.path.exists(tts_path) or os.path.getsize(tts_path) == 0:
-             print(f"Error: TTS file missing or empty: {tts_path}"); return None
-        audio_clip = AudioFileClip(tts_path)
-        if audio_clip.duration is None or audio_clip.duration <= 0:
-             print(f"Error: Audio clip has invalid duration: {tts_path}"); return None
-        segment_duration = audio_clip.duration + 0.3
 
-        if asset_type == "video":
-            if not os.path.exists(media_path) or os.path.getsize(media_path) == 0:
-                 print(f"Error: Video file missing or empty: {media_path}"); return None
-            try:
-                 video_clip = VideoFileClip(media_path)
-                 if video_clip.duration is None or video_clip.duration <= 0:
-                      print(f"Error: Video clip has invalid duration: {media_path}")
-                      video_clip.close() # Close the clip
-                      return None
-                 if video_clip.duration < segment_duration:
-                      if video_clip.duration > 0:
-                           loops = math.ceil(segment_duration / video_clip.duration)
-                           video_clip_looped = concatenate_videoclips([video_clip] * loops)
-                           video_clip.close() # Close original after looping
-                           video_clip = video_clip_looped
-                      else: # Should have been caught above, but double check
-                           print(f"Error: Cannot loop zero-duration video: {media_path}")
-                           video_clip.close(); return None
-
-                 # Ensure subclip duration is valid
-                 video_clip_final = video_clip.subclip(0, min(segment_duration, video_clip.duration))
-                 video_clip.close() # Close intermediate clip if looped
-                 video_clip = video_clip_final
-
-                 visual_clip = resize_to_fill(video_clip, TARGET_RESOLUTION)
-                 video_clip.close() # Close after resize_to_fill finishes
-
-            except Exception as video_load_err:
-                 print(f"Error loading or processing video {media_path}: {video_load_err}")
-                 return None
 
-        elif asset_type == "image":
-            if not os.path.exists(media_path) or os.path.getsize(media_path) == 0:
-                 print(f"Error: Image file missing or empty: {media_path}"); return None
-            try:
-                 # Load image clip
-                 img_clip = ImageClip(media_path).set_duration(segment_duration)
-                 # Apply Ken Burns
-                 visual_clip = apply_kenburns_effect(img_clip, TARGET_RESOLUTION, segment_duration)
-                 # Ensure final size - Ken Burns should handle this, but double check
-                 visual_clip = visual_clip.resize(newsize=TARGET_RESOLUTION)
-                 # Close the base image clip resource if possible (ImageClip doesn't have explicit close)
-            except Exception as img_load_err:
-                 print(f"Error loading or processing image {media_path}: {img_load_err}")
-                 return None
-        else: print(f"Error: Unknown asset type: {asset_type}"); return None
-
-        visual_clip = visual_clip.fadein(0.15).fadeout(0.15)
-        subtitle_clips = []
-        if USE_CAPTIONS and narration_text:
-            words = narration_text.split()
-            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: 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
-                start_time = 0.1
-                for i, chunk_text in enumerate(chunks):
-                    # Ensure chunk end time doesn't exceed visual clip duration
-                    chunk_end_time = min(start_time + chunk_duration, visual_clip.duration - 0.05) # Leave tiny buffer
-                    actual_chunk_duration = max(0.1, chunk_end_time - start_time) # Min duration 0.1s
-
-                    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(actual_chunk_duration)
-                         subtitle_clips.append(txt_clip)
-                         start_time = chunk_end_time # Next chunk starts where the last one ended
-                    except Exception as txt_err:
-                         print(f"ERROR creating TextClip for '{chunk_text}': {txt_err}. Skipping subtitle chunk.")
-
-        final_clip = CompositeVideoClip([visual_clip] + subtitle_clips, size=TARGET_RESOLUTION) if subtitle_clips else visual_clip
-        # Set audio with slight offset
-        final_clip = final_clip.set_audio(audio_clip.set_start(0.15).set_duration(audio_clip.duration))
-        # Ensure final clip duration matches segment duration closely
-        final_clip = final_clip.set_duration(segment_duration)
-
-        print(f"Clip segment created successfully. Duration: {final_clip.duration:.2f}s")
-        # Explicitly close audio clip resource
-        audio_clip.close()
-        # Close visual clip resources if they have close methods (VideoClips do)
-        if hasattr(visual_clip, 'close'):
-             visual_clip.close()
-        for sub in subtitle_clips:
-            if hasattr(sub, 'close'): # TextClips might not have close
-                 sub.close()
-
-        return final_clip
-    except Exception as e:
-        print(f"Error creating clip segment: {e}")
-        import traceback
-        traceback.print_exc()
-        # Clean up resources if possible on error
-        if 'audio_clip' in locals() and hasattr(audio_clip, 'close'): audio_clip.close()
-        if 'visual_clip' in locals() and hasattr(visual_clip, 'close'): visual_clip.close()
-        if 'video_clip' in locals() and hasattr(video_clip, 'close'): video_clip.close()
-        return None
 
 
 # ---------------- Main Video Generation Function ---------------- #
+def generate_video(user_input, resolution, caption_option):
+    """Generate a video based on user input via Gradio."""
+    global TARGET_RESOLUTION, CAPTION_COLOR, TEMP_FOLDER
+    
+    # Set resolution
+    if resolution == "Full":
+        TARGET_RESOLUTION = (1920, 1080)
+    elif resolution == "Short":
+        TARGET_RESOLUTION = (1080, 1920)
+    else:
+        TARGET_RESOLUTION = (1920, 1080)  # Default
 
-def generate_full_video(user_input, resolution_choice, caption_choice, music_file_info):
-    """Main function orchestrating the video generation process."""
-    # (Retained from previous versions - logic relies on the new generate_media)
-    global TARGET_RESOLUTION, TEMP_FOLDER, USE_CAPTIONS
-    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:
-            music_file_path = os.path.join(TEMP_FOLDER, "background_music.mp3")
-            # Ensure temp folder exists before copying
-            os.makedirs(TEMP_FOLDER, exist_ok=True)
-            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
-
-    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)
-
-    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.")
-
-    print("\nStep 3: Generating media and TTS for each segment...")
-    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']}")
-
-        media_info = generate_media(segment['prompt']) # Using user's generate_media
-        if not media_info:
-            print(f"Warning: Failed to get media for segment {i+1} ('{segment['prompt']}'). Skipping this segment.")
-            continue
+    # Set caption color
+    CAPTION_COLOR = "white" if caption_option == "Yes" else "transparent"
+
+    # Create a unique temporary folder
+    TEMP_FOLDER = tempfile.mkdtemp()
+
+    # Fix ImageMagick policy
+    fix_success = fix_imagemagick_policy()
+    if not fix_success:
+        print("Will use alternative methods if needed")
+
+    print("Generating script from API...")
+    script = generate_script(user_input)
+    if not script:
+        print("Failed to generate script.")
+        shutil.rmtree(TEMP_FOLDER)
+        return None
+    print("Generated Script:\n", script)
+    elements = parse_script(script)
+    if not elements:
+        print("Failed to parse script into elements.")
+        shutil.rmtree(TEMP_FOLDER)
+        return None
+    print(f"Parsed {len(elements)//2} script segments.")
+
+    paired_elements = []
+    for i in range(0, len(elements), 2):
+        if i + 1 < len(elements):
+            paired_elements.append((elements[i], elements[i + 1]))
+
+    if not paired_elements:
+        print("No valid script segments found.")
+        shutil.rmtree(TEMP_FOLDER)
+        return None
 
-        tts_path = generate_tts(segment['narration'], selected_voice, voice_speed)
+    clips = []
+    for idx, (media_elem, tts_elem) in enumerate(paired_elements):
+        print(f"\nProcessing segment {idx+1}/{len(paired_elements)} with prompt: '{media_elem['prompt']}'")
+        media_asset = generate_media(media_elem['prompt'], current_index=idx, total_segments=len(paired_elements))
+        if not media_asset:
+            print(f"Skipping segment {idx+1} due to missing media asset.")
+            continue
+        tts_path = generate_tts(tts_elem['text'], tts_elem['voice'])
         if not tts_path:
-            print(f"Warning: Failed to generate TTS for segment {i+1}. Skipping segment.")
-            if media_info and os.path.exists(media_info['path']):
-                 try: os.remove(media_info['path']); print(f"Cleaned up unused media: {media_info['path']}")
-                 except OSError as e: print(f"Error removing unused media {media_info['path']}: {e}")
+            print(f"Skipping segment {idx+1} due to TTS generation failure.")
             continue
-
-        # Pass current_index=i to create_segment if needed by that function (currently not)
-        clip = create_segment_clip(media_info, tts_path, segment['narration'])
+        clip = create_clip(
+            media_path=media_asset['path'],
+            asset_type=media_asset['asset_type'],
+            tts_path=tts_path,
+            duration=tts_elem['duration'],
+            effects=media_elem.get('effects', 'fade-in'),
+            narration_text=tts_elem['text'],
+            segment_index=idx
+        )
         if clip:
-            segment_clips.append(clip)
+            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']); print(f"Cleaned up media for failed clip: {media_info['path']}")
-                 except OSError as e: print(f"Error removing media for failed clip {media_info['path']}: {e}")
-            if tts_path and os.path.exists(tts_path):
-                 try: os.remove(tts_path); print(f"Cleaned up TTS for failed clip: {tts_path}")
-                 except OSError as e: print(f"Error removing TTS for failed clip {tts_path}: {e}")
-
-
-    if not segment_clips:
-        print("ERROR: No video clips were successfully created. Aborting.")
-        try: shutil.rmtree(TEMP_FOLDER)
-        except Exception as e: print(f"Error removing temp folder during abort: {e}")
-        return None, "Error: Failed to create any video segments. Check logs for media/TTS issues."
-
-    print("\nStep 4: Concatenating video segments...");
-    final_video = None # Initialize to None
-    try:
-        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.")
-        # Concatenate
-        final_video = concatenate_videoclips(valid_clips, method="compose")
-        print("Segments concatenated successfully.")
-        # Close individual clips after concatenation
-        for clip in valid_clips:
-             if hasattr(clip, 'close'): clip.close()
-
-    except Exception as e:
-        print(f"ERROR: Failed to concatenate video clips: {e}");
-        # Clean up individual clips if concatenation failed
-        for clip in segment_clips:
-             if clip and hasattr(clip, 'close'): clip.close()
-        try: shutil.rmtree(TEMP_FOLDER)
-        except Exception as e_clean: print(f"Error removing temp folder after concat error: {e_clean}")
-        return None, f"Error: Concatenation failed: {e}"
-
-
-    print("\nStep 5: Adding background music...");
-    if final_video: # Only add music if concatenation was successful
-        final_video = add_background_music(final_video, music_file_path, bg_music_volume)
-    else:
-        print("Skipping background music as concatenation failed.")
-
+            print(f"Clip creation failed for segment {idx+1}.")
 
-    print(f"\nStep 6: Exporting final video to '{OUTPUT_VIDEO_FILENAME}'..."); export_success = False
-    if final_video: # Only export if we have a final video object
-        try:
-            final_video.write_videofile(OUTPUT_VIDEO_FILENAME, codec='libx264', audio_codec='aac', fps=fps, preset=preset, threads=4, logger='bar', ffmpeg_params=["-vsync", "vfr"]) # Added vsync param
-            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()
-        finally:
-             # Ensure final video resources are closed after export
-             if hasattr(final_video, 'close'): final_video.close()
-             print("Closed final video resources.")
-    else:
-         print("Skipping export as final video generation failed.")
+    if not clips:
+        print("No clips were successfully created.")
+        shutil.rmtree(TEMP_FOLDER)
+        return None
 
+    print("\nConcatenating clips...")
+    final_video = concatenate_videoclips(clips, method="compose")
+    final_video = add_background_music(final_video, bg_music_volume=bg_music_volume)
 
-    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"Exporting final video to {OUTPUT_VIDEO_FILENAME}...")
+    final_video.write_videofile(OUTPUT_VIDEO_FILENAME, codec='libx264', fps=fps, preset=preset)
+    print(f"Final video saved as {OUTPUT_VIDEO_FILENAME}")
 
-    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"
-    elif not final_video: return None, f"Error: Video generation failed before export. Check logs. Time: {total_time:.2f}s"
-    else: return None, f"Error: Video export failed. Check logs. Time: {total_time:.2f}s"
+    # Clean up
+    print("Cleaning up temporary files...")
+    shutil.rmtree(TEMP_FOLDER)
+    print("Temporary files removed.")
 
+    return OUTPUT_VIDEO_FILENAME
 
-# ---------------- Gradio Interface Definition ---------------- #
-# (Retained from previous versions)
+# ---------------- Gradio Interface ---------------- #
 VOICE_CHOICES = {
-    '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',
+    'Emma (Female)': 'af_heart',
+    'Bella (Female)': 'af_bella',
+    'Nicole (Female)': 'af_nicole',
+    'Aoede (Female)': 'af_aoede',
+    'Kore (Female)': 'af_kore',
+    'Sarah (Female)': 'af_sarah',
+    'Nova (Female)': 'af_nova',
+    'Sky (Female)': 'af_sky',
+    'Alloy (Female)': 'af_alloy',
+    'Jessica (Female)': 'af_jessica',
+    'River (Female)': 'af_river',
+    'Michael (Male)': 'am_michael',
+    'Fenrir (Male)': 'am_fenrir',
+    'Puck (Male)': 'am_puck',
+    'Echo (Male)': 'am_echo',
+    'Eric (Male)': 'am_eric',
+    'Liam (Male)': 'am_liam',
+    'Onyx (Male)': 'am_onyx',
+    'Santa (Male)': 'am_santa',
+    'Adam (Male)': 'am_adam',
+    'Emma 🇬🇧 (Female)': 'bf_emma',
+    'Isabella 🇬🇧 (Female)': 'bf_isabella',
+    'Alice 🇬🇧 (Female)': 'bf_alice',
+    'Lily 🇬🇧 (Female)': 'bf_lily',
+    'George 🇬🇧 (Male)': 'bm_george',
+    'Fable 🇬🇧 (Male)': 'bm_fable',
+    'Lewis 🇬🇧 (Male)': 'bm_lewis',
+    'Daniel 🇬🇧 (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):
-    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}")
 
+def generate_video_with_options(user_input, resolution, caption_option, music_file, voice, vclip_prob, bg_vol, video_fps, video_preset, v_speed, caption_size):
     global selected_voice, voice_speed, font_size, video_clip_probability, bg_music_volume, fps, preset
-    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 video_path, status_message
-
-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.")
-    with gr.Row():
-        with gr.Column(scale=2):
-            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.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")
-    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])
+    
+    # Update global variables with user selections
+    selected_voice = VOICE_CHOICES[voice]
+    voice_speed = v_speed
+    font_size = caption_size
+    video_clip_probability = vclip_prob / 100  # Convert from percentage to decimal
+    bg_music_volume = bg_vol
+    fps = video_fps
+    preset = video_preset
+    
+    # Handle music upload
+    if music_file is not None:
+        target_path = "music.mp3"
+        shutil.copy(music_file.name, target_path)
+        print(f"Uploaded music saved as: {target_path}")
+    
+    # Generate the video
+    return generate_video(user_input, resolution, caption_option)
+
+# Create the Gradio interface
+iface = gr.Interface(
+    fn=generate_video_with_options,
+    inputs=[
+        gr.Textbox(label="Video Concept", placeholder="Enter your video concept here..."),
+        gr.Radio(["Full", "Short"], label="Resolution", value="Full"),
+        gr.Radio(["Yes", "No"], label="Captions", value="Yes"),
+        gr.File(label="Upload Background Music (MP3)", file_types=[".mp3"]),
+        gr.Dropdown(choices=list(VOICE_CHOICES.keys()), label="Choose Voice", value="Emma (Female)"),
+        gr.Slider(0, 100, value=25, step=1, label="Video Clip Usage Probability (%)"),
+        gr.Slider(0.0, 1.0, value=0.08, step=0.01, label="Background Music Volume"),
+        gr.Slider(10, 60, value=30, step=1, label="Video FPS"),
+        gr.Dropdown(choices=["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow"], 
+                   value="veryfast", label="Export Preset"),
+        gr.Slider(0.5, 1.5, value=0.9, step=0.05, label="Voice Speed"),
+        gr.Slider(20, 100, value=45, step=1, label="Caption Font Size")
+    ],
+    outputs=gr.Video(label="Generated Video"),
+    title="AI Documentary Video Generator",
+    description="Create short documentary videos with AI. Upload music, choose voice, and customize settings."
+)
 
 # Launch the interface
 if __name__ == "__main__":
-    print("Launching Gradio Interface...")
-    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)