Update app.py

app.py

@@ -1,6 +1,5 @@
 import gradio as gr
 import subprocess
-import os
 import tempfile
 import librosa
 import librosa.display
@@ -8,447 +7,268 @@ import matplotlib.pyplot as plt
 import numpy as np
 import scipy.ndimage
 from pathlib import Path
-
 import logging
 import warnings
-
-
-
 import shutil
-from typing import Tuple, Optional, Dict, Any
+from typing import Tuple, Optional
 
-# Configure matplotlib for web display
+# Configure matplotlib and logging
 plt.switch_backend('Agg')
 warnings.filterwarnings('ignore')
-
-# Setup logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(levelname)s - %(message)s",
-    handlers=[logging.StreamHandler()]
-)
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 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 __init__(self):
+        self.temp_dir = Path(tempfile.mkdtemp())
+        self.plot_files = []
 
-    def cleanup(self) -> None:
-        """Remove temporary directory and plot files."""
+    def cleanup(self):
         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}")
+            Path(plot_file).unlink(missing_ok=True)
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
 
     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
-        ]
-
+        progress(0.1, desc="Downloading...")
+        output_file = self.temp_dir / "audio.mp3"
+        
         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}"
+            subprocess.run([
+                "yt-dlp", "-x", "--audio-format", "mp3", 
+                "-o", str(output_file), video_url
+            ], check=True, capture_output=True)
+            progress(1.0, desc="Complete!")
+            return str(output_file), "Download successful"
         except FileNotFoundError:
-            return None, "yt-dlp not found. Install it with: pip install yt-dlp"
+            return None, "yt-dlp not found. Install 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 save_plot(self, fig) -> str:
+        plot_path = self.temp_dir / f"plot_{len(self.plot_files)}.png"
+        fig.savefig(plot_path, dpi=150, bbox_inches='tight')
+        plt.close(fig)
+        self.plot_files.append(str(plot_path))
+        return str(plot_path)
 
-    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."""
+    def analyze_audio(self, audio_path: str, analysis_type: str = "basic", 
+                     patch_duration: float = 5.0, progress=gr.Progress()) -> Tuple[Optional[str], str]:
         if not audio_path or not Path(audio_path).exists():
-            return None, None, "Invalid or missing audio file"
+            return None, "No audio file provided"
 
         try:
             progress(0.1, desc="Loading audio...")
-            y, sr = librosa.load(audio_path, sr=sr)
-            duration = librosa.get_duration(y=y, sr=sr)
-
+            y, sr = librosa.load(audio_path, sr=22050)
+            duration = len(y) / sr
+            
+            # Limit duration for processing
+            max_duration = 60 if analysis_type == "basic" else 30
             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
-
+            if analysis_type == "basic":
+                return self._basic_analysis(y, sr, duration, progress)
+            elif analysis_type == "chroma":
+                return self._chroma_analysis(y, sr, progress)
+            elif analysis_type == "patches":
+                return self._patch_analysis(y, sr, patch_duration, progress)
+                
         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"
-
-        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
-
-        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."""
+            logger.error(f"Analysis error: {e}")
+            return None, f"Analysis failed: {str(e)}"
+
+    def _basic_analysis(self, y, sr, duration, progress):
+        progress(0.3, desc="Computing features...")
+        
+        # Extract features
+        tempo = float(librosa.beat.beat_track(y=y, sr=sr)[0])
+        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]
+        
+        progress(0.6, desc="Creating visualizations...")
+        
+        # Create mel spectrogram
+        S_mel = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=80)
+        S_dB = librosa.power_to_db(S_mel, ref=np.max)
+        
+        # Plot
+        fig, axes = plt.subplots(2, 2, figsize=(12, 8))
+        
+        # Waveform
+        time = np.linspace(0, duration, len(y))
+        axes[0, 0].plot(time, y, alpha=0.8)
+        axes[0, 0].set_title('Waveform', fontweight='bold')
+        axes[0, 0].set_xlabel('Time (s)')
+        
+        # Mel Spectrogram
+        librosa.display.specshow(S_dB, sr=sr, x_axis='time', y_axis='mel', ax=axes[0, 1])
+        axes[0, 1].set_title('Mel Spectrogram', fontweight='bold')
+        
+        # MFCC
+        librosa.display.specshow(mfcc, sr=sr, x_axis='time', ax=axes[1, 0])
+        axes[1, 0].set_title('MFCC Features', fontweight='bold')
+        
+        # Spectral features
+        times = librosa.frames_to_time(range(len(spectral_centroid)), sr=sr)
+        axes[1, 1].plot(times, spectral_centroid, label='Centroid', linewidth=2)
+        axes[1, 1].plot(times, spectral_rolloff, label='Rolloff', linewidth=2)
+        axes[1, 1].set_title('Spectral Features', fontweight='bold')
+        axes[1, 1].legend()
+        axes[1, 1].set_xlabel('Time (s)')
+        
+        plt.tight_layout()
+        plot_path = self.save_plot(fig)
+        
+        summary = f"""**Audio Analysis Results**
+- Duration: {duration:.1f}s | Sample Rate: {sr:,} Hz
+- Tempo: {tempo:.1f} BPM | Samples: {len(y):,}
+- MFCC shape: {mfcc.shape} | Features extracted successfully"""
+        
+        progress(1.0, desc="Complete!")
+        return plot_path, summary
+
+    def _chroma_analysis(self, y, sr, progress):
+        progress(0.3, desc="Computing chroma features...")
+        
+        # Different chroma extraction methods
+        chroma_cqt = librosa.feature.chroma_cqt(y=y, sr=sr)
+        chroma_stft = librosa.feature.chroma_stft(y=y, sr=sr)
+        
+        # Harmonic separation
+        y_harm = librosa.effects.harmonic(y=y)
+        chroma_harm = librosa.feature.chroma_cqt(y=y_harm, sr=sr)
+        
+        progress(0.7, desc="Creating visualizations...")
+        
+        fig, axes = plt.subplots(2, 2, figsize=(12, 8))
+        
+        # Plot different chroma features
+        chromas = [
+            (chroma_cqt, 'Chroma (CQT)'),
+            (chroma_stft, 'Chroma (STFT)'),
+            (chroma_harm, 'Harmonic Chroma'),
+            (chroma_cqt - chroma_harm, 'Chroma Difference')
+        ]
+        
+        for i, (chroma, title) in enumerate(chromas):
+            ax = axes[i//2, i%2]
+            librosa.display.specshow(chroma, y_axis='chroma', x_axis='time', ax=ax)
+            ax.set_title(title, fontweight='bold')
+        
+        plt.tight_layout()
+        plot_path = self.save_plot(fig)
+        
+        summary = f"""**Chroma Analysis Results**
+- Multiple chroma extraction methods compared
+- CQT vs STFT analysis | Harmonic separation applied
+- Chroma shape: {chroma_cqt.shape}"""
+        
+        progress(1.0, desc="Complete!")
+        return plot_path, summary
+
+    def _patch_analysis(self, y, sr, patch_duration, progress):
+        progress(0.3, desc="Generating patches...")
+        
+        # Create 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)
+        
+        # Generate patches
+        patch_frames = librosa.time_to_frames(patch_duration, sr=sr, hop_length=hop_length)
+        hop_frames = patch_frames // 2  # 50% overlap
+        patches = librosa.util.frame(S_dB, frame_length=patch_frames, hop_length=hop_frames)
+        
+        progress(0.7, desc="Creating visualizations...")
+        
+        # Show first 6 patches
+        num_show = min(6, patches.shape[-1])
+        fig, axes = plt.subplots(2, 3, figsize=(15, 8))
+        axes = axes.flatten()
+        
+        for i in range(num_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}', fontweight='bold')
+        
+        # Hide unused subplots
+        for i in range(num_show, 6):
+            axes[i].set_visible(False)
+        
+        plt.tight_layout()
+        plot_path = self.save_plot(fig)
+        
+        summary = f"""**Patch Generation Results**
+- Total patches: {patches.shape[-1]} | Duration: {patch_duration}s each
+- Patch shape: {patches.shape} | 50% overlap between patches
+- Ready for transformer input"""
+        
+        progress(1.0, desc="Complete!")
+        return plot_path, summary
+
+def create_interface():
     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`.
-        """)
-
+    
+    with gr.Blocks(title="Audio Analysis Suite") as demo:
+        gr.Markdown("# 🎵 Audio Analysis Suite")
+        
         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)
-        """)
-
+            with gr.Column():
+                # Input section
+                gr.Markdown("### Input")
+                youtube_url = gr.Textbox(label="YouTube URL", placeholder="https://youtube.com/watch?v=...")
+                download_btn = gr.Button("Download Audio")
+                
+                audio_file = gr.Audio(label="Or upload audio file", type="filepath")
+                
+                # Analysis options
+                gr.Markdown("### Analysis Options")
+                analysis_type = gr.Radio(
+                    choices=["basic", "chroma", "patches"], 
+                    value="basic", 
+                    label="Analysis Type"
+                )
+                patch_duration = gr.Slider(1, 10, 5, step=0.5, label="Patch Duration (s)", 
+                                         visible=False)
+                
+                analyze_btn = gr.Button("Analyze Audio", variant="primary")
+            
+            with gr.Column():
+                # Results
+                gr.Markdown("### Results")
+                plot_output = gr.Image(label="Visualizations")
+                summary_output = gr.Markdown()
+                status_output = gr.Textbox(label="Status", interactive=False)
+        
         # Event handlers
         download_btn.click(
-            fn=analyzer.download_youtube_audio,
+            analyzer.download_youtube_audio,
             inputs=[youtube_url],
-            outputs=[audio_file, download_status]
+            outputs=[audio_file, status_output]
         )
-
-        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]
+        
+        analyze_btn.click(
+            analyzer.analyze_audio,
+            inputs=[audio_file, analysis_type, patch_duration],
+            outputs=[plot_output, summary_output]
         )
-
-        patches_btn.click(
-            fn=analyzer.generate_patches,
-            inputs=[audio_file, patch_duration, hop_duration],
-            outputs=[patches_plot, patches_summary, error_output]
+        
+        # Show patch duration slider only for patches analysis
+        analysis_type.change(
+            lambda x: gr.update(visible=(x == "patches")),
+            inputs=[analysis_type],
+            outputs=[patch_duration]
         )
-
-        audio_file.change(
-            fn=analyzer.extract_basic_features,
-            inputs=[audio_file],
-            outputs=[basic_plot, basic_summary, error_output]
-        )
-
-        demo.unload(fn=analyzer.cleanup)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+        
+        demo.unload(analyzer.cleanup)
+    
     return demo
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 if __name__ == "__main__":
-    demo = create_gradio_interface()
+    demo = create_interface()
     demo.launch()