Update app.py

app.py

@@ -1,29 +1,26 @@
+# Import necessary libraries
 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 requests
+import io
+import time
+import re
 import random
 import cv2
 import math
-import os, requests, io, time, re, random
+import tempfile
+import shutil
 from moviepy.editor import (
-VideoFileClip, concatenate_videoclips, AudioFileClip, ImageClip,
-CompositeVideoClip, TextClip, CompositeAudioClip
+    VideoFileClip, concatenate_videoclips, AudioFileClip, ImageClip,
+    CompositeVideoClip, TextClip, CompositeAudioClip, concatenate_audioclips
 )
 import gradio as gr
-import shutil
-import os
 import moviepy.video.fx.all as vfx
 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
@@ -31,46 +28,35 @@ import base64
 from urllib.parse import quote
 import pysrt
 from gtts import gTTS
-import gradio as gr # Import Gradio
 
-# Import Kokoro
-from kokoro import KPipeline
+# Initialize Kokoro TTS pipeline (using American English)
+pipeline = KPipeline(lang_code='a')
 
-# Import moviepy components
-from moviepy.editor import (
-    VideoFileClip, concatenate_videoclips, AudioFileClip, ImageClip,
-    CompositeVideoClip, TextClip, CompositeAudioClip, concatenate_audioclips
-)
-import moviepy.video.fx.all as vfx
-from PIL import Image, ImageDraw, ImageFont
-from pydub import AudioSegment
-from pydub.generators import Sine
+# Try to set ImageMagick binary if available
+try:
+    mpy_config.change_settings({"IMAGEMAGICK_BINARY": "/usr/bin/convert"})
+except:
+    print("ImageMagick not found, using alternative methods")
 
-# ---------------- Secret Management ---------------- #
-# Get secrets from environment variables (set in Gradio Space settings)
-PEXELS_API_KEY = os.getenv('PEXELS_API_KEY', '')
-OPENROUTER_API_KEY = os.getenv('OPENROUTER_API_KEY', '')
-OPENROUTER_MODEL = os.getenv('OPENROUTER_MODEL', 'openai/gpt-oss-120b:free')
+# ---------------- Global Configuration ---------------- #
 
-# Check if secrets are loaded
-if not PEXELS_API_KEY or not OPENROUTER_API_KEY:
-    print("WARNING: API keys not found in environment variables!")
-    print("Please set PEXELS_API_KEY and OPENROUTER_API_KEY in your Gradio Space secrets.")
+# Get secrets from environment variables (Gradio Spaces)
+PEXELS_API_KEY = os.environ.get('PEXELS_API_KEY', '')
+OPENROUTER_API_KEY = os.environ.get('OPENROUTER_API_KEY', '')
 
-# ---------------- Global Configuration ---------------- #
-OUTPUT_VIDEO_FILENAME = "final_video.mp4"
-USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+# Fallback to hardcoded values if secrets not set (for local testing only)
+if not PEXELS_API_KEY:
+    PEXELS_API_KEY = 'YOUR_PEXELS_KEY_HERE'  # Replace with your key for local testing
+if not OPENROUTER_API_KEY:
+    OPENROUTER_API_KEY = 'YOUR_OPENROUTER_KEY_HERE'  # Replace with your key for local testing
 
-# Initialize Kokoro TTS pipeline (using American English)
-try:
-    pipeline = KPipeline(lang_code='a')
-except Exception as e:
-    print(f"Warning: Kokoro initialization failed: {e}")
-    pipeline = None
+OPENROUTER_MODEL = "moonshotai/kimi-k2:free"
+OUTPUT_VIDEO_FILENAME = "final_video.mp4"
+USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
 
-# Global variables for video generation
+# Global variables for Gradio interface
 selected_voice = 'af_heart'  # Default voice
-voice_speed = 0.9  # Default voice speed
+voice_speed = 1.2  # Default voice speed (changed from 0.9 to 1.2 to match slider default)
 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
@@ -80,17 +66,53 @@ TARGET_RESOLUTION = None
 CAPTION_COLOR = None
 TEMP_FOLDER = None
 
+# Voice choices dictionary
+VOICE_CHOICES = {
+    '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'
+}
+
 # ---------------- Helper Functions ---------------- #
 
+def check_api_keys():
+    """Check if API keys are properly configured."""
+    if not PEXELS_API_KEY or PEXELS_API_KEY == 'YOUR_PEXELS_KEY_HERE':
+        return False, "PEXELS_API_KEY not configured"
+    if not OPENROUTER_API_KEY or OPENROUTER_API_KEY == 'YOUR_OPENROUTER_KEY_HERE':
+        return False, "OPENROUTER_API_KEY not configured"
+    return True, "API keys configured"
+
 def generate_script(user_input):
     """Generate documentary script with proper OpenRouter handling."""
-    if not OPENROUTER_API_KEY:
-        print("OpenRouter API key not configured")
-        return None
-        
     headers = {
         'Authorization': f'Bearer {OPENROUTER_API_KEY}',
-        'HTTP-Referer': 'https://huggingface.co',  # Use HuggingFace as referer
+        'HTTP-Referer': 'https://huggingface.co',
         'X-Title': 'AI Documentary Maker'
     }
 
@@ -211,10 +233,6 @@ def parse_script(script_text):
 
 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:
-        print("Pexels API key not configured")
-        return None
-        
     headers = {'Authorization': pexels_api_key}
     base_url = "https://api.pexels.com/videos/search"
     num_pages = 3
@@ -250,11 +268,11 @@ def search_pexels_videos(query, pexels_api_key):
                     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. 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}")
                     break
 
             except requests.exceptions.RequestException as e:
@@ -266,15 +284,11 @@ def search_pexels_videos(query, pexels_api_key):
         print(f"Selected random video from {len(all_videos)} HD videos")
         return random_video
     else:
-        print("No suitable videos found after searching all pages.")
+        print("No suitable videos found.")
         return None
 
 def search_pexels_images(query, pexels_api_key):
     """Search for an image on Pexels by query."""
-    if not pexels_api_key:
-        print("Pexels API key not configured")
-        return None
-        
     headers = {'Authorization': pexels_api_key}
     url = "https://api.pexels.com/v1/search"
     params = {"query": query, "per_page": 5, "orientation": "landscape"}
@@ -298,18 +312,18 @@ def search_pexels_images(query, pexels_api_key):
                     return None
 
             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. Retrying in {retry_delay} seconds...")
                 time.sleep(retry_delay)
                 retry_delay *= 2
             else:
-                print(f"Error fetching images: {response.status_code} {response.text}")
-                break
+                print(f"Error fetching images: {response.status_code}")
+                return None
 
         except requests.exceptions.RequestException as e:
             print(f"Request exception: {e}")
-            break
+            return None
 
-    print(f"No Pexels images found for query: {query} after all attempts")
+    print(f"No Pexels images found for query: {query}")
     return None
 
 def search_google_images(query):
@@ -348,8 +362,6 @@ def download_image(image_url, filename):
             for chunk in response.iter_content(chunk_size=8192):
                 f.write(chunk)
 
-        print(f"Image downloaded successfully to: {filename}")
-
         try:
             img = Image.open(filename)
             img.verify()
@@ -359,19 +371,14 @@ def download_image(image_url, filename):
                 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}")
+        except Exception as e:
+            print(f"Downloaded file is not a valid image: {e}")
             if os.path.exists(filename):
                 os.remove(filename)
             return None
 
-    except requests.exceptions.RequestException as e_download:
-        print(f"Image download error: {e_download}")
-        if os.path.exists(filename):
-            os.remove(filename)
-        return None
-    except Exception as e_general:
-        print(f"General error during image processing: {e_general}")
+    except Exception as e:
+        print(f"Image download error: {e}")
         if os.path.exists(filename):
             os.remove(filename)
         return None
@@ -393,7 +400,7 @@ def download_video(video_url, filename):
         return None
 
 def generate_media(prompt, user_image=None, current_index=0, total_segments=1):
-    """Generate a visual asset by searching for videos or images."""
+    """Generate a visual asset by searching for media."""
     safe_prompt = re.sub(r'[^\w\s-]', '', prompt).strip().replace(' ', '_')
 
     if "news" in prompt.lower():
@@ -450,41 +457,33 @@ def generate_silent_audio(duration, sample_rate=24000):
 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")
+    file_path = os.path.join(TEMP_FOLDER, f"tts_{safe_text}_{int(time.time())}.wav")
 
-    if os.path.exists(file_path):
-        print(f"Using cached TTS for text '{text[:10]}...'")
+    try:
+        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
-
-    # Try Kokoro if available
-    if pipeline:
+    except Exception as e:
+        print(f"Error with Kokoro TTS: {e}")
         try:
-            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)")
+            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 e:
-            print(f"Error with Kokoro TTS: {e}")
-
-    # Fallback to gTTS
-    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))
+        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."""
@@ -505,8 +504,8 @@ def apply_kenburns_effect(clip, target_resolution, effect_type=None):
     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
+    max_offset_x = max(0, new_width - target_w)
+    max_offset_y = max(0, 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":
@@ -525,17 +524,17 @@ def apply_kenburns_effect(clip, target_resolution, effect_type=None):
     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)
+        start_center = (max_offset_x + target_w / 2, (max_offset_y // 2) + target_h / 2) if max_offset_x > 0 else (new_width / 2, new_height / 2)
+        end_center = (target_w / 2, (max_offset_y // 2) + target_h / 2) if max_offset_x > 0 else start_center
     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)
+        start_center = (target_w / 2, (max_offset_y // 2) + target_h / 2) if max_offset_x > 0 else (new_width / 2, new_height / 2)
+        end_center = (max_offset_x + target_w / 2, (max_offset_y // 2) + target_h / 2) if max_offset_x > 0 else start_center
     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)
+        start_center = (max_offset_x + target_w / 2, max_offset_y + target_h / 2) if max_offset_x > 0 and max_offset_y > 0 else (new_width / 2, new_height / 2)
         end_center = (target_w / 2, target_h / 2)
     else:
         raise ValueError(f"Unsupported effect_type: {effect_type}")
@@ -596,17 +595,16 @@ def add_background_music(final_video, bg_music_volume=0.10):
             final_video = final_video.set_audio(mixed_audio)
             print("Background music added successfully")
         else:
-            print("No MP3 files found, skipping background music")
+            print("No music.mp3 file 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}")
+        print(f"Creating clip #{segment_index} with asset_type: {asset_type}")
         if not os.path.exists(media_path) or not os.path.exists(tts_path):
             print("Missing media or TTS file")
             return None
@@ -635,7 +633,20 @@ def create_clip(media_path, asset_type, tts_path, duration=None, effects=None, n
         else:
             return None
 
-        # Skip subtitles for now since captions are disabled
+        # Simplified subtitle handling (no ImageMagick dependency)
+        if narration_text and CAPTION_COLOR != "transparent":
+            try:
+                # Create a simple subtitle without complex text effects
+                subtitle_text = narration_text
+                # Create subtitle as image overlay to avoid ImageMagick issues
+                subtitle_img = create_subtitle_image(subtitle_text, TARGET_RESOLUTION)
+                subtitle_clip = ImageClip(subtitle_img).set_duration(target_duration)
+                subtitle_clip = subtitle_clip.set_position(('center', 'bottom'))
+                clip = CompositeVideoClip([clip, subtitle_clip])
+            except Exception as sub_error:
+                print(f"Subtitle creation failed: {sub_error}")
+                # Continue without subtitles
+
         clip = clip.set_audio(audio_clip)
         print(f"Clip created: {clip.duration:.1f}s")
         return clip
@@ -643,14 +654,54 @@ def create_clip(media_path, asset_type, tts_path, duration=None, effects=None, n
         print(f"Error in create_clip: {str(e)}")
         return None
 
+def create_subtitle_image(text, resolution):
+    """Create a subtitle image using PIL instead of TextClip to avoid ImageMagick issues."""
+    width, height = resolution
+    img = Image.new('RGBA', (width, 100), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(img)
+    
+    # Try to use a font, fall back to default if not available
+    try:
+        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", font_size)
+    except:
+        font = ImageFont.load_default()
+    
+    # Get text size
+    bbox = draw.textbbox((0, 0), text, font=font)
+    text_width = bbox[2] - bbox[0]
+    text_height = bbox[3] - bbox[1]
+    
+    # Center the text
+    position = ((width - text_width) // 2, (100 - text_height) // 2)
+    
+    # Draw text with outline effect
+    for adj in range(-2, 3):
+        for adj2 in range(-2, 3):
+            draw.text((position[0] + adj, position[1] + adj2), text, font=font, fill=(0, 0, 0, 128))
+    
+    draw.text(position, text, font=font, fill=(255, 255, 255, 255))
+    
+    # Save to temporary file
+    temp_path = os.path.join(TEMP_FOLDER, f"subtitle_{int(time.time())}.png")
+    img.save(temp_path)
+    return temp_path
+
+def fix_imagemagick_policy():
+    """Attempt to fix ImageMagick security policies (may not work in Gradio Spaces)."""
+    # This won't work in Gradio Spaces due to lack of sudo access
+    # We'll handle this gracefully
+    return False
+
 # ---------------- Main Video Generation Function ---------------- #
+
 def generate_video(user_input, resolution, caption_option):
-    """Generate a video based on user input via Gradio."""
+    """Generate a video based on user input."""
     global TARGET_RESOLUTION, CAPTION_COLOR, TEMP_FOLDER
     
-    # Check if API keys are configured
-    if not PEXELS_API_KEY or not OPENROUTER_API_KEY:
-        return None
+    # Check API keys
+    api_status, api_message = check_api_keys()
+    if not api_status:
+        return None, f"Error: {api_message}. Please configure the API keys in Space secrets."
     
     # Set resolution
     if resolution == "Full":
@@ -658,7 +709,7 @@ def generate_video(user_input, resolution, caption_option):
     elif resolution == "Short":
         TARGET_RESOLUTION = (1080, 1920)
     else:
-        TARGET_RESOLUTION = (1920, 1080)  # Default
+        TARGET_RESOLUTION = (1920, 1080)
 
     # Set caption color
     CAPTION_COLOR = "white" if caption_option == "Yes" else "transparent"
@@ -666,119 +717,88 @@ def generate_video(user_input, resolution, caption_option):
     # Create a unique temporary folder
     TEMP_FOLDER = tempfile.mkdtemp()
 
-    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
-
-    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"Skipping segment {idx+1} due to TTS generation failure.")
-            continue
-        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:
-            clips.append(clip)
-        else:
-            print(f"Clip creation failed for segment {idx+1}.")
-
-    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(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}")
+    try:
+        print("Generating script from API...")
+        script = generate_script(user_input)
+        if not script:
+            print("Failed to generate script.")
+            return None, "Failed to generate script. Please check your API key and try again."
+        
+        print("Generated Script:\n", script)
+        elements = parse_script(script)
+        if not elements:
+            print("Failed to parse script into elements.")
+            return None, "Failed to parse script. Please try again."
+        
+        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.")
+            return None, "No valid script segments found."
+
+        clips = []
+        for idx, (media_elem, tts_elem) in enumerate(paired_elements):
+            print(f"\nProcessing segment {idx+1}/{len(paired_elements)}")
+            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"Skipping segment {idx+1} due to TTS generation failure.")
+                continue
+            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:
+                clips.append(clip)
+
+        if not clips:
+            print("No clips were successfully created.")
+            return None, "No clips were successfully created."
+
+        print("\nConcatenating clips...")
+        final_video = concatenate_videoclips(clips, method="compose")
+        final_video = add_background_music(final_video, bg_music_volume=bg_music_volume)
+
+        print(f"Exporting final video...")
+        final_video.write_videofile(OUTPUT_VIDEO_FILENAME, codec='libx264', fps=fps, preset=preset)
+        print(f"Final video saved as {OUTPUT_VIDEO_FILENAME}")
+
+        return OUTPUT_VIDEO_FILENAME, "Video generated successfully!"
 
-    # Clean up
-    print("Cleaning up temporary files...")
-    shutil.rmtree(TEMP_FOLDER)
-    print("Temporary files removed.")
+    except Exception as e:
+        print(f"Error during video generation: {str(e)}")
+        return None, f"Error: {str(e)}"
+    finally:
+        # Clean up
+        print("Cleaning up temporary files...")
+        if TEMP_FOLDER and os.path.exists(TEMP_FOLDER):
+            shutil.rmtree(TEMP_FOLDER)
+        print("Temporary files removed.")
 
-    return OUTPUT_VIDEO_FILENAME
-
-# ---------------- Gradio Interface ---------------- #
-VOICE_CHOICES = {
-    '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'
-}
+# ---------------- Gradio Interface Functions ---------------- #
 
 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):
+    """Wrapper function for Gradio interface."""
     global selected_voice, voice_speed, font_size, video_clip_probability, bg_music_volume, fps, preset
     
-    # Check if API keys are configured
-    if not PEXELS_API_KEY or not OPENROUTER_API_KEY:
-        return gr.Error("API keys not configured. Please set PEXELS_API_KEY and OPENROUTER_API_KEY in Space secrets.")
-    
     # 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
+    video_clip_probability = vclip_prob / 100
     bg_music_volume = bg_vol
     fps = video_fps
     preset = video_preset
@@ -790,29 +810,77 @@ def generate_video_with_options(user_input, resolution, caption_option, music_fi
         print(f"Uploaded music saved as: {target_path}")
     
     # Generate the video
-    return generate_video(user_input, resolution, caption_option)
+    video_path, message = generate_video(user_input, resolution, caption_option)
+    
+    if video_path:
+        return video_path, message
+    else:
+        return None, message
 
 # Create the Gradio interface
-iface = gr.Interface(
-    fn=generate_video_with_options,
-    inputs=[
-        gr.Textbox(label="Video Concept", placeholder="Enter your video concept here...", lines=3),
-        gr.Radio(["Full", "Short"], label="Resolution", value="Full"),
-        gr.Radio(["No"], label="Captions (Coming Soon)", value="No"),
-        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=1.2, 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.\n\n⚠️ **Important**: Make sure to set your API keys in the Space secrets!"
-)
+with gr.Blocks(title="AI Documentary Video Generator") as iface:
+    gr.Markdown("# 🎬 AI Documentary Video Generator")
+    gr.Markdown("Create professional documentary-style videos with AI narration and visuals.")
+    
+    with gr.Row():
+        with gr.Column():
+            user_input = gr.Textbox(
+                label="Video Concept",
+                placeholder="Enter your video concept here... (e.g., 'The history of space exploration', 'Climate change impacts on oceans')",
+                lines=3
+            )
+            
+            with gr.Row():
+                resolution = gr.Radio(["Full", "Short"], label="Resolution", value="Full")
+                caption_option = gr.Radio(["No"], label="Captions (Coming Soon)", value="No")
+            
+            music_file = gr.File(label="Upload Background Music (MP3)", file_types=[".mp3"])
+            
+            with gr.Accordion("Advanced Settings", open=False):
+                voice = gr.Dropdown(
+                    choices=list(VOICE_CHOICES.keys()),
+                    label="Choose Voice",
+                    value="Emma (Female)"
+                )
+                vclip_prob = gr.Slider(0, 100, value=25, step=1, label="Video Clip Usage Probability (%)")
+                bg_vol = gr.Slider(0.0, 1.0, value=0.08, step=0.01, label="Background Music Volume")
+                video_fps = gr.Slider(10, 60, value=30, step=1, label="Video FPS")
+                video_preset = gr.Dropdown(
+                    choices=["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow"],
+                    value="veryfast",
+                    label="Export Preset"
+                )
+                v_speed = gr.Slider(0.5, 1.5, value=1.2, step=0.05, label="Voice Speed")
+                caption_size = gr.Slider(20, 100, value=45, step=1, label="Caption Font Size")
+            
+            generate_btn = gr.Button("🎬 Generate Video", variant="primary")
+        
+        with gr.Column():
+            output_video = gr.Video(label="Generated Video")
+            status_message = gr.Textbox(label="Status", interactive=False)
+    
+    gr.Markdown("""
+    ### 📝 Instructions:
+    1. Enter a topic or concept for your documentary
+    2. Choose resolution (Full for 16:9, Short for 9:16)
+    3. Optionally upload background music
+    4. Adjust advanced settings if needed
+    5. Click Generate Video and wait for processing
+    
+    ### ⚠️ Note:
+    - Video generation may take 2-5 minutes depending on length
+    - Make sure API keys are configured in Space secrets
+    """)
+    
+    generate_btn.click(
+        fn=generate_video_with_options,
+        inputs=[
+            user_input, resolution, caption_option, music_file,
+            voice, vclip_prob, bg_vol, video_fps, video_preset,
+            v_speed, caption_size
+        ],
+        outputs=[output_video, status_message]
+    )
 
 # Launch the interface
 if __name__ == "__main__":