Configure containerized Streamlit app for HF Spaces

.space/config.json

@@ -1,11 +1,31 @@
 {
-  "app_file": "src/app.py",
+  "docker": {
+    "image": "Dockerfile",
+    "env": {
+      "PYTHONPATH": "$PYTHONPATH:/app:/app/src",
+      "MODEL_REVISION": "20e66eb3d0788373c3bdc5b28fa2f2587b0e475f3bbc47e8ab9ff0dbdbb2df32",
+      "MODEL_HF_REPO": "dennisvdang/chorus-detection",
+      "HF_MODEL_FILENAME": "chorus_detection_crnn.h5"
+    }
+  },
+  "runtime": {
+    "storage": {
+      "models": {
+        "writable": true,
+        "mount": true
+      }
+    }
+  },
+  "app": {
+    "port": 7860,
+    "entrypoint": ".space/app-entrypoint.sh"
+  },
+  "app_file": "app.py",
   "docker_build_args": {
     "MODEL_HF_REPO": "dennisvdang/chorus-detection"
   },
   "sdk": "streamlit",
   "python_requirements": "requirements.txt",
   "suggested_hardware": "t4-small",
-  "suggested_cuda": "11.8",
-  "app_entrypoint": ".space/app-entrypoint.sh"
+  "suggested_cuda": "11.8"
 } 

Dockerfile

@@ -0,0 +1,38 @@
+FROM python:3.9-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONPATH="${PYTHONPATH}:/app:/app/src"
+ENV MODEL_REVISION="20e66eb3d0788373c3bdc5b28fa2f2587b0e475f3bbc47e8ab9ff0dbdbb2df32"
+ENV MODEL_HF_REPO="dennisvdang/chorus-detection"
+ENV HF_MODEL_FILENAME="chorus_detection_crnn.h5"
+
+# Set work directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y ffmpeg && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+# Copy app files
+COPY . .
+
+# Install package in development mode
+RUN pip install -e .
+
+# Make the entry point script executable
+RUN if [ -f .space/app-entrypoint.sh ]; then chmod +x .space/app-entrypoint.sh; fi
+
+# Ensure model exists
+RUN python -c "from src.download_model import ensure_model_exists; ensure_model_exists(revision='${MODEL_REVISION}')"
+
+# Expose port for Streamlit
+EXPOSE 7860
+
+# Run the app
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]
+

README_HF.md

@@ -0,0 +1,30 @@
+# Chorus Detection
+
+This app automatically finds the chorus sections in songs using machine learning.
+
+## How to Use
+
+1. **Upload a song** or **enter a YouTube URL**
+2. Click **Analyze**
+3. The app will:
+   - Process the audio
+   - Detect chorus sections
+   - Generate a visualization
+   - Create a chorus compilation
+
+## Technical Details
+
+- Uses a CRNN (Convolutional Recurrent Neural Network) model
+- Trained on a dataset of manually labeled chorus sections
+- Model ID: `dennisvdang/chorus-detection`
+- Processes audio in real-time using TensorFlow
+
+## Features
+
+- Chorus detection in any music track
+- Audio visualization with highlighted chorus sections
+
+
+## Contact
+
+Created by [Dennis Dang](https://huggingface.co/dennisvdang). For more details, check out the [GitHub repository](https://github.com/dennisvdang/chorus-detection). 

app.py

@@ -1,653 +1,47 @@
 #!/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.
+"""
+Main entry point for the Chorus Detection Streamlit app.
+This file ensures the correct import paths are set up before running the app.
 """
 
 import os
-# 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
+import sys
+import logging
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"
+)
+logger = logging.getLogger("chorus-detection")
+
+# 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"PYTHONPATH: {os.environ.get('PYTHONPATH')}")
+    logger.info(f"MODEL_REVISION: {os.environ.get('MODEL_REVISION')}")
+
+# Add the src directory to the Python path
 try:
-    from download_model import ensure_model_exists
-except ImportError:
-    from src.download_model import ensure_model_exists
-
-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
-
-from chorus_detection.audio.data_processing import process_audio
-from chorus_detection.audio.processor import extract_audio
-from chorus_detection.config import MODEL_PATH
-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
-
-# Ensure the model is downloaded before proceeding
-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);
-        }}
-        .stTextInput>div>div>input,
-        .stFileUploader>div>div {{
-            background-color: {THEME_COLORS['card_bg']};
-            color: {THEME_COLORS['text']};
-            border: 1px solid {THEME_COLORS['border']};
-            border-radius: 4px;
-        }}
-        .stExpander {{
-            background-color: {THEME_COLORS['card_bg']};
-            border-radius: 8px;
-            margin-bottom: 10px;
-            border: 1px solid {THEME_COLORS['border']};
-        }}
-        .stExpander>div {{
-            border: none !important;
-        }}
-        .chorus-card {{
-            background-color: {THEME_COLORS['card_bg']};
-            border-radius: 8px;
-            padding: 20px;
-            margin-bottom: 15px;
-            border: 1px solid {THEME_COLORS['border']};
-        }}
-        .result-container {{
-            padding: 20px;
-            border-radius: 8px;
-            background-color: {THEME_COLORS['card_bg']};
-            margin-bottom: 20px;
-            border: 1px solid {THEME_COLORS['border']};
-        }}
-        .song-title {{
-            font-size: 24px;
-            font-weight: 700;
-            color: {THEME_COLORS['text']};
-            margin-bottom: 10px;
-        }}
-        .time-stamp {{
-            color: {THEME_COLORS['primary']};
-            font-weight: 600;
-        }}
-        audio {{
-            width: 100%;
-            border-radius: 500px;
-            margin-top: 10px;
-        }}
-        .stAlert {{
-            background-color: {THEME_COLORS['card_bg']};
-            color: {THEME_COLORS['text']};
-            border: 1px solid {THEME_COLORS['border']};
-        }}
-        .stRadio > div {{
-            gap: 1rem;
-        }}
-        .stRadio label {{
-            background-color: {THEME_COLORS['card_bg']};
-            padding: 10px 20px;
-            border-radius: 500px;
-            margin-right: 10px;
-            border: 1px solid {THEME_COLORS['border']};
-        }}
-        .stRadio label:hover {{
-            border-color: {THEME_COLORS['primary']};
-        }}
-        .stRadio [data-baseweb="radio"] {{
-            margin-right: 20px;
-        }}
-        .subheader {{
-            color: {THEME_COLORS['subtext']};
-            font-size: 14px;
-            margin-bottom: 20px;
-        }}
-        .input-option {{
-            background-color: {THEME_COLORS['card_bg']};
-            border-radius: 10px;
-            padding: 25px;
-            margin-bottom: 20px;
-            border: 1px solid {THEME_COLORS['border']};
-        }}
-        .or-divider {{
-            text-align: center;
-            font-size: 18px;
-            font-weight: 600;
-            color: {THEME_COLORS['text']};
-            margin: 20px 0;
-            position: relative;
-        }}
-        .or-divider:before, .or-divider:after {{
-            content: "";
-            display: inline-block;
-            width: 40%;
-            margin: 0 10px;
-            vertical-align: middle;
-            border-top: 1px solid {THEME_COLORS['border']};
-        }}
-    </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 to process
-        
-    Returns:
-        Tuple containing the path to the extracted audio file and the video title
-    """
-    progress_bar = st.progress(0)
-    status_text = st.empty()
-    
-    try:
-        status_text.text("Getting video information...")
-        progress_bar.progress(10)
-        
-        status_text.text("Downloading audio from YouTube...")
-        progress_bar.progress(30)
-        
-        # Use yt-dlp to download the video
-        audio_path, video_name = extract_audio(url)
-        
-        if not audio_path:
-            status_text.text("Download failed.")
-            progress_bar.progress(100)
-            
-            st.error("Failed to extract audio from the provided URL.")
-            st.info("Try downloading the video manually and uploading it instead.")
-            return None, None
-        
-        progress_bar.progress(90)
-        status_text.text(f"Successfully downloaded '{video_name}'")
-        progress_bar.progress(100)
-        return audio_path, video_name
-        
-    except Exception as e:
-        import traceback
-        progress_bar.progress(100)
-        status_text.text("Download failed with an error.")
-        st.error(f"Failed to extract audio: {str(e)}")
-        st.code(traceback.format_exc())
-        return None, None
-
-
-def process_uploaded_file(uploaded_file) -> Tuple[Optional[str], Optional[str]]:
-    """Process an uploaded audio file.
-    
-    Args:
-        uploaded_file: File uploaded through Streamlit
-        
-    Returns:
-        Tuple containing the path to the saved file and the file name
-    """
-    try:
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp3') as tmp:
-            tmp.write(uploaded_file.getvalue())
-            audio_path = tmp.name
-        return audio_path, uploaded_file.name
-    except Exception as e:
-        st.error(f"Error processing uploaded file: {e}")
-        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 the audio array with 1 second before each chorus.
-    
-    Args:
-        y: Audio array
-        sr: Sample rate
-        smoothed_predictions: Array of binary predictions
-        meter_grid_times: Array of meter grid times
-        
-    Returns:
-        List of tuples (start_time, end_time, audio_segment)
-    """
-    # Find continuous chorus segments
-    chorus_segments = []
-    start_idx = None
-    
-    for i, pred in enumerate(smoothed_predictions):
-        if pred == 1 and (i == 0 or smoothed_predictions[i-1] == 0):
-            start_idx = i
-        elif pred == 0 and start_idx is not None:
-            # Found the end of a segment
-            start_time = meter_grid_times[start_idx]
-            end_time = meter_grid_times[i]
-            chorus_segments.append((start_idx, i, start_time, end_time))
-            start_idx = None
-    
-    # Handle the case where the last segment extends to the end
-    if start_idx is not None:
-        start_time = meter_grid_times[start_idx]
-        end_time = meter_grid_times[-1] if len(meter_grid_times) > start_idx + 1 else len(y) / sr
-        chorus_segments.append((start_idx, len(smoothed_predictions), start_time, end_time))
-    
-    # Extract the audio segments with 1 second before each chorus
-    extracted_segments = []
-    for _, _, start_time, end_time in chorus_segments:
-        # Add 1 second before the chorus starts
-        adjusted_start_time = max(0, start_time - 1.0)
-        # Convert times to samples
-        start_sample = int(adjusted_start_time * sr)
-        end_sample = min(len(y), int(end_time * sr))
-        # Extract the segment
-        segment = y[start_sample:end_sample]
-        extracted_segments.append((adjusted_start_time, end_time, segment))
-    
-    return extracted_segments
-
-
-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 all chorus segments with fading between segments.
-    
-    Args:
-        segments: List of tuples (start_time, end_time, audio_segment)
-        sr: Sample rate
-        fade_duration: Duration of fade in/out in seconds
-        
-    Returns:
-        Tuple containing the compiled audio array and a string with timing info
-    """
-    if not segments:
-        return np.array([]), ""
-    
-    # Create a compilation of all segments
-    compilation = np.array([])
-    timing_info = ""
-    current_position = 0
-    
-    for i, (start_time, end_time, segment) in enumerate(segments):
-        # Add 0.5 seconds of silence between segments
-        if i > 0:
-            silence_samples = int(0.5 * sr)
-            compilation = np.concatenate([compilation, np.zeros(silence_samples)])
-            current_position += 0.5
-        
-        # Add segment info to timing
-        minutes_start = int(current_position // 60)
-        seconds_start = int(current_position % 60)
-        
-        # Add the segment
-        compilation = np.concatenate([compilation, segment])
-        
-        # Update current position
-        segment_duration = len(segment) / sr
-        current_position += segment_duration
-        
-        minutes_end = int(current_position // 60)
-        seconds_end = int(current_position % 60)
-        
-        # Original times in the song
-        orig_min_start = int(start_time // 60)
-        orig_sec_start = int(start_time % 60)
-        orig_min_end = int(end_time // 60)
-        orig_sec_end = int(end_time % 60)
-        
-        # Add timing info
-        timing_info += f"Chorus {i+1}: {minutes_start}:{seconds_start:02d} - {minutes_end}:{seconds_end:02d} "
-        timing_info += f"(Original: {orig_min_start}:{orig_sec_start:02d} - {orig_min_end}:{orig_sec_end:02d})\n"
-    
-    return compilation, timing_info
-
-
-def save_audio_for_streamlit(audio_data: np.ndarray, sr: int, file_format: str = 'mp3') -> bytes:
-    """Save audio data to a BytesIO object for use with st.audio.
-    
-    Args:
-        audio_data: Audio array
-        sr: Sample rate
-        file_format: Audio file format
-        
-    Returns:
-        BytesIO object containing the audio data
-    """
-    buffer = io.BytesIO()
-    sf.write(buffer, audio_data, sr, format=file_format)
-    buffer.seek(0)
-    return buffer
-
-
-def format_time(seconds: float) -> str:
-    """Format time in seconds to MM:SS format.
-    
-    Args:
-        seconds: Time in seconds
-        
-    Returns:
-        Formatted time string
-    """
-    minutes = int(seconds // 60)
-    secs = int(seconds % 60)
-    return f"{minutes}:{secs:02d}"
-
-
-def create_waveform_visualization(audio_features, smoothed_predictions, meter_grid_times):
-    """Create waveform visualization with highlighted chorus sections.
-    
-    Args:
-        audio_features: Audio features
-        smoothed_predictions: Array of binary predictions
-        meter_grid_times: Array of meter grid times
-        
-    Returns:
-        Matplotlib figure with visualization
-    """
-    from chorus_detection.visualization.plotter import plot_meter_lines
-    
-    # Set Matplotlib style to be dark and minimal
-    plt.style.use('dark_background')
-    
-    fig, ax = plt.subplots(figsize=(12, 4), dpi=120)
-    
-    # Display harmonic and percussive components
-    librosa.display.waveshow(audio_features.y_harm, sr=audio_features.sr,
-                           alpha=0.8, ax=ax, color='#1DB954')  # Primary color
-    librosa.display.waveshow(audio_features.y_perc, sr=audio_features.sr,
-                           alpha=0.7, ax=ax, color='#B3B3B3')  # Light gray
-    plot_meter_lines(ax, meter_grid_times)
-
-    # Highlight chorus sections
-    for i, prediction in enumerate(smoothed_predictions):
-        start_time = meter_grid_times[i]
-        end_time = meter_grid_times[i + 1] if i < len(
-            meter_grid_times) - 1 else len(audio_features.y) / audio_features.sr
-        if prediction == 1:
-            ax.axvspan(start_time, end_time, color='#1DB954', alpha=0.3,
-                    label='Predicted Chorus' if i == 0 else None)
-
-    # Set plot limits and labels
-    ax.set_xlim([0, len(audio_features.y) / audio_features.sr])
-    ax.set_ylabel('Amplitude', color='#FFFFFF')
-    
-    # Add legend
-    chorus_patch = plt.Rectangle((0, 0), 1, 1, fc='#1DB954', alpha=0.3)
-    handles, labels = ax.get_legend_handles_labels()
-    handles.append(chorus_patch)
-    labels.append('Chorus')
-    ax.legend(handles=handles, labels=labels)
-
-    # Set x-tick labels in minutes:seconds format
-    duration = len(audio_features.y) / audio_features.sr
-    xticks = [i for i in range(0, int(duration) + 10, 30)]  # Every 30 seconds
-    xlabels = [f"{int(tick // 60)}:{int(tick % 60):02d}" for tick in xticks]
-    ax.set_xticks(xticks)
-    ax.set_xticklabels(xlabels, color='#FFFFFF')
-    ax.tick_params(axis='y', colors='#FFFFFF')
-    
-    # Style the plot
-    ax.spines['top'].set_visible(False)
-    ax.spines['right'].set_visible(False)
-    ax.spines['bottom'].set_color('#333333')
-    ax.spines['left'].set_color('#333333')
-    ax.set_facecolor('#121212')
-    fig.patch.set_facecolor('#121212')
-
-    plt.tight_layout()
-    return fig
+    sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
+    logger.info(f"Added src directory to Python path: {os.path.join(os.path.dirname(__file__), 'src')}")
+except Exception as e:
+    logger.error(f"Error setting up Python path: {e}")
+    sys.exit(1)
 
+# Import the app module from src
+try:
+    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}")
+    sys.exit(1)
 
-def analyze_audio(audio_path: str, video_name: str, model_path: str = str(MODEL_PATH)) -> None:
-    """Analyze audio file and display predictions.
-    
-    Args:
-        audio_path: Path to the audio file
-        video_name: Name of the video or audio file
-        model_path: Path to the model file
-    """
+if __name__ == "__main__":
     try:
-        # Process audio
-        with st.spinner("Processing audio..."):
-            processed_audio, audio_features = process_audio(audio_path)
-            
-        if processed_audio is None:
-            st.error("Failed to process audio. Please try a different file.")
-            return
-
-        # Load model
-        with st.spinner("Loading model..."):
-            model = load_CRNN_model(model_path=model_path)
-
-        # Make predictions
-        with st.spinner("Generating predictions..."):
-            smoothed_predictions = make_predictions(model, processed_audio, audio_features, None, None)
-            
-            # Get chorus start times
-            meter_grid_times = librosa.frames_to_time(
-                audio_features.meter_grid, sr=audio_features.sr, hop_length=audio_features.hop_length)
-            chorus_start_times = [
-                meter_grid_times[i] for i in range(len(smoothed_predictions)) 
-                if smoothed_predictions[i] == 1 and (i == 0 or smoothed_predictions[i - 1] == 0)
-            ]
-        
-        # Extract chorus segments
-        chorus_segments = []
-        chorus_audio = None
-        
-        if chorus_start_times:
-            with st.spinner("Extracting chorus segments..."):
-                chorus_segments = extract_chorus_segments(
-                    audio_features.y, audio_features.sr, smoothed_predictions, meter_grid_times)
-                
-                compilation, _ = create_chorus_compilation(
-                    chorus_segments, audio_features.sr)
-                
-                if len(compilation) > 0:
-                    chorus_audio = save_audio_for_streamlit(compilation, audio_features.sr)
-
-        # Create waveform visualization
-        waveform_fig = create_waveform_visualization(audio_features, smoothed_predictions, meter_grid_times)
-
-        # Display results in custom-style container
-        st.markdown('<div class="result-container">', unsafe_allow_html=True)
-        st.subheader("Results")
-        st.markdown(f'<div class="song-title">{video_name}</div>', unsafe_allow_html=True)
-        
-        # Display waveform
-        st.pyplot(waveform_fig)
-        
-        if chorus_start_times:
-            # Create chorus compilation section
-            st.markdown("### Chorus Compilation")
-            st.markdown('<div class="subheader">All choruses with 1-second lead-in</div>', unsafe_allow_html=True)
-            st.audio(chorus_audio, format="audio/mp3")
-            
-            # Display individual chorus segments
-            st.markdown("### Chorus Segments")
-            
-            # Create columns for each chorus segment
-            for i, (start_time, end_time, segment) in enumerate(chorus_segments):
-                segment_audio = save_audio_for_streamlit(segment, audio_features.sr)
-                
-                st.markdown(f"""
-                <div class="chorus-card">
-                    <span style="font-weight: 700;">Chorus {i+1}:</span> 
-                    <span class="time-stamp">{format_time(start_time)} - {format_time(end_time)}</span>
-                </div>
-                """, unsafe_allow_html=True)
-                
-                st.audio(segment_audio, format="audio/mp3")
-        else:
-            st.warning("No choruses were identified in this song.")
-        
-        st.markdown('</div>', unsafe_allow_html=True)
-
+        main()
     except Exception as e:
-        st.error(f"An error occurred: {e}")
-        import traceback
-        st.error(traceback.format_exc())
-
-
-def main() -> None:
-    """Main function for the Streamlit app."""
-    st.set_page_config(
-        page_title="Automated Chorus Detection",
-        page_icon="🎵",
-        layout="wide",
-        initial_sidebar_state="expanded",
-    )
-    
-    # Apply custom theme
-    set_custom_theme()
-
-    # Header
-    col1, col2 = st.columns([1, 5])
-    with col2:
-        st.title("Automated Chorus Detection")
-        st.markdown('<div class="subheader">Analyze songs and identify chorus sections using AI</div>', unsafe_allow_html=True)
-
-    # Sidebar
-    st.sidebar.markdown("## About")
-    st.sidebar.markdown("""
-    This app uses a deep learning model trained on over 300 annotated songs 
-    to identify chorus sections in music.
-    
-    **Features:**
-    - Detects chorus sections in songs
-    - Creates playable audio snippets of choruses
-    - Visualizes audio waveform with highlighted choruses
-    
-    For more information, visit the [GitHub repository](https://github.com/dennisvdang/chorus-detection).
-    """)
-
-    # Main content with vertically stacked input methods
-    st.markdown("## Select Input Method")
-    
-    # File upload option (now first)
-    st.markdown("### Upload Audio File")
-    uploaded_file = st.file_uploader(
-        "", 
-        type=["mp3", "wav", "ogg", "flac", "m4a"],
-        help="Upload an audio file in MP3, WAV, OGG, FLAC, or M4A format",
-        key="file_upload"
-    )
-    
-    if uploaded_file is not None:
-        st.audio(uploaded_file, format="audio/mp3")
-    
-    upload_process_button = st.button("Process Uploaded Audio")
-    
-    # OR divider
-    st.markdown('<div class="or-divider">OR</div>', unsafe_allow_html=True)
-    
-    # YouTube URL input (now second)
-    st.markdown("### YouTube URL")
-    url = st.text_input(
-        "", 
-        placeholder="Paste a YouTube video URL here...", 
-        help="Enter the URL of a YouTube video to analyze",
-        key="youtube_url"
-    )
-    
-    youtube_process_button = st.button("Process YouTube Video")
-    
-    # Process uploaded file if selected
-    if uploaded_file is not None and upload_process_button:
-        audio_path, file_name = process_uploaded_file(uploaded_file)
-        if audio_path:
-            analyze_audio(audio_path, file_name)
-            # Clean up the temporary file
-            try:
-                os.remove(audio_path)
-            except:
-                pass
-    
-    # Process YouTube URL if selected
-    if youtube_process_button and url:
-        if not is_youtube_url(url):
-            st.error("Please enter a valid YouTube URL.")
-        else:
-            audio_path, video_name = process_youtube(url)
-            if audio_path:
-                analyze_audio(audio_path, video_name)
-                # Clean up the temporary file
-                try:
-                    os.remove(audio_path)
-                except:
-                    pass
-
-
-if __name__ == "__main__":
-    main() 
+        logger.error(f"Error running main: {e}", exc_info=True)
+        sys.exit(1) 

src

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Script to download the chorus detection model from HuggingFace.
+
+This script checks if the model file exists locally, and if not, downloads it
+from the specified HuggingFace repository.
+"""
+
+import os
+import sys
+from pathlib import Path
+import logging
+
+# Use huggingface_hub for better integration with HF ecosystem
+try:
+    from huggingface_hub import hf_hub_download
+    HF_HUB_AVAILABLE = True
+except ImportError:
+    HF_HUB_AVAILABLE = False
+    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.
+    
+    Args:
+        url: URL to download from
+        destination: Path to save the file to
+    """
+    # Create parent directories if they don't exist
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    
+    # Stream the download with progress bar
+    response = requests.get(url, stream=True)
+    response.raise_for_status()
+    
+    total_size = int(response.headers.get('content-length', 0))
+    block_size = 1024  # 1 Kibibyte
+    
+    logger.info(f"Downloading model from {url}")
+    logger.info(f"File size: {total_size / (1024*1024):.1f} MB")
+    
+    with open(destination, 'wb') as file, tqdm(
+            desc=destination.name,
+            total=total_size,
+            unit='iB',
+            unit_scale=True,
+            unit_divisor=1024,
+    ) as bar:
+        for data in response.iter_content(block_size):
+            size = file.write(data)
+            bar.update(size)
+
+def ensure_model_exists(
+    model_filename: str = "best_model_V3.h5",
+    repo_id: str = None,
+    model_dir: Path = Path("models/CRNN"),
+    hf_model_filename: str = None,
+    revision: str = None
+) -> Path:
+    """Ensure the model file exists, downloading it if necessary.
+    
+    Args:
+        model_filename: Local filename for the model
+        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")
+    
+    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}")
+        return model_path
+    
+    # Create model directory if it doesn't exist
+    model_dir.mkdir(parents=True, exist_ok=True)
+    
+    logger.info(f"Model not found at {model_path}. Downloading...")
+    
+    try:
+        if HF_HUB_AVAILABLE:
+            # Use huggingface_hub to download the model
+            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,
+                revision=revision  # Specify the exact revision to use
+            )
+            
+            # Rename if necessary
+            if os.path.basename(downloaded_path) != model_filename:
+                downloaded_path_obj = Path(downloaded_path)
+                model_path.parent.mkdir(parents=True, exist_ok=True)
+                if model_path.exists():
+                    model_path.unlink()
+                downloaded_path_obj.rename(model_path)
+                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/{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)
+
+if __name__ == "__main__":
+    ensure_model_exists()