Update app.py

app.py

@@ -1,408 +1,205 @@
 import gradio as gr
-import subprocess
-import os
-import tempfile
-import librosa
-import librosa.display
-import matplotlib.pyplot as plt
-import numpy as np
-import scipy.ndimage
 from pathlib import Path
+import yt_dlp
 import logging
-import warnings
+import librosa
+import numpy as np
+from PIL import Image
+import ffmpeg
 import shutil
-from typing import Tuple, Optional, Dict, Any
-
-# Configure matplotlib for web display
-plt.switch_backend('Agg')
-warnings.filterwarnings('ignore')
-
-# Setup logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(levelname)s - %(message)s",
-    handlers=[logging.StreamHandler()]
-)
-logger = logging.getLogger(__name__)
-
-class AudioAnalyzer:
-    """Core class for audio analysis with modular feature extraction methods."""
-
-    def __init__(self, temp_dir: Optional[str] = None):
-        """Initialize with a temporary directory for file storage."""
-        self.temp_dir = Path(temp_dir or tempfile.mkdtemp())
-        self.temp_dir.mkdir(exist_ok=True)
-        self.plot_files = []  # Track plot files for cleanup
-        logger.info(f"Initialized temporary directory: {self.temp_dir}")
-
-    def cleanup(self) -> None:
-        """Remove temporary directory and plot files."""
-        for plot_file in self.plot_files:
-            if Path(plot_file).exists():
-                try:
-                    Path(plot_file).unlink()
-                    logger.info(f"Removed plot file: {plot_file}")
-                except Exception as e:
-                    logger.warning(f"Failed to remove plot file {plot_file}: {str(e)}")
-        if self.temp_dir.exists():
-            shutil.rmtree(self.temp_dir, ignore_errors=True)
-            logger.info(f"Cleaned up temporary directory: {self.temp_dir}")
-
-    def download_youtube_audio(self, video_url: str, progress=gr.Progress()) -> Tuple[Optional[str], str]:
-        """Download audio from YouTube using yt-dlp."""
-        if not video_url:
-            return None, "Please provide a valid YouTube URL"
-
-        progress(0.1, desc="Initializing download...")
-        output_dir = self.temp_dir / "downloaded_audio"
-        output_dir.mkdir(exist_ok=True)
-        output_file = output_dir / "audio.mp3"
-
-        command = [
-            "yt-dlp",
-            "-x",
-            "--audio-format", "mp3",
-            "-o", str(output_file),
-            "--no-playlist",
-            "--restrict-filenames",
-            video_url
-        ]
-
-        try:
-            progress(0.3, desc="Downloading audio...")
-            subprocess.run(command, check=True, capture_output=True, text=True)
-            progress(1.0, desc="Download complete!")
-            return str(output_file), f"Successfully downloaded audio: {output_file.name}"
-        except FileNotFoundError:
-            return None, "yt-dlp not found. Install it with: pip install yt-dlp"
-        except subprocess.CalledProcessError as e:
-            return None, f"Download failed: {e.stderr}"
-        except Exception as e:
-            logger.error(f"Unexpected error during download: {str(e)}")
-            return None, f"Error: {str(e)}"
-
-    def save_plot(self, fig, filename: str) -> Optional[str]:
-        """Save matplotlib figure to a temporary file and verify existence."""
-        try:
-            # Use NamedTemporaryFile to ensure persistence
-            with tempfile.NamedTemporaryFile(suffix='.png', delete=False, dir=self.temp_dir) as tmp_file:
-                plot_path = tmp_file.name
-            fig.savefig(plot_path, dpi=300, bbox_inches='tight', format='png')
-            plt.close(fig)
-            if not Path(plot_path).exists():
-                logger.error(f"Plot file not created: {plot_path}")
-                return None
-            self.plot_files.append(plot_path)
-            logger.info(f"Saved plot: {plot_path}")
-            return str(plot_path)
-        except Exception as e:
-            logger.error(f"Error saving plot {filename}: {str(e)}")
-            plt.close(fig)
-            return None
-
-    def extract_basic_features(self, audio_path: str, sr: int = 16000, max_duration: float = 60.0, 
-                             progress=gr.Progress()) -> Tuple[Optional[str], Optional[str], Optional[str]]:
-        """Extract basic audio features and generate visualizations."""
-        if not audio_path or not Path(audio_path).exists():
-            return None, None, "Invalid or missing audio file"
-
-        try:
-            progress(0.1, desc="Loading audio...")
-            y, sr = librosa.load(audio_path, sr=sr)
-            duration = librosa.get_duration(y=y, sr=sr)
-
-            if duration > max_duration:
-                y = y[:int(sr * max_duration)]
-                duration = max_duration
-
-            progress(0.3, desc="Computing features...")
-            features: Dict[str, Any] = {
-                'duration': duration,
-                'sample_rate': sr,
-                'samples': len(y),
-                'tempo': float(librosa.beat.beat_track(y=y, sr=sr)[0]),  # Convert to float
-                'mfcc': librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13),
-                'spectral_centroid': librosa.feature.spectral_centroid(y=y, sr=sr)[0],
-                'spectral_rolloff': librosa.feature.spectral_rolloff(y=y, sr=sr)[0],
-                'zero_crossing_rate': librosa.feature.zero_crossing_rate(y)[0]
-            }
-
-            progress(0.5, desc="Computing mel spectrogram...")
-            hop_length = 512
-            S_mel = librosa.feature.melspectrogram(y=y, sr=sr, hop_length=hop_length, n_mels=80)
-            S_dB = librosa.power_to_db(S_mel, ref=np.max)
-
-            progress(0.8, desc="Creating visualizations...")
-            fig, axes = plt.subplots(2, 2, figsize=(15, 10))
-
-            time_axis = np.linspace(0, duration, len(y))
-            axes[0, 0].plot(time_axis, y)
-            axes[0, 0].set_title('Waveform')
-            axes[0, 0].set_xlabel('Time (s)')
-            axes[0, 0].set_ylabel('Amplitude')
-
-            librosa.display.specshow(S_dB, sr=sr, hop_length=hop_length, 
-                                    x_axis='time', y_axis='mel', ax=axes[0, 1])
-            axes[0, 1].set_title('Mel Spectrogram')
-
-            librosa.display.specshow(features['mfcc'], sr=sr, x_axis='time', ax=axes[1, 0])
-            axes[1, 0].set_title('MFCC')
-
-            times = librosa.frames_to_time(range(len(features['spectral_centroid'])), sr=sr, hop_length=hop_length)
-            axes[1, 1].plot(times, features['spectral_centroid'], label='Spectral Centroid')
-            axes[1, 1].plot(times, features['spectral_rolloff'], label='Spectral Rolloff')
-            axes[1, 1].set_title('Spectral Features')
-            axes[1, 1].set_xlabel('Time (s)')
-            axes[1, 1].legend()
-
-            plt.tight_layout()
-            plot_path = self.save_plot(fig, "basic_features")
-            if not plot_path:
-                return None, None, "Failed to save feature visualizations"
-
-            # Validate feature shapes
-            for key in ['mfcc', 'spectral_centroid', 'spectral_rolloff', 'zero_crossing_rate']:
-                if not isinstance(features[key].shape, tuple):
-                    logger.error(f"Invalid shape for {key}: {features[key].shape}")
-                    return None, None, f"Invalid feature shape for {key}"
-
-            summary = f"""
-**Audio Summary:**
-- Duration: {duration:.2f} seconds
-- Sample Rate: {sr} Hz
-- Estimated Tempo: {features['tempo']:.1f} BPM
-- Number of Samples: {features['samples']:,}
-
-**Feature Shapes:**
-- MFCC: {features['mfcc'].shape}
-- Spectral Centroid: {features['spectral_centroid'].shape}
-- Spectral Rolloff: {features['spectral_rolloff'].shape}
-- Zero Crossing Rate: {features['zero_crossing_rate'].shape}
-            """
-
-            progress(1.0, desc="Analysis complete!")
-            return plot_path, summary, None
-
-        except Exception as e:
-            logger.error(f"Error processing audio: {str(e)}")
-            return None, None, f"Error processing audio: {str(e)}"
-
-    def extract_chroma_features(self, audio_path: str, sr: int = 16000, max_duration: float = 30.0, 
-                              progress=gr.Progress()) -> Tuple[Optional[str], Optional[str], Optional[str]]:
-        """Extract and visualize enhanced chroma features."""
-        if not audio_path or not Path(audio_path).exists():
-            return None, None, "Invalid or missing audio file"
-
-        try:
-            progress(0.1, desc="Loading audio...")
-            y, sr = librosa.load(audio_path, sr=sr)
-            if len(y) > sr * max_duration:
-                y = y[:int(sr * max_duration)]
-
-            progress(0.3, desc="Computing chroma variants...")
-            chroma_orig = librosa.feature.chroma_cqt(y=y, sr=sr)
-            y_harm = librosa.effects.harmonic(y=y, margin=8)
-            chroma_harm = librosa.feature.chroma_cqt(y=y_harm, sr=sr)
-            chroma_filter = np.minimum(chroma_harm,
-                                     librosa.decompose.nn_filter(chroma_harm,
-                                                                aggregate=np.median,
-                                                                metric='cosine'))
-            chroma_smooth = scipy.ndimage.median_filter(chroma_filter, size=(1, 9))
-            chroma_stft = librosa.feature.chroma_stft(y=y, sr=sr)
-            chroma_cens = librosa.feature.chroma_cens(y=y, sr=sr)
-
-            progress(0.8, desc="Creating visualizations...")
-            fig, axes = plt.subplots(3, 2, figsize=(15, 12))
-            axes = axes.flatten()
-
-            for i, (chroma, title) in enumerate([
-                (chroma_orig, 'Original Chroma (CQT)'),
-                (chroma_harm, 'Harmonic Chroma'),
-                (chroma_filter, 'Non-local Filtered'),
-                (chroma_smooth, 'Median Filtered'),
-                (chroma_stft, 'Chroma (STFT)'),
-                (chroma_cens, 'CENS Features')
-            ]):
-                librosa.display.specshow(chroma, y_axis='chroma', x_axis='time', ax=axes[i])
-                axes[i].set_title(title)
-
-            plt.tight_layout()
-            plot_path = self.save_plot(fig, "chroma_features")
-            if not plot_path:
-                return None, None, "Failed to save chroma visualizations"
-
-            summary = "Chroma feature analysis complete! Visualizations show different chroma extraction methods for harmonic analysis."
-            progress(1.0, desc="Chroma analysis complete!")
-            return plot_path, summary, None
-
-        except Exception as e:
-            logger.error(f"Error processing chroma features: {str(e)}")
-            return None, None, f"Error processing chroma features: {str(e)}"
-
-    def generate_patches(self, audio_path: str, sr: int = 16000, patch_duration: float = 5.0, 
-                        hop_duration: float = 1.0, progress=gr.Progress()) -> Tuple[Optional[str], Optional[str], Optional[str]]:
-        """Generate fixed-duration patches for transformer input."""
-        if not audio_path or not Path(audio_path).exists():
-            return None, None, "Invalid or missing audio file"
-
+import tempfile
+import time
+
+# Set up logging for debugging
+logging.basicConfig(level=logging.DEBUG)
+
+def analyze_audio(youtube_url, input_text, input_image=None, slider_value=50, checkbox_value=False):
+    """
+    Downloads YouTube audio, performs automatic audio feature analysis with librosa, and processes inputs.
+    Automatically handles file and folder management.
+
+    Args:
+        youtube_url (str): YouTube video URL (optional).
+        input_text (str): Text input for processing.
+        input_image (PIL.Image, optional): Image input for processing.
+        slider_value (float): Numerical parameter (e.g., analysis threshold).
+        checkbox_value (bool): Toggle for enhanced analysis.
+
+    Returns:
+        tuple: (processed_text, output_image_display, output_audio, extra_info)
+    """
+    # Create a unique temporary directory for this run
+    temp_dir = Path(tempfile.mkdtemp(prefix="audio_analysis_"))
+    output_dir = temp_dir / "downloaded_media"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    logging.debug(f"Created temporary directory: {temp_dir}, output directory: {output_dir}")
+
+    try:
+        # Initialize outputs
+        processed_text = f"Processed: '{input_text}'."
+        output_image_display = input_image
+        output_audio = None
+        extra_info = f"Threshold: {slider_value/100:.2f}"
+
+        # Handle YouTube download if URL is provided
+        if youtube_url:
+            try:
+                # Validate YouTube URL
+                if not youtube_url.startswith(("https://www.youtube.com/", "https://youtu.be/")):
+                    return "Error: Invalid YouTube URL", None, None, "Processing failed."
+
+                # YouTube download options (audio only)
+                ydl_opts = {
+                    'format': 'bestaudio/best',
+                    'outtmpl': str(output_dir / '%(title)s.%(ext)s'),
+                    'postprocessors': [{
+                        'key': 'FFmpegExtractAudio',
+                        'preferredcodec': 'mp3',
+                        'preferredquality': '192',
+                    }],
+                    'restrictfilenames': True,
+                    'noplaylist': True,
+                }
+
+                # Download audio
+                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                    info = ydl.extract_info(youtube_url, download=True)
+                    audio_file = output_dir / f"{info['title']}.mp3"
+                    logging.debug(f"Downloaded audio: {audio_file}")
+                    output_audio = str(audio_file)
+
+                # Perform automatic audio feature analysis with librosa
+                y, sr = librosa.load(audio_file)
+                hop_length = 512  # Valid hop_length to fix "Invalid hop_length: 0" error
+                logging.debug(f"Using hop_length: {hop_length}")
+
+                # Extract features
+                mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13, hop_length=hop_length)
+                spectral_centroid = librosa.feature.spectral_centroid(y=y, sr=sr, hop_length=hop_length)
+                tempo, _ = librosa.beat.beat_track(y=y, sr=sr, hop_length=hop_length)
+
+                # Aggregate features
+                mfcc_mean = np.mean(mfcc, axis=1).tolist()[:3]  # Mean of first 3 MFCC coefficients
+                spectral_centroid_mean = np.mean(spectral_centroid)
+                features_summary = (
+                    f"Audio Features: MFCC (mean of first 3 coeffs): {mfcc_mean}, "
+                    f"Spectral Centroid: {spectral_centroid_mean:.2f} Hz, "
+                    f"Tempo: {tempo:.2f} BPM"
+                )
+
+                processed_text += f" {features_summary}."
+                extra_info += f", Audio: {audio_file.name}"
+
+            except Exception as e:
+                logging.error(f"YouTube download or audio processing error: {str(e)}")
+                processed_text += f" Error processing YouTube audio: {str(e)}."
+
+        # Handle image processing if provided
+        if input_image is not None:
+            from PIL import ImageEnhance
+            enhancer = ImageEnhance.Brightness(input_image)
+            output_image_display = enhancer.enhance(1.5)
+            processed_text += " Image processed (brightened)."
+        else:
+            processed_text += " No image provided."
+
+        # Incorporate slider and checkbox
+        processed_text += f" Slider: {slider_value}, Enhanced Analysis: {checkbox_value}."
+        if checkbox_value:
+            processed_text += " Enhanced analysis enabled."
+            if youtube_url and slider_value > 50:
+                processed_text += f" High threshold ({slider_value}) applied for deeper analysis."
+
+        return processed_text, output_image_display, output_audio, extra_info
+
+    except Exception as e:
+        logging.error(f"Error in analyze_audio: {str(e)}")
+        return f"Error: {str(e)}", None, None, "Processing failed."
+
+    finally:
+        # Clean up temporary directory after a delay to ensure file access
         try:
-            progress(0.1, desc="Loading audio...")
-            y, sr = librosa.load(audio_path, sr=sr)
-
-            progress(0.3, desc="Computing mel spectrogram...")
-            hop_length = 512
-            S_mel = librosa.feature.melspectrogram(y=y, sr=sr, hop_length=hop_length, n_mels=80)
-            S_dB = librosa.power_to_db(S_mel, ref=np.max)
-
-            progress(0.5, desc="Generating patches...")
-            patch_frames = librosa.time_to_frames(patch_duration, sr=sr, hop_length=hop_length)
-            hop_frames = librosa.time_to_frames(hop_duration, sr=sr, hop_length=hop_length)
-            patches = librosa.util.frame(S_dB, frame_length=patch_frames, hop_length=hop_frames)
-
-            progress(0.8, desc="Creating visualizations...")
-            num_patches_to_show = min(6, patches.shape[-1])
-            fig, axes = plt.subplots(2, 3, figsize=(18, 8))
-            axes = axes.flatten()
-
-            for i in range(num_patches_to_show):
-                librosa.display.specshow(patches[..., i], y_axis='mel', x_axis='time', 
-                                       ax=axes[i], sr=sr, hop_length=hop_length)
-                axes[i].set_title(f'Patch {i+1}')
-
-            for i in range(num_patches_to_show, len(axes)):
-                axes[i].set_visible(False)
-
-            plt.tight_layout()
-            plot_path = self.save_plot(fig, "patches")
-            if not plot_path:
-                return None, None, "Failed to save patch visualizations"
-
-            summary = f"""
-**Patch Generation Summary:**
-- Total patches generated: {patches.shape[-1]}
-- Patch duration: {patch_duration:.1f} seconds
-- Hop duration: {hop_duration:.1f} seconds
-- Patch shape (mels, time, patches): {patches.shape}
-- Each patch covers {patch_frames} time frames
-            """
-
-            progress(1.0, desc="Patch generation complete!")
-            return plot_path, summary, None
-
+            time.sleep(1)  # Brief delay to ensure Gradio can serve the audio file
+            if temp_dir.exists():
+                shutil.rmtree(temp_dir)
+                logging.debug(f"Cleaned up temporary directory: {temp_dir}")
         except Exception as e:
-            logger.error(f"Error generating patches: {str(e)}")
-            return None, None, f"Error generating patches: {str(e)}"
-
-def create_gradio_interface() -> gr.Blocks:
-    """Create a modular Gradio interface for audio analysis."""
-    analyzer = AudioAnalyzer()
-
-    with gr.Blocks(title="🎵 Audio Analysis Suite", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("""
-        # 🎵 Audio Analysis Suite
-
-        Analyze audio from YouTube videos or uploaded files. Extract features or generate transformer patches for deep learning applications.
-
-        **Features:**
-        - 📊 **Basic Features**: Waveform, Mel Spectrogram, MFCC, Spectral Analysis, Tempo Detection
-        - 🎼 **Chroma Features**: Harmonic content analysis with multiple extraction methods
-        - 🧩 **Transformer Patches**: Fixed-duration patches for deep learning
-
-        **Requirements**: Dependencies are automatically installed in Hugging Face Spaces via `requirements.txt`.
-        """)
+            logging.error(f"Error cleaning up temporary directory: {str(e)}")
 
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### 📁 Audio Input")
-                with gr.Group():
-                    gr.Markdown("**Download from YouTube** (Supported formats: MP3, WAV, etc.)")
-                    youtube_url = gr.Textbox(
-                        label="YouTube URL",
-                        placeholder="https://www.youtube.com/watch?v=...",
-                    )
-                    download_btn = gr.Button("📥 Download Audio", variant="primary")
-                    download_status = gr.Textbox(label="Download Status", interactive=False)
-
-                with gr.Group():
-                    gr.Markdown("**Or upload audio file** (Supported formats: MP3, WAV, FLAC, etc.)")
-                    audio_file = gr.Audio(
-                        label="Upload Audio File",
-                        type="filepath",
-                    )
-
-            with gr.Column(scale=2):
-                gr.Markdown("### 🔍 Analysis Results")
-                with gr.Tabs():
-                    with gr.Tab("📊 Basic Features"):
-                        basic_plot = gr.Image(label="Feature Visualizations")
-                        basic_summary = gr.Markdown(label="Feature Summary")
-                        basic_btn = gr.Button("🔍 Analyze Basic Features", variant="secondary")
-
-                    with gr.Tab("🎼 Chroma Features"):
-                        chroma_plot = gr.Image(label="Chroma Visualizations")
-                        chroma_summary = gr.Markdown(label="Chroma Summary")
-                        chroma_btn = gr.Button("🎼 Analyze Chroma Features", variant="secondary")
-
-                    with gr.Tab("🧩 Transformer Patches"):
-                        with gr.Row():
-                            patch_duration = gr.Slider(
-                                label="Patch Duration (seconds)",
-                                minimum=1.0, maximum=10.0, value=5.0, step=0.5,
-                            )
-                            hop_duration = gr.Slider(
-                                label="Hop Duration (seconds)",
-                                minimum=0.1, maximum=5.0, value=1.0, step=0.1,
-                            )
-                        patches_plot = gr.Image(label="Generated Patches")
-                        patches_summary = gr.Markdown(label="Patch Summary")
-                        patches_btn = gr.Button("🧩 Generate Patches", variant="secondary")
-
-                error_output = gr.Textbox(label="Error Messages", interactive=False)
-
-        gr.Markdown("""
-        ### ℹ️ Usage Tips
-        - **Processing Limits**: 60s for basic features, 30s for chroma features for fast response
-        - **YouTube Downloads**: Ensure URLs are valid and respect YouTube's terms of service
-        - **Visualizations**: High-quality, suitable for research and education
-        - **Storage**: Temporary files are cleaned up when the interface closes
-        - **Support**: For issues, check the [GitHub repository](https://github.com/your-repo)
-        """)
-
-        # Event handlers
-        download_btn.click(
-            fn=analyzer.download_youtube_audio,
-            inputs=[youtube_url],
-            outputs=[audio_file, download_status]
-        )
-
-        basic_btn.click(
-            fn=analyzer.extract_basic_features,
-            inputs=[audio_file],
-            outputs=[basic_plot, basic_summary, error_output]
-        )
-
-        chroma_btn.click(
-            fn=analyzer.extract_chroma_features,
-            inputs=[audio_file],
-            outputs=[chroma_plot, chroma_summary, error_output]
-        )
-
-        patches_btn.click(
-            fn=analyzer.generate_patches,
-            inputs=[audio_file, patch_duration, hop_duration],
-            outputs=[patches_plot, patches_summary, error_output]
-        )
-
-        audio_file.change(
-            fn=analyzer.extract_basic_features,
-            inputs=[audio_file],
-            outputs=[basic_plot, basic_summary, error_output]
-        )
+# Define input components
+input_youtube_url = gr.Textbox(
+    label="YouTube Video URL",
+    placeholder="e.g., https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+    info="Optional: Enter a YouTube URL to download and analyze audio."
+)
+input_text_component = gr.Textbox(
+    label="Input Text",
+    placeholder="e.g., Analyze this audio track",
+    info="Type a description or query for processing."
+)
+input_image_component = gr.Image(
+    type="pil",
+    label="Upload Image (Optional)",
+    sources=["upload", "webcam", "clipboard"]
+)
+input_slider_component = gr.Slider(
+    minimum=0,
+    maximum=100,
+    value=50,
+    step=1,
+    label="Analysis Threshold",
+    info="Adjusts sensitivity of audio feature analysis."
+)
+input_checkbox_component = gr.Checkbox(
+    label="Enable Enhanced Analysis",
+    info="Toggle for deeper audio feature extraction."
+)
 
-        demo.unload(fn=analyzer.cleanup)
+# Define output components
+output_text_component = gr.Textbox(
+    label="Analysis Results",
+    info="Text results including audio feature analysis."
+)
+output_image_component = gr.Image(
+    label="Processed Image (if any)",
+    info="Processed image output (if provided)."
+)
+output_audio_component = gr.Audio(
+    label="Downloaded Audio",
+    type="filepath",
+    info="Audio downloaded from YouTube."
+)
+output_label_component = gr.Label(
+    label="Analysis Summary",
+    info="Feature analysis details and processing info."
+)
 
-    return demo
+# Create the Gradio interface
+iface = gr.Interface(
+    fn=analyze_audio,
+    inputs=[
+        input_youtube_url,
+        input_text_component,
+        input_image_component,
+        input_slider_component,
+        input_checkbox_component
+    ],
+    outputs=[
+        output_text_component,
+        output_image_component,
+        output_audio_component,
+        output_label_component
+    ],
+    title="YouTube Audio Feature Analysis",
+    description="Download YouTube audio, analyze features with librosa, and process text/image inputs. Customize with slider and checkbox.",
+    examples=[
+        ["https://www.youtube.com/watch?v=dQw4w9WgXcQ", "Analyze this track", None, 75, True],
+        [None, "Describe a music track", None, 30, False],
+        ["https://www.youtube.com/watch?v=9bZkp7q19f0", "Extract audio features", None, 60, True]
+    ],
+    allow_flagging="never",
+    theme=gr.themes.Soft()
+)
 
 if __name__ == "__main__":
-    demo = create_gradio_interface()
-    demo.launch()
+    iface.launch()