Fix import structure to resolve circular imports

app.py

@@ -3,7 +3,8 @@
 
 """
 Main entry point for the Chorus Detection Streamlit app.
-This file ensures the correct import paths are set up before running the app.
+This file is a simple wrapper that starts the Streamlit app
+without circular imports.
 """
 
 import os
@@ -24,43 +25,16 @@ if os.environ.get("SPACE_ID"):
     logger.info(f"MODEL_REVISION: {os.environ.get('MODEL_REVISION')}")
     logger.info(f"Current working directory: {os.getcwd()}")
     logger.info(f"Directory contents: {os.listdir()}")
+    if os.path.exists('src'):
+        logger.info(f"src directory contents: {os.listdir('src')}")
 
-# Add the src directory to the Python path
-try:
-    app_dir = os.path.dirname(os.path.abspath(__file__))
-    src_dir = os.path.join(app_dir, "src")
-    sys.path.insert(0, app_dir)
-    sys.path.insert(0, src_dir)
-    logger.info(f"Added directories to Python path: {app_dir}, {src_dir}")
-    logger.info(f"Python path: {sys.path}")
-except Exception as e:
-    logger.error(f"Error setting up Python path: {e}")
-    sys.exit(1)
-
-# Import the app module from src
-try:
-    # Try direct import first
-    if os.path.exists(os.path.join(src_dir, "app.py")):
-        import src.app as app_module
-        logger.info("Successfully imported app module directly")
-        main = app_module.main
-    else:
-        # Fall back to regular import
-        from src.app import main
-        logger.info("Successfully imported main from src.app")
-except ImportError as e:
-    logger.error(f"Failed to import main from src.app: {e}")
-    logger.info(f"Trying alternative import approach...")
-    
-    try:
-        # Try importing directly from the current directory
-        sys.path.append('.')
-        from app import main as direct_main
-        main = direct_main
-        logger.info("Successfully imported main using direct approach")
-    except ImportError as e2:
-        logger.error(f"All import attempts failed: {e2}")
-        sys.exit(1)
+def main():
+    """Main entry point for the Streamlit app."""
+    logger.info("Starting Streamlit app...")
+    # Import the Streamlit app module directly
+    import src.streamlit_app
+    # Run the Streamlit app
+    src.streamlit_app.main()
 
 if __name__ == "__main__":
     try:

download_model.py

@@ -12,22 +12,31 @@ import sys
 from pathlib import Path
 import logging
 
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger("model-downloader")
+
+# Debug environment info
+logger.info(f"Current working directory: {os.getcwd()}")
+logger.info(f"Python path: {sys.path}")
+logger.info(f"MODEL_REVISION: {os.environ.get('MODEL_REVISION')}")
+logger.info(f"MODEL_HF_REPO: {os.environ.get('MODEL_HF_REPO')}")
+logger.info(f"HF_MODEL_FILENAME: {os.environ.get('HF_MODEL_FILENAME')}")
+
 # Use huggingface_hub for better integration with HF ecosystem
 try:
     from huggingface_hub import hf_hub_download
     HF_HUB_AVAILABLE = True
+    logger.info("huggingface_hub is available")
 except ImportError:
     HF_HUB_AVAILABLE = False
+    logger.warning("huggingface_hub is not available, falling back to direct download")
     import requests
     from tqdm import tqdm
 
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
-logger = logging.getLogger("model-downloader")
-
 def download_file_with_progress(url: str, destination: Path) -> None:
     """Download a file with a progress bar.
     
@@ -61,9 +70,10 @@ def download_file_with_progress(url: str, destination: Path) -> None:
 
 def ensure_model_exists(
     model_filename: str = "best_model_V3.h5",
-    repo_id: str = "dennisvdang/chorus-detection",
-    model_dir: Path = Path("models/CRNN"),
-    hf_model_filename: str = "chorus_detection_crnn.h5"
+    repo_id: str = None,
+    model_dir: Path = None,
+    hf_model_filename: str = None,
+    revision: str = None
 ) -> Path:
     """Ensure the model file exists, downloading it if necessary.
     
@@ -72,12 +82,59 @@ def ensure_model_exists(
         repo_id: HuggingFace repository ID
         model_dir: Directory to save the model to
         hf_model_filename: Filename of the model in the HuggingFace repo
+        revision: Specific version of the model to use (SHA-256 hash)
         
     Returns:
         Path to the model file
     """
+    # Get parameters from environment variables if not provided
+    if repo_id is None:
+        repo_id = os.environ.get("MODEL_HF_REPO", "dennisvdang/chorus-detection")
+    
+    if hf_model_filename is None:
+        hf_model_filename = os.environ.get("HF_MODEL_FILENAME", "chorus_detection_crnn.h5")
+    
+    if revision is None:
+        revision = os.environ.get("MODEL_REVISION", "20e66eb3d0788373c3bdc5b28fa2f2587b0e475f3bbc47e8ab9ff0dbdbb2df32")
+    
+    # Handle model directory paths for different environments
+    if model_dir is None:
+        # Check if we're in HF Spaces
+        if os.environ.get("SPACE_ID"):
+            # Try several possible locations
+            possible_dirs = [
+                Path("models/CRNN"),
+                Path("/home/user/app/models/CRNN"),
+                Path("/app/models/CRNN"),
+                Path(os.getcwd()) / "models" / "CRNN"
+            ]
+            
+            for directory in possible_dirs:
+                if directory.exists() or directory.parent.exists():
+                    model_dir = directory
+                    break
+            
+            # If none exist, use the first option and create it
+            if model_dir is None:
+                model_dir = possible_dirs[0]
+        else:
+            model_dir = Path("models/CRNN")
+    
+    # Make sure model_dir is a Path object
+    if isinstance(model_dir, str):
+        model_dir = Path(model_dir)
+    
+    logger.info(f"Using model directory: {model_dir}")
+    
     model_path = model_dir / model_filename
     
+    # Log environment info when running in HF Space
+    if os.environ.get("SPACE_ID"):
+        logger.info(f"Running in Hugging Face Space: {os.environ.get('SPACE_ID')}")
+        logger.info(f"Using model repo: {repo_id}")
+        logger.info(f"Using model file: {hf_model_filename}")
+        logger.info(f"Using revision: {revision}")
+    
     # Check if the model already exists
     if model_path.exists():
         logger.info(f"Model already exists at {model_path}")
@@ -91,14 +148,17 @@ def ensure_model_exists(
     try:
         if HF_HUB_AVAILABLE:
             # Use huggingface_hub to download the model
-            logger.info(f"Downloading model from {repo_id}/{hf_model_filename} using huggingface_hub")
+            logger.info(f"Downloading model from {repo_id}/{hf_model_filename} (revision: {revision}) using huggingface_hub")
             downloaded_path = hf_hub_download(
                 repo_id=repo_id,
                 filename=hf_model_filename,
                 local_dir=model_dir,
-                local_dir_use_symlinks=False
+                local_dir_use_symlinks=False,
+                revision=revision  # Specify the exact revision to use
             )
             
+            logger.info(f"Downloaded to: {downloaded_path}")
+            
             # Rename if necessary
             if os.path.basename(downloaded_path) != model_filename:
                 downloaded_path_obj = Path(downloaded_path)
@@ -109,20 +169,20 @@ def ensure_model_exists(
                 logger.info(f"Renamed {downloaded_path} to {model_path}")
         else:
             # Fallback to direct download if huggingface_hub is not available
-            huggingface_url = f"https://huggingface.co/{repo_id}/resolve/main/{hf_model_filename}"
+            huggingface_url = f"https://huggingface.co/{repo_id}/resolve/{revision}/{hf_model_filename}"
             download_file_with_progress(huggingface_url, model_path)
         
         logger.info(f"Successfully downloaded model to {model_path}")
         return model_path
     except Exception as e:
-        logger.error(f"Failed to download model: {e}")
-        sys.exit(1)
+        logger.error(f"Failed to download model: {e}", exc_info=True)
+        
+        # Handle error more gracefully in production environment
+        if os.environ.get("SPACE_ID"):
+            logger.warning("Continuing despite model download failure")
+            return model_path
+        else:
+            sys.exit(1)
 
 if __name__ == "__main__":
-    # Allow overriding the repository via environment variable
-    repo_id = os.environ.get("MODEL_HF_REPO", "dennisvdang/chorus-detection")
-    
-    # Check if an alternative model filename was provided
-    hf_model_filename = os.environ.get("HF_MODEL_FILENAME", "chorus_detection_crnn.h5")
-    
-    ensure_model_exists(repo_id=repo_id, hf_model_filename=hf_model_filename) 
+    ensure_model_exists() 

src/streamlit_app.py

@@ -0,0 +1,495 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Streamlit web app for chorus detection in audio files.
+
+This module provides a web-based interface for the chorus detection system,
+allowing users to upload audio files or provide YouTube URLs for analysis.
+"""
+
+import os
+import sys
+import logging
+
+# Configure logging
+logger = logging.getLogger("streamlit-app")
+
+# Configure TensorFlow logging before importing TensorFlow
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'  # Suppress TensorFlow logs
+
+# Import model downloader to ensure model is available
+try:
+    if os.path.exists(os.path.join(os.getcwd(), "download_model.py")):
+        # If in the root directory
+        from download_model import ensure_model_exists
+    else:
+        # If in the src directory
+        sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        from download_model import ensure_model_exists
+except ImportError as e:
+    logger.error(f"Error importing ensure_model_exists: {e}")
+    try:
+        # Try alternative import
+        from src.download_model import ensure_model_exists
+    except ImportError as e2:
+        logger.error(f"Alternative import failed: {e2}")
+        raise
+
+import base64
+import tempfile
+import warnings
+from typing import Optional, Tuple, List
+import time
+import io
+
+import matplotlib.pyplot as plt
+import streamlit as st
+import tensorflow as tf
+import librosa
+import soundfile as sf
+import numpy as np
+from pydub import AudioSegment
+
+# Suppress warnings
+warnings.filterwarnings("ignore")  # Suppress all warnings
+tf.get_logger().setLevel('ERROR')  # Suppress TensorFlow ERROR logs
+
+try:
+    from chorus_detection.audio.data_processing import process_audio
+    from chorus_detection.audio.processor import extract_audio
+    from chorus_detection.models.crnn import load_CRNN_model, make_predictions
+    from chorus_detection.utils.cli import is_youtube_url
+    from chorus_detection.utils.logging import logger
+except ImportError as e:
+    logger.error(f"Error importing chorus_detection modules: {e}")
+    logger.info("Trying alternative imports...")
+    # Adjust import paths as needed
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    from chorus_detection.audio.data_processing import process_audio
+    from chorus_detection.audio.processor import extract_audio
+    from chorus_detection.models.crnn import load_CRNN_model, make_predictions
+    from chorus_detection.utils.cli import is_youtube_url
+    from chorus_detection.utils.logging import logger
+
+# Define the MODEL_PATH directly
+MODEL_PATH = os.path.join(os.getcwd(), "models", "CRNN", "best_model_V3.h5")
+if not os.path.exists(MODEL_PATH):
+    MODEL_PATH = ensure_model_exists()
+
+# Define color scheme
+THEME_COLORS = {
+    'background': '#121212',
+    'card_bg': '#181818',
+    'primary': '#1DB954',
+    'secondary': '#1ED760',
+    'text': '#FFFFFF',
+    'subtext': '#B3B3B3',
+    'highlight': '#1DB954',
+    'border': '#333333',
+}
+
+
+def get_binary_file_downloader_html(bin_file: str, file_label: str = 'File') -> str:
+    """Generate HTML for file download link.
+    
+    Args:
+        bin_file: Path to the binary file
+        file_label: Label for the download link
+        
+    Returns:
+        HTML string for the download link
+    """
+    with open(bin_file, 'rb') as f:
+        data = f.read()
+    b64 = base64.b64encode(data).decode()
+    return f'<a href="data:application/octet-stream;base64,{b64}" download="{os.path.basename(bin_file)}">{file_label}</a>'
+
+
+def set_custom_theme() -> None:
+    """Apply custom Spotify-inspired theme to Streamlit UI."""
+    custom_theme = f"""
+    <style>
+        .stApp {{
+            background-color: {THEME_COLORS['background']};
+            color: {THEME_COLORS['text']};
+        }}
+        .css-18e3th9 {{
+            padding-top: 2rem;
+            padding-bottom: 10rem;
+            padding-left: 5rem;
+            padding-right: 5rem;
+        }}
+        h1, h2, h3, h4, h5, h6 {{
+            color: {THEME_COLORS['text']} !important;
+            font-weight: 700 !important;
+        }}
+        .stSidebar .sidebar-content {{
+            background-color: {THEME_COLORS['card_bg']};
+        }}
+        .stButton>button {{
+            background-color: {THEME_COLORS['primary']};
+            color: white;
+            border-radius: 500px;
+            padding: 8px 32px;
+            font-weight: 600;
+            border: none;
+            transition: all 0.3s ease;
+        }}
+        .stButton>button:hover {{
+            background-color: {THEME_COLORS['secondary']};
+            transform: scale(1.04);
+        }}
+    </style>
+    """
+    st.markdown(custom_theme, unsafe_allow_html=True)
+
+
+def process_youtube(url: str) -> Tuple[Optional[str], Optional[str]]:
+    """Process a YouTube URL and extract audio.
+    
+    Args:
+        url: YouTube URL
+        
+    Returns:
+        Tuple of (audio_path, video_name)
+    """
+    try:
+        with st.spinner('Downloading audio from YouTube...'):
+            audio_path, video_name = extract_audio(url)
+            return audio_path, video_name
+    except Exception as e:
+        st.error(f"Error processing YouTube URL: {e}")
+        logger.error(f"Error processing YouTube URL: {e}", exc_info=True)
+        return None, None
+
+
+def process_uploaded_file(uploaded_file) -> Tuple[Optional[str], Optional[str]]:
+    """Process an uploaded audio file.
+    
+    Args:
+        uploaded_file: Streamlit UploadedFile object
+        
+    Returns:
+        Tuple of (audio_path, file_name)
+    """
+    try:
+        with st.spinner('Processing uploaded file...'):
+            # Save the uploaded file to a temporary location
+            temp_dir = tempfile.mkdtemp()
+            file_name = uploaded_file.name
+            temp_path = os.path.join(temp_dir, file_name)
+            
+            with open(temp_path, 'wb') as f:
+                f.write(uploaded_file.getbuffer())
+            
+            return temp_path, file_name.split('.')[0]
+    except Exception as e:
+        st.error(f"Error processing uploaded file: {e}")
+        logger.error(f"Error processing uploaded file: {e}", exc_info=True)
+        return None, None
+
+
+def extract_chorus_segments(y: np.ndarray, sr: int, smoothed_predictions: np.ndarray, 
+                       meter_grid_times: np.ndarray) -> List[Tuple[float, float, np.ndarray]]:
+    """Extract chorus segments from predictions.
+    
+    Args:
+        y: Audio data
+        sr: Sample rate
+        smoothed_predictions: Smoothed model predictions
+        meter_grid_times: Time grid for predictions
+        
+    Returns:
+        List of (start_time, end_time, audio_segment) tuples
+    """
+    # Define threshold for chorus detection (probability > 0.5)
+    threshold = 0.5
+    
+    # Find the segments where the predictions are above the threshold
+    chorus_mask = smoothed_predictions > threshold
+    
+    # Group consecutive True values to identify segments
+    segments = []
+    current_segment = None
+    
+    for i, is_chorus in enumerate(chorus_mask):
+        time = meter_grid_times[i]
+        
+        if is_chorus and current_segment is None:
+            # Start a new segment
+            current_segment = (time, None, None)
+        elif not is_chorus and current_segment is not None:
+            # End the current segment
+            start_time = current_segment[0]
+            current_segment = (start_time, time, None)
+            segments.append(current_segment)
+            current_segment = None
+    
+    # Handle the case where the last segment extends to the end of the song
+    if current_segment is not None:
+        start_time = current_segment[0]
+        segments.append((start_time, meter_grid_times[-1], None))
+    
+    # Extract the actual audio for each segment
+    segments_with_audio = []
+    for start_time, end_time, _ in segments:
+        # Convert times to sample indices
+        start_idx = int(start_time * sr)
+        end_idx = int(end_time * sr)
+        
+        # Extract the audio segment
+        segment_audio = y[start_idx:end_idx]
+        
+        segments_with_audio.append((start_time, end_time, segment_audio))
+    
+    return segments_with_audio
+
+
+def create_chorus_compilation(segments: List[Tuple[float, float, np.ndarray]], 
+                         sr: int, fade_duration: float = 0.3) -> Tuple[np.ndarray, str]:
+    """Create a compilation of chorus segments.
+    
+    Args:
+        segments: List of (start_time, end_time, audio_data) tuples
+        sr: Sample rate
+        fade_duration: Duration of fade in/out in seconds
+        
+    Returns:
+        Tuple of (compilation_audio, description)
+    """
+    if not segments:
+        return np.array([]), "No chorus segments found"
+    
+    # Calculate the number of samples for fading
+    fade_samples = int(fade_duration * sr)
+    
+    # Prepare a list to store the processed segments
+    processed_segments = []
+    
+    # Description of segments
+    segment_descriptions = []
+    
+    # Process each segment
+    for i, (start_time, end_time, audio) in enumerate(segments):
+        # Apply fade in and fade out
+        segment_length = len(audio)
+        
+        if segment_length <= 2 * fade_samples:
+            # Segment is too short for fading, skip it
+            continue
+        
+        # Create a linear fade in and fade out
+        fade_in = np.linspace(0, 1, fade_samples)
+        fade_out = np.linspace(1, 0, fade_samples)
+        
+        # Apply the fades
+        audio_faded = audio.copy()
+        audio_faded[:fade_samples] *= fade_in
+        audio_faded[-fade_samples:] *= fade_out
+        
+        processed_segments.append(audio_faded)
+        
+        # Format the times for the description
+        start_fmt = format_time(start_time)
+        end_fmt = format_time(end_time)
+        segment_descriptions.append(f"Chorus {i+1}: {start_fmt} - {end_fmt}")
+    
+    if not processed_segments:
+        return np.array([]), "No chorus segments long enough for compilation"
+    
+    # Concatenate all the processed segments
+    compilation = np.concatenate(processed_segments)
+    
+    # Join the descriptions
+    description = "\n".join(segment_descriptions)
+    
+    return compilation, description
+
+
+def save_audio_for_streamlit(audio_data: np.ndarray, sr: int, file_format: str = 'mp3') -> bytes:
+    """Save audio data to a format suitable for Streamlit audio playback.
+    
+    Args:
+        audio_data: Audio samples
+        sr: Sample rate
+        file_format: Output format ('mp3', 'wav', etc.)
+        
+    Returns:
+        Audio bytes
+    """
+    with io.BytesIO() as buffer:
+        sf.write(buffer, audio_data, sr, format=file_format)
+        buffer.seek(0)
+        return buffer.read()
+
+
+def format_time(seconds: float) -> str:
+    """Format seconds as MM:SS.
+    
+    Args:
+        seconds: Time in seconds
+        
+    Returns:
+        Formatted time string
+    """
+    minutes = int(seconds // 60)
+    seconds = int(seconds % 60)
+    return f"{minutes:02d}:{seconds:02d}"
+
+
+def main() -> None:
+    """Main function for the Streamlit app."""
+    # Set page config
+    st.set_page_config(
+        page_title="Chorus Detection",
+        page_icon="🎵",
+        layout="wide",
+        initial_sidebar_state="collapsed",
+    )
+    
+    # Apply custom theme
+    set_custom_theme()
+    
+    # App title and description
+    st.title("Chorus Detection")
+    st.markdown("""
+    <div class="subheader">
+    Upload a song or enter a YouTube URL to automatically detect chorus sections using AI
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # User input section
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown('<div class="input-option">', unsafe_allow_html=True)
+        st.subheader("Option 1: Upload an audio file")
+        uploaded_file = st.file_uploader("Choose an audio file", type=['mp3', 'wav', 'ogg', 'flac', 'm4a'])
+        st.markdown('</div>', unsafe_allow_html=True)
+    
+    with col2:
+        st.markdown('<div class="input-option">', unsafe_allow_html=True)
+        st.subheader("Option 2: YouTube URL")
+        youtube_url = st.text_input("Enter a YouTube URL", placeholder="https://www.youtube.com/watch?v=...")
+        st.markdown('</div>', unsafe_allow_html=True)
+    
+    # Process button
+    if st.button("Analyze"):
+        # Check the input method
+        audio_path = None
+        file_name = None
+        
+        if uploaded_file is not None:
+            audio_path, file_name = process_uploaded_file(uploaded_file)
+        elif youtube_url:
+            if is_youtube_url(youtube_url):
+                audio_path, file_name = process_youtube(youtube_url)
+            else:
+                st.error("Invalid YouTube URL. Please enter a valid YouTube URL.")
+        else:
+            st.error("Please upload an audio file or enter a YouTube URL.")
+        
+        # If we have a valid audio path, process it
+        if audio_path and file_name:
+            try:
+                # Load and process the audio file
+                with st.spinner('Processing audio...'):
+                    # Load audio and extract features
+                    y, sr = librosa.load(audio_path, sr=22050)
+                    
+                    # Create a temporary directory for model output
+                    temp_output_dir = tempfile.mkdtemp()
+                    
+                    # Load the model
+                    model = load_CRNN_model(MODEL_PATH)
+                    
+                    # Process audio and make predictions
+                    audio_features, _ = process_audio(audio_path, output_path=temp_output_dir)
+                    meter_grid_times, predictions = make_predictions(model, audio_features)
+                    
+                    # Smooth predictions to avoid rapid transitions
+                    smoothed_predictions = np.convolve(predictions, 
+                                                     np.ones(5)/5, 
+                                                     mode='same')
+                    
+                    # Extract chorus segments
+                    chorus_segments = extract_chorus_segments(y, sr, smoothed_predictions, meter_grid_times)
+                    
+                    # Create a chorus compilation
+                    compilation_audio, segments_desc = create_chorus_compilation(chorus_segments, sr)
+                    
+                # Display results
+                st.markdown(f"""
+                <div class="result-container">
+                    <div class="song-title">{file_name}</div>
+                </div>
+                """, unsafe_allow_html=True)
+                
+                # Display waveform with highlighted chorus sections
+                fig, ax = plt.subplots(figsize=(14, 5))
+                
+                # Plot the waveform
+                times = np.linspace(0, len(y)/sr, len(y))
+                ax.plot(times, y, color='#b3b3b3', alpha=0.5, linewidth=1)
+                ax.set_xlabel('Time (s)')
+                ax.set_ylabel('Amplitude')
+                ax.set_title('Audio Waveform with Chorus Sections Highlighted')
+                
+                # Highlight chorus sections
+                for start_time, end_time, _ in chorus_segments:
+                    ax.axvspan(start_time, end_time, alpha=0.3, color=THEME_COLORS['primary'])
+                    
+                    # Add a label at the start of each chorus
+                    ax.annotate('Chorus', 
+                               xy=(start_time, 0.8 * max(y)), 
+                               xytext=(start_time + 0.5, 0.9 * max(y)),
+                               color=THEME_COLORS['primary'],
+                               weight='bold')
+                
+                # Customize plot appearance
+                ax.set_facecolor(THEME_COLORS['card_bg'])
+                fig.patch.set_facecolor(THEME_COLORS['background'])
+                ax.spines['top'].set_visible(False)
+                ax.spines['right'].set_visible(False)
+                ax.spines['bottom'].set_color(THEME_COLORS['border'])
+                ax.spines['left'].set_color(THEME_COLORS['border'])
+                ax.tick_params(axis='x', colors=THEME_COLORS['text'])
+                ax.tick_params(axis='y', colors=THEME_COLORS['text'])
+                ax.xaxis.label.set_color(THEME_COLORS['text'])
+                ax.yaxis.label.set_color(THEME_COLORS['text'])
+                ax.title.set_color(THEME_COLORS['text'])
+                
+                st.pyplot(fig)
+                
+                # Display chorus segments
+                if chorus_segments:
+                    st.markdown('<div class="chorus-card">', unsafe_allow_html=True)
+                    st.subheader("Chorus Segments")
+                    for i, (start_time, end_time, segment_audio) in enumerate(chorus_segments):
+                        st.markdown(f"""
+                        <div class="time-stamp">Chorus {i+1}: {format_time(start_time)} - {format_time(end_time)}</div>
+                        """, unsafe_allow_html=True)
+                        
+                        # Convert segment audio to bytes for playback
+                        audio_bytes = save_audio_for_streamlit(segment_audio, sr)
+                        st.audio(audio_bytes, format='audio/mp3')
+                    st.markdown('</div>', unsafe_allow_html=True)
+                    
+                    # Chorus compilation
+                    if len(compilation_audio) > 0:
+                        st.markdown('<div class="chorus-card">', unsafe_allow_html=True)
+                        st.subheader("Chorus Compilation")
+                        st.markdown("All chorus segments combined into one track:")
+                        
+                        compilation_bytes = save_audio_for_streamlit(compilation_audio, sr)
+                        st.audio(compilation_bytes, format='audio/mp3')
+                        st.markdown('</div>', unsafe_allow_html=True)
+                else:
+                    st.info("No chorus sections detected in this audio.")
+                
+            except Exception as e:
+                st.error(f"Error processing audio: {e}")
+                logger.error(f"Error processing audio: {e}", exc_info=True)
+
+if __name__ == "__main__":
+    main()