Update app.py

app.py

@@ -55,6 +55,28 @@ def error(message):
     print(formatted_message)
     return formatted_message
 
+def get_music_files():
+    """Get list of available music files in the music directory."""
+    if not os.path.exists(MUSIC_DIR):
+        return ["none"]
+    
+    music_files = [f for f in os.listdir(MUSIC_DIR) if f.endswith(('.mp3', '.wav'))]
+    if not music_files:
+        return ["none"]
+    
+    return ["random"] + music_files
+
+def get_font_files():
+    """Get list of available font files in the fonts directory."""
+    if not os.path.exists(FONTS_DIR):
+        return ["default"]
+    
+    font_files = [f.split('.')[0] for f in os.listdir(FONTS_DIR) if f.endswith(('.ttf', '.otf'))]
+    if not font_files:
+        return ["default"]
+    
+    return ["default"] + font_files
+
 def choose_random_music():
     """Selects a random music file from the music directory."""
     if not os.path.exists(MUSIC_DIR):
@@ -70,11 +92,13 @@ def choose_random_music():
 
 class YouTube:
     def __init__(self, niche: str, language: str, 
-                 text_gen="gemini", text_model="gemini-2.0-flash", 
-                 image_gen="prodia", image_model="sdxl", 
-                 tts_engine="elevenlabs", tts_voice="Sarah", 
-                 subtitle_font="Helvetica-Bold", font_size=80, 
-                 text_color="white", highlight_color="blue", 
+                 text_gen="g4f", text_model="gpt-4", 
+                 image_gen="g4f", image_model="flux", 
+                 tts_engine="edge", tts_voice="en-US-AriaNeural", 
+                 subtitle_font="default", font_size=80, 
+                 text_color="white", highlight_color="blue",
+                 subtitles_enabled=True, highlighting_enabled=True,
+                 subtitle_position="bottom", music_file="random",
                  api_keys=None, progress=gr.Progress()) -> None:
         
         """Initialize the YouTube Shorts Generator."""
@@ -95,6 +119,10 @@ class YouTube:
         self.font_size = font_size
         self.text_color = text_color
         self.highlight_color = highlight_color
+        self.subtitles_enabled = subtitles_enabled
+        self.highlighting_enabled = highlighting_enabled
+        self.subtitle_position = subtitle_position
+        self.music_file = music_file
         self.api_keys = api_keys or {}
         self.images = []
         self.logs = []
@@ -120,6 +148,8 @@ class YouTube:
         self.log(f"Text generator: {text_gen} - Model: {text_model}")
         self.log(f"Image generator: {image_gen} - Model: {image_model}")
         self.log(f"TTS engine: {tts_engine} - Voice: {tts_voice}")
+        self.log(f"Subtitles: {'Enabled' if subtitles_enabled else 'Disabled'} - Highlighting: {'Enabled' if highlighting_enabled else 'Disabled'}")
+        self.log(f"Music: {music_file}")
     
     def log(self, message):
         """Add a log message to the logs list."""
@@ -158,7 +188,7 @@ class YouTube:
             elif self.text_gen == "g4f":
                 self.log("Using G4F for text generation")
                 import g4f
-                model_to_use = model if model else "gpt-3.5-turbo"
+                model_to_use = model if model else self.text_model
                 self.log(f"Using G4F model: {model_to_use}")
                 response = g4f.ChatCompletion.create(
                     model=model_to_use,
@@ -687,6 +717,10 @@ class YouTube:
 
     def generate_subtitles(self, audio_path):
         """Generate word-level subtitles for the video."""
+        if not self.subtitles_enabled:
+            self.log("Subtitles are disabled. Skipping subtitle generation.")
+            return None
+            
         self.progress(0.65, desc="Creating subtitles")
         self.log("Starting subtitle generation process")
 
@@ -726,7 +760,7 @@ class YouTube:
             FONT = self.subtitle_font
             FONTSIZE = self.font_size
             COLOR = self.text_color
-            BG_COLOR = self.highlight_color
+            BG_COLOR = self.highlight_color if self.highlighting_enabled else None
             FRAME_SIZE = (1080, 1920)
             MAX_CHARS = 30
             MAX_DURATION = 3.0
@@ -777,7 +811,15 @@ class YouTube:
             self.log(success(f"Generated {len(subtitles)} subtitle lines"))
             return {
                 "wordlevel": wordlevel_info,
-                "linelevel": subtitles
+                "linelevel": subtitles,
+                "settings": {
+                    "font": FONT,
+                    "fontsize": FONTSIZE,
+                    "color": COLOR,
+                    "bg_color": BG_COLOR,
+                    "position": self.subtitle_position,
+                    "highlighting_enabled": self.highlighting_enabled
+                }
             }
             
         except Exception as e:
@@ -854,9 +896,20 @@ class YouTube:
         
         self.log(success(f"Generated {len(wordlevel_info)} simulated word timings and {len(subtitles)} subtitle lines"))
         
+        # Define settings for subtitle display
+        settings = {
+            "font": self.subtitle_font,
+            "fontsize": self.font_size,
+            "color": self.text_color,
+            "bg_color": self.highlight_color if self.highlighting_enabled else None,
+            "position": self.subtitle_position,
+            "highlighting_enabled": self.highlighting_enabled
+        }
+        
         return {
             "wordlevel": wordlevel_info,
-            "linelevel": subtitles
+            "linelevel": subtitles,
+            "settings": settings
         }
 
     def combine(self) -> str:
@@ -937,11 +990,16 @@ class YouTube:
             final_clip = final_clip.set_fps(30)
             
             # Add background music if available
-            background_music = choose_random_music()
-            if background_music and os.path.exists(background_music):
-                self.log(f"Adding background music: {background_music}")
+            music_path = None
+            if self.music_file == "random":
+                music_path = choose_random_music()
+            elif self.music_file != "none" and os.path.exists(os.path.join(MUSIC_DIR, self.music_file)):
+                music_path = os.path.join(MUSIC_DIR, self.music_file)
+                
+            if music_path and os.path.exists(music_path):
+                self.log(f"Adding background music: {music_path}")
                 try:
-                    music_clip = AudioFileClip(background_music)
+                    music_clip = AudioFileClip(music_path)
                     # Loop music if it's shorter than the video
                     if music_clip.duration < max_duration:
                         repeats = int(max_duration / music_clip.duration) + 1
@@ -964,58 +1022,86 @@ class YouTube:
             # Set final duration
             final_clip = final_clip.set_duration(tts_clip.duration)
             
-            # Generate subtitles if available
+            # Generate subtitles if enabled
             subtitle_clips = []
-            subtitles = self.generate_subtitles(self.tts_path)
-            
-            if subtitles and 'wordlevel' in subtitles:
-                self.log("Adding word-level subtitles")
+            if self.subtitles_enabled:
+                subtitles = self.generate_subtitles(self.tts_path)
                 
-                from moviepy.video.tools.subtitles import TextClip
-                
-                # Define subtitle styles
-                font = self.subtitle_font if os.path.exists(os.path.join(FONTS_DIR, f"{self.subtitle_font}.ttf")) else None
-                fontsize = self.font_size
-                color = self.text_color
-                bg_color = self.highlight_color
-                
-                # Add subtitles as highlighted words
-                for subtitle in subtitles['linelevel']:
-                    full_duration = subtitle['end'] - subtitle['start']
+                if subtitles and 'wordlevel' in subtitles:
+                    self.log("Adding word-level subtitles")
                     
-                    # Calculate position on screen (bottom centered)
-                    frame_width, frame_height = 1080, 1920
-                    x_pos = 0
-                    y_pos = frame_height * 0.85  # Position at 85% of frame height
-                    x_buffer = frame_width * 1 / 10
+                    from moviepy.video.tools.subtitles import TextClip
+                    
+                    # Define subtitle styles
+                    font = subtitles['settings']['font'] if subtitles['settings']['font'] != "default" and os.path.exists(os.path.join(FONTS_DIR, f"{subtitles['settings']['font']}.ttf")) else None
+                    fontsize = subtitles['settings']['fontsize']
+                    color = subtitles['settings']['color']
+                    bg_color = subtitles['settings']['bg_color'] if subtitles['settings']['highlighting_enabled'] else None
                     
-                    # Add each word with proper timing and highlighting
-                    for word_data in subtitle['words']:
-                        word = word_data['word']
-                        start = word_data['start']
-                        end = word_data['end']
+                    # Calculate position based on subtitle_position setting
+                    frame_width, frame_height = 1080, 1920
+                    if self.subtitle_position == "top":
+                        y_pos = frame_height * 0.1  # Position at 10% from top
+                    elif self.subtitle_position == "middle":
+                        y_pos = frame_height * 0.5  # Position at middle
+                    else:  # bottom (default)
+                        y_pos = frame_height * 0.85  # Position at 85% from top
+                        
+                    for subtitle in subtitles['linelevel']:
+                        full_duration = subtitle['end'] - subtitle['start']
                         
-                        # Create text clip for word
-                        try:
-                            word_clip = TextClip(
-                                txt=word, 
-                                font=font,
-                                fontsize=fontsize, 
-                                color=color,
-                                bg_color=bg_color,
-                                stroke_color='black',
-                                stroke_width=1
-                            ).set_position((x_pos + x_buffer, y_pos)).set_start(start).set_duration(end - start)
-                            
-                            subtitle_clips.append(word_clip)
-                            x_pos += word_clip.w + 10  # Add spacing between words
-                            
-                            # Wrap to next line if needed
-                            if x_pos + word_clip.w > frame_width - 2 * x_buffer:
-                                x_pos = 0
-                                y_pos += word_clip.h + 10
-                        except Exception as e:
-                            self.log(warning(f"Error creating subtitle for word '{word}': {str(e)}"))
+                        # Initialize position for each subtitle line
+                        x_pos = 0
+                        x_buffer = frame_width * 1 / 10
+                        
+                        # Handle word-level subtitles if highlighting is enabled
+                        if self.highlighting_enabled:
+                            # Add each word with proper timing and highlighting
+                            for word_data in subtitle['words']:
+                                word = word_data['word']
+                                start = word_data['start']
+                                end = word_data['end']
+                                
+                                # Create text clip for word
+                                try:
+                                    word_clip = TextClip(
+                                        txt=word, 
+                                        font=font,
+                                        fontsize=fontsize, 
+                                        color=color,
+                                        bg_color=bg_color,
+                                        stroke_color='black',
+                                        stroke_width=1
+                                    ).set_position((x_pos + x_buffer, y_pos)).set_start(start).set_duration(end - start)
+                                    
+                                    subtitle_clips.append(word_clip)
+                                    x_pos += word_clip.w + 10  # Add spacing between words
+                                    
+                                    # Wrap to next line if needed
+                                    if x_pos + word_clip.w > frame_width - 2 * x_buffer:
+                                        x_pos = 0
+                                        y_pos += word_clip.h + 10
+                                except Exception as e:
+                                    self.log(warning(f"Error creating subtitle for word '{word}': {str(e)}"))
+                        else:
+                            # Show entire line without word-level highlighting
+                            try:
+                                line_clip = TextClip(
+                                    txt=subtitle['text'], 
+                                    font=font,
+                                    fontsize=fontsize, 
+                                    color=color,
+                                    bg_color=None,
+                                    stroke_color='black',
+                                    stroke_width=1,
+                                    method='caption',
+                                    size=(frame_width - 2 * x_buffer, None),
+                                    align='center'
+                                ).set_position(('center', y_pos)).set_start(subtitle['start']).set_duration(full_duration)
+                                
+                                subtitle_clips.append(line_clip)
+                            except Exception as e:
+                                self.log(warning(f"Error creating subtitle line: {str(e)}"))
             
             # Add subtitles to video if any were created
             if subtitle_clips:
@@ -1130,18 +1216,18 @@ def get_text_generator_models(generator):
             "gemini-1.5-pro"
         ],
         "g4f": [
-            "gpt-3.5-turbo", 
-            "gpt-4", 
+            "gpt-4",
             "gpt-4o", 
+            "gpt-3.5-turbo", 
             "llama-3-70b-chat", 
             "claude-3-opus-20240229", 
             "claude-3-sonnet-20240229", 
             "claude-3-haiku-20240307"
         ],
         "openai": [
-            "gpt-3.5-turbo", 
+            "gpt-4o",
             "gpt-4-turbo", 
-            "gpt-4o"
+            "gpt-3.5-turbo"
         ]
     }
     return models.get(generator, ["default"])
@@ -1163,6 +1249,7 @@ def get_image_generator_models(generator):
             "lexica"
         ],
         "g4f": [
+            "flux",
             "dall-e-3", 
             "dall-e-2", 
             "midjourney"
@@ -1223,16 +1310,25 @@ def get_tts_voices(engine):
 
 # Create the Gradio interface
 def create_interface():
-    with gr.Blocks(title="YouTube Shorts Generator") as demo:
-        gr.Markdown("# YouTube Shorts Generator")
-        gr.Markdown("Generate engaging YouTube Shorts videos with just a niche and language selection.")
-        
+    with gr.Blocks(theme=gr.themes.Soft(primary_hue="indigo"), title="YouTube Shorts Generator") as demo:
         with gr.Row():
-            with gr.Column(scale=1):
-                # Main Inputs
+            gr.Markdown(
+                """
+                # 📱 YouTube Shorts Generator
+                Generate engaging YouTube Shorts videos with AI. Just provide a niche and language to get started!
+                """
+            )
+            
+        with gr.Row(equal_height=True):
+            # Left panel: Content Settings
+            with gr.Column(scale=1, min_width=400):
                 with gr.Group():
-                    gr.Markdown("### Required Inputs")
-                    niche = gr.Textbox(label="Niche/Topic", placeholder="E.g., Fitness tips, Technology facts, Travel destinations")
+                    gr.Markdown("### 📝 Content")
+                    niche = gr.Textbox(
+                        label="Niche/Topic", 
+                        placeholder="What's your video about?",
+                        value="Historical Facts"
+                    )
                     language = gr.Dropdown(
                         choices=["English", "Spanish", "French", "German", "Italian", "Portuguese", 
                                 "Russian", "Japanese", "Chinese", "Hindi"],
@@ -1240,8 +1336,78 @@ def create_interface():
                         value="English"
                     )
                 
-                # API Keys
-                with gr.Accordion("API Keys", open=False):
+                # Middle panel: Generator Settings
+                with gr.Group():
+                    gr.Markdown("### 🔧 Generator Settings")
+                    with gr.Tabs():
+                        with gr.TabItem("Text"):
+                            text_gen = gr.Dropdown(
+                                choices=["g4f", "gemini", "openai"], 
+                                label="Text Generator",
+                                value="g4f"
+                            )
+                            text_model = gr.Dropdown(
+                                choices=get_text_generator_models("g4f"), 
+                                label="Text Model",
+                                value="gpt-4"
+                            )
+                        
+                        with gr.TabItem("Image"):
+                            image_gen = gr.Dropdown(
+                                choices=["g4f", "prodia", "hercai", "segmind", "pollinations"],
+                                label="Image Generator",
+                                value="g4f"
+                            )
+                            image_model = gr.Dropdown(
+                                choices=get_image_generator_models("g4f"),
+                                label="Image Model",
+                                value="flux"
+                            )
+                        
+                        with gr.TabItem("Audio"):
+                            tts_engine = gr.Dropdown(
+                                choices=["edge", "elevenlabs", "gtts", "openai"],
+                                label="Speech Engine",
+                                value="edge"
+                            )
+                            tts_voice = gr.Dropdown(
+                                choices=get_tts_voices("edge"),
+                                label="Voice",
+                                value="en-US-AriaNeural"
+                            )
+                            music_file = gr.Dropdown(
+                                choices=get_music_files(),
+                                label="Background Music",
+                                value="random"
+                            )
+                        
+                        with gr.TabItem("Subtitles"):
+                            subtitles_enabled = gr.Checkbox(label="Enable Subtitles", value=True)
+                            highlighting_enabled = gr.Checkbox(label="Enable Word Highlighting", value=True)
+                            subtitle_font = gr.Dropdown(
+                                choices=get_font_files(),
+                                label="Font",
+                                value="default"
+                            )
+                            with gr.Row():
+                                font_size = gr.Slider(
+                                    minimum=40,
+                                    maximum=120,
+                                    value=80,
+                                    step=5,
+                                    label="Font Size"
+                                )
+                                subtitle_position = gr.Dropdown(
+                                    choices=["bottom", "middle", "top"],
+                                    label="Position",
+                                    value="bottom"
+                                )
+                            with gr.Row():
+                                text_color = gr.ColorPicker(label="Text Color", value="#FFFFFF")
+                                highlight_color = gr.ColorPicker(label="Highlight Color", value="#0000FF")
+                
+                # API Keys section
+                with gr.Accordion("🔑 API Keys", open=False):
                     gemini_api_key = gr.Textbox(
                         label="Gemini API Key", 
                         type="password",
@@ -1268,78 +1434,22 @@ def create_interface():
                         value=os.environ.get("OPENAI_API_KEY", "")
                     )
                 
-                # Model Selection
-                with gr.Accordion("Model Selection", open=True):
-                    # Text Generator
-                    text_gen = gr.Dropdown(
-                        choices=["gemini", "g4f", "openai"], 
-                        label="Text Generator",
-                        value="gemini"
-                    )
-                    text_model = gr.Dropdown(
-                        choices=get_text_generator_models("gemini"), 
-                        label="Text Model",
-                        value="gemini-2.0-flash"
-                    )
-                    
-                    # Image Generator
-                    image_gen = gr.Dropdown(
-                        choices=["prodia", "hercai", "g4f", "segmind", "pollinations"],
-                        label="Image Generator",
-                        value="prodia"
-                    )
-                    image_model = gr.Dropdown(
-                        choices=get_image_generator_models("prodia"),
-                        label="Image Model",
-                        value="sdxl"
-                    )
-                    
-                    # TTS Engine
-                    tts_engine = gr.Dropdown(
-                        choices=["elevenlabs", "gtts", "openai", "edge"],
-                        label="Text-to-Speech Engine",
-                        value="elevenlabs"
-                    )
-                    tts_voice = gr.Dropdown(
-                        choices=get_tts_voices("elevenlabs"),
-                        label="TTS Voice",
-                        value="Sarah"
-                    )
-                
-                # Subtitle Options
-                with gr.Accordion("Subtitle Options", open=False):
-                    subtitle_font = gr.Dropdown(
-                        choices=["Helvetica-Bold", "Arial-Bold", "Impact", "Comic-Sans-MS"],
-                        label="Font",
-                        value="Helvetica-Bold"
-                    )
-                    font_size = gr.Slider(
-                        minimum=40,
-                        maximum=120,
-                        value=80,
-                        step=5,
-                        label="Font Size"
-                    )
-                    
-                    with gr.Row():
-                        text_color = gr.ColorPicker(label="Text Color", value="#FFFFFF")
-                        highlight_color = gr.ColorPicker(label="Highlight Color", value="#0000FF")
-                
                 # Generate button
-                generate_btn = gr.Button("Generate Video", variant="primary")
-                
-            with gr.Column(scale=1):
-                # Output display
-                video_output = gr.Video(label="Generated Video")
-                
+                generate_btn = gr.Button("🎬 Generate Video", variant="primary", size="lg")
+            
+            # Right panel: Output display
+            with gr.Column(scale=1, min_width=400):
                 with gr.Tabs():
+                    with gr.TabItem("Video", selected=True):
+                        video_output = gr.Video(label="Generated Video", height=600)
+                        
                     with gr.TabItem("Metadata"):
-                        title_output = gr.Textbox(label="Title")
-                        description_output = gr.Textbox(label="Description", lines=3)
-                        script_output = gr.Textbox(label="Script", lines=5)
-                    
-                    with gr.TabItem("Logs"):
-                        log_output = gr.Textbox(label="Process Log", lines=10)
+                        title_output = gr.Textbox(label="Title", lines=2)
+                        description_output = gr.Textbox(label="Description", lines=4)
+                        script_output = gr.Textbox(label="Script", lines=8)
+                        
+                    with gr.TabItem("Log"):
+                        log_output = gr.Textbox(label="Process Log", lines=20, max_lines=100)
         
         # Dynamic dropdown updates
         def update_text_models(generator):
@@ -1360,8 +1470,9 @@ def create_interface():
         def generate_youtube_short(niche, language, gemini_api_key, assemblyai_api_key, 
                                   elevenlabs_api_key, segmind_api_key, openai_api_key,
                                   text_gen, text_model, image_gen, image_model, 
-                                  tts_engine, tts_voice, subtitle_font, font_size, 
-                                  text_color, highlight_color, progress=gr.Progress()):
+                                  tts_engine, tts_voice, subtitles_enabled, highlighting_enabled,
+                                  subtitle_font, font_size, subtitle_position, 
+                                  text_color, highlight_color, music_file, progress=gr.Progress()):
             
             if not niche.strip():
                 return {
@@ -1396,6 +1507,10 @@ def create_interface():
                     font_size=font_size,
                     text_color=text_color,
                     highlight_color=highlight_color,
+                    subtitles_enabled=subtitles_enabled,
+                    highlighting_enabled=highlighting_enabled,
+                    subtitle_position=subtitle_position,
+                    music_file=music_file,
                     api_keys=api_keys,
                     progress=progress
                 )
@@ -1438,11 +1553,25 @@ def create_interface():
             inputs=[
                 niche, language, gemini_api_key, assemblyai_api_key, elevenlabs_api_key,
                 segmind_api_key, openai_api_key, text_gen, text_model, image_gen, image_model,
-                tts_engine, tts_voice, subtitle_font, font_size, text_color, highlight_color
+                tts_engine, tts_voice, subtitles_enabled, highlighting_enabled,
+                subtitle_font, font_size, subtitle_position, text_color, highlight_color, music_file
             ],
             outputs=[video_output, title_output, description_output, script_output, log_output]
         )
         
+        # Add examples
+        gr.Examples(
+            [
+                ["Historical Facts", "English", "g4f", "gpt-4", "g4f", "flux", "edge", "en-US-AriaNeural", True, True, "default", 80, "bottom", "#FFFFFF", "#0000FF", "random"],
+                ["Cooking Tips", "English", "g4f", "gpt-4", "g4f", "flux", "edge", "en-US-AriaNeural", True, True, "default", 80, "bottom", "#FFFFFF", "#FF0000", "random"],
+                ["Technology News", "English", "g4f", "gpt-4", "g4f", "flux", "edge", "en-US-GuyNeural", True, True, "default", 80, "bottom", "#FFFFFF", "#00FF00", "random"],
+            ],
+            [niche, language, text_gen, text_model, image_gen, image_model, tts_engine, tts_voice, 
+             subtitles_enabled, highlighting_enabled, subtitle_font, font_size, 
+             subtitle_position, text_color, highlight_color, music_file],
+            label="Quick Start Templates"
+        )
+        
     return demo
 
 # Create and launch the interface