Update app.py

app.py

@@ -1,404 +1,632 @@
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-from kokoro import KPipeline
-import soundfile as sf
-import torch
+"""
+AI Documentary Video Generator
+Version: 2.0
+Author: AI Assistant
+Description: Creates documentary-style videos from text prompts using TTS, media APIs, and video processing
+"""
+
 import os
-from moviepy.editor import (
-    VideoFileClip, AudioFileClip, ImageClip, concatenate_videoclips,
-    CompositeVideoClip, CompositeAudioClip, TextClip
-)
-import moviepy.video.fx.all as vfx
-import moviepy.config as mpy_config
-from PIL import Image
-import tempfile
-import random
-import cv2
-import math
-import requests
+import sys
 import re
 import time
-import numpy as np
-from bs4 import BeautifulSoup
-from urllib.parse import quote
-import gradio as gr
+import random
+import tempfile
 import shutil
 import traceback
+import math
+from typing import Optional, Tuple, Dict, List, Union
+from dataclasses import dataclass
+from concurrent.futures import ThreadPoolExecutor
+from urllib.parse import quote
 
-# --- Initialize Kokoro TTS pipeline ---
-pipeline = None
-def initialize_kokoro():
-    global pipeline
-    if pipeline is None:
-        try:
-            print("Initializing Kokoro TTS pipeline (lang_code='a')...")
-            pipeline = KPipeline(lang_code='a')
-            print("Kokoro TTS pipeline initialized successfully.")
-        except Exception as e:
-            print(f"FATAL ERROR initializing Kokoro pipeline: {e}")
-            print("TTS generation will not be available.")
-            pipeline = None
-    return pipeline
+# Third-party imports
+import numpy as np
+import cv2
+import requests
+from PIL import Image
+import soundfile as sf
+import torch
+from bs4 import BeautifulSoup
+import gradio as gr
 
-# Attempt initialization once at the start
-initialize_kokoro()
+# MoviePy imports
+from moviepy.editor import (
+    VideoFileClip, AudioFileClip, ImageClip, 
+    concatenate_videoclips, CompositeVideoClip,
+    CompositeAudioClip, TextClip
+)
+import moviepy.video.fx.all as vfx
+import moviepy.config as mpy_config
 
-# --- Configure ImageMagick ---
+# Custom imports
 try:
-    imagemagick_path = None
-    common_paths = ["/usr/bin/convert", "/usr/local/bin/convert", "/opt/homebrew/bin/convert"]
-    for path in common_paths:
-        if os.path.exists(path):
-            imagemagick_path = path
-            break
-    if imagemagick_path:
-         mpy_config.change_settings({"IMAGEMAGICK_BINARY": imagemagick_path})
-         print(f"ImageMagick path set to: {imagemagick_path}")
-    elif not any(shutil.which(cmd) for cmd in ["convert", "magick"]):
-         print("Warning: ImageMagick 'convert' or 'magick' command not found in common paths or system PATH.")
-         print("         TextClip captions requiring ImageMagick may fail.")
-except Exception as e:
-    print(f"Warning: Error configuring ImageMagick: {e}. TextClip captions might fail.")
-
-# --- Global Configuration ---
-PEXELS_API_KEY = os.getenv('PEXELS_API_KEY', 'your_pexels_api_key_here')
-OPENROUTER_API_KEY = os.getenv('OPENROUTER_API_KEY', 'your_openrouter_api_key_here')
-
-OPENROUTER_MODEL = "mistralai/mistral-small-3.1-24b-instruct:free"
-OUTPUT_VIDEO_FILENAME = "final_video.mp4"
-USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36"
-
-TARGET_RESOLUTION = None
-CAPTION_COLOR = None
-TEMP_FOLDER = None
-
-# --- Helper Functions ---
-
-def generate_script(user_input):
-    """Generates script using OpenRouter API."""
-    if not OPENROUTER_API_KEY or 'your_openrouter_api_key_here' in OPENROUTER_API_KEY:
-        print("Error: OpenRouter API Key not set or looks invalid.")
-        return "Error: OpenRouter API Key not configured."
-    
-    headers = {
-        'Authorization': f'Bearer {OPENROUTER_API_KEY}',
-        'HTTP-Referer': 'http://localhost:7860',
-        'X-Title': 'AI Documentary Maker'
+    from kokoro import KPipeline
+except ImportError:
+    print("Warning: Kokoro TTS not available. TTS features will be disabled.")
+
+# ======================
+# CONSTANTS & CONFIG
+# ======================
+DEFAULT_CONFIG = {
+    'PEXELS_API_KEY': os.getenv('PEXELS_API_KEY', 'your_pexels_key_here'),
+    'OPENROUTER_API_KEY': os.getenv('OPENROUTER_API_KEY', 'your_openrouter_key_here'),
+    'OUTPUT_VIDEO': "documentary_output.mp4",
+    'USER_AGENT': "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+    'MAX_RETRIES': 3,
+    'RETRY_DELAY': 2,
+    'MAX_VIDEO_DURATION': 600,  # 10 minutes
+    'TTS_SAMPLE_RATE': 24000,
+    'DEFAULT_VOICE': 'en',
+    'CAPTION_FONT': 'Arial-Bold',
+    'CAPTION_FONT_SIZES': {
+        '1080p': 40,
+        '720p': 32,
+        '480p': 24
+    },
+    'BACKGROUND_MUSIC_VOLUME': 0.08,
+    'DEFAULT_FPS': 30,
+    'VIDEO_PROBABILITY': 0.45,
+    'RESOLUTIONS': {
+        '1080p': (1920, 1080),
+        '720p': (1280, 720),
+        '480p': (854, 480),
+        'vertical_1080p': (1080, 1920),
+        'vertical_720p': (720, 1280)
     }
-    
-    prompt = f"""Short Documentary Script GeneratorInstructions:
-[Previous prompt content remains exactly the same...]
-Now here is the Topic/scrip: {user_input}
-"""
-    
-    data = {
-        'model': OPENROUTER_MODEL,
-        'messages': [{'role': 'user', 'content': prompt}],
-        'temperature': 0.4,
-        'max_tokens': 1024
-    }
-    
-    try:
-        response = requests.post('https://openrouter.ai/api/v1/chat/completions', 
-                              headers=headers, json=data, timeout=60)
-        response.raise_for_status()
-        response_data = response.json()
+}
+
+# ======================
+# CORE CLASSES
+# ======================
+
+@dataclass
+class VideoSegment:
+    media_path: str
+    tts_path: str
+    narration: str
+    duration: float
+    media_type: str  # 'image' or 'video'
+    effects: Dict
+    caption_style: Dict
+
+class DocumentaryGenerator:
+    def __init__(self, config: Optional[Dict] = None):
+        self.config = config or DEFAULT_CONFIG
+        self.tts_pipeline = None
+        self.temp_dir = None
+        self.current_resolution = None
+        self.caption_color = None
+        
+        # Initialize subsystems
+        self._initialize_tts()
+        self._configure_imagemagick()
         
-        if 'choices' in response_data and len(response_data['choices']) > 0:
-            script_content = response_data['choices'][0]['message']['content'].strip()
-            if '[' in script_content and ']' in script_content:
-                print("Script generated successfully.")
-                return script_content
+    def _initialize_tts(self):
+        """Initialize the TTS pipeline"""
+        try:
+            if 'KPipeline' in globals():
+                print("Initializing Kokoro TTS pipeline...")
+                self.tts_pipeline = KPipeline(lang_code='a')
+                print("TTS pipeline ready")
+        except Exception as e:
+            print(f"Could not initialize TTS: {str(e)}")
+            self.tts_pipeline = None
+            
+    def _configure_imagemagick(self):
+        """Configure ImageMagick paths"""
+        try:
+            common_paths = [
+                "/usr/bin/convert", 
+                "/usr/local/bin/convert",
+                "/opt/homebrew/bin/convert"
+            ]
+            for path in common_paths:
+                if os.path.exists(path):
+                    mpy_config.change_settings({"IMAGEMAGICK_BINARY": path})
+                    print(f"ImageMagick configured: {path}")
+                    break
             else:
-                print("Warning: Generated script missing expected format '[Title] Narration'.")
-                return script_content
-        else:
-            print(f"API Error: Unexpected response format from OpenRouter: {response_data}")
-            return "Error: Could not parse script from API response."
-            
-    except requests.exceptions.Timeout:
-        print("API Error: Request to OpenRouter timed out.")
-        return "Error: Script generation timed out."
-    except requests.exceptions.RequestException as e:
-        print(f"API Error: Request failed: {e}")
-        error_details = f"Status Code: {e.response.status_code}, Response: {e.response.text}" if e.response else str(e)
-        print(f"  Details: {error_details}")
-        return f"Error: Failed connect to script generation service ({e.response.status_code if e.response else 'N/A'})."
-    except Exception as e:
-        print(f"Error during script generation: {e}")
-        traceback.print_exc()
-        return f"Error: Unexpected error during script generation."
-
-[Rest of the functions with proper formatting...]
-
-def generate_video_from_script(script, resolution, caption_option, music_file, fps, preset, video_probability):
-    """Generates the final video from script and options."""
-    global TARGET_RESOLUTION, CAPTION_COLOR, TEMP_FOLDER
-    start_time = time.time()
-    print("\n--- Starting Video Generation ---")
-    print(f"  Options: Res={resolution}, Caps={caption_option}, FPS={fps}, Preset={preset}, VidProb={video_probability:.2f}")
-    if music_file:
-        print(f"  Music File: {os.path.basename(music_file)}")
-
-    # Setup Resolution
-    if resolution == "Full (1920x1080)":
-        TARGET_RESOLUTION = (1920, 1080)
-    elif resolution == "Short (1080x1920)":
-        TARGET_RESOLUTION = (1080, 1920)
-    else:
-        TARGET_RESOLUTION = (1080, 1920)
-        print("Warning: Unknown resolution, defaulting to Short.")
+                print("ImageMagick not found - text rendering may be limited")
+        except Exception as e:
+            print(f"ImageMagick config error: {str(e)}")
     
-    CAPTION_COLOR = "white" if caption_option == "Yes" else "transparent"
-
-    # Setup Temp Folder
-    try:
-        TEMP_FOLDER = tempfile.mkdtemp(prefix="aivideo_")
-        print(f"Temp folder: {TEMP_FOLDER}")
-    except Exception as e:
-        print(f"Error creating temp folder: {e}")
-        return None, 0, 0
-
-    # ImageMagick Policy Fix (optional)
-    if CAPTION_COLOR != "transparent":
-        fix_imagemagick_policy()
-
-    # Parse Script
-    print("Parsing script...")
-    elements = parse_script(script)
-    if not elements:
-        print("Error: Failed to parse script.")
-        shutil.rmtree(TEMP_FOLDER)
-        return None, 0, 0
-
-    paired_elements = []
-    for i in range(0, len(elements), 2):
-        if i + 1 < len(elements) and elements[i]['type'] == 'media' and elements[i+1]['type'] == 'tts':
-            paired_elements.append((elements[i], elements[i+1]))
-        else:
-            print(f"Warning: Skipping mismatched element pair at index {i}.")
-
-    total_segments = len(paired_elements)
-    if total_segments == 0:
-        print("Error: No valid segments found.")
-        shutil.rmtree(TEMP_FOLDER)
-        return None, 0, 0
-
-    # Generate Clips
-    clips = []
-    successful_segments = 0
+    def _create_temp_dir(self):
+        """Create a temporary working directory"""
+        if self.temp_dir and os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir)
+        self.temp_dir = tempfile.mkdtemp(prefix="docgen_")
+        print(f"Created temp directory: {self.temp_dir}")
+        return self.temp_dir
     
-    for idx, (media_elem, tts_elem) in enumerate(paired_elements):
-        segment_start_time = time.time()
-        print(f"\n--- Processing Segment {idx+1}/{total_segments} ---")
+    def _cleanup(self):
+        """Clean up temporary resources"""
+        if self.temp_dir and os.path.exists(self.temp_dir):
+            try:
+                shutil.rmtree(self.temp_dir)
+                print("Cleaned up temporary files")
+            except Exception as e:
+                print(f"Cleanup error: {str(e)}")
+    
+    def generate_script(self, topic: str) -> str:
+        """Generate a documentary script using OpenRouter API"""
+        if not self.config['OPENROUTER_API_KEY']:
+            return "Error: OpenRouter API key not configured"
+            
+        prompt = f"""Create a funny, engaging documentary script about {topic}.
+        Format each section with [TITLE] followed by narration text.
+        Keep narration concise (1-2 sentences per section).
+        Include at least 5 sections.
+        End with a humorous call-to-action."""
         
-        media_asset = generate_media(media_elem['prompt'], video_probability, idx, total_segments)
-        if not media_asset or not media_asset.get('path'):
-            print("Error: Failed media. Skipping segment.")
-            continue
-
-        tts_path = generate_tts(tts_elem['text'], tts_elem['voice'])  # voice ignored
-        if not tts_path:
-            print("Error: Failed TTS. Skipping segment.")
-            if os.path.exists(media_asset['path']):
-                try:
-                    os.remove(media_asset['path'])
-                except OSError:
-                    pass
-            continue
-
-        clip = create_clip(
-            media_path=media_asset['path'],
-            asset_type=media_asset['asset_type'],
-            tts_path=tts_path,
-            narration_text=tts_elem['text'],
-            segment_index=idx
-        )
-
-        if clip:
-            clips.append(clip)
-            successful_segments += 1
-            print(f"Segment {idx+1} processed in {time.time() - segment_start_time:.2f}s.")
-        else:
-            print("Error: Clip creation failed. Skipping segment.")
-            if os.path.exists(media_asset['path']):
-                try:
-                    os.remove(media_asset['path'])
-                except OSError:
-                    pass
-            if os.path.exists(tts_path):
-                try:
-                    os.remove(tts_path)
-                except OSError:
-                    pass
-            continue
-
-    # Final Assembly
-    final_video = None
-    output_path = None
+        headers = {
+            'Authorization': f'Bearer {self.config['OPENROUTER_API_KEY']}',
+            'Content-Type': 'application/json'
+        }
+        
+        data = {
+            "model": "mistralai/mistral-small-3.1-24b-instruct:free",
+            "messages": [{"role": "user", "content": prompt}],
+            "temperature": 0.7,
+            "max_tokens": 1024
+        }
+        
+        try:
+            response = requests.post(
+                'https://openrouter.ai/api/v1/chat/completions',
+                headers=headers,
+                json=data,
+                timeout=30
+            )
+            response.raise_for_status()
+            return response.json()['choices'][0]['message']['content']
+        except Exception as e:
+            return f"Error generating script: {str(e)}"
     
-    if not clips:
-        print("Error: No clips created.")
-        return None, total_segments, successful_segments
+    def _download_media(self, url: str, filename: str) -> Optional[str]:
+        """Download media file from URL"""
+        local_path = os.path.join(self.temp_dir, filename)
         
-    if successful_segments < total_segments:
-        print(f"\nWARNING: Only {successful_segments}/{total_segments} segments succeeded.")
-
-    print(f"\nConcatenating {len(clips)} clips...")
-    try:
-        final_video = concatenate_videoclips(clips, method="compose")
-        print("Concatenation complete.")
-
-        # Close individual clips after successful concatenation
-        print("Closing individual segment clips...")
-        for c in clips:
-            try:
-                c.close()
-            except Exception as e:
-                print(f"Minor error closing segment clip: {e}")
-
-        # Add Music
-        if music_file:
-            final_video = add_background_music(final_video, music_file, bg_music_volume=0.08)
-
-        # Export
-        output_path = OUTPUT_VIDEO_FILENAME
-        print(f"Exporting final video to '{output_path}' (FPS: {fps}, Preset: {preset})...")
-        final_video.write_videofile(
-            output_path,
-            codec='libx264',
-            audio_codec='aac',
-            fps=fps,
-            preset=preset,
-            threads=os.cpu_count() or 4,
-            logger='bar'
-        )
-        print(f"\nFinal video saved: '{output_path}'")
-        print(f"Total generation time: {time.time() - start_time:.2f} seconds.")
-
-    except Exception as e:
-        print(f"FATAL Error during final assembly/export: {e}")
-        traceback.print_exc()
-        output_path = None
-    finally:
-        print("Final cleanup...")
-        if final_video:
+        for attempt in range(self.config['MAX_RETRIES']):
             try:
-                final_video.close()
+                with requests.get(url, stream=True, timeout=15) as r:
+                    r.raise_for_status()
+                    with open(local_path, 'wb') as f:
+                        for chunk in r.iter_content(chunk_size=8192):
+                            f.write(chunk)
+                
+                # Validate downloaded file
+                if os.path.getsize(local_path) > 1024:
+                    return local_path
+                
             except Exception as e:
-                print(f"Minor error closing final video: {e}")
+                print(f"Download attempt {attempt + 1} failed: {str(e)}")
+                time.sleep(self.config['RETRY_DELAY'] * (attempt + 1))
         
-        clips.clear()
+        return None
+    
+    def _search_pexels_video(self, query: str) -> Optional[str]:
+        """Search for videos on Pexels"""
+        if not self.config['PEXELS_API_KEY']:
+            return None
+            
+        headers = {'Authorization': self.config['PEXELS_API_KEY']}
+        params = {
+            'query': query,
+            'per_page': 15,
+            'orientation': 'landscape'
+        }
         
-        if TEMP_FOLDER and os.path.exists(TEMP_FOLDER):
-            print(f"Removing temp folder: {TEMP_FOLDER}")
-            try:
-                shutil.rmtree(TEMP_FOLDER)
-                print("Temp folder removed.")
-            except Exception as e:
-                print(f"Warning: Could not remove temp folder {TEMP_FOLDER}: {e}")
-
-    return output_path, total_segments, successful_segments
-
-# --- Gradio Interface ---
-with gr.Blocks(title="AI Documentary Video Generator", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# Create a Funny AI Documentary Video")
-    gr.Markdown("Concept -> Generate Script -> Edit (Optional) -> Configure -> Generate Video!")
-    gr.Markdown("---")
-
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### 1. Concept & Script")
-            concept = gr.Textbox(label="Video Concept/Topic", placeholder="e.g., 'The secret life of squirrels'")
-            generate_script_btn = gr.Button("📝 Generate Script", variant="secondary")
-            script = gr.Textbox(label="Script (Edit if needed)", lines=15, placeholder="Generated script...", interactive=True)
-        with gr.Column(scale=1):
-            gr.Markdown("### 2. Video Options")
-            resolution = gr.Radio(["Full (1920x1080)", "Short (1080x1920)"], label="Resolution", value="Short (1080x1920)")
-            captions = gr.Radio(["Yes", "No"], label="Add Captions?", value="Yes")
-            music = gr.Audio(label="Background Music (Optional)", type="filepath")
-            gr.Markdown("### 3. Advanced Settings")
-            fps_slider = gr.Slider(minimum=15, maximum=60, step=1, value=30, label="Output FPS")
-            preset_dropdown = gr.Dropdown(
-                ["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow"],
-                value="veryfast",
-                label="Encoding Preset",
-                info="Faster=Quicker, Larger File"
+        try:
+            response = requests.get(
+                'https://api.pexels.com/videos/search',
+                headers=headers,
+                params=params,
+                timeout=10
+            )
+            response.raise_for_status()
+            
+            videos = response.json().get('videos', [])
+            if videos:
+                video_files = videos[0].get('video_files', [])
+                for file in video_files:
+                    if file.get('quality') == 'hd':
+                        return file.get('link')
+        except Exception as e:
+            print(f"Pexels search error: {str(e)}")
+        
+        return None
+    
+    def _generate_tts(self, text: str) -> Optional[str]:
+        """Generate TTS audio for narration"""
+        if not self.tts_pipeline:
+            return None
+            
+        safe_name = re.sub(r'[^\w\-_]', '', text[:20]) + '.wav'
+        output_path = os.path.join(self.temp_dir, safe_name)
+        
+        try:
+            audio_segments = []
+            for chunk in self.tts_pipeline(text, speed=1.0):
+                if isinstance(chunk, tuple):
+                    chunk = chunk[-1]  # Get audio data from tuple
+                audio_segments.append(chunk)
+            
+            full_audio = np.concatenate(audio_segments)
+            sf.write(output_path, full_audio, self.config['TTS_SAMPLE_RATE'])
+            return output_path
+        except Exception as e:
+            print(f"TTS generation error: {str(e)}")
+            return None
+    
+    def _create_video_segment(self, segment: VideoSegment) -> Optional[VideoClip]:
+        """Create a single video segment with media, audio, and effects"""
+        try:
+            # Load media
+            if segment.media_type == 'video':
+                media_clip = VideoFileClip(segment.media_path)
+            else:
+                media_clip = ImageClip(segment.media_path).set_duration(segment.duration)
+            
+            # Apply effects
+            if segment.media_type == 'image':
+                media_clip = self._apply_kenburns(media_clip)
+            else:
+                media_clip = self._resize_clip(media_clip)
+            
+            # Add audio
+            audio_clip = AudioFileClip(segment.tts_path)
+            media_clip = media_clip.set_audio(audio_clip)
+            
+            # Add captions if enabled
+            if segment.caption_style.get('enabled', False):
+                media_clip = self._add_captions(media_clip, segment.narration, segment.caption_style)
+            
+            return media_clip
+        except Exception as e:
+            print(f"Segment creation error: {str(e)}")
+            traceback.print_exc()
+            return None
+    
+    def _apply_kenburns(self, clip: ImageClip) -> VideoClip:
+        """Apply Ken Burns effect to an image clip"""
+        try:
+            target_w, target_h = self.current_resolution
+            base_scale = 1.2
+            
+            # Choose random effect
+            effects = {
+                'zoom_in': {'start_scale': 1.0, 'end_scale': base_scale},
+                'zoom_out': {'start_scale': base_scale, 'end_scale': 1.0},
+                'pan_left': {'start_pos': (0.7, 0.5), 'end_pos': (0.3, 0.5)},
+                'pan_right': {'start_pos': (0.3, 0.5), 'end_pos': (0.7, 0.5)}
+            }
+            effect = random.choice(list(effects.values()))
+            
+            def transform(get_frame, t):
+                ratio = t / clip.duration
+                scale = effect['start_scale'] + (effect['end_scale'] - effect['start_scale']) * ratio
+                pos_x = effect['start_pos'][0] + (effect['end_pos'][0] - effect['start_pos'][0]) * ratio
+                pos_y = effect['start_pos'][1] + (effect['end_pos'][1] - effect['start_pos'][1]) * ratio
+                
+                frame = get_frame(t)
+                h, w = frame.shape[:2]
+                crop_size = (int(w/scale), int(h/scale))
+                
+                center_x = int(pos_x * w)
+                center_y = int(pos_y * h)
+                
+                x = max(0, min(center_x - crop_size[0]//2, w - crop_size[0]))
+                y = max(0, min(center_y - crop_size[1]//2, h - crop_size[1]))
+                
+                cropped = frame[y:y+crop_size[1], x:x+crop_size[0]]
+                return cv2.resize(cropped, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
+            
+            return clip.fl(transform)
+        except Exception as e:
+            print(f"Ken Burns error: {str(e)}")
+            return self._resize_clip(clip)
+    
+    def _resize_clip(self, clip: Union[VideoClip, ImageClip]) -> VideoClip:
+        """Resize clip to target resolution"""
+        try:
+            target_w, target_h = self.current_resolution
+            clip_aspect = clip.w / clip.h
+            target_aspect = target_w / target_h
+            
+            if abs(clip_aspect - target_aspect) < 0.01:
+                return clip.resize((target_w, target_h))
+            
+            if clip_aspect > target_aspect:
+                # Wider than target
+                new_height = target_h
+                new_width = int(clip.w * (new_height / clip.h))
+                resized = clip.resize(height=new_height)
+                crop = (resized.w - target_w) / 2
+                return resized.crop(x1=crop, y1=0, x2=crop+target_w, y2=target_h)
+            else:
+                # Taller than target
+                new_width = target_w
+                new_height = int(clip.h * (new_width / clip.w))
+                resized = clip.resize(width=new_width)
+                crop = (resized.h - target_h) / 2
+                return resized.crop(x1=0, y1=crop, x2=target_w, y2=crop+target_h)
+        except Exception as e:
+            print(f"Resize error: {str(e)}")
+            return clip
+    
+    def _add_captions(self, clip: VideoClip, text: str, style: Dict) -> VideoClip:
+        """Add captions to a video clip"""
+        try:
+            words = text.split()
+            chunks = []
+            current_chunk = []
+            char_count = 0
+            
+            # Split text into manageable chunks
+            for word in words:
+                if char_count + len(word) > 30 and current_chunk:
+                    chunks.append(' '.join(current_chunk))
+                    current_chunk = [word]
+                    char_count = len(word)
+                else:
+                    current_chunk.append(word)
+                    char_count += len(word) + 1
+            
+            if current_chunk:
+                chunks.append(' '.join(current_chunk))
+            
+            # Create text clips
+            text_clips = []
+            duration_per_chunk = clip.duration / len(chunks)
+            
+            for i, chunk in enumerate(chunks):
+                txt_clip = TextClip(
+                    chunk,
+                    fontsize=style['font_size'],
+                    font=style['font'],
+                    color=style['color'],
+                    bg_color=style['bg_color'],
+                    stroke_color=style['stroke_color'],
+                    stroke_width=style['stroke_width'],
+                    method='caption',
+                    size=(style['max_width'], None)
+                ).set_start(i * duration_per_chunk).set_duration(duration_per_chunk)
+                
+                txt_clip = txt_clip.set_position(('center', style['y_position']))
+                text_clips.append(txt_clip)
+            
+            return CompositeVideoClip([clip] + text_clips)
+        except Exception as e:
+            print(f"Caption error: {str(e)}")
+            return clip
+    
+    def generate_video(self, script: str, resolution: str, captions: bool, 
+                      music_path: Optional[str] = None) -> Optional[str]:
+        """Main video generation pipeline"""
+        start_time = time.time()
+        
+        try:
+            # Setup
+            self._create_temp_dir()
+            self.current_resolution = self.config['RESOLUTIONS'].get(resolution, (1920, 1080))
+            self.caption_color = 'white' if captions else None
+            
+            # Parse script into segments
+            segments = self._parse_script(script)
+            if not segments:
+                print("Error: No valid segments found in script")
+                return None
+            
+            # Process segments in parallel
+            with ThreadPoolExecutor() as executor:
+                video_segments = list(executor.map(self._process_segment, segments))
+            
+            # Combine segments
+            final_clip = concatenate_videoclips(
+                [s for s in video_segments if s is not None],
+                method="compose"
             )
-            video_prob_slider = gr.Slider(
-                minimum=0.0,
-                maximum=1.0,
-                step=0.05,
-                value=0.45,
-                label="Video Clip Probability",
-                info="Chance (0-1) to use video per segment"
+            
+            # Add background music if provided
+            if music_path and os.path.exists(music_path):
+                music_clip = AudioFileClip(music_path).volumex(self.config['BACKGROUND_MUSIC_VOLUME'])
+                if music_clip.duration < final_clip.duration:
+                    music_clip = music_clip.loop(duration=final_clip.duration)
+                final_clip = final_clip.set_audio(
+                    CompositeAudioClip([final_clip.audio, music_clip])
+                )
+            
+            # Export final video
+            output_path = self.config['OUTPUT_VIDEO']
+            final_clip.write_videofile(
+                output_path,
+                codec='libx264',
+                audio_codec='aac',
+                fps=self.config['DEFAULT_FPS'],
+                threads=os.cpu_count() or 4
             )
-            gr.Markdown("### 4. Generate")
-            generate_video_btn = gr.Button("🎬 Generate Video", variant="primary")
-
-    with gr.Row():
-        video_output = gr.Video(label="Generated Video", interactive=False)
-    with gr.Row():
-        status_message = gr.Markdown("")
-
-    # Event Handlers
-    def on_generate_script(concept_text):
-        if not concept_text:
-            return gr.update(value="", placeholder="Please enter a concept first."), gr.Markdown("⚠️ Please enter a video concept.")
+            
+            print(f"Video generated in {time.time() - start_time:.2f} seconds")
+            return output_path
+            
+        except Exception as e:
+            print(f"Video generation failed: {str(e)}")
+            traceback.print_exc()
+            return None
+        finally:
+            self._cleanup()
+    
+    def _parse_script(self, script: str) -> List[Dict]:
+        """Parse script into media and narration segments"""
+        segments = []
+        current_title = None
+        current_text = ""
         
-        yield gr.update(), gr.Markdown("⏳ Generating script...")
-        script_text = generate_script(concept_text)
+        for line in script.split('\n'):
+            line = line.strip()
+            if not line:
+                continue
+                
+            # Check for section title
+            title_match = re.match(r'^\s*\[([^\]]+)\]\s*(.*)', line)
+            if title_match:
+                if current_title and current_text:
+                    segments.append({
+                        'title': current_title,
+                        'text': current_text.strip()
+                    })
+                current_title = title_match.group(1).strip()
+                current_text = title_match.group(2).strip() + " "
+            elif current_title:
+                current_text += line + " "
         
-        if script_text and "Error:" not in script_text:
-            yield gr.update(value=script_text), gr.Markdown("✅ Script generated!")
-        elif script_text and "Error:" in script_text:
-            yield gr.update(value=""), gr.Markdown(f"❌ Script Error: {script_text}")
-        else:
-            yield gr.update(value=""), gr.Markdown("❌ Script generation failed. Check logs.")
-
-    def on_generate_video(script_text, resolution_choice, captions_choice, music_path, fps, preset, video_probability):
-        if not script_text or "Error:" in script_text or "Failed to generate script" in script_text:
-            yield None, gr.Markdown("❌ Cannot generate: Invalid script.")
-            return
+        # Add the last segment
+        if current_title and current_text:
+            segments.append({
+                'title': current_title,
+                'text': current_text.strip()
+            })
         
-        if not PEXELS_API_KEY or 'your_pexels_api_key_here' in PEXELS_API_KEY:
-            yield None, gr.Markdown("❌ Cannot generate: Pexels API Key missing/invalid.")
-            return
+        return segments
+    
+    def _process_segment(self, segment: Dict) -> Optional[VideoSegment]:
+        """Process a single script segment into a video segment"""
+        try:
+            # Get media
+            use_video = random.random() < self.config['VIDEO_PROBABILITY']
+            if use_video:
+                media_url = self._search_pexels_video(segment['title'])
+                media_type = 'video'
+            else:
+                media_url = self._search_pexels_image(segment['title'])
+                media_type = 'image'
+            
+            if not media_url:
+                print(f"No media found for: {segment['title']}")
+                return None
+            
+            # Download media
+            media_ext = '.mp4' if media_type == 'video' else '.jpg'
+            media_filename = f"media_{len(segment['title'])}_media_ext"
+            media_path = self._download_media(media_url, media_filename)
+            
+            if not media_path:
+                print(f"Failed to download media for: {segment['title']}")
+                return None
+            
+            # Generate TTS
+            tts_path = self._generate_tts(segment['text'])
+            if not tts_path:
+                print(f"Failed to generate TTS for: {segment['title']}")
+                return None
+            
+            # Calculate duration based on TTS
+            tts_duration = AudioFileClip(tts_path).duration
+            duration = max(3.0, min(tts_duration * 1.1, 10.0))  # 3-10 seconds
+            
+            # Prepare caption style
+            caption_style = {
+                'enabled': self.caption_color is not None,
+                'font_size': self._get_font_size(),
+                'font': self.config['CAPTION_FONT'],
+                'color': self.caption_color or 'white',
+                'bg_color': 'rgba(0,0,0,0.5)',
+                'stroke_color': 'black',
+                'stroke_width': 1.5,
+                'max_width': int(self.current_resolution[0] * 0.8),
+                'y_position': int(self.current_resolution[1] * 0.8)
+            }
+            
+            return VideoSegment(
+                media_path=media_path,
+                tts_path=tts_path,
+                narration=segment['text'],
+                duration=duration,
+                media_type=media_type,
+                effects={'type': 'random'},
+                caption_style=caption_style
+            )
             
-        if pipeline is None:
-            yield None, gr.Markdown("❌ Cannot generate: Kokoro TTS failed initialization. Check console.")
-            return
+        except Exception as e:
+            print(f"Segment processing error: {str(e)}")
+            return None
+    
+    def _get_font_size(self) -> int:
+        """Get appropriate font size for current resolution"""
+        if self.current_resolution[1] >= 1080:
+            return self.config['CAPTION_FONT_SIZES']['1080p']
+        elif self.current_resolution[1] >= 720:
+            return self.config['CAPTION_FONT_SIZES']['720p']
+        else:
+            return self.config['CAPTION_FONT_SIZES']['480p']
 
-        yield None, gr.Markdown("⏳ Starting video generation... Check console for detailed progress.")
+# ======================
+# GRADIO INTERFACE
+# ======================
+
+def create_gradio_interface():
+    """Create the Gradio web interface"""
+    generator = DocumentaryGenerator()
+    
+    with gr.Blocks(title="AI Documentary Maker", theme="soft") as app:
+        gr.Markdown("# AI Documentary Video Generator")
         
-        video_path, total_segments, successful_segments = generate_video_from_script(
-            script_text, resolution_choice, captions_choice, music_path, fps, preset, video_probability
+        with gr.Row():
+            with gr.Column():
+                topic_input = gr.Textbox(label="Documentary Topic", placeholder="Enter your topic...")
+                generate_script_btn = gr.Button("Generate Script")
+                script_output = gr.Textbox(label="Generated Script", lines=10, interactive=True)
+                
+                with gr.Accordion("Advanced Options", open=False):
+                    resolution = gr.Dropdown(
+                        list(generator.config['RESOLUTIONS'].keys()),
+                        value="1080p",
+                        label="Resolution"
+                    )
+                    captions = gr.Checkbox(
+                        value=True,
+                        label="Enable Captions"
+                    )
+                    music_input = gr.Audio(
+                        label="Background Music",
+                        type="filepath",
+                        optional=True
+                    )
+                    video_prob = gr.Slider(
+                        minimum=0.1,
+                        maximum=1.0,
+                        value=generator.config['VIDEO_PROBABILITY'],
+                        label="Video Clip Probability"
+                    )
+                
+                generate_video_btn = gr.Button("Generate Video", variant="primary")
+                
+            with gr.Column():
+                video_output = gr.Video(label="Generated Documentary")
+                status_output = gr.Textbox(label="Status", interactive=False)
+        
+        # Event handlers
+        generate_script_btn.click(
+            fn=generator.generate_script,
+            inputs=[topic_input],
+            outputs=[script_output]
         )
         
-        final_status = ""
-        if video_path and os.path.exists(video_path):
-            final_status = f"✅ Video generated: {os.path.basename(video_path)}!"
-            if successful_segments < total_segments:
-                final_status += f" (Warning: {total_segments - successful_segments} out of {total_segments} segments failed)"
-            yield video_path, gr.Markdown(final_status)
-        else:
-            final_status = "❌ Video generation failed. Please check the console logs for errors."
-            yield None, gr.Markdown(final_status)
-
-    # Connect buttons
-    generate_script_btn.click(
-        fn=on_generate_script,
-        inputs=[concept],
-        outputs=[script, status_message],
-        api_name="generate_script"
-    )
+        generate_video_btn.click(
+            fn=generator.generate_video,
+            inputs=[script_output, resolution, captions, music_input],
+            outputs=[video_output],
+            api_name="generate"
+        )
     
-    generate_video_btn.click(
-        fn=on_generate_video,
-        inputs=[script, resolution, captions, music, fps_slider, preset_dropdown, video_prob_slider],
-        outputs=[video_output, status_message],
-        api_name="generate_video"
-    )
+    return app
+
+# ======================
+# MAIN EXECUTION
+# ======================
 
-# Launch App
-print("Starting Gradio Interface...")
-demo.queue().launch(share=True, debug=True)
+if __name__ == "__main__":
+    app = create_gradio_interface()
+    app.launch(server_name="0.0.0.0", server_port=7860)