Update app.py

app.py

@@ -12,9 +12,9 @@ import re
 import requests
 import io
 import shutil
-from urllib.parse import quote
+from urllib.parse import quote # Needed for search_google_images
 import numpy as np
-from bs4 import BeautifulSoup # Keep import in case needed elsewhere, but not for search
+from bs4 import BeautifulSoup # Needed for search_google_images
 import base64
 from gtts import gTTS
 import gradio as gr
@@ -33,7 +33,6 @@ from pydub import AudioSegment
 from pydub.generators import Sine
 
 # ---------------- Global Configuration ---------------- #
-# --- API Keys (Replace with your actual keys) ---
 PEXELS_API_KEY = 'BhJqbcdm9Vi90KqzXKAhnEHGsuFNv4irXuOjWtT761U49lRzo03qBGna'
 OPENROUTER_API_KEY = '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'
 OPENROUTER_MODEL = "mistralai/mistral-small-3.1-24b-instruct:free"
@@ -71,8 +70,7 @@ 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)
+    # (Retained from previous versions)
     headers = {
         'Authorization': f'Bearer {OPENROUTER_API_KEY}',
         'Content-Type': 'application/json',
@@ -144,8 +142,7 @@ Now generate the script based on: {user_input}
 
 def parse_script(script_text):
     """Parse the generated script into segments."""
-    # --- Retain previous parse_script function ---
-    # (No changes needed here based on the request)
+    # (Retained from previous versions)
     segments = []
     current_title = None
     current_narration = ""
@@ -178,219 +175,414 @@ def parse_script(script_text):
     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 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.")
+# --- 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
+    videos_per_page = 15
+
+    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)
+
+                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
+
+                    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
 
-    base_url = f"https://api.pexels.com/{search_type}/search"
-    headers = {'Authorization': api_key}
+                    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
+                elif response.status_code == 429:
+                    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}")
+                    if attempt < max_retries - 1:
+                        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
+
+            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}")
+                if attempt < max_retries - 1:
+                    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
+
+    if all_videos:
+        random_video = random.choice(all_videos)
+        print(f"Selected random video from {len(all_videos)} suitable videos found across pages.")
+        return random_video
+    else:
+        print(f"No suitable videos found for '{query}' after searching {num_pages} 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"}
-    if search_type == "videos":
-        params["size"] = "medium" # Request medium or large
 
     max_retries = 3
-    retry_delay = 2 # Slightly longer initial delay
-    timeout_duration = 20 # Increased timeout
+    retry_delay = 1
+    timeout_duration = 15 # Increased timeout slightly
 
-    print(f"Searching Pexels {search_type} for '{query}'...")
+    print(f"Searching Pexels images for '{query}'...")
 
     for attempt in range(max_retries):
         try:
-            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
+            response = requests.get(url, headers=headers, params=params, timeout=timeout_duration)
+
+            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
+                else:
+                    print(f"No images found for query: {query}")
+                    return None # API returned empty 'photos' list
+
+            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...")
+                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
-                 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 # No results found
-
-            # --- Filtering logic remains the same ---
-            valid_items = []
-            if search_type == "videos":
-                for video in items:
-                    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)
-            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 valid_items:
-                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
+                print(f" Error fetching images: {response.status_code} {response.text}")
+                if attempt < max_retries - 1:
+                    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"Pexels API request timed out after {timeout_duration}s (attempt {attempt+1}/{max_retries}). Retrying in {retry_delay}s...")
+            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"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 # Stop retrying on unexpected python errors
+            print(f" Request exception: {e}")
+            if attempt < max_retries - 1:
+                print(f" Retrying in {retry_delay} seconds...")
+                time.sleep(retry_delay)
+                retry_delay *= 2
+            else:
+                break # Max retries after request exception
 
-    print(f"Pexels {search_type} search failed for '{query}' after {max_retries} attempts.")
+    print(f"No Pexels images found for query: {query} after all attempts")
     return None
 
-# --- REMOVED: search_google_images Function ---
-# def search_google_images(query):
-#     # ... function content removed ...
-#     pass
+# 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)")
+    try:
+        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 = []
+        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)
+
+        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)])
+        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
+
 
-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)
+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}
-        response = requests.get(media_url, headers=headers, stream=True, timeout=30)
+        print(f"Downloading image from: {image_url} to {filename}")
+        response = requests.get(image_url, headers=headers, stream=True, timeout=20) # Increased timeout
         response.raise_for_status()
-        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"
-        else: # Guess from URL
-            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}")
+
+        # 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"Media downloaded successfully to: {filename}")
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
 
-        if file_extension in [".jpg", ".png", ".webp"]:
-            try:
-                img = Image.open(filename)
-                img.verify()
-                img.close()
-                img = Image.open(filename)
-                if img.mode != 'RGB':
-                    print(f"Converting image {filename} to RGB.")
+        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 = 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')
-                    jpg_filename = os.path.join(target_folder, f"{filename_prefix}.jpg")
-                    rgb_img.save(jpg_filename, "JPEG")
+                    # 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()
-                    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
+                    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)
+            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"Media download error from {media_url}: {e_download}")
+        print(f" Image download error: {e_download}")
+        # Don't remove file here, might not exist or be partial
         return None
-    except Exception as e_general:
-        print(f"General error during media download/processing: {e_general}")
+    except Exception as e_general_download:
+        print(f" General error during image download request: {e_general_download}")
         return None
 
-# --- MODIFIED: generate_media Function ---
-def generate_media(prompt):
+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.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
+                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 download error: {e}")
+        # Don't remove file here, might not exist or be partial
+        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):
     """
-    Find and download a visual asset (video or image) based on the prompt.
-    Prioritizes Pexels Video, then Pexels Image. NO Google Image fallback.
-    Uses a single generic Pexels image search as the final fallback.
+    Generate a visual asset using user-provided functions.
+    Checks for "news", tries Pexels video/image, falls back to generic Pexels image.
     """
-    safe_prompt = re.sub(r'[^\w\s-]', '', prompt).strip().replace(' ', '_')
-    # Limit length of prompt in filename to avoid issues
-    safe_prompt = safe_prompt[:50]
-    filename_prefix = f"{safe_prompt}_{int(time.time())}"
+    # 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())}"
+
+    # --- News Check (Uses Google Images) ---
+    if "news" in prompt.lower():
+        print(f"News-related query detected: '{prompt}'. Trying 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
+        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)}")
+                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
 
-    # 1. Try Pexels Video (if probability met)
+    # --- Pexels Video Attempt ---
     if random.random() < video_clip_probability:
-        video_url = search_pexels(prompt, PEXELS_API_KEY, search_type="videos")
+        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_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"}
+            downloaded_video = download_video(video_url, video_file)
+            if downloaded_video:
+                print(f" Using Pexels video asset: {os.path.basename(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 failed or no suitable video found for '{prompt}'. Trying image...")
+            print(f" Pexels video search yielded no results for '{prompt}'.")
+    else:
+         print(f"Skipping Pexels video search based on probability for '{prompt}'.")
 
-    # 2. Try Pexels Image
-    image_url = search_pexels(prompt, PEXELS_API_KEY, search_type="photos")
+
+    # --- Pexels Image Attempt ---
+    print(f"Attempting Pexels image search for: '{prompt}'")
+    image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_image.jpg")
+    image_url = search_pexels_images(prompt, PEXELS_API_KEY)
     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"}
+        downloaded_image = download_image(image_url, image_file)
+        if downloaded_image:
+            print(f" Using Pexels image asset: {os.path.basename(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 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
+        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_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")
+        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")
+        fallback_url = search_pexels_images(term, PEXELS_API_KEY)
         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"}
+            downloaded_fallback = download_image(fallback_url, fallback_file)
+            if downloaded_fallback:
+                print(f" Using Pexels fallback image asset: {os.path.basename(downloaded_fallback)}")
+                return {"path": downloaded_fallback, "asset_type": "image"}
             else:
-                 print(f"Pexels fallback image download failed for term '{fallback_term}'.")
+                print(f" Pexels fallback image download failed for term: '{term}'")
         else:
-            print(f"Pexels fallback image search failed for term '{fallback_term}'.")
+            print(f" Pexels fallback image search failed for term: '{term}'")
     else:
-        print(f"Skipping fallback search for instructional prompt: '{prompt}'")
+         print(f"Skipping fallback search for instructional prompt: '{prompt}'")
+
 
+    # --- Final Failure ---
+    print(f"FATAL: Failed to generate any visual asset for prompt: '{prompt}'")
+    return None
 
-    # 4. Final Failure
-    print(f"FATAL: Could not retrieve any suitable media for prompt: '{prompt}' after all attempts.")
-    return None # Indicate failure
+# --- End: User Provided Functions ---
 
 
 def generate_tts(text, voice_id, speed):
     """Generate TTS audio using Kokoro, falling back to gTTS."""
-    # --- Retain previous generate_tts function ---
+    # (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:
@@ -421,10 +613,17 @@ def generate_tts(text, voice_id, speed):
         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}")
-        return 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
@@ -434,27 +633,57 @@ def generate_tts(text, voice_id, speed):
 
 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 ---
+    # (Retained from previous versions)
     target_w, target_h = target_resolution
-    img_w, img_h = clip.size
+    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
-    scaled_w, scaled_h = img_w * scale_factor, img_h * scale_factor
-    if scaled_w / scaled_h > target_w / target_h:
+    # Handle potential division by zero if img_h is 0
+    if img_h == 0: img_h = 1
+    img_aspect = img_w / img_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_w / img_h)
+        final_w = final_h * img_aspect
     else:
         final_w = target_w * scale_factor
-        final_h = final_w * (img_h / img_w)
+        final_h = final_w / img_aspect # Use img_aspect here
+
     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
+
     try:
-        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}")
+        # 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)
+    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
@@ -462,54 +691,170 @@ def apply_kenburns_effect(clip, target_resolution, duration):
     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):
-        interp = t / duration if duration else 0
+        # 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
-        crop_w = target_w / (current_zoom / scale_factor); crop_h = target_h / (current_zoom / scale_factor)
+
+        # 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)
-        cropped_frame = frame[int(y1):int(y1 + crop_h), int(x1):int(x1 + crop_w)]
-        final_frame = cv2.resize(cropped_frame, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
+
+        # 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
+
+            # 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
-    return resized_clip.fl(make_frame, apply_to=['mask'])
+
+    # 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."""
-    # --- Retain previous resize_to_fill function ---
+    # (Retained from previous versions)
     target_w, target_h = target_resolution
-    target_aspect = target_w / target_h
-    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
+    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."""
-    # --- Retain previous add_background_music function ---
+    # (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)
-            bg_music = concatenate_audioclips([bg_music] * loops_needed)
-            bg_music = bg_music.subclip(0, video_clip.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)
-        # Check if video_clip has audio before composing
+
         if video_clip.audio:
-             final_audio = CompositeAudioClip([video_clip.audio, bg_music])
+             # 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:
-             # If original clip has no audio, just use the background music
-             final_audio = bg_music
+             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
@@ -519,39 +864,65 @@ def add_background_music(video_clip, music_file_path, volume):
 
 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 ---
+    # (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): print(f"Error: TTS file not found: {tts_path}"); return None
+        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): print(f"Error: Video file not found: {media_path}"); return None
-            video_clip = VideoFileClip(media_path)
-            if video_clip.duration < segment_duration:
-                loops = math.ceil(segment_duration / video_clip.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)
-            visual_clip = resize_to_fill(video_clip, TARGET_RESOLUTION)
+            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): print(f"Error: Image file not found: {media_path}"); return None
-            img_clip = ImageClip(media_path).set_duration(segment_duration)
-            visual_clip = apply_kenburns_effect(img_clip, TARGET_RESOLUTION, segment_duration)
-            visual_clip = visual_clip.resize(newsize=TARGET_RESOLUTION)
+            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:
@@ -566,35 +937,54 @@ def create_segment_clip(media_info, tts_path, narration_text):
                 num_chunks = len(chunks); chunk_duration = audio_clip.duration / num_chunks
                 start_time = 0.1
                 for i, chunk_text in enumerate(chunks):
-                    end_time = min(start_time + chunk_duration, segment_duration - 0.1)
+                    # 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(max(0.1, end_time - start_time)) # Ensure non-zero duration
+                         txt_clip = txt_clip.set_start(start_time).set_duration(actual_chunk_duration)
                          subtitle_clips.append(txt_clip)
-                         start_time = end_time
+                         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.")
-                         # 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))
+        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_full_video(user_input, resolution_choice, caption_choice, music_file_info):
     """Main function orchestrating the video generation process."""
-    # --- Retain most of previous generate_full_video function ---
-    # (Ensure it handles None from generate_media correctly)
+    # (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)")
@@ -605,6 +995,8 @@ def generate_full_video(user_input, resolution_choice, caption_choice, music_fil
     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
@@ -624,57 +1016,84 @@ def generate_full_video(user_input, resolution_choice, caption_choice, music_fil
         print(f"  Prompt: {segment['prompt']}")
         print(f"  Narration: {segment['narration']}")
 
-        media_info = generate_media(segment['prompt'])
-        # --- Crucial Check ---
+        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 # Skip segment if media generation failed
+            continue
 
         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.")
             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: pass
+                 except OSError as e: print(f"Error removing unused media {media_info['path']}: {e}")
             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'])
         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']); print(f"Cleaned up media for failed clip: {media_info['path']}")
-                 except OSError: pass
+                 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: pass
+                 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.")
-        shutil.rmtree(TEMP_FOLDER)
+        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:
-        # 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.")
+        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}"); shutil.rmtree(TEMP_FOLDER); return None, f"Error: Concatenation failed: {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("\nStep 5: Adding background music..."); final_video = add_background_music(final_video, music_file_path, bg_music_volume)
 
     print(f"\nStep 6: Exporting final video to '{OUTPUT_VIDEO_FILENAME}'..."); export_success = False
-    try:
-        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()
+    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.")
+
 
     print("\nStep 7: Cleaning up temporary files...");
     try: shutil.rmtree(TEMP_FOLDER); print(f"Temporary folder {TEMP_FOLDER} removed.")
@@ -683,11 +1102,12 @@ def generate_full_video(user_input, resolution_choice, caption_choice, music_fil
     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"
 
 
 # ---------------- Gradio Interface Definition ---------------- #
-# --- Retain previous Gradio Interface code ---
+# (Retained from previous versions)
 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',
@@ -696,8 +1116,18 @@ VOICE_CHOICES = {
 }
 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 inputs for debugging
-    # ... (print other inputs) ...
+    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}")
+
     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
@@ -745,4 +1175,4 @@ if __name__ == "__main__":
         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)
+    iface.launch(share=True, debug=True) # Share=True for public link, Debug=True for more logs