Update app.py

app.py

@@ -1,28 +1,35 @@
 # Import necessary libraries
-from kokoro import KPipeline
-import soundfile as sf
 import os
-from moviepy.editor import (
-    VideoFileClip, concatenate_videoclips, AudioFileClip, ImageClip,
-    CompositeVideoClip, TextClip
-)
-import moviepy.video.fx.all as vfx
-import moviepy.config as mpy_config
-from pydub import AudioSegment
-from PIL import Image
-import tempfile
+import re
 import random
-import cv2
 import math
+import shutil
+import tempfile
 import requests
+from urllib.parse import quote
+from bs4 import BeautifulSoup
+import numpy as np
+from PIL import Image
+import cv2
+from pydub import AudioSegment
 from gtts import gTTS
 import gradio as gr
-import numpy as np
-import shutil
+import soundfile as sf
+from moviepy.editor import (
+    VideoFileClip, concatenate_videoclips, AudioFileClip, ImageClip,
+    CompositeVideoClip, TextClip, CompositeAudioClip
+)
+import moviepy.video.fx.all as vfx
+import moviepy.config as mpy_config
 
-# Initialize Kokoro TTS pipeline
-pipeline = KPipeline(lang_code='a')
-# Ensure ImageMagick binary is set (adjust path as needed)
+# Initialize Kokoro TTS pipeline (assuming it's available; replace with dummy if not)
+try:
+    from kokoro import KPipeline
+    pipeline = KPipeline(lang_code='a')
+except ImportError:
+    pipeline = None  # Fallback to gTTS if Kokoro is unavailable
+
+# Ensure ImageMagick binary is set (adjust path as needed for your system)
 mpy_config.change_settings({"IMAGEMAGICK_BINARY": "/usr/bin/convert"})
 
 # Global Configuration
@@ -36,7 +43,9 @@ MAX_CLIPS = 10  # Maximum number of editable clips
 # Temporary folder setup
 TEMP_FOLDER = tempfile.mkdtemp()
 
-# Existing Helper Functions (unchanged)
+# Helper Functions
+
+## Script Generation
 def generate_script(user_input):
     headers = {
         'Authorization': f'Bearer {OPENROUTER_API_KEY}',
@@ -95,10 +104,10 @@ Now here is the Topic/scrip: {user_input}
             return response.json()['choices'][0]['message']['content']
         else:
             print(f"API Error {response.status_code}: {response.text}")
-            return None
+            return "Failed to generate script due to API error."
     except Exception as e:
         print(f"Request failed: {str(e)}")
-        return None
+        return "Oops, script generation broke. Blame the internet!"
 
 def parse_script(script_text):
     sections = {}
@@ -110,7 +119,7 @@ def parse_script(script_text):
             bracket_start = line.find("[")
             bracket_end = line.find("]", bracket_start)
             if bracket_start != -1 and bracket_end != -1:
-                if current_title is not None:
+                if current_title:
                     sections[current_title] = current_text.strip()
                 current_title = line[bracket_start+1:bracket_end]
                 current_text = line[bracket_end+1:].strip()
@@ -121,6 +130,7 @@ def parse_script(script_text):
     clips = [{"title": title, "narration": narration} for title, narration in sections.items()]
     return clips
 
+## Media Fetching
 def search_pexels_videos(query, pexels_api_key):
     headers = {'Authorization': pexels_api_key}
     url = "https://api.pexels.com/videos/search"
@@ -131,9 +141,10 @@ def search_pexels_videos(query, pexels_api_key):
             videos = response.json().get("videos", [])
             hd_videos = [v["video_files"][0]["link"] for v in videos if v["video_files"] and v["video_files"][0]["quality"] == "hd"]
             return random.choice(hd_videos) if hd_videos else None
+        return None
     except Exception as e:
         print(f"Video search error: {e}")
-    return None
+        return None
 
 def search_pexels_images(query, pexels_api_key):
     headers = {'Authorization': pexels_api_key}
@@ -144,9 +155,10 @@ def search_pexels_images(query, pexels_api_key):
         if response.status_code == 200:
             photos = response.json().get("photos", [])
             return random.choice(photos)["src"]["original"] if photos else None
+        return None
     except Exception as e:
         print(f"Image search error: {e}")
-    return None
+        return None
 
 def search_google_images(query):
     search_url = f"https://www.google.com/search?q={quote(query)}&tbm=isch"
@@ -188,9 +200,10 @@ def download_video(video_url, filename):
         print(f"Video download error: {e}")
         return None
 
+## Media and TTS Generation
 def generate_media(prompt, custom_media=None, video_prob=0.25):
-    if custom_media:
-        asset_type = "video" if custom_media.endswith(('.mp4', '.avi', '.mov')) else "image"
+    if isinstance(custom_media, str) and os.path.exists(custom_media):
+        asset_type = "video" if custom_media.lower().endswith(('.mp4', '.avi', '.mov')) else "image"
         return {"path": custom_media, "asset_type": asset_type}
     safe_prompt = re.sub(r'[^\w\s-]', '', prompt).strip().replace(' ', '_')
     if "news" in prompt.lower():
@@ -207,26 +220,33 @@ def generate_media(prompt, custom_media=None, video_prob=0.25):
     image_url = search_pexels_images(prompt, PEXELS_API_KEY)
     if image_url and download_image(image_url, image_file):
         return {"path": image_file, "asset_type": "image"}
+    print(f"No media generated for prompt: {prompt}")
     return None
 
-def generate_tts(text, voice):
+def generate_tts(text, voice='en'):
+    if not text.strip():
+        return None
     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:
-        audio_segments = [audio for _, _, audio in pipeline(text, voice='af_heart', speed=0.9, split_pattern=r'\n+')]
-        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:
-        tts = gTTS(text=text, lang='en')
-        mp3_path = os.path.join(TEMP_FOLDER, f"tts_{safe_text}.mp3")
-        tts.save(mp3_path)
-        AudioSegment.from_mp3(mp3_path).export(file_path, format="wav")
-        os.remove(mp3_path)
+        if pipeline:
+            audio_segments = [audio for _, _, audio in pipeline(text, voice='af_heart', speed=0.9, split_pattern=r'\n+')]
+            full_audio = np.concatenate(audio_segments) if len(audio_segments) > 1 else audio_segments[0]
+            sf.write(file_path, full_audio, 24000)
+        else:
+            tts = gTTS(text=text, lang=voice)
+            mp3_path = os.path.join(TEMP_FOLDER, f"tts_{safe_text}.mp3")
+            tts.save(mp3_path)
+            AudioSegment.from_mp3(mp3_path).export(file_path, format="wav")
+            os.remove(mp3_path)
         return file_path
+    except Exception as e:
+        print(f"TTS generation failed: {e}")
+        return None
 
+## Video Processing
 def apply_kenburns_effect(clip, target_resolution):
     target_w, target_h = target_resolution
     clip_aspect = clip.w / clip.h
@@ -266,8 +286,11 @@ def add_background_music(final_video, bgm_path=None, bgm_volume=0.15):
     return final_video
 
 def create_clip(media_path, asset_type, tts_path, narration_text, target_resolution, subtitles_enabled, font, font_size, outline_width, font_color, outline_color, position, zoom_pan_effect):
-    audio_clip = AudioFileClip(tts_path).audio_fadeout(0.2)
-    target_duration = audio_clip.duration + 0.2
+    if not media_path or not os.path.exists(media_path) or (tts_path and not os.path.exists(tts_path)):
+        print("Missing media or TTS file")
+        return None
+    audio_clip = AudioFileClip(tts_path).audio_fadeout(0.2) if tts_path else None
+    target_duration = audio_clip.duration + 0.2 if audio_clip else 5.0
     if asset_type == "video":
         clip = VideoFileClip(media_path)
         clip = resize_to_fill(clip, target_resolution)
@@ -277,10 +300,10 @@ def create_clip(media_path, asset_type, tts_path, narration_text, target_resolut
         if zoom_pan_effect:
             clip = apply_kenburns_effect(clip, target_resolution)
         clip = resize_to_fill(clip, target_resolution)
-    if subtitles_enabled and narration_text:
+    if subtitles_enabled and narration_text and audio_clip:
         words = narration_text.split()
         chunks = [' '.join(words[i:i+5]) for i in range(0, len(words), 5)]
-        chunk_duration = audio_clip.duration / len(chunks)
+        chunk_duration = audio_clip.duration / max(len(chunks), 1)
         subtitle_clips = []
         y_position = target_resolution[1] * (0.1 if position == "top" else 0.8 if position == "bottom" else 0.5)
         for i, chunk in enumerate(chunks):
@@ -297,9 +320,11 @@ def create_clip(media_path, asset_type, tts_path, narration_text, target_resolut
             ).set_start(i * chunk_duration).set_end((i + 1) * chunk_duration).set_position(('center', y_position))
             subtitle_clips.append(txt_clip)
         clip = CompositeVideoClip([clip] + subtitle_clips)
-    return clip.set_audio(audio_clip)
+    if audio_clip:
+        clip = clip.set_audio(audio_clip)
+    return clip
 
-# Main Video Generation Function
+## Main Video Generation Function
 def generate_video(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, *clip_data):
     target_resolution = (1080, 1920) if resolution == "Short (1080x1920)" else (1920, 1080)
     clips = []
@@ -309,21 +334,23 @@ def generate_video(resolution, render_speed, video_clip_percent, zoom_pan_effect
             media_asset = generate_media(prompt, custom_media, video_clip_percent / 100.0)
             if not media_asset:
                 continue
-            tts_path = generate_tts(narration, 'en')
+            tts_path = generate_tts(narration) if narration.strip() else None
             clip = create_clip(
                 media_asset['path'], media_asset['asset_type'], tts_path, narration, target_resolution,
                 subtitles_enabled, font, font_size, outline_width, font_color, outline_color, position, zoom_pan_effect
             )
-            clips.append(clip)
+            if clip:
+                clips.append(clip)
     if not clips:
+        print("No clips generated.")
         return None
     final_video = concatenate_videoclips(clips, method="compose")
     final_video = add_background_music(final_video, bgm_upload, bgm_volume)
-    final_video.write_videofile(OUTPUT_VIDEO_FILENAME, codec='libx264', fps=24, preset=render_speed)
+    final_video.write_videofile(OUTPUT_VIDEO_FILENAME, codec='libx264', fps=24, preset=render_speed, logger=None)
     shutil.rmtree(TEMP_FOLDER)
     return OUTPUT_VIDEO_FILENAME
 
-# Load Clips Function
+## Load Clips Function
 def load_clips(topic, script):
     raw_script = script.strip() if script.strip() else generate_script(topic)
     clips = parse_script(raw_script)[:MAX_CLIPS]
@@ -333,11 +360,14 @@ def load_clips(topic, script):
             updates.extend([
                 gr.update(value=clips[i]["title"]),
                 gr.update(value=clips[i]["narration"]),
-                gr.update(value=None),
-                gr.update(visible=True)
+                gr.update(value=None)  # Clear custom media
             ])
         else:
-            updates.extend([gr.update(value=""), gr.update(value=""), gr.update(value=None), gr.update(visible=False)])
+            updates.extend([
+                gr.update(value=""),
+                gr.update(value=""),
+                gr.update(value=None)
+            ])
     return updates
 
 # Gradio Interface
@@ -349,19 +379,18 @@ with gr.Blocks(title="🚀 Orbit Video Engine") as app:
             topic_input = gr.Textbox(label="Video Topic", placeholder="e.g., Funny Cat Facts")
             script_input = gr.Textbox(label="Or Paste Full Script", lines=10, placeholder="[Title]\nNarration...")
             generate_script_btn = gr.Button("📝 Generate Script & Load Clips")
-            generated_script_display = gr.Textbox(label="Generated Script", interactive=False)
+            generated_script_display = gr.Textbox(label="Generated Script", interactive=False, lines=10)
 
         # Column 2: Clip Editor
         with gr.Column():
             gr.Markdown("### 2. Edit Clips")
             gr.Markdown("Modify prompts, narration, and upload custom media for each clip.")
-            clip_rows, prompts, narrations, custom_medias = [], [], [], []
+            prompts, narrations, custom_medias = [], [], []
             for i in range(MAX_CLIPS):
-                with gr.Row(visible=False) as row:
-                    prompt = gr.Textbox(label="Visual Prompt")
-                    narration = gr.Textbox(label="Narration", lines=3)
-                    custom_media = gr.File(label="Upload Custom Media (Image/Video)", file_types=["image", "video"])
-                clip_rows.append(row)
+                with gr.Row():  # Always visible
+                    prompt = gr.Textbox(label=f"Clip {i+1} Visual Prompt")
+                    narration = gr.Textbox(label=f"Clip {i+1} Narration", lines=3)
+                    custom_media = gr.File(label=f"Clip {i+1} Upload Custom Media (Image/Video)", file_types=["image", "video"], value=None)
                 prompts.append(prompt)
                 narrations.append(narration)
                 custom_medias.append(custom_media)
@@ -390,14 +419,15 @@ with gr.Blocks(title="🚀 Orbit Video Engine") as app:
 
     # Event Handlers
     generate_script_btn.click(
-        load_clips,
+        fn=load_clips,
         inputs=[topic_input, script_input],
-        outputs=[generated_script_display] + prompts + narrations + custom_medias + clip_rows
+        outputs=[generated_script_display] + prompts + narrations + custom_medias
     )
     generate_video_btn.click(
-        generate_video,
+        fn=generate_video,
         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] + prompts + narrations + custom_medias,
         outputs=video_output
     )
 
+# Launch the app
 app.launch(share=True)