Update app.py

app.py

@@ -13,319 +13,378 @@ from pydub import AudioSegment
 from dotenv import load_dotenv
 import tempfile
 import spaces
+
+# Coqui TTS
 from TTS.api import TTS
 
-# -------------------------------
-# Configuration
-# -------------------------------
+# ---------------------------------------------------------------------
+# Load Environment Variables
+# ---------------------------------------------------------------------
 load_dotenv()
 HF_TOKEN = os.getenv("HF_TOKEN")
 
-MODEL_CONFIG = {
-    "llama_models": {
-        "Meta-Llama-3-8B": "meta-llama/Meta-Llama-3-8B-Instruct",
-        "Mistral-7B": "mistralai/Mistral-7B-Instruct-v0.2",
-        "Phi-3-mini": "microsoft/Phi-3-mini-4k-instruct"
-    },
-    "tts_models": {
-        "Standard English": "tts_models/en/ljspeech/tacotron2-DDC",
-        "High Quality": "tts_models/en/ljspeech/vits",
-        "Fast Inference": "tts_models/en/sam/tacotron-DDC"
-    }
-}
-
-# -------------------------------
-# Model Manager
-# -------------------------------
-class ModelManager:
-    def __init__(self):
-        self.llama_pipelines = {}
-        self.musicgen_models = {}
-        self.tts_models = {}
-
-    def get_llama_pipeline(self, model_id, token):
-        if model_id not in self.llama_pipelines:
-            tokenizer = AutoTokenizer.from_pretrained(model_id, use_auth_token=token)
-            model = AutoModelForCausalLM.from_pretrained(
-                model_id,
-                use_auth_token=token,
-                torch_dtype=torch.float16,
-                device_map="auto",
-                attn_implementation="flash_attention_2"
-            )
-            self.llama_pipelines[model_id] = pipeline(
-                "text-generation",
-                model=model,
-                tokenizer=tokenizer,
-                device_map="auto"
-            )
-        return self.llama_pipelines[model_id]
-
-    def get_musicgen_model(self, model_key="facebook/musicgen-large"):
-        if model_key not in self.musicgen_models:
-            model = MusicgenForConditionalGeneration.from_pretrained(model_key)
-            processor = AutoProcessor.from_pretrained(model_key)
-            device = "cuda" if torch.cuda.is_available() else "cpu"
-            model.to(device)
-            self.musicgen_models[model_key] = (model, processor)
-        return self.musicgen_models[model_key]
-
-    def get_tts_model(self, model_name):
-        if model_name not in self.tts_models:
-            self.tts_models[model_name] = TTS(model_name)
-        return self.tts_models[model_name]
-
-model_manager = ModelManager()
-
-# -------------------------------
-# Core Functions
-# -------------------------------
-@spaces.GPU(duration=120)
-def generate_script(user_prompt, model_id, duration, temperature=0.7, max_tokens=512):
+# ---------------------------------------------------------------------
+# Global Model Caches
+# ---------------------------------------------------------------------
+LLAMA_PIPELINES = {}
+MUSICGEN_MODELS = {}
+TTS_MODELS = {}
+
+# ---------------------------------------------------------------------
+# Helper Functions
+# ---------------------------------------------------------------------
+def get_llama_pipeline(model_id: str, token: str):
+    """
+    Returns a cached LLaMA pipeline if available; otherwise, loads it.
+    """
+    if model_id in LLAMA_PIPELINES:
+        return LLAMA_PIPELINES[model_id]
+
+    tokenizer = AutoTokenizer.from_pretrained(model_id, use_auth_token=token)
+    model = AutoModelForCausalLM.from_pretrained(
+        model_id,
+        use_auth_token=token,
+        torch_dtype=torch.float16,
+        device_map="auto",
+        trust_remote_code=True,
+    )
+    text_pipeline = pipeline("text-generation", model=model, tokenizer=tokenizer)
+    LLAMA_PIPELINES[model_id] = text_pipeline
+    return text_pipeline
+
+
+def get_musicgen_model(model_key: str = "facebook/musicgen-large"):
+    """
+    Returns a cached MusicGen model if available; otherwise, loads it.
+    Uses the 'large' variant for higher quality outputs.
+    """
+    if model_key in MUSICGEN_MODELS:
+        return MUSICGEN_MODELS[model_key]
+
+    model = MusicgenForConditionalGeneration.from_pretrained(model_key)
+    processor = AutoProcessor.from_pretrained(model_key)
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    model.to(device)
+    MUSICGEN_MODELS[model_key] = (model, processor)
+    return model, processor
+
+
+def get_tts_model(model_name: str = "tts_models/en/ljspeech/tacotron2-DDC"):
+    """
+    Returns a cached TTS model if available; otherwise, loads it.
+    """
+    if model_name in TTS_MODELS:
+        return TTS_MODELS[model_name]
+
+    tts_model = TTS(model_name)
+    TTS_MODELS[model_name] = tts_model
+    return tts_model
+
+
+# ---------------------------------------------------------------------
+# Script Generation Function
+# ---------------------------------------------------------------------
+@spaces.GPU(duration=100)
+def generate_script(user_prompt: str, model_id: str, token: str, duration: int):
+    """
+    Generates a script, sound design suggestions, and music ideas from a user prompt.
+    Returns a tuple of strings: (voice_script, sound_design, music_suggestions).
+    """
     try:
-        text_pipeline = model_manager.get_llama_pipeline(model_id, HF_TOKEN)
-        
-        system_prompt = f"""You are an expert radio imaging producer. Create content for a {duration}-second promo:
-1. Voice Script: [Clear narration]
-2. Sound Design: [3-5 effects]
-3. Music: [Genre/tempo/mood]
-
-Respond in this exact format:"""
-
-        prompt = f"{system_prompt}\nConcept: {user_prompt}\nVoice Script:"
-        
-        response = text_pipeline(
-            prompt,
-            max_new_tokens=max_tokens,
-            temperature=temperature,
-            do_sample=True,
-            top_p=0.95,
-            eos_token_id=text_pipeline.tokenizer.eos_token_id
+        text_pipeline = get_llama_pipeline(model_id, token)
+
+        system_prompt = (
+            "You are an expert radio imaging producer specializing in sound design and music. "
+            f"Based on the user's concept and the selected duration of {duration} seconds, produce the following: "
+            "1. A concise voice-over script. Prefix this section with 'Voice-Over Script:'.\n"
+            "2. Suggestions for sound design. Prefix this section with 'Sound Design Suggestions:'.\n"
+            "3. Music styles or track recommendations. Prefix this section with 'Music Suggestions:'."
         )
+        combined_prompt = f"{system_prompt}\nUser concept: {user_prompt}\nOutput:"
+
+        with torch.inference_mode():
+            result = text_pipeline(
+                combined_prompt,
+                max_new_tokens=300,
+                do_sample=True,
+                temperature=0.8
+            )
+
+        generated_text = result[0]["generated_text"]
+        if "Output:" in generated_text:
+            generated_text = generated_text.split("Output:")[-1].strip()
+
+        # Default placeholders
+        voice_script = "No voice-over script found."
+        sound_design = "No sound design suggestions found."
+        music_suggestions = "No music suggestions found."
+
+        # Voice-Over Script
+        if "Voice-Over Script:" in generated_text:
+            parts = generated_text.split("Voice-Over Script:")
+            voice_script_part = parts[1]
+            if "Sound Design Suggestions:" in voice_script_part:
+                voice_script = voice_script_part.split("Sound Design Suggestions:")[0].strip()
+            else:
+                voice_script = voice_script_part.strip()
+
+        # Sound Design
+        if "Sound Design Suggestions:" in generated_text:
+            parts = generated_text.split("Sound Design Suggestions:")
+            sound_design_part = parts[1]
+            if "Music Suggestions:" in sound_design_part:
+                sound_design = sound_design_part.split("Music Suggestions:")[0].strip()
+            else:
+                sound_design = sound_design_part.strip()
+
+        # Music Suggestions
+        if "Music Suggestions:" in generated_text:
+            parts = generated_text.split("Music Suggestions:")
+            music_suggestions = parts[1].strip()
+
+        return voice_script, sound_design, music_suggestions
 
-        return parse_generated_content(response[0]["generated_text"])
     except Exception as e:
-        return f"Error: {str(e)}", "", ""
-
-def parse_generated_content(text):
-    sections = {
-        "Voice Script": "",
-        "Sound Design": "",
-        "Music": ""
-    }
-    current_section = None
-    
-    for line in text.split('\n'):
-        line = line.strip()
-        if "Voice Script:" in line:
-            current_section = "Voice Script"
-            line = line.replace("Voice Script:", "").strip()
-        elif "Sound Design:" in line:
-            current_section = "Sound Design"
-            line = line.replace("Sound Design:", "").strip()
-        elif "Music:" in line:
-            current_section = "Music"
-            line = line.replace("Music:", "").strip()
-        
-        if current_section and line:
-            sections[current_section] += line + "\n"
-    
-    return sections["Voice Script"].strip(), sections["Sound Design"].strip(), sections["Music"].strip()
+        return f"Error generating script: {e}", "", ""
 
+
+# ---------------------------------------------------------------------
+# Voice-Over Generation Function
+# ---------------------------------------------------------------------
 @spaces.GPU(duration=100)
-def generate_voice(script, tts_model, speed=1.0):
+def generate_voice(script: str, tts_model_name: str = "tts_models/en/ljspeech/tacotron2-DDC"):
+    """
+    Generates a voice-over from the provided script using the Coqui TTS model.
+    Returns the file path to the generated .wav file.
+    """
     try:
         if not script.strip():
-            return "Error: Empty script"
-            
-        tts = model_manager.get_tts_model(tts_model)
-        output_path = os.path.join(tempfile.gettempdir(), "voice.wav")
-        
-        tts.tts_to_file(
-            text=script,
-            file_path=output_path,
-            speed=speed
-        )
+            return "Error: No script provided."
+
+        tts_model = get_tts_model(tts_model_name)
+
+        # Generate and save voice
+        output_path = os.path.join(tempfile.gettempdir(), "voice_over.wav")
+        tts_model.tts_to_file(text=script, file_path=output_path)
         return output_path
+
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"Error generating voice: {e}"
 
-@spaces.GPU(duration=150)
-def generate_music(prompt, duration_sec=30, temperature=1.0, guidance_scale=3.0):
+
+# ---------------------------------------------------------------------
+# Music Generation Function
+# ---------------------------------------------------------------------
+@spaces.GPU(duration=100)
+def generate_music(prompt: str, audio_length: int):
+    """
+    Generates music from the 'facebook/musicgen-large' model based on the prompt.
+    Returns the file path to the generated .wav file.
+    """
     try:
-        model, processor = model_manager.get_musicgen_model()
+        if not prompt.strip():
+            return "Error: No music suggestion provided."
+
+        model_key = "facebook/musicgen-large"
+        musicgen_model, musicgen_processor = get_musicgen_model(model_key)
+
         device = "cuda" if torch.cuda.is_available() else "cpu"
-        
-        inputs = processor(
-            text=[prompt],
-            padding=True,
-            return_tensors="pt",
-        ).to(device)
-
-        audio_values = model.generate(
-            **inputs,
-            max_new_tokens=int(duration_sec * 50),
-            temperature=temperature,
-            guidance_scale=guidance_scale,
-            do_sample=True
-        )
+        inputs = musicgen_processor(text=[prompt], padding=True, return_tensors="pt").to(device)
+
+        with torch.inference_mode():
+            outputs = musicgen_model.generate(**inputs, max_new_tokens=audio_length)
+
+        audio_data = outputs[0, 0].cpu().numpy()
+        normalized_audio = (audio_data / max(abs(audio_data)) * 32767).astype("int16")
+
+        output_path = f"{tempfile.gettempdir()}/musicgen_large_generated_music.wav"
+        write(output_path, 44100, normalized_audio)
 
-        output_path = os.path.join(tempfile.gettempdir(), "music.wav")
-        write(output_path, 44100, audio_values[0, 0].cpu().numpy())
         return output_path
+
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"Error generating music: {e}"
+
 
-def blend_audio(voice_path, music_path, ducking=True, duck_level=10, crossfade=500):
+# ---------------------------------------------------------------------
+# Audio Blending with Duration Sync & Ducking
+# ---------------------------------------------------------------------
+@spaces.GPU(duration=100)
+def blend_audio(voice_path: str, music_path: str, ducking: bool, duck_level: int = 10):
+    """
+    Blends two audio files (voice and music).
+    1. If music < voice, loops the music until it meets/exceeds the voice duration.
+    2. If music > voice, trims music to the voice duration.
+    3. If ducking=True, the music is attenuated by 'duck_level' dB while the voice is playing.
+    Returns the file path to the blended .wav file.
+    """
     try:
+        if not os.path.isfile(voice_path) or not os.path.isfile(music_path):
+            return "Error: Missing audio files for blending."
+
         voice = AudioSegment.from_wav(voice_path)
         music = AudioSegment.from_wav(music_path)
-        
-        # Align durations with crossfade
-        if len(music) < len(voice):
-            loops = (len(voice) // len(music)) + 1
-            music = music * loops
-        
-        music = music[:len(voice)].fade_out(crossfade)
-        voice = voice.fade_in(crossfade)
-        
-        # Apply ducking
+
+        voice_len = len(voice)  # in milliseconds
+        music_len = len(music)  # in milliseconds
+
+        # 1) If the music is shorter than the voice, loop it:
+        if music_len < voice_len:
+            looped_music = AudioSegment.empty()
+            # Keep appending until we exceed voice length
+            while len(looped_music) < voice_len:
+                looped_music += music
+            music = looped_music
+
+        # 2) If the music is longer than the voice, truncate it:
+        if len(music) > voice_len:
+            music = music[:voice_len]
+
+        # Now music and voice are the same length
         if ducking:
+            # Step 1: Reduce music dB while voice is playing
             ducked_music = music - duck_level
-            mixed = ducked_music.overlay(voice)
+            # Step 2: Overlay voice on top of ducked music
+            final_audio = ducked_music.overlay(voice)
         else:
-            mixed = music.overlay(voice)
-            
-        output_path = os.path.join(tempfile.gettempdir(), "final_mix.wav")
-        mixed.export(output_path, format="wav")
+            # No ducking, just overlay
+            final_audio = music.overlay(voice)
+
+        output_path = os.path.join(tempfile.gettempdir(), "blended_output.wav")
+        final_audio.export(output_path, format="wav")
         return output_path
+
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"Error blending audio: {e}"
 
-# -------------------------------
-# Gradio Interface
-# -------------------------------
-theme = gr.themes.Soft(
-    primary_hue="blue",
-    secondary_hue="teal",
-).set(
-    body_text_color_dark='#FFFFFF',
-    background_fill_primary_dark='#1F1F1F'
-)
 
-with gr.Blocks(theme=theme, title="AI Radio Studio Pro") as demo:
+# ---------------------------------------------------------------------
+# Gradio Interface
+# ---------------------------------------------------------------------
+with gr.Blocks() as demo:
     gr.Markdown("""
-    # 🎧 AI Radio Studio Pro
-    *Professional Audio Production in 4 Steps*
-    """)
+# 🎧 AI Promo Studio
+Welcome to **AI Promo Studio**, your all-in-one solution for creating professional, engaging audio promos with minimal effort!  
+
+This next-generation platform uses powerful AI models to handle:
+- **Script Generation**: Craft concise and impactful copy with LLaMA.
+- **Voice Synthesis**: Convert text into natural-sounding voice-overs using Coqui TTS.
+- **Music Production**: Generate custom music tracks with MusicGen Large for sound bed.
+- **Seamless Blending**: Easily combine voice and music—loop or trim tracks to match your desired promo length, with optional ducking to keep the voice front and center.
+
+Whether you’re a radio producer, podcaster, or content creator, **AI Promo Studio** streamlines your entire production pipeline—cutting hours of manual editing down to a few clicks.
+""")
+
 
     with gr.Tabs():
-        # Step 1: Concept Development
-        with gr.Tab("1️⃣ Concept"):
-            with gr.Row():
-                with gr.Column(scale=2):
-                    concept_input = gr.Textbox(
-                        label="Your Idea",
-                        placeholder="e.g., A 30-second morning show intro with energetic music...",
-                        lines=3
-                    )
-                    with gr.Accordion("Advanced Settings", open=False):
-                        model_selector = gr.Dropdown(
-                            choices=list(MODEL_CONFIG["llama_models"].values()),
-                            label="AI Model",
-                            value=MODEL_CONFIG["llama_models"]["Meta-Llama-3-8B"]
-                        )
-                        duration_slider = gr.Slider(15, 120, 30, step=15, label="Duration (seconds)")
-                        temp_slider = gr.Slider(0.1, 1.5, 0.7, step=0.1, label="Creativity")
-                    generate_btn = gr.Button("Generate Script", variant="primary")
-                
-                with gr.Column(scale=1):
-                    script_output = gr.Textbox(label="Voice Script", interactive=True)
-                    sound_output = gr.Textbox(label="Sound Design", interactive=True)
-                    music_output = gr.Textbox(label="Music Style", interactive=True)
-
-        # Step 2: Voice Production
-        with gr.Tab("2️⃣ Voice"):
+        # Step 1: Generate Script
+        with gr.Tab("Step 1: Generate Script"):
             with gr.Row():
-                with gr.Column():
-                    tts_selector = gr.Dropdown(
-                        choices=list(MODEL_CONFIG["tts_models"].values()),
-                        label="Voice Model",
-                        value="tts_models/en/ljspeech/tacotron2-DDC"
-                    )
-                    speed_slider = gr.Slider(0.5, 2.0, 1.0, step=0.1, label="Speaking Rate")
-                    voice_btn = gr.Button("Generate Voiceover", variant="primary")
-                with gr.Column():
-                    voice_preview = gr.Audio(label="Preview", type="filepath")
-
-        # Step 3: Music Production
-        with gr.Tab("3️⃣ Music"):
-            with gr.Row():
-                with gr.Column():
-                    music_duration = gr.Slider(10, 120, 30, label="Duration (seconds)")
-                    music_temp = gr.Slider(0.1, 2.0, 1.0, label="Creativity")
-                    guidance_scale = gr.Slider(1.0, 5.0, 3.0, label="Focus")
-                    music_btn = gr.Button("Generate Music", variant="primary")
-                with gr.Column():
-                    music_preview = gr.Audio(label="Preview", type="filepath")
-
-        # Step 4: Final Mix
-        with gr.Tab("4️⃣ Mix"):
-            with gr.Row():
-                with gr.Column():
-                    ducking_toggle = gr.Checkbox(True, label="Enable Voice Ducking")
-                    duck_level = gr.Slider(0, 30, 12, label="Ducking Strength (dB)")
-                    crossfade_time = gr.Slider(0, 2000, 500, label="Crossfade (ms)")
-                    mix_btn = gr.Button("Create Final Mix", variant="primary")
-                with gr.Column():
-                    final_mix = gr.Audio(label="Master Output", type="filepath")
-
-    # Examples & Footer
-    with gr.Accordion("💡 Example Prompts", open=False):
-        gr.Examples(
-            examples=[
-                ["A 45-second tech podcast intro with futuristic synth effects"],
-                ["A 15-second coffee shop radio ad with morning acoustic vibes"],
-                ["A 60-second documentary trailer with epic orchestral music"]
-            ],
-            inputs=concept_input
-        )
+                user_prompt = gr.Textbox(
+                    label="Promo Idea", 
+                    placeholder="E.g., A 30-second promo for a morning show...",
+                    lines=2
+                )
+                llama_model_id = gr.Textbox(
+                    label="LLaMA Model ID", 
+                    value="meta-llama/Meta-Llama-3-8B-Instruct", 
+                    placeholder="Enter a valid Hugging Face model ID"
+                )
+                duration = gr.Slider(
+                    label="Desired Promo Duration (seconds)",
+                    minimum=15, 
+                    maximum=60, 
+                    step=15, 
+                    value=30
+                )
+
+            generate_script_button = gr.Button("Generate Script")
+            script_output = gr.Textbox(label="Generated Voice-Over Script", lines=5, interactive=False)
+            sound_design_output = gr.Textbox(label="Sound Design Suggestions", lines=3, interactive=False)
+            music_suggestion_output = gr.Textbox(label="Music Suggestions", lines=3, interactive=False)
+
+            generate_script_button.click(
+                fn=lambda user_prompt, model_id, dur: generate_script(user_prompt, model_id, HF_TOKEN, dur),
+                inputs=[user_prompt, llama_model_id, duration],
+                outputs=[script_output, sound_design_output, music_suggestion_output],
+            )
+
+        # Step 2: Generate Voice
+        with gr.Tab("Step 2: Generate Voice"):
+            gr.Markdown("Generate the voice-over using a Coqui TTS model.")
+            selected_tts_model = gr.Dropdown(
+                label="TTS Model",
+                choices=[
+                    "tts_models/en/ljspeech/tacotron2-DDC",  
+                    "tts_models/en/ljspeech/vits", 
+                    "tts_models/en/sam/tacotron-DDC", 
+                ],
+                value="tts_models/en/ljspeech/tacotron2-DDC",
+                multiselect=False
+            )
+            generate_voice_button = gr.Button("Generate Voice-Over")
+            voice_audio_output = gr.Audio(label="Voice-Over (WAV)", type="filepath")
+
+            generate_voice_button.click(
+                fn=lambda script, tts_model: generate_voice(script, tts_model),
+                inputs=[script_output, selected_tts_model],
+                outputs=voice_audio_output,
+            )
+
+        # Step 3: Generate Music (MusicGen Large)
+        with gr.Tab("Step 3: Generate Music"):
+            gr.Markdown("Generate a music track with the **MusicGen Large** model.")
+            audio_length = gr.Slider(
+                label="Music Length (tokens)",
+                minimum=128, 
+                maximum=1024, 
+                step=64, 
+                value=512,
+                info="Increase tokens for longer audio, but be mindful of inference time."
+            )
+            generate_music_button = gr.Button("Generate Music")
+            music_output = gr.Audio(label="Generated Music (WAV)", type="filepath")
+
+            generate_music_button.click(
+                fn=lambda music_suggestion, length: generate_music(music_suggestion, length),
+                inputs=[music_suggestion_output, audio_length],
+                outputs=[music_output],
+            )
+
+        # Step 4: Blend Audio (Loop/Trim + Ducking)
+        with gr.Tab("Step 4: Blend Audio"):
+            gr.Markdown("**Music** will be looped or trimmed to match **Voice** duration, then optionally ducked.")
+            ducking_checkbox = gr.Checkbox(label="Enable Ducking?", value=True)
+            duck_level_slider = gr.Slider(
+                label="Ducking Level (dB attenuation)", 
+                minimum=0, 
+                maximum=20, 
+                step=1, 
+                value=10
+            )
+            blend_button = gr.Button("Blend Voice + Music")
+            blended_output = gr.Audio(label="Final Blended Output (WAV)", type="filepath")
 
+            blend_button.click(
+                fn=blend_audio,
+                inputs=[voice_audio_output, music_output, ducking_checkbox, duck_level_slider],
+                outputs=blended_output
+            )
+
+    # Footer
     gr.Markdown("""
-    <div style="text-align: center; margin-top: 30px; padding-top: 20px; border-top: 1px solid #444;">
-        <p style="font-size: 0.9em; color: #888;">
-            Created with ❤️ by <a href="https://bilsimaging.com" target="_blank" style="color: #66b3ff;">bilsimaging.com</a>
-        </p>
-        <a href="https://visitorbadge.io/status?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2FBils%2Fradiogold">
-            <img src="https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2FBils%2Fradiogold&countColor=%23263759"/>
-        </a>
-    </div>
+    <hr>
+    <p style="text-align: center; font-size: 0.9em;">
+        Created with ❤️ by <a href="https://bilsimaging.com" target="_blank">bilsimaging.com</a>
+    </p>
     """)
-
-    # Event Handling
-    generate_btn.click(
-        generate_script,
-        inputs=[concept_input, model_selector, duration_slider, temp_slider],
-        outputs=[script_output, sound_output, music_output]
-    )
-    
-    voice_btn.click(
-        generate_voice,
-        inputs=[script_output, tts_selector, speed_slider],
-        outputs=voice_preview
-    )
-    
-    music_btn.click(
-        generate_music,
-        inputs=[music_output, music_duration, music_temp, guidance_scale],
-        outputs=music_preview
-    )
     
-    mix_btn.click(
-        blend_audio,
-        inputs=[voice_preview, music_preview, ducking_toggle, duck_level, crossfade_time],
-        outputs=final_mix
-    )
+    # Visitor Badge
+    gr.HTML("""
+    <a href="https://visitorbadge.io/status?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2FBils%2Fradiogold">
+        <img src="https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2FBils%2Fradiogold&countColor=%23263759" />
+    </a>
+    """)
 
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+demo.launch(debug=True)