Update app.py

app.py

@@ -1,95 +1,160 @@
-import asyncio
-import platform
+
+
+# Import necessary libraries
+from kokoro import KPipeline
+
+import soundfile as sf
+import torch
+
+import soundfile as sf
 import os
-import shutil
+from moviepy.editor import VideoFileClip, AudioFileClip, ImageClip
+from PIL import Image
 import tempfile
 import random
-import re
-import math
-import time
-import requests
-from urllib.parse import quote
-from bs4 import BeautifulSoup
-import numpy as np
-from PIL import Image, ImageDraw, ImageFont
 import cv2
-import soundfile as sf
-from pydub import AudioSegment
-from gtts import gTTS
-from kokoro import KPipeline
+import math
+import os, requests, io, time, re, random
 from moviepy.editor import (
     VideoFileClip, concatenate_videoclips, AudioFileClip, ImageClip,
     CompositeVideoClip, TextClip, CompositeAudioClip
 )
+import gradio as gr
+import shutil
+import os
 import moviepy.video.fx.all as vfx
 import moviepy.config as mpy_config
-import gradio as gr
+from pydub import AudioSegment
+from pydub.generators import Sine
+
+from PIL import Image, ImageDraw, ImageFont
+import numpy as np
+from bs4 import BeautifulSoup
+import base64
+from urllib.parse import quote
+import pysrt
+from gtts import gTTS
+import gradio as gr  # Import Gradio
 
-# Initialize Kokoro TTS pipeline
-pipeline = KPipeline(lang_code='a')
+# Initialize Kokoro TTS pipeline (using American English)
+pipeline = KPipeline(lang_code='a')  # Use voice 'af_heart' for American English
+# Ensure ImageMagick binary is set
 mpy_config.change_settings({"IMAGEMAGICK_BINARY": "/usr/bin/convert"})
 
-# Global Configuration
+# ---------------- Global Configuration ---------------- #
 PEXELS_API_KEY = 'BhJqbcdm9Vi90KqzXKAhnEHGsuFNv4irXuOjWtT761U49lRzo03qBGna'
 OPENROUTER_API_KEY = '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'
 OPENROUTER_MODEL = "mistralai/mistral-small-3.1-24b-instruct:free"
 OUTPUT_VIDEO_FILENAME = "final_video.mp4"
 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"
 
-# Global Variables
+# ---------------- Helper Functions ---------------- #
+# (Your existing helper functions remain unchanged: generate_script, parse_script,
+# search_pexels_videos, search_pexels_images, search_google_images, download_image,
+# download_video, generate_media, generate_tts, apply_kenburns_effect,
+# resize_to_fill, find_mp3_files, add_background_music, create_clip,
+# fix_imagemagick_policy)
+
+# Define these globally as they were in your original code but will be set per run
 TARGET_RESOLUTION = None
 CAPTION_COLOR = None
-CAPTION_FONT_SIZE = None
 TEMP_FOLDER = None
 
-# Helper Functions (unchanged from original code)
 def generate_script(user_input):
+    """Generate documentary script with proper OpenRouter handling."""
     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 a assistant AI your task is to create script. You aren't a chatbot. So, don't write extra text
+
+
+
 Generalized Search Terms:
+
+
 If a term is too specific, make it more general for Pexels search.
+
+
+
 Scene-Specific Writing:
+
+
 Each section describes only what should be shown in the video.
+
+
+
 Output Only the Script, and also make it funny and humarous and helirous and also add to subscribe with a funny statement like subscribe now or .....
+
+
 No extra text, just the script.
+
+
+
 Example Output:
 [North Korea]
+
 Top 5 unknown facts about North Korea.
+
 [Invisibility]
+
 North Korea’s internet speed is so fast… it doesn’t exist.
+
 [Leadership]
+
 Kim Jong-un once won an election with 100% votes… against himself.
+
 [Magic]
+
 North Korea discovered time travel. That’s why their news is always from the past.
+
 [Warning]
+
 Subscribe now, or Kim Jong-un will send you a free one-way ticket… to North Korea.
+
 [Freedom]
+
 North Korean citizens can do anything… as long as it's government-approved.
 Now here is the Topic/scrip: {user_input}
 """
+
     data = {
         'model': OPENROUTER_MODEL,
         'messages': [{'role': 'user', 'content': prompt}],
         'temperature': 0.4,
         'max_tokens': 5000
     }
+
     try:
         response = requests.post(
             'https://openrouter.ai/api/v1/chat/completions',
@@ -97,6 +162,7 @@ Now here is the Topic/scrip: {user_input}
             json=data,
             timeout=30
         )
+
         if response.status_code == 200:
             response_data = response.json()
             if 'choices' in response_data and len(response_data['choices']) > 0:
@@ -107,14 +173,22 @@ Now here is the Topic/scrip: {user_input}
         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.
+    For each section, create two elements:
+      - A 'media' element using the section title as the visual prompt.
+      - A 'tts' element with the narration text, voice info, and computed duration.
+    """
     sections = {}
     current_title = None
     current_text = ""
+
     try:
         for line in script_text.splitlines():
             line = line.strip()
@@ -128,50 +202,63 @@ def parse_script(script_text):
                     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."""
     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 in {retry_delay} seconds...")
                     time.sleep(retry_delay)
@@ -184,6 +271,7 @@ def search_pexels_videos(query, pexels_api_key):
                         retry_delay *= 2
                     else:
                         break
+
             except requests.exceptions.RequestException as e:
                 print(f"Request exception: {e}")
                 if attempt < max_retries - 1:
@@ -192,6 +280,7 @@ def search_pexels_videos(query, pexels_api_key):
                     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")
@@ -201,14 +290,18 @@ def search_pexels_videos(query, pexels_api_key):
         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", [])
@@ -219,6 +312,7 @@ def search_pexels_images(query, pexels_api_key):
                 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 in {retry_delay} seconds...")
                 time.sleep(retry_delay)
@@ -229,27 +323,32 @@ def search_pexels_images(query, pexels_api_key):
                     print(f"Retrying in {retry_delay} seconds...")
                     time.sleep(retry_delay)
                     retry_delay *= 2
+
         except requests.exceptions.RequestException as e:
             print(f"Request exception: {e}")
             if attempt < max_retries - 1:
                 print(f"Retrying in {retry_delay} seconds...")
                 time.sleep(retry_delay)
                 retry_delay *= 2
+
     print(f"No Pexels images found for query: {query} after all attempts")
     return None
 
 def search_google_images(query):
+    """Search for images on Google Images (for news-related 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:
@@ -260,15 +359,19 @@ def search_google_images(query):
         return None
 
 def download_image(image_url, filename):
+    """Download an image from a URL to a local file with enhanced error handling."""
     try:
         headers = {"User-Agent": USER_AGENT}
         print(f"Downloading image from: {image_url} to {filename}")
         response = requests.get(image_url, headers=headers, stream=True, timeout=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 successfully to: {filename}")
+
         try:
             img = Image.open(filename)
             img.verify()
@@ -283,6 +386,7 @@ def download_image(image_url, filename):
             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):
@@ -295,6 +399,7 @@ def download_image(image_url, 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()
@@ -310,7 +415,13 @@ 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 first searching for a video or using a specific search strategy.
+    For news-related queries, use Google Images.
+    Returns a dict: {'path': <file_path>, 'asset_type': 'video' or 'image'}.
+    """
     safe_prompt = re.sub(r'[^\w\s-]', '', prompt).strip().replace(' ', '_')
+
     if "news" in prompt.lower():
         print(f"News-related query detected: {prompt}. Using Google Images...")
         image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}_news.jpg")
@@ -322,6 +433,7 @@ def generate_media(prompt, user_image=None, current_index=0, total_segments=1):
                 return {"path": downloaded_image, "asset_type": "image"}
         else:
             print(f"Google Images search failed for prompt: {prompt}")
+
     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)
@@ -332,6 +444,7 @@ def generate_media(prompt, user_image=None, current_index=0, total_segments=1):
                 return {"path": downloaded_video, "asset_type": "video"}
         else:
             print(f"Pexels video search failed for prompt: {prompt}")
+
     image_file = os.path.join(TEMP_FOLDER, f"{safe_prompt}.jpg")
     image_url = search_pexels_images(prompt, PEXELS_API_KEY)
     if image_url:
@@ -341,6 +454,7 @@ def generate_media(prompt, user_image=None, current_index=0, total_segments=1):
             return {"path": downloaded_image, "asset_type": "image"}
         else:
             print(f"Pexels image download failed for prompt: {prompt}")
+
     fallback_terms = ["nature", "people", "landscape", "technology", "business"]
     for term in fallback_terms:
         print(f"Trying fallback image search with term: {term}")
@@ -355,10 +469,12 @@ def generate_media(prompt, user_image=None, current_index=0, total_segments=1):
                 print(f"Fallback image download failed for term: {term}")
         else:
             print(f"Fallback image search failed for term: {term}")
+
     print(f"Failed to generate visual asset for prompt: {prompt}")
     return None
 
 def generate_silent_audio(duration, sample_rate=24000):
+    """Generate a silent WAV audio file lasting 'duration' seconds."""
     num_samples = int(duration * sample_rate)
     silence = np.zeros(num_samples, dtype=np.float32)
     silent_path = os.path.join(TEMP_FOLDER, f"silent_{int(time.time())}.wav")
@@ -366,15 +482,20 @@ def generate_silent_audio(duration, sample_rate=24000):
     print(f"Silent audio generated: {silent_path}")
     return silent_path
 
-def generate_tts(text, voice, voice_speed):
+def generate_tts(text, voice):
+    """
+    Generate TTS audio using Kokoro, falling back to gTTS or silent audio if needed.
+    """
     safe_text = re.sub(r'[^\w\s-]', '', text[:10]).strip().replace(' ', '_')
     file_path = os.path.join(TEMP_FOLDER, f"tts_{safe_text}.wav")
+
     if os.path.exists(file_path):
         print(f"Using cached TTS for text '{text[:10]}...'")
         return file_path
+
     try:
-        kokoro_voice = voice
-        generator = pipeline(text, voice=kokoro_voice, speed=voice_speed, split_pattern=r'\n+')
+        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)
@@ -399,25 +520,31 @@ def generate_tts(text, voice, voice_speed):
             return generate_silent_audio(duration=max(3, len(text.split()) * 0.5))
 
 def apply_kenburns_effect(clip, target_resolution, effect_type=None):
+    """Apply a smooth Ken Burns effect with a single movement pattern."""
     target_w, target_h = target_resolution
     clip_aspect = clip.w / clip.h
     target_aspect = target_w / target_h
+
     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
@@ -445,6 +572,7 @@ def apply_kenburns_effect(clip, target_resolution, effect_type=None):
         end_center = (target_w / 2, target_h / 2)
     else:
         raise ValueError(f"Unsupported effect_type: {effect_type}")
+
     def transform_frame(get_frame, t):
         frame = get_frame(t)
         ratio = t / clip.duration if clip.duration > 0 else 0
@@ -463,12 +591,15 @@ def apply_kenburns_effect(clip, target_resolution, effect_type=None):
         cropped_frame = cv2.getRectSubPix(frame, (crop_w, crop_h), (current_center_x, current_center_y))
         resized_frame = cv2.resize(cropped_frame, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
         return resized_frame
+
     return clip.fl(transform_frame)
 
 def resize_to_fill(clip, target_resolution):
+    """Resize and crop a clip to fill the target resolution while maintaining aspect ratio."""
     target_w, target_h = target_resolution
     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
@@ -477,9 +608,22 @@ def resize_to_fill(clip, target_resolution):
         clip = clip.resize(width=target_w)
         crop_amount = (clip.h - target_h) / 2
         clip = clip.crop(x1=0, x2=clip.w, y1=crop_amount, y2=clip.h - crop_amount)
+
     return clip
 
+def find_mp3_files():
+    """Search for any MP3 files in the current directory and subdirectories."""
+    mp3_files = []
+    for root, dirs, files in os.walk('.'):
+        for file in files:
+            if file.endswith('.mp3'):
+                mp3_path = os.path.join(root, file)
+                mp3_files.append(mp3_path)
+                print(f"Found MP3 file: {mp3_path}")
+    return mp3_files[0] if mp3_files else None
+
 def add_background_music(final_video, bg_music_volume=0.10):
+    """Add background music to the final video using any MP3 file found."""
     try:
         bg_music_path = "music.mp3"
         if bg_music_path and os.path.exists(bg_music_path):
@@ -503,15 +647,18 @@ def add_background_music(final_video, bg_music_volume=0.10):
         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, caption_color="white", caption_font_size=45, transition_effect="fade"):
+def create_clip(media_path, asset_type, tts_path, duration=None, effects=None, narration_text=None, segment_index=0):
+    """Create a video clip with synchronized subtitles and narration."""
     try:
         print(f"Creating clip #{segment_index} with asset_type: {asset_type}, media_path: {media_path}")
         if not os.path.exists(media_path) or not os.path.exists(tts_path):
             print("Missing media or TTS file")
             return None
+
         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)
@@ -531,7 +678,8 @@ def create_clip(media_path, asset_type, tts_path, duration=None, effects=None, n
             clip = clip.fadein(0.3).fadeout(0.3)
         else:
             return None
-        if narration_text and caption_color != "transparent":
+
+        if narration_text and CAPTION_COLOR != "transparent":
             try:
                 words = narration_text.split()
                 chunks = []
@@ -543,42 +691,42 @@ def create_clip(media_path, asset_type, tts_path, duration=None, effects=None, n
                         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=caption_font_size,
+                        fontsize=45,
                         font='Arial-Bold',
-                        color=caption_color,
+                        color=CAPTION_COLOR,
                         bg_color='rgba(0, 0, 0, 0.25)',
                         method='caption',
                         align='center',
                         stroke_width=2,
-                        stroke_color=caption_color,
+                        stroke_color=CAPTION_COLOR,
                         size=(TARGET_RESOLUTION[0] * 0.8, None)
                     ).set_start(start_time).set_end(end_time)
                     txt_clip = txt_clip.set_position(('center', subtitle_y_position))
                     subtitle_clips.append(txt_clip)
+
                 clip = CompositeVideoClip([clip] + subtitle_clips)
             except Exception as sub_error:
                 print(f"Subtitle error: {sub_error}")
                 txt_clip = TextClip(
                     narration_text,
-                    fontsize=caption_font_size,
-                    color=caption_color,
+                    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)
-        if transition_effect == "fade":
-            clip = clip.crossfadein(0.5)
-        elif transition_effect == "slide":
-            clip = clip.set_position(lambda t: ('center', -TARGET_RESOLUTION[1] + t * TARGET_RESOLUTION[1] / clip.duration))
         print(f"Clip created: {clip.duration:.1f}s")
         return clip
     except Exception as e:
@@ -586,6 +734,7 @@ def create_clip(media_path, asset_type, tts_path, duration=None, effects=None, n
         return None
 
 def fix_imagemagick_policy():
+    """Fix ImageMagick security policies."""
     try:
         print("Attempting to fix ImageMagick security policies...")
         policy_paths = [
@@ -609,45 +758,31 @@ def fix_imagemagick_policy():
         print(f"Error fixing policies: {e}")
         return False
 
-def handle_music_upload(music_file):
-    if music_file:
-        music_path = "music.mp3"
-        try:
-            if isinstance(music_file, str):
-                shutil.copy(music_file, music_path)
-            else:
-                with open(music_path, 'wb') as f:
-                    f.write(music_file.read())
-            print(f"Music file uploaded and renamed to {music_path}")
-            return music_path
-        except Exception as e:
-            print(f"Error handling music upload: {e}")
-            return None
-    return None
+# ---------------- Main Function with Gradio Integration ---------------- #
+def generate_video(user_input, resolution, caption_option):
+    """Generate a video based on user input via Gradio."""
+    global TARGET_RESOLUTION, CAPTION_COLOR, TEMP_FOLDER
+    import shutil
 
-def generate_video(user_input, resolution, caption_option, voice_option, voice_speed, music_file, caption_color, caption_font_size, fps, preset, transition_effect, bitrate):
-    global TARGET_RESOLUTION, CAPTION_COLOR, CAPTION_FONT_SIZE, TEMP_FOLDER
-    import Shri
     # Set resolution
     if resolution == "Full":
         TARGET_RESOLUTION = (1920, 1080)
     elif resolution == "Short":
         TARGET_RESOLUTION = (1080, 1920)
-    elif resolution == "Square":
-        TARGET_RESOLUTION = (1080, 1080)
     else:
-        TARGET_RESOLUTION = (1920, 1080)
-    # Set caption settings
-    CAPTION_COLOR = caption_color if caption_option == "Yes" else "transparent"
-    CAPTION_FONT_SIZE = caption_font_size
+        TARGET_RESOLUTION = (1920, 1080)  # Default
+
+    # Set caption color
+    CAPTION_COLOR = "white" if caption_option == "Yes" else "transparent"
+
     # Create a unique temporary folder
     TEMP_FOLDER = tempfile.mkdtemp()
-    # Handle music upload
-    handle_music_upload(music_file)
+
     # Fix ImageMagick policy
     fix_success = fix_imagemagick_policy()
     if not fix_success:
         print("Will use alternative methods if needed")
+
     print("Generating script from API...")
     script = generate_script(user_input)
     if not script:
@@ -661,14 +796,17 @@ def generate_video(user_input, resolution, caption_option, voice_option, voice_s
         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']}'")
@@ -676,7 +814,7 @@ def generate_video(user_input, resolution, caption_option, voice_option, voice_s
         if not media_asset:
             print(f"Skipping segment {idx+1} due to missing media asset.")
             continue
-        tts_path = generate_tts(tts_elem['text'], voice_option, voice_speed)
+        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
@@ -687,107 +825,68 @@ def generate_video(user_input, resolution, caption_option, voice_option, voice_s
             duration=tts_elem['duration'],
             effects=media_elem.get('effects', 'fade-in'),
             narration_text=tts_elem['text'],
-            segment_index=idx,
-            caption_color=CAPTION_COLOR,
-            caption_font_size=CAPTION_FONT_SIZE,
-            transition_effect=transition_effect
+            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", transition=TextClip("", duration=0.5) if transition_effect == "fade" else None)
+    final_video = concatenate_videoclips(clips, method="compose")
     final_video = add_background_music(final_video, bg_music_volume=0.08)
+
     print(f"Exporting final video to {OUTPUT_VIDEO_FILENAME}...")
-    final_video.write_videofile(
-        OUTPUT_VIDEO_FILENAME,
-        codec='libx264',
-        fps=fps,
-        preset=preset,
-        bitrate=f"{bitrate}k" if bitrate else None
-    )
+    final_video.write_videofile(OUTPUT_VIDEO_FILENAME, codec='libx264', fps=30, preset='veryfast')
     print(f"Final video saved as {OUTPUT_VIDEO_FILENAME}")
+
     # Clean up
     print("Cleaning up temporary files...")
     shutil.rmtree(TEMP_FOLDER)
-    if os.path.exists("music.mp3"):
-        os.remove("music.mp3")
-        print("Removed uploaded music file.")
     print("Temporary files removed.")
+
     return OUTPUT_VIDEO_FILENAME
 
-# Gradio Interface
-iface = gr.Interface(
-    fn=generate_video,
-    inputs=[
-        gr.Textbox(label="Video Concept", placeholder="Enter your video concept here..."),
-        gr.Radio(["Full", "Short", "Square"], label="Resolution", value="Full"),
-        gr.Radio(["Yes", "No"], label="Captions", value="Yes"),
-        gr.Dropdown(
-            ["af_heart", "en_male", "en_female", "en_neutral"],
-            label="Voice Option",
-            value="af_heart"
-        ),
-        gr.Slider(
-            minimum=0.5,
-            maximum=1.5,
-            step=0.1,
-            label="Voice Speed",
-            value=0.9
-        ),
-        gr.File(
-            label="Upload Background Music (MP3)",
-            file_types=[".mp3"]
-        ),
-        gr.ColorPicker(
-            label="Caption Color",
-            value="#FFFFFF"
-        ),
-        gr.Slider(
-            minimum=20,
-            maximum=60,
-            step=1,
-            label="Caption Font Size",
-            value=45
-        ),
-        gr.Slider(
-            minimum=24,
-            maximum=60,
-            step=1,
-            label="FPS",
-            value=30
-        ),
-        gr.Dropdown(
-            ["ultrafast", "veryfast", "fast", "medium", "slow"],
-            label="Encoding Preset",
-            value="veryfast"
-        ),
-        gr.Dropdown(
-            ["fade", "slide", "none"],
-            label="Transition Effect",
-            value="fade"
-        ),
-        gr.Slider(
-            minimum=1000,
-            maximum=8000,
-            step=500,
-            label="Bitrate (kbps)",
-            value=4000
-        )
-    ],
-    outputs=gr.Video(label="Generated Video"),
-    title="AI Documentary Video Generator",
-    description="Create a funny documentary-style video with customizable options. Upload background music, adjust voice, captions, and video settings. Note: Generation may take several minutes on CPU."
-)
 
-# Launch the interface
-if platform.system() == "Emscripten":
-    asyncio.ensure_future(iface.launch(share=False))
-else:
-    if __name__ == "__main__":
-        asyncio.run(iface.launch(share=False))
+
+    
+def save_as_music(file):
+    if file is None:
+        return "No file uploaded!"
+    
+    new_filename = "music.mp3"
+    shutil.copy(file, new_filename)
+    return f"File saved as {new_filename}"
+
+def generate_video(concept, resolution, captions):
+    # Dummy response — replace this with your real video generation code!
+    return "https://sample-videos.com/video123/mp4/720/big_buck_bunny_720p_1mb.mp4"
+
+with gr.Blocks() as demo:
+    with gr.Tab("Upload MP3"):
+        mp3_input = gr.File(label="Upload MP3", file_types=[".mp3"])
+        mp3_output = gr.Textbox(label="Status")
+        upload_btn = gr.Button("Save as music.mp3")
+        upload_btn.click(save_as_music, inputs=mp3_input, outputs=mp3_output)
+
+    with gr.Tab("AI Video Generator"):
+        concept_input = gr.Textbox(label="Video Concept", placeholder="Enter your video concept here...")
+        resolution_input = gr.Radio(["Full", "Short"], label="Resolution", value="Full")
+        captions_input = gr.Radio(["Yes", "No"], label="Captions", value="Yes")
+        video_output = gr.Video(label="Generated Video")
+        generate_btn = gr.Button("Generate Video")
+        generate_btn.click(generate_video, 
+                           inputs=[concept_input, resolution_input, captions_input], 
+                           outputs=video_output)
+
+demo.launch(share=True)
+
+
+
+
+