Update app.py

app.py

@@ -1,807 +1,225 @@
-"""
-Full Code: Orbit Video Engine with Dynamic Clip Editor and Video Output Download
-
-This script implements a Gradio Blocks UI that:
-  1. Accepts a video topic or a full script.
-  2. Generates a documentary-style script using an AI API.
-  3. Parses the script into clip data.
-  4. Dynamically creates an editor for each clip, where users can:
-      - Edit the visual prompt.
-      - Edit the TTS (narration) text.
-      - Upload their own image/video to override the generated media.
-  5. Provides video settings (resolution, render speed, clip preferences, background music, subtitle settings).
-  6. Renders the video and displays it so you can preview it and download the final MP4 file.
-  
-Make sure you have all required dependencies installed.
-"""
-
-# ------------------- IMPORTS -------------------
-from kokoro import KPipeline
-import soundfile as sf
-import torch
-import os, time, random, math, json, tempfile, shutil, re, requests
-from moviepy.editor import (VideoFileClip, AudioFileClip, ImageClip, concatenate_videoclips,
-                            CompositeVideoClip, TextClip, CompositeAudioClip)
-import moviepy.video.fx.all as vfx
-import moviepy.config as mpy_config
-from pydub import AudioSegment
-from PIL import Image
-import numpy as np
-from bs4 import BeautifulSoup
-from urllib.parse import quote
-import pysrt
-from gtts import gTTS
-import cv2
+# Import necessary libraries (assuming all your imports remain the same)
 import gradio as gr
+import os
+import tempfile
+import shutil
+from moviepy.editor import concatenate_videoclips, CompositeVideoClip, AudioFileClip, TextClip
 
-# ------------------- GLOBAL CONFIGURATION -------------------
-pipeline = KPipeline(lang_code='a')  # American English voice (uses 'af_heart')
-mpy_config.change_settings({"IMAGEMAGICK_BINARY": "/usr/bin/convert"})
-
-PEXELS_API_KEY = 'BhJqbcdm9Vi90KqzXKAhnEHGsuFNv4irXuOjWtT761U49lRzo03qBGna'
-OPENROUTER_API_KEY = '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'
-OPENROUTER_MODEL = "mistralai/mistral-small-3.1-24b-instruct:free"
-OUTPUT_VIDEO_FILENAME = "final_video.mp4"
-USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/91.0.4472.124 Safari/537.36"
-
-# These globals will be set for each run
-TARGET_RESOLUTION = None
-CAPTION_COLOR = None
-TEMP_FOLDER = None
-
-# ------------------- HELPER FUNCTIONS -------------------
-
-def generate_script(user_input):
-    """Generate a documentary script using the OpenRouter API."""
-    headers = {
-        'Authorization': f'Bearer {OPENROUTER_API_KEY}',
-        'HTTP-Referer': 'https://your-domain.com',
-        'X-Title': 'AI Documentary Maker'
-    }
-    prompt = f"""Short Documentary Script GeneratorInstructions:
-
-If I say "use this," just output the script exactly as I gave it.
-If I only give topics, generate a script based on them.
-If I provide a full script, rewrite it without any changes. Make everything short simple and humarous funny and act as serious but humarous. And don't say anything off topic. Also alway say a funny statement to subscribe based on the video topic at the end. Use normal conversational text like a normal person talking and avoid AI phase make the statements humanize and normal conversational
-And always talk negative views don't really wants any positive statement and the full script will be one video about one topic so keep in mind
-Formatting Rules:
-
-Title in Square Brackets:
-
-Each section starts with a one-word title inside [ ] (max two words if necessary).
-This title will be used as a search term for Pexels footage.
-
-Casual & Funny Narration:
-
-Each section has 5-10 words of narration.
-Keep it natural, funny, and unpredictable (not robotic, poetic, or rhythmic).
-
-No Special Formatting:
-
-No bold, italics, or special characters. You are an assistant AI your task is to create script. You aren't a chatbot. So, don't write extra text
-
-Generalized Search Terms:
-
-If a term is too specific, make it more general for Pexels search.
-
-Scene-Specific Writing:
-
-Each section describes only what should be shown in the video.
-
-Output Only the Script, and also make it funny and humarous and helirous and also add to subscribe with a funny statement like subscribe now or ..... 
+# Your existing helper functions (generate_script, parse_script, etc.) remain unchanged
+# Ensure TEMP_FOLDER, TARGET_RESOLUTION, and CAPTION_COLOR are set within functions as needed
 
-No extra text, just the script.
-
-Example Output:
-[North Korea]
-Top 5 unknown facts about North Korea.
-[Invisibility]
-North Korea’s internet speed is so fast… it doesn’t exist.
-[Leadership]
-Kim Jong-un once won an election with 100% votes… against himself.
-[Magic]
-North Korea discovered time travel. That’s why their news is always from the past.
-[Warning]
-Subscribe now, or Kim Jong-un will send you a free one-way ticket… to North Korea.
-[Freedom]
-North Korean citizens can do anything… as long as it's government-approved.
-Now here is the Topic/scrip: {user_input}
-"""
-    data = {
-        'model': OPENROUTER_MODEL,
-        'messages': [{'role': 'user', 'content': prompt}],
-        'temperature': 0.4,
-        'max_tokens': 5000
-    }
-    try:
-        response = requests.post(
-            'https://openrouter.ai/api/v1/chat/completions',
-            headers=headers,
-            json=data,
-            timeout=30
-        )
-        if response.status_code == 200:
-            response_data = response.json()
-            if 'choices' in response_data and len(response_data['choices']) > 0:
-                return response_data['choices'][0]['message']['content']
-            else:
-                print("Unexpected response format:", response_data)
-                return None
-        else:
-            print(f"API Error {response.status_code}: {response.text}")
-            return None
-    except Exception as e:
-        print(f"Request failed: {str(e)}")
-        return None
-
-def parse_script(script_text):
-    """
-    Parse the generated script into a list of elements.
-    Each clip (segment) is represented as a pair of elements:
-      - A media element with a 'prompt'
-      - A TTS element with narration text and duration
-    """
-    sections = {}
-    current_title = None
-    current_text = ""
-    try:
-        for line in script_text.splitlines():
-            line = line.strip()
-            if line.startswith("[") and "]" in line:
-                bracket_start = line.find("[")
-                bracket_end = line.find("]", bracket_start)
-                if bracket_start != -1 and bracket_end != -1:
-                    if current_title is not None:
-                        sections[current_title] = current_text.strip()
-                    current_title = line[bracket_start+1:bracket_end]
-                    current_text = line[bracket_end+1:].strip()
-            elif current_title:
-                current_text += line + " "
-        if current_title:
-            sections[current_title] = current_text.strip()
-        elements = []
-        for title, narration in sections.items():
-            if not title or not narration:
-                continue
-            media_element = {"type": "media", "prompt": title, "effects": "fade-in"}
-            words = narration.split()
-            duration = max(3, len(words) * 0.5)
-            tts_element = {"type": "tts", "text": narration, "voice": "en", "duration": duration}
-            elements.append(media_element)
-            elements.append(tts_element)
-        return elements
-    except Exception as e:
-        print(f"Error parsing script: {e}")
-        return []
-
-def search_pexels_videos(query, pexels_api_key):
-    """Search for a video on Pexels by query and return a random HD video link."""
-    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
-    search_query = query
-    all_videos = []
-    for page in range(1, num_pages + 1):
-        for attempt in range(max_retries):
-            try:
-                params = {"query": search_query, "per_page": videos_per_page, "page": page}
-                response = requests.get(base_url, headers=headers, params=params, timeout=10)
-                if response.status_code == 200:
-                    data = response.json()
-                    videos = data.get("videos", [])
-                    if not videos:
-                        print(f"No videos found on page {page}.")
-                        break
-                    for video in videos:
-                        video_files = video.get("video_files", [])
-                        for file in video_files:
-                            if file.get("quality") == "hd":
-                                all_videos.append(file.get("link"))
-                                break
-                    break
-                elif response.status_code == 429:
-                    print(f"Rate limit hit (attempt {attempt+1}/{max_retries}). Retrying...")
-                    time.sleep(retry_delay)
-                    retry_delay *= 2
-                else:
-                    print(f"Error fetching videos: {response.status_code} {response.text}")
-                    if attempt < max_retries - 1:
-                        time.sleep(retry_delay)
-                        retry_delay *= 2
-                    else:
-                        break
-            except requests.exceptions.RequestException as e:
-                print(f"Request exception: {e}")
-                if attempt < max_retries - 1:
-                    time.sleep(retry_delay)
-                    retry_delay *= 2
-                else:
-                    break
-    if all_videos:
-        random_video = random.choice(all_videos)
-        print(f"Selected random video from {len(all_videos)} HD videos")
-        return random_video
-    else:
-        print("No suitable videos found.")
-        return None
-
-def search_pexels_images(query, pexels_api_key):
-    """Search for an image on Pexels by query."""
-    headers = {'Authorization': pexels_api_key}
-    url = "https://api.pexels.com/v1/search"
-    params = {"query": query, "per_page": 5, "orientation": "landscape"}
-    max_retries = 3
-    retry_delay = 1
-    for attempt in range(max_retries):
-        try:
-            response = requests.get(url, headers=headers, params=params, timeout=10)
-            if response.status_code == 200:
-                data = response.json()
-                photos = data.get("photos", [])
-                if photos:
-                    photo = random.choice(photos[:min(5, len(photos))])
-                    img_url = photo.get("src", {}).get("original")
-                    return img_url
-                else:
-                    print(f"No images found for query: {query}")
-                    return None
-            elif response.status_code == 429:
-                print(f"Rate limit hit (attempt {attempt+1}/{max_retries}). Retrying...")
-                time.sleep(retry_delay)
-                retry_delay *= 2
-            else:
-                print(f"Error fetching images: {response.status_code} {response.text}")
-                if attempt < max_retries - 1:
-                    time.sleep(retry_delay)
-                    retry_delay *= 2
-        except requests.exceptions.RequestException as e:
-            print(f"Request exception: {e}")
-            if attempt < max_retries - 1:
-                time.sleep(retry_delay)
-                retry_delay *= 2
-    print(f"No Pexels images found for query: {query}")
-    return None
-
-def search_google_images(query):
-    """Search for images on Google Images (useful for news-like queries)."""
-    try:
-        search_url = f"https://www.google.com/search?q={quote(query)}&tbm=isch"
-        headers = {"User-Agent": USER_AGENT}
-        response = requests.get(search_url, headers=headers, timeout=10)
-        soup = BeautifulSoup(response.text, "html.parser")
-        img_tags = soup.find_all("img")
-        image_urls = []
-        for img in img_tags:
-            src = img.get("src", "")
-            if src.startswith("http") and "gstatic" not in src:
-                image_urls.append(src)
-        if image_urls:
-            return random.choice(image_urls[:5]) if len(image_urls) >= 5 else image_urls[0]
-        else:
-            print(f"No Google Images found for query: {query}")
-            return None
-    except Exception as e:
-        print(f"Error in Google Images search: {e}")
-        return None
-
-def download_image(image_url, filename):
-    """Download an image from a URL to a local file and verify it."""
-    try:
-        headers = {"User-Agent": USER_AGENT}
-        print(f"Downloading image from: {image_url}")
-        response = requests.get(image_url, headers=headers, stream=True, timeout=15)
-        response.raise_for_status()
-        with open(filename, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=8192):
-                f.write(chunk)
-        print(f"Image downloaded to: {filename}")
-        try:
-            img = Image.open(filename)
-            img.verify()
-            img = Image.open(filename)
-            if img.mode != 'RGB':
-                img = img.convert('RGB')
-                img.save(filename)
-            return filename
-        except Exception as e_validate:
-            print(f"Invalid image file: {e_validate}")
-            if os.path.exists(filename):
-                os.remove(filename)
-            return None
-    except Exception as e:
-        print(f"Image download error: {e}")
-        if os.path.exists(filename):
-            os.remove(filename)
-        return None
-
-def download_video(video_url, filename):
-    """Download a video from a URL to a local file."""
-    try:
-        response = requests.get(video_url, stream=True, timeout=30)
-        response.raise_for_status()
-        with open(filename, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=8192):
-                f.write(chunk)
-        return filename
-    except Exception as e:
-        print(f"Video download error: {e}")
-        if os.path.exists(filename):
-            os.remove(filename)
-        return None
-
-def generate_media(prompt, user_image=None, current_index=0, total_segments=1):
-    """
-    Generate a visual asset for the clip.
-    If a user_image (custom media) is provided, it is used directly.
-    Otherwise, use Pexels (or Google Images for news queries) with fallbacks.
-    """
-    safe_prompt = re.sub(r'[^\w\s-]', '', prompt).strip().replace(' ', '_')
-    if user_image is not None:
-        print(f"Using custom media for prompt: {prompt}")
-        return {"path": user_image, "asset_type": "image"}
-    if "news" in prompt.lower():
-        image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_news.jpg")
-        image_url = search_google_images(prompt)
-        if image_url:
-            downloaded_image = download_image(image_url, image_file)
-            if downloaded_image:
-                return {"path": downloaded_image, "asset_type": "image"}
-    if random.random() < 0.25:
-        video_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_video.mp4")
-        video_url = search_pexels_videos(prompt, PEXELS_API_KEY)
-        if video_url:
-            downloaded_video = download_video(video_url, video_file)
-            if downloaded_video:
-                return {"path": downloaded_video, "asset_type": "video"}
-    image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}.jpg")
-    image_url = search_pexels_images(prompt, PEXELS_API_KEY)
-    if image_url:
-        downloaded_image = download_image(image_url, image_file)
-        if downloaded_image:
-            return {"path": downloaded_image, "asset_type": "image"}
-    fallback_terms = ["nature", "people", "landscape", "technology", "business"]
-    for term in fallback_terms:
-        fallback_file = os.path.join(TEMP_FOLDER, f"fallback_{term}.jpg")
-        fallback_url = search_pexels_images(term, PEXELS_API_KEY)
-        if fallback_url:
-            downloaded_fallback = download_image(fallback_url, fallback_file)
-            if downloaded_fallback:
-                return {"path": downloaded_fallback, "asset_type": "image"}
-    print(f"Failed to generate asset for prompt: {prompt}")
-    return None
-
-def generate_silent_audio(duration, sample_rate=24000):
-    """Generate a silent WAV audio file of given duration."""
-    num_samples = int(duration * sample_rate)
-    silence = np.zeros(num_samples, dtype=np.float32)
-    silent_path = os.path.join(TEMP_FOLDER, f"silent_{int(time.time())}.wav")
-    sf.write(silent_path, silence, sample_rate)
-    return silent_path
-
-def generate_tts(text, voice):
-    """Generate TTS audio using Kokoro with fallback to gTTS."""
-    safe_text = re.sub(r'[^\w\s-]', '', text[:10]).strip().replace(' ', '_')
-    file_path = os.path.join(TEMP_FOLDER, f"tts_{safe_text}.wav")
-    if os.path.exists(file_path):
-        return file_path
-    try:
-        kokoro_voice = 'af_heart' if voice == 'en' else voice
-        generator = pipeline(text, voice=kokoro_voice, speed=0.9, 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)
-        return file_path
-    except Exception as e:
-        try:
-            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)
-            return file_path
-        except Exception as 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 Ken Burns effect to the clip (used for images)."""
-    target_w, target_h = target_resolution
-    clip_aspect = clip.w / clip.h
-    target_aspect = target_w / target_h
-    if clip_aspect > target_aspect:
-        new_height = target_h
-        new_width = int(new_height * clip_aspect)
-    else:
-        new_width = target_w
-        new_height = int(new_width / clip_aspect)
-    clip = clip.resize(newsize=(new_width, new_height))
-    base_scale = 1.15
-    new_width = int(new_width * base_scale)
-    new_height = int(new_height * base_scale)
-    clip = clip.resize(newsize=(new_width, new_height))
-    max_offset_x = new_width - target_w
-    max_offset_y = new_height - target_h
-    available_effects = ["zoom-in", "zoom-out", "pan-left", "pan-right", "up-left"]
-    if effect_type is None or effect_type == "random":
-        effect_type = random.choice(available_effects)
-    if effect_type == "zoom-in":
-        start_zoom = 0.9; end_zoom = 1.1; start_center = (new_width/2, new_height/2); end_center = start_center
-    elif effect_type == "zoom-out":
-        start_zoom = 1.1; end_zoom = 0.9; start_center = (new_width/2, new_height/2); end_center = start_center
-    elif effect_type == "pan-left":
-        start_zoom = 1.0; end_zoom = 1.0; start_center = (max_offset_x+target_w/2, (max_offset_y//2)+target_h/2); end_center = (target_w/2, (max_offset_y//2)+target_h/2)
-    elif effect_type == "pan-right":
-        start_zoom = 1.0; end_zoom = 1.0; start_center = (target_w/2, (max_offset_y//2)+target_h/2); end_center = (max_offset_x+target_w/2, (max_offset_y//2)+target_h/2)
-    elif effect_type == "up-left":
-        start_zoom = 1.0; end_zoom = 1.0; start_center = (max_offset_x+target_w/2, max_offset_y+target_h/2); end_center = (target_w/2, target_h/2)
-    else:
-        raise ValueError(f"Unsupported effect: {effect_type}")
-    def transform_frame(get_frame, t):
-        frame = get_frame(t)
-        ratio = t / clip.duration if clip.duration > 0 else 0
-        ratio = 0.5 - 0.5 * math.cos(math.pi * ratio)
-        current_zoom = start_zoom + (end_zoom - start_zoom) * ratio
-        crop_w = int(target_w / current_zoom)
-        crop_h = int(target_h / current_zoom)
-        current_center_x = start_center[0] + (end_center[0] - start_center[0]) * ratio
-        current_center_y = start_center[1] + (end_center[1] - start_center[1]) * ratio
-        min_center_x = crop_w / 2; max_center_x = new_width - crop_w / 2
-        min_center_y = crop_h / 2; max_center_y = new_height - crop_h / 2
-        current_center_x = max(min_center_x, min(current_center_x, max_center_x))
-        current_center_y = max(min_center_y, min(current_center_y, max_center_y))
-        cropped_frame = cv2.getRectSubPix(frame, (crop_w, crop_h), (current_center_x, current_center_y))
-        resized_frame = cv2.resize(cropped_frame, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
-        return resized_frame
-    return clip.fl(transform_frame)
+# Define maximum number of clips to handle in the UI
+MAX_CLIPS = 10
 
-def resize_to_fill(clip, target_resolution):
-    """Resize and crop a clip to fill the target resolution."""
-    target_w, target_h = target_resolution
-    clip_aspect = clip.w / clip.h
-    target_aspect = target_w / target_h
-    if clip_aspect > target_aspect:
-        clip = clip.resize(height=target_h)
-        crop_amount = (clip.w - target_w) / 2
-        clip = clip.crop(x1=crop_amount, x2=clip.w - crop_amount, y1=0, y2=clip.h)
+def process_script(topic, script_input):
+    """Process the topic or script and return updates for the UI."""
+    if script_input.strip():
+        raw_script = script_input
     else:
-        clip = clip.resize(width=target_w)
-        crop_amount = (clip.h - target_h) / 2
-        clip = clip.crop(x1=0, x2=clip.w, y1=crop_amount, y2=clip.h - crop_amount)
-    return clip
-
-def find_mp3_files():
-    """Search for an MP3 file in the current directory (for background music)."""
-    mp3_files = []
-    for root, dirs, files in os.walk('.'):
-        for file in files:
-            if file.endswith('.mp3'):
-                mp3_files.append(os.path.join(root, file))
-    return mp3_files[0] if mp3_files else None
-
-def add_background_music(final_video, bg_music_volume=0.08):
-    """Add background music to the final video if an MP3 file is found."""
-    try:
-        bg_music_path = find_mp3_files()
-        if bg_music_path and os.path.exists(bg_music_path):
-            bg_music = AudioFileClip(bg_music_path)
-            if bg_music.duration < final_video.duration:
-                loops_needed = math.ceil(final_video.duration / bg_music.duration)
-                bg_segments = [bg_music] * loops_needed
-                bg_music = concatenate_videoclips(bg_segments)
-            bg_music = bg_music.subclip(0, final_video.duration)
-            bg_music = bg_music.volumex(bg_music_volume)
-            video_audio = final_video.audio
-            mixed_audio = CompositeAudioClip([video_audio, bg_music])
-            final_video = final_video.set_audio(mixed_audio)
-        return final_video
-    except Exception as e:
-        print(f"Error adding background music: {e}")
-        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 from a media asset and TTS audio, and add subtitles if enabled."""
-    try:
-        if not os.path.exists(media_path) or not os.path.exists(tts_path):
-            return None
-        audio_clip = AudioFileClip(tts_path).audio_fadeout(0.2)
-        audio_duration = audio_clip.duration
-        target_duration = audio_duration + 0.2
-        if asset_type == "video":
-            clip = VideoFileClip(media_path)
-            clip = resize_to_fill(clip, TARGET_RESOLUTION)
-            if clip.duration < target_duration:
-                clip = clip.loop(duration=target_duration)
-            else:
-                clip = clip.subclip(0, target_duration)
-        elif asset_type == "image":
-            img = Image.open(media_path)
-            if img.mode != 'RGB':
-                with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as temp:
-                    img.convert('RGB').save(temp.name)
-                    media_path = temp.name
-                img.close()
-            clip = ImageClip(media_path).set_duration(target_duration)
-            clip = apply_kenburns_effect(clip, TARGET_RESOLUTION)
-            clip = clip.fadein(0.3).fadeout(0.3)
+        raw_script = generate_script(topic)
+        if not raw_script:
+            return "Failed to generate script", 0, [], [], [], []
+
+    elements = parse_script(raw_script)
+    paired_elements = [(elements[i], elements[i + 1]) for i in range(0, len(elements) - 1, 2)]
+    num_clips = min(len(paired_elements), MAX_CLIPS)
+
+    # Prepare updates for clip editor
+    accordion_updates = []
+    prompt_updates = []
+    narration_updates = []
+    media_updates = []
+    for i in range(MAX_CLIPS):
+        if i < num_clips:
+            media_elem, tts_elem = paired_elements[i]
+            accordion_updates.append(gr.update(visible=True, label=f"Clip {i+1}: {media_elem['prompt'][:20]}..."))
+            prompt_updates.append(gr.update(value=media_elem['prompt']))
+            narration_updates.append(gr.update(value=tts_elem['text']))
+            media_updates.append(gr.update(value=None))  # Reset file upload
         else:
-            return None
-        if narration_text and CAPTION_COLOR != "transparent":
-            try:
-                words = narration_text.split()
-                chunks = []
-                current_chunk = []
-                for word in words:
-                    current_chunk.append(word)
-                    if len(current_chunk) >= 5:
-                        chunks.append(' '.join(current_chunk))
-                        current_chunk = []
-                if current_chunk:
-                    chunks.append(' '.join(current_chunk))
-                chunk_duration = audio_duration / len(chunks)
-                subtitle_clips = []
-                subtitle_y_position = int(TARGET_RESOLUTION[1] * 0.70)
-                for i, chunk_text in enumerate(chunks):
-                    start_time = i * chunk_duration
-                    end_time = (i + 1) * chunk_duration
-                    txt_clip = TextClip(
-                        chunk_text,
-                        fontsize=45,
-                        font='Arial-Bold',
-                        color=CAPTION_COLOR,
-                        bg_color='rgba(0, 0, 0, 0.25)',
-                        method='caption',
-                        align='center',
-                        stroke_width=2,
-                        stroke_color=CAPTION_COLOR,
-                        size=(TARGET_RESOLUTION[0] * 0.8, None)
-                    ).set_start(start_time).set_end(end_time)
-                    txt_clip = txt_clip.set_position(('center', subtitle_y_position))
-                    subtitle_clips.append(txt_clip)
-                clip = CompositeVideoClip([clip] + subtitle_clips)
-            except Exception as sub_error:
-                txt_clip = TextClip(
-                    narration_text,
-                    fontsize=28,
-                    color=CAPTION_COLOR,
-                    align='center',
-                    size=(TARGET_RESOLUTION[0] * 0.7, None)
-                ).set_position(('center', int(TARGET_RESOLUTION[1] / 3))).set_duration(clip.duration)
-                clip = CompositeVideoClip([clip, txt_clip])
-        clip = clip.set_audio(audio_clip)
-        return clip
-    except Exception as e:
-        print(f"Error in create_clip: {str(e)}")
-        return None
-
-def fix_imagemagick_policy():
-    """Attempt to modify ImageMagick security policies if needed."""
-    try:
-        policy_paths = [
-            "/etc/ImageMagick-6/policy.xml",
-            "/etc/ImageMagick-7/policy.xml",
-            "/etc/ImageMagick/policy.xml",
-            "/usr/local/etc/ImageMagick-7/policy.xml"
-        ]
-        found_policy = next((path for path in policy_paths if os.path.exists(path)), None)
-        if not found_policy:
-            return False
-        os.system(f"sudo cp {found_policy} {found_policy}.bak")
-        os.system(f"sudo sed -i 's/rights=\"none\"/rights=\"read|write\"/g' {found_policy}")
-        os.system(f"sudo sed -i 's/<policy domain=\"path\" pattern=\"@\\*\"[^>]*>/<policy domain=\"path\" pattern=\"@*\" rights=\"read|write\"/g' {found_policy}")
-        os.system(f"sudo sed -i 's/<policy domain=\"coder\" rights=\"none\" pattern=\"PDF\"[^>]*>/<!-- <policy domain=\"coder\" rights=\"none\" pattern=\"PDF\"> -->/g' {found_policy}")
-        return True
-    except Exception as e:
-        return False
-
-def generate_video(user_input, resolution, caption_option):
-    """
-    Original video generation function.
-    This version uses the generated script to create video clips.
-    (Integration with custom clip edits could be extended further.)
-    """
+            accordion_updates.append(gr.update(visible=False))
+            prompt_updates.append(gr.update(value=""))
+            narration_updates.append(gr.update(value=""))
+            media_updates.append(gr.update(value=None))
+
+    return raw_script, num_clips, accordion_updates, prompt_updates, narration_updates, media_updates
+
+def generate_video_full(resolution, render_speed, video_clip_percent, zoom_pan_effect, 
+                        bgm_upload, bgm_volume, subtitles_enabled, font, font_size, 
+                        outline_width, font_color, outline_color, position, num_clips, 
+                        *clip_inputs):
+    """Generate the video using all settings and edited clip data."""
     global TARGET_RESOLUTION, CAPTION_COLOR, TEMP_FOLDER
-    if resolution == "Full HD (1920x1080)":
-        TARGET_RESOLUTION = (1920, 1080)
-    elif resolution == "Short (1080x1920)":
-        TARGET_RESOLUTION = (1080, 1920)
-    else:
-        TARGET_RESOLUTION = (1920, 1080)
-    CAPTION_COLOR = "white" if caption_option == "Yes" else "transparent"
+    
+    # Set resolution
+    TARGET_RESOLUTION = (1080, 1920) if resolution == "Short (1080x1920)" else (1920, 1080)
+    
+    # Set caption settings
+    CAPTION_COLOR = font_color if subtitles_enabled else "transparent"
+    
+    # Create temporary folder
     TEMP_FOLDER = tempfile.mkdtemp()
-    fix_imagemagick_policy()
-    print("Generating script from API...")
-    script = generate_script(user_input)
-    if not script:
-        shutil.rmtree(TEMP_FOLDER)
-        return None
-    print("Generated Script:\n", script)
-    elements = parse_script(script)
-    if not elements:
-        shutil.rmtree(TEMP_FOLDER)
-        return None
-    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:
-        shutil.rmtree(TEMP_FOLDER)
-        return None
+    
+    # Parse clip inputs (visual_prompt, narration, custom_media for each clip)
+    clips_data = []
+    for i in range(num_clips):
+        idx = i * 3
+        visual_prompt = clip_inputs[idx]
+        narration = clip_inputs[idx + 1]
+        custom_media = clip_inputs[idx + 2]
+        clips_data.append({
+            'visual_prompt': visual_prompt,
+            'narration': narration,
+            'custom_media': custom_media
+        })
+
+    # Generate clips
     clips = []
-    for idx, (media_elem, tts_elem) in enumerate(paired_elements):
-        print(f"Processing segment {idx+1} with prompt: '{media_elem['prompt']}'")
-        media_asset = generate_media(media_elem['prompt'])
-        if not media_asset:
-            continue
-        tts_path = generate_tts(tts_elem['text'], tts_elem['voice'])
+    for idx, clip_data in enumerate(clips_data):
+        # Use custom media if provided, otherwise generate media
+        if clip_data['custom_media']:
+            media_path = clip_data['custom_media']
+            asset_type = 'video' if media_path.endswith(('.mp4', '.avi', '.mov')) else 'image'
+        else:
+            media_asset = generate_media(clip_data['visual_prompt'], current_index=idx, total_segments=num_clips)
+            if not media_asset:
+                continue
+            media_path = media_asset['path']
+            asset_type = media_asset['asset_type']
+        
+        # Adjust video clip percentage
+        original_random = random.random()
+        adjusted_random = original_random * (video_clip_percent / 100)
+        if adjusted_random < (video_clip_percent / 100) and not clip_data['custom_media']:
+            media_asset = generate_media(clip_data['visual_prompt'], current_index=idx, total_segments=num_clips)
+            if media_asset and media_asset['asset_type'] == 'video':
+                media_path = media_asset['path']
+                asset_type = 'video'
+
+        # Generate TTS
+        tts_path = generate_tts(clip_data['narration'], 'en')
         if not tts_path:
             continue
+
+        # Create clip
+        duration = max(3, len(clip_data['narration'].split()) * 0.5)
         clip = create_clip(
-            media_path=media_asset['path'],
-            asset_type=media_asset['asset_type'],
+            media_path=media_path,
+            asset_type=asset_type,
             tts_path=tts_path,
-            duration=tts_elem['duration'],
-            effects=media_elem.get('effects', 'fade-in'),
-            narration_text=tts_elem['text'],
+            duration=duration,
+            effects='fade-in',
+            narration_text=clip_data['narration'],
             segment_index=idx
         )
+        if clip and zoom_pan_effect and asset_type == 'image':
+            clip = apply_kenburns_effect(clip, TARGET_RESOLUTION)
         if clip:
             clips.append(clip)
+
     if not clips:
         shutil.rmtree(TEMP_FOLDER)
-        return None
-    final_video = concatenate_videoclips(clips, method="compose")
-    final_video = add_background_music(final_video, bg_music_volume=0.08)
-    final_video.write_videofile(OUTPUT_VIDEO_FILENAME, codec='libx264', fps=24, preset='veryfast')
-    shutil.rmtree(TEMP_FOLDER)
-    return OUTPUT_VIDEO_FILENAME
+        return None, None
 
-# ------------------- NEW CALLBACKS FOR THE ADVANCED UI -------------------
+    # Concatenate clips
+    final_video = concatenate_videoclips(clips, method="compose")
 
-# Global variable to store clip data from the script generation.
-generated_clip_data = []
+    # Add background music if uploaded
+    if bgm_upload:
+        bg_music = AudioFileClip(bgm_upload).volumex(bgm_volume)
+        if bg_music.duration < final_video.duration:
+            bg_music = bg_music.loop(duration=final_video.duration)
+        else:
+            bg_music = bg_music.subclip(0, final_video.duration)
+        final_video = final_video.set_audio(CompositeVideoClip([final_video.audio, bg_music]))
 
-def generate_script_clips(topic_input, full_script):
-    """
-    Callback when "📝 Generate Script & Load Clips" is clicked.
-    Uses the full_script if provided; otherwise, generates based on the topic.
-    Returns the raw generated script and a JSON string containing the clip data.
-    """
-    input_text = full_script if full_script.strip() != "" else topic_input
-    script = generate_script(input_text)
-    if not script:
-        return "Error: failed to generate script", "{}"
-    elements = parse_script(script)
-    clip_list = []
-    for i in range(0, len(elements), 2):
-        if i + 1 < len(elements):
-            media_elem = elements[i]
-            tts_elem = elements[i+1]
-            clip_info = {
-                "prompt": media_elem.get("prompt", ""),
-                "narration": tts_elem.get("text", ""),
-                "custom_media": ""  # initially empty; user may upload a file later
-            }
-            clip_list.append(clip_info)
-    global generated_clip_data
-    generated_clip_data = clip_list
-    return script, json.dumps(clip_list)
+    # Export video
+    output_path = "final_video.mp4"
+    final_video.write_videofile(output_path, codec='libx264', fps=24, preset=render_speed)
 
-def update_clip_editor(clip_json):
-    """
-    Dynamically build a UI editor for each clip.
-    Each editor contains:
-       - A textbox to edit the visual prompt.
-       - A textbox to edit the TTS text.
-       - A File uploader to allow custom media upload.
-    Returns a list of dynamically generated Accordions.
-    """
-    clip_list = json.loads(clip_json)
-    editors = []
-    # Create a container for all clip editors.
-    for idx, clip in enumerate(clip_list, start=1):
-        with gr.Accordion(label=f"Clip {idx}: {clip['prompt']}", open=(idx<=2)) as acc:
-            prompt_box = gr.Textbox(label="Visual Prompt", value=clip["prompt"])
-            tts_box = gr.Textbox(label="TTS Text", value=clip["narration"], lines=3)
-            custom_media_box = gr.File(label="Upload custom image/video", file_types=[".jpg", ".png", ".mp4"])
-            # Pack values in a dictionary and return them later (here we simply display the components).
-            # In a full integration you could use additional state to track these values.
-            editors.append(acc)
-    return editors
+    # Clean up
+    shutil.rmtree(TEMP_FOLDER)
 
-def generate_final_video(topic_input, full_script, clip_data_json, resolution, render_speed,
-                         video_clip_percent, zoom_pan, bg_music_file, bg_music_volume,
-                         subtitle_enabled, font_dropdown, font_size, outline_width,
-                         font_color, outline_color, subtitle_position):
-    """
-    Callback when "🎬 Generate Video" is clicked.
-    In a full implementation you would update each clip from the dynamic editors.
-    Here, for demonstration purposes, we simply call the original generate_video function.
-    The final video file is returned and used both for preview and download.
-    """
-    print("Final settings:")
-    print(f"Resolution: {resolution}, Render Speed: {render_speed}, Video Clip %: {video_clip_percent}, Zoom/Pan: {zoom_pan}")
-    if bg_music_file is not None:
-        print("Custom background music provided.")
-    video_file = generate_video(topic_input, resolution, "Yes")
-    # Return the file path for both the video preview and the download component.
-    return video_file, video_file
+    return output_path, output_path
 
-# ------------------- GRADIO BLOCKS UI -------------------
+# Gradio Blocks Interface
 with gr.Blocks(title="🚀 Orbit Video Engine") as demo:
+    gr.Markdown("# 🚀 Orbit Video Engine")
+    gr.Markdown("Create funny documentary-style videos with ease!")
+    
     with gr.Row():
         # Column 1: Content Input & Script Generation
         with gr.Column(scale=1):
-            gr.Markdown("## 1. Content Input")
-            topic_input = gr.Textbox(label="Topic Input", placeholder="Enter your video topic here...")
-            full_script = gr.Textbox(label="Or Paste Full Script", placeholder="Paste full script (using [Title] etc.)", lines=5)
-            generate_script_btn = gr.Button("📝 Generate Script & Load Clips")
-            generated_script_disp = gr.Textbox(label="Generated Script", interactive=False, visible=False)
-            # Hidden storage for clip JSON data
-            clip_data_storage = gr.Textbox(visible=False)
-        # Column 2: Dynamic Clip Editor
+            gr.Markdown("### 1. Content Input")
+            topic_input = gr.Textbox(label="Topic", placeholder="e.g., Funny Cat Facts")
+            script_input = gr.Textbox(label="Or Paste Full Script", lines=10, placeholder="[Title]\nNarration...")
+            generate_button = gr.Button("📝 Generate Script & Load Clips")
+            script_display = gr.Textbox(label="Generated Script", interactive=False, visible=False)
+        
+        # Column 2: Clip Editor
+        with gr.Column(scale=2):
+            gr.Markdown("### 2. Edit Clips")
+            gr.Markdown("Modify prompts, narration, or upload custom media below.")
+            with gr.Column() as clip_editor:
+                clip_accordions = []
+                for i in range(MAX_CLIPS):
+                    with gr.Accordion(f"Clip {i+1}", visible=False) as acc:
+                        visual_prompt = gr.Textbox(label="Visual Prompt")
+                        narration = gr.Textbox(label="Narration", lines=3)
+                        custom_media = gr.File(label="Upload Custom Media (Image/Video)")
+                        clip_accordions.append((acc, visual_prompt, narration, custom_media))
+        
+        # Column 3: Settings & Output
         with gr.Column(scale=1):
-            gr.Markdown("## 2. Edit Clips")
-            gr.Markdown("Modify each clip's Visual Prompt, TTS Text or upload your own media.")
-            clip_editor_container = gr.Column(visible=False)
-        # Column 3: Video Settings & Output
-        with gr.Column(scale=1):
-            gr.Markdown("## 3. Video Settings")
-            resolution = gr.Radio(choices=["Short (1080x1920)", "Full HD (1920x1080)"],
-                                  label="Resolution", value="Full HD (1920x1080)")
-            render_speed = gr.Dropdown(choices=["ultrafast", "veryfast", "fast", "medium", "slow", "veryslow"],
-                                       label="Render Speed", value="fast")
-            video_clip_percent = gr.Slider(0, 100, step=5, label="Video Clip Percentage", value=25)
-            zoom_pan = gr.Checkbox(label="Add Zoom/Pan Effect (Images)", value=True)
+            gr.Markdown("### 3. Video Settings")
+            resolution = gr.Radio(["Short (1080x1920)", "Full HD (1920x1080)"], label="Resolution", value="Full HD (1920x1080)")
+            render_speed = gr.Dropdown(["ultrafast", "faster", "fast", "medium", "slow", "slower", "veryslow"], label="Render Speed", value="fast")
+            video_clip_percent = gr.Slider(0, 100, value=25, label="Video Clip Percentage")
+            zoom_pan_effect = gr.Checkbox(label="Add Zoom/Pan Effect (Images)", value=True)
+            
             with gr.Accordion("Background Music", open=False):
-                bg_music_file = gr.File(label="Upload Background Music (MP3)", file_types=[".mp3"])
-                bg_music_volume = gr.Slider(0.0, 1.0, step=0.05, label="BGM Volume", value=0.15)
+                bgm_upload = gr.Audio(label="Upload Background Music", type="filepath")
+                bgm_volume = gr.Slider(0.0, 1.0, value=0.15, label="BGM Volume")
+            
             with gr.Accordion("Subtitle Settings", open=True):
-                subtitle_enabled = gr.Checkbox(label="Enable Subtitles", value=True)
-                font_dropdown = gr.Dropdown(choices=["Impact", "Arial", "Helvetica", "Times New Roman"],
-                                            label="Font", value="Arial")
+                subtitles_enabled = gr.Checkbox(label="Enable Subtitles", value=True)
+                font = gr.Dropdown(["Impact", "Arial", "Times New Roman"], label="Font", value="Arial")
                 font_size = gr.Number(label="Font Size", value=45)
                 outline_width = gr.Number(label="Outline Width", value=2)
                 font_color = gr.ColorPicker(label="Font Color", value="#FFFFFF")
                 outline_color = gr.ColorPicker(label="Outline Color", value="#000000")
-                subtitle_position = gr.Radio(choices=["center", "bottom", "top"], label="Subtitle Position", value="center")
-            gr.Markdown("## 4. Output")
-            generate_video_btn = gr.Button("🎬 Generate Video")
-            # Two outputs: one for video preview, one for file download
-            video_preview = gr.Video(label="Generated Video")
-            download_video_file = gr.File(label="Download Video", interactive=False)
-    
-    # ------------------- INTERACTIONS -------------------
-    # When "Generate Script & Load Clips" is clicked:
-    generate_script_btn.click(
-        fn=generate_script_clips,
-        inputs=[topic_input, full_script],
-        outputs=[generated_script_disp, clip_data_storage]
+                position = gr.Radio(["center", "bottom", "top"], label="Position", value="bottom")
+            
+            generate_video_button = gr.Button("🎬 Generate Video")
+            
+            gr.Markdown("### 4. Output")
+            output_video = gr.Video(label="Generated Video")
+            download_button = gr.File(label="Download Video")
+
+    # State to track number of clips
+    num_clips_state = gr.State(value=0)
+
+    # Event handlers
+    generate_button.click(
+        fn=process_script,
+        inputs=[topic_input, script_input],
+        outputs=[script_display, num_clips_state] + 
+                [comp for acc in clip_accordions for comp in [acc[0], acc[1], acc[2], acc[3]]],
+        _js="() => {return [document.querySelector('#topic_input textarea').value, document.querySelector('#script_input textarea').value]}"
     ).then(
-        fn=lambda script: gr.update(visible=True),
-        inputs=[generated_script_disp],
-        outputs=[generated_script_disp]
-    ).then(
-        fn=update_clip_editor,
-        inputs=[clip_data_storage],
-        outputs=[clip_editor_container]
-    ).then(
-        fn=lambda _: gr.update(visible=True),
-        inputs=[clip_editor_container],
-        outputs=[clip_editor_container]
+        fn=lambda x: gr.update(visible=True),
+        inputs=[script_display],
+        outputs=[script_display]
     )
-    
-    # When "Generate Video" is clicked, call the video generation callback.
-    generate_video_btn.click(
-        fn=generate_final_video,
-        inputs=[topic_input, full_script, clip_data_storage, resolution, render_speed,
-                video_clip_percent, zoom_pan, bg_music_file, bg_music_volume,
-                subtitle_enabled, font_dropdown, font_size, outline_width, font_color, outline_color, subtitle_position],
-        outputs=[video_preview, download_video_file]
+
+    generate_video_button.click(
+        fn=generate_video_full,
+        inputs=[resolution, render_speed, video_clip_percent, zoom_pan_effect, 
+                bgm_upload, bgm_volume, subtitles_enabled, font, font_size, 
+                outline_width, font_color, outline_color, position, num_clips_state] + 
+               [comp for acc in clip_accordions for comp in acc[1:]],  # visual_prompt, narration, custom_media
+        outputs=[output_video, download_button]
     )
 
-demo.launch(share=True)
+# Launch the interface
+demo.launch(share=True)