Upload src/streamlit_app.py with huggingface_hub

src/streamlit_app.py

@@ -1,40 +1,753 @@
-import altair as alt
-import numpy as np
-import pandas as pd
+=== streamlit_app.py ===
 import streamlit as st
+import time
+import json
+from datetime import datetime
+import random
+from utils import (
+    interpret_prompt,
+    generate_music_simulation,
+    analyze_algorithmic_fit,
+    optimize_metadata,
+    get_trending_tags,
+    create_waveform_data
+)
+from config import GENRES, MOODS, TEMPO_RANGES, DSP_PLATFORMS
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# Page configuration
+st.set_page_config(
+    page_title="Prompt Composer - AI-Aware Music Creation",
+    page_icon="🎧",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS
+st.markdown("""
+<style>
+    .main-header {
+        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+        padding: 2rem;
+        border-radius: 10px;
+        margin-bottom: 2rem;
+        color: white;
+    }
+    .metric-card {
+        background: #f8f9fa;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid #667eea;
+        margin: 0.5rem 0;
+    }
+    .success-card {
+        background: #d4edda;
+        border-left: 4px solid #28a745;
+        padding: 1rem;
+        border-radius: 5px;
+    }
+    .warning-card {
+        background: #fff3cd;
+        border-left: 4px solid #ffc107;
+        padding: 1rem;
+        border-radius: 5px;
+    }
+    .gradient-text {
+        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Header
+st.markdown("""
+<div class="main-header">
+    <h1>🎧 Prompt Composer</h1>
+    <p>AI-Aware Music Creation for Streaming Algorithms</p>
+    <p style="font-size: 0.9rem; opacity: 0.9;">
+        Built with <a href="https://huggingface.co/spaces/akhaliq/anycoder" target="_blank" style="color: white; text-decoration: underline;">anycoder</a>
+    </p>
+</div>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if 'generated_track' not in st.session_state:
+    st.session_state.generated_track = None
+if 'analysis_complete' not in st.session_state:
+    st.session_state.analysis_complete = False
+
+# Sidebar
+with st.sidebar:
+    st.header("⚙️ Settings")
+    
+    # Target Platform
+    target_platform = st.selectbox(
+        "Target Platform",
+        DSP_PLATFORMS,
+        help="Choose which streaming platform to optimize for"
+    )
+    
+    # Advanced Options
+    st.subheader("Advanced Options")
+    auto_optimize = st.checkbox("Auto-optimize for algorithms", value=True)
+    include_vocals = st.checkbox("Include vocals", value=True)
+    target_duration = st.slider("Target Duration (seconds)", 60, 300, 180)
+    
+    # Trending Tags
+    st.subheader("🔥 Trending Tags")
+    trending_tags = get_trending_tags()
+    selected_trending = st.multiselect(
+        "Add trending tags",
+        trending_tags,
+        help="Include trending tags to boost discoverability"
+    )
+
+# Main Content
+col1, col2 = st.columns([3, 2])
+
+with col1:
+    st.header("🎵 Create Your Track")
+    
+    # Prompt Input
+    prompt_input = st.text_area(
+        "Describe your music prompt:",
+        placeholder="e.g., 'Upbeat 115 BPM house track with soulful vocals, optimized for workout playlists'",
+        height=100,
+        help="Be as specific as possible about genre, mood, tempo, and intended use case"
+    )
+    
+    # Quick Templates
+    st.subheader("📝 Quick Templates")
+    template_cols = st.columns(3)
+    
+    templates = [
+        ("Workout Mix", "High-energy 128 BPM EDM track with driving bass, perfect for gym sessions"),
+        ("Chill Study", "Ambient lo-fi hip hop at 90 BPM, minimal vocals, focus-enhancing"),
+        ("Party Anthem", "Catchy pop-dance 120 BPM with memorable chorus, festival-ready")
+    ]
+    
+    for i, (name, template) in enumerate(templates):
+        with template_cols[i]:
+            if st.button(name, key=f"template_{i}"):
+                prompt_input = template
+                st.rerun()
+    
+    # Generate Button
+    if st.button("🚀 Generate & Analyze Track", type="primary", use_container_width=True):
+        if not prompt_input:
+            st.error("Please enter a music prompt first!")
+        else:
+            with st.spinner("🎵 Interpreting prompt..."):
+                time.sleep(1)
+                interpreted = interpret_prompt(prompt_input)
+            
+            with st.spinner("🎹 Generating music..."):
+                time.sleep(2)
+                generated = generate_music_simulation(interpreted)
+            
+            with st.spinner("📊 Analyzing algorithmic fit..."):
+                time.sleep(1.5)
+                analysis = analyze_algorithmic_fit(generated, target_platform)
+            
+            with st.spinner("🏷️ Optimizing metadata..."):
+                time.sleep(1)
+                metadata = optimize_metadata(generated, analysis, target_platform, selected_trending)
+            
+            # Store in session state
+            st.session_state.generated_track = {
+                'prompt': prompt_input,
+                'interpreted': interpreted,
+                'generated': generated,
+                'analysis': analysis,
+                'metadata': metadata,
+                'timestamp': datetime.now().isoformat()
+            }
+            st.session_state.analysis_complete = True
+            st.success("✅ Track generated and analyzed successfully!")
+            st.rerun()
+
+with col2:
+    st.header("📈 Algorithm Insights")
+    
+    if st.session_state.analysis_complete:
+        track_data = st.session_state.generated_track
+        analysis = track_data['analysis']
+        
+        # Algorithmic Fit Score
+        fit_score = analysis['algorithmic_fit_score']
+        st.metric(
+            "Algorithmic Fit Score",
+            f"{fit_score}%",
+            delta=f"+{fit_score - 50}%" if fit_score > 50 else f"{fit_score - 50}%",
+            delta_color="normal" if fit_score > 70 else "inverse"
+        )
+        
+        # Key Metrics
+        st.subheader("🎯 Key Metrics")
+        
+        metrics = analysis['key_metrics']
+        col_a, col_b = st.columns(2)
+        
+        with col_a:
+            st.metric(
+                "Skip Resistance",
+                f"{metrics['skip_resistance']}%",
+                help="Likelihood listeners stay past 30 seconds"
+            )
+            st.metric(
+                "Loudness",
+                f"{metrics['loudness']} LUFS",
+                help="Target: -14 LUFS for Spotify"
+            )
+        
+        with col_b:
+            st.metric(
+                "Energy Match",
+                f"{metrics['energy_match']}%",
+                help="How well energy matches genre expectations"
+            )
+            st.metric(
+                "Hook Timing",
+                f"{metrics['hook_timing']}s",
+                help="Time to first hook (ideal: <30s)"
+            )
+        
+        # Platform Recommendations
+        st.subheader("🎯 Platform Recommendations")
+        for rec in analysis['recommendations']:
+            if rec['type'] == 'success':
+                st.markdown(f"""
+                <div class="success-card">
+                    ✅ {rec['message']}
+                </div>
+                """, unsafe_allow_html=True)
+            else:
+                st.markdown(f"""
+                <div class="warning-card">
+                    ⚠️ {rec['message']}
+                </div>
+                """, unsafe_allow_html=True)
+
+# Results Section
+if st.session_state.analysis_complete:
+    st.markdown("---")
+    track_data = st.session_state.generated_track
+    
+    # Track Details Tabs
+    tab1, tab2, tab3, tab4 = st.tabs(["🎵 Track Preview", "📊 Audio Analysis", "🏷️ Optimized Metadata", "📤 Export Options"])
+    
+    with tab1:
+        col1, col2 = st.columns([2, 1])
+        
+        with col1:
+            st.subheader("Generated Track")
+            # Simulated audio player
+            st.markdown("""
+            <div style="background: #f0f0f0; padding: 2rem; border-radius: 10px; text-align: center;">
+                <h4>🎵 {title}</h4>
+                <p>{artist}</p>
+                <div style="margin: 1rem 0;">
+                    <div style="background: #ddd; height: 4px; border-radius: 2px; position: relative;">
+                        <div style="background: #667eea; height: 100%; width: 0%; border-radius: 2px; animation: pulse 2s infinite;"></div>
+                    </div>
+                </div>
+                <p>⏱️ {duration} | 🎵 {genre} | 💫 {mood}</p>
+            </div>
+            """.format(
+                title=track_data['metadata']['title'],
+                artist=track_data['metadata']['artist'],
+                duration=f"{track_data['generated']['duration']}s",
+                genre=track_data['interpreted']['genre'],
+                mood=track_data['interpreted']['mood']
+            ), unsafe_allow_html=True)
+            
+            # Waveform visualization
+            st.subheader("Waveform")
+            waveform_data = create_waveform_data(track_data['generated']['duration'])
+            st.line_chart(waveform_data)
+        
+        with col2:
+            st.subheader("Track Structure")
+            structure = track_data['interpreted']['structure']
+            for section in structure:
+                st.write(f"🎵 {section}")
+    
+    with tab2:
+        st.subheader("📊 Detailed Audio Analysis")
+        
+        # Analysis metrics in grid
+        cols = st.columns(3)
+        
+        audio_features = track_data['analysis']['audio_features']
+        
+        with cols[0]:
+            st.metric("BPM", f"{audio_features['bpm']}")
+            st.metric("Key", audio_features['key'])
+            st.metric("Mode", audio_features['mode'])
+        
+        with cols[1]:
+            st.metric("Danceability", f"{audio_features['danceability']}%")
+            st.metric("Energy", f"{audio_features['energy']}%")
+            st.metric("Valence", f"{audio_features['valence']}%")
+        
+        with cols[2]:
+            st.metric("Acousticness", f"{audio_features['acousticness']}%")
+            st.metric("Instrumentalness", f"{audio_features['instrumentalness']}%")
+            st.metric("Speechiness", f"{audio_features['speechiness']}%")
+        
+        # Spectral Analysis
+        st.subheader("🎛️ Spectral Profile")
+        spectral_data = track_data['analysis']['spectral_analysis']
+        
+        fig_col1, fig_col2 = st.columns(2)
+        
+        with fig_col1:
+            st.bar_chart({
+                'Low': spectral_data['low_freq'],
+                'Mid': spectral_data['mid_freq'],
+                'High': spectral_data['high_freq']
+            })
+        
+        with fig_col2:
+            st.bar_chart({
+                'Centroid': spectral_data['spectral_centroid'],
+                'Rolloff': spectral_data['spectral_rolloff'],
+                'Bandwidth': spectral_data['spectral_bandwidth']
+            })
+    
+    with tab3:
+        st.subheader("🏷️ Optimized Metadata")
+        metadata = track_data['metadata']
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.write("**Title:**")
+            st.code(metadata['title'])
+            
+            st.write("**Artist:**")
+            st.code(metadata['artist'])
+            
+            st.write("**Genre:**")
+            st.code(metadata['genre'])
+        
+        with col2:
+            st.write("**Description:**")
+            st.info(metadata['description'])
+            
+            st.write("**Tags:**")
+            tags_str = ", ".join(metadata['tags'])
+            st.code(tags_str)
+        
+        # Platform-specific optimizations
+        st.subheader(f"🎯 {target_platform} Optimization")
+        platform_data = metadata['platform_specific'][target_platform]
+        
+        for key, value in platform_data.items():
+            st.write(f"**{key.replace('_', ' ').title()}:**")
+            st.write(value)
+    
+    with tab4:
+        st.subheader("📤 Export & Distribution")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.write("**Download Options:**")
+            if st.button("📥 Download WAV", use_container_width=True):
+                st.success("WAV file ready for download!")
+            if st.button("📥 Download MP3", use_container_width=True):
+                st.success("MP3 file ready for download!")
+            
+            st.write("**Export Metadata:**")
+            if st.button("📄 Export JSON", use_container_width=True):
+                json_data = json.dumps(track_data, indent=2)
+                st.download_button(
+                    "Download metadata.json",
+                    json_data,
+                    "track_metadata.json",
+                    "application/json"
+                )
+        
+        with col2:
+            st.write("**Platform Upload:**")
+            if st.button("🎵 Upload to SoundCloud", use_container_width=True):
+                st.success("✅ Track uploaded to SoundCloud!")
+            if st.button("🎵 Submit to Spotify", use_container_width=True):
+                st.info("Track submitted for Spotify review!")
+            
+            st.write("**Share:**")
+            share_url = f"https://promptcomposer.app/track/{random.randint(10000, 99999)}"
+            st.code(share_url)
+            if st.button("🔗 Copy Link", use_container_width=True):
+                st.success("Link copied to clipboard!")
+
+# Footer
+st.markdown("---")
+st.markdown("""
+<div style="text-align: center; color: #666; padding: 1rem;">
+    <p>Prompt Composer - AI-Aware Music Creation for Streaming Algorithms</p>
+    <p style="font-size: 0.8rem;">Optimize your music for maximum algorithmic compatibility</p>
+</div>
+""", unsafe_allow_html=True)
+
+=== utils.py ===
+import random
+import re
+from datetime import datetime
+from config import GENRES, MOODS, TEMPO_RANGES
+
+def interpret_prompt(prompt):
+    """Interpret natural language prompt into structured metadata"""
+    # Simulated LLM interpretation
+    prompt_lower = prompt.lower()
+    
+    # Extract genre
+    detected_genre = "electronic"
+    for genre in GENRES:
+        if genre in prompt_lower:
+            detected_genre = genre
+            break
+    
+    # Extract mood
+    detected_mood = "energetic"
+    for mood in MOODS:
+        if mood in prompt_lower:
+            detected_mood = mood
+            break
+    
+    # Extract BPM
+    bpm_match = re.search(r'(\d+)\s*bpm', prompt_lower)
+    if bpm_match:
+        bpm = int(bpm_match.group(1))
+    else:
+        bpm = random.randint(*TEMPO_RANGES.get(detected_genre, (90, 140)))
+    
+    # Extract key
+    keys = ['C', 'D', 'E', 'F', 'G', 'A', 'B']
+    detected_key = random.choice(keys) + random.choice([' major', ' minor'])
+    
+    # Determine structure
+    structure = ['Intro', 'Verse', 'Chorus', 'Verse', 'Chorus', 'Bridge', 'Chorus', 'Outro']
+    if 'short intro' in prompt_lower:
+        structure[0] = 'Short Intro'
+    
+    # Energy curve
+    energy_curve = [0.3, 0.5, 0.9, 0.6, 0.9, 0.7, 1.0, 0.4]
+    
+    # Vocal presence
+    vocal_presence = 'high' if 'vocals' in prompt_lower else 'low'
+    
+    # Emotional intent
+    emotional_intent = detected_mood
+    
+    return {
+        'genre': detected_genre,
+        'mood': detected_mood,
+        'bpm': bpm,
+        'key': detected_key,
+        'structure': structure,
+        'energy_curve': energy_curve,
+        'vocal_presence': vocal_presence,
+        'emotional_intent': emotional_intent,
+        'duration': random.randint(150, 240)
+    }
+
+def generate_music_simulation(interpreted):
+    """Simulate music generation based on interpreted metadata"""
+    # Simulate generation process
+    time.sleep(0.1)  # Simulate processing time
+    
+    # Generate stems info
+    stems = {
+        'drums': {'level': random.uniform(0.7, 0.9), 'presence': True},
+        'bass': {'level': random.uniform(0.6, 0.8), 'presence': True},
+        'synths': {'level': random.uniform(0.5, 0.8), 'presence': True},
+        'vocals': {'level': random.uniform(0.6, 0.9), 'presence': interpreted['vocal_presence'] == 'high'},
+        'effects': {'level': random.uniform(0.2, 0.5), 'presence': True}
+    }
+    
+    # Mix settings
+    mix_settings = {
+        'compression': random.uniform(2, 6),
+        'reverb': random.uniform(10, 30),
+        'stereo_width': random.uniform(80, 120),
+        'loudness_target': -14  # LUFS
+    }
+    
+    return {
+        'stems': stems,
+        'mix_settings': mix_settings,
+        'duration': interpreted['duration'],
+        'file_format': 'WAV',
+        'sample_rate': 44100,
+        'bit_depth': 24,
+        'generated_at': datetime.now().isoformat()
+    }
+
+def analyze_algorithmic_fit(generated, platform):
+    """Analyze how well the track fits algorithmic preferences"""
+    # Simulate algorithmic analysis
+    base_score = random.randint(60, 95)
+    
+    # Calculate key metrics
+    skip_resistance = min(95, base_score + random.randint(-10, 10))
+    energy_match = min(95, base_score + random.randint(-5, 15))
+    loudness = -14 + random.randint(-2, 2)
+    hook_timing = random.randint(15, 35)
+    
+    # Audio features
+    audio_features = {
+        'bpm': random.randint(90, 140),
+        'key': random.choice(['C', 'D', 'E', 'F', 'G', 'A', 'B']) + random.choice([' major', ' minor']),
+        'mode': random.choice(['major', 'minor']),
+        'danceability': random.randint(60, 95),
+        'energy': random.randint(60, 95),
+        'valence': random.randint(40, 80),
+        'acousticness': random.randint(5, 30),
+        'instrumentalness': random.randint(10, 60),
+        'speechiness': random.randint(5, 25)
+    }
+    
+    # Spectral analysis
+    spectral_analysis = {
+        'low_freq': random.randint(30, 50),
+        'mid_freq': random.randint(40, 60),
+        'high_freq': random.randint(20, 40),
+        'spectral_centroid': random.randint(2000, 4000),
+        'spectral_rolloff': random.randint(8000, 12000),
+        'spectral_bandwidth': random.randint(1000, 3000)
+    }
+    
+    # Generate recommendations
+    recommendations = []
+    if skip_resistance > 80:
+        recommendations.append({
+            'type': 'success',
+            'message': 'Excellent skip resistance - listeners likely to stay engaged'
+        })
+    else:
+        recommendations.append({
+            'type': 'warning',
+            'message': 'Consider adding a stronger hook in the first 30 seconds'
+        })
+    
+    if abs(loudness + 14) <= 2:
+        recommendations.append({
+            'type': 'success',
+            'message': 'Perfect loudness normalization for streaming platforms'
+        })
+    else:
+        recommendations.append({
+            'type': 'warning',
+            'message': f'Adjust loudness to -14 LUFS (currently {loudness} LUFS)'
+        })
+    
+    if hook_timing < 30:
+        recommendations.append({
+            'type': 'success',
+            'message': 'Optimal hook timing for algorithmic favorability'
+        })
+    
+    return {
+        'algorithmic_fit_score': base_score,
+        'key_metrics': {
+            'skip_resistance': skip_resistance,
+            'energy_match': energy_match,
+            'loudness': loudness,
+            'hook_timing': hook_timing
+        },
+        'audio_features': audio_features,
+        'spectral_analysis': spectral_analysis,
+        'recommendations': recommendations,
+        'platform': platform
+    }
+
+def optimize_metadata(generated, analysis, platform, trending_tags=None):
+    """Generate optimized metadata for streaming platforms"""
+    # Generate title
+    title_templates = [
+        "{mood} {genre} Vibes",
+        "Midnight {genre}",
+        "{genre} Dreams",
+        "Electric {mood}",
+        "{genre} Revolution"
+    ]
+    
+    title = random.choice(title_templates).format(
+        mood=analysis['audio_features']['valence'] > 60 and "Uplifting" or "Deep",
+        genre=analysis['audio_features']['danceability'] > 70 and "Dance" or "Chill"
+    )
+    
+    # Generate artist name
+    artist = f"AI Artist {random.randint(100, 999)}"
+    
+    # Generate description
+    description = f"""
+    A carefully crafted {analysis['audio_features']['mode']} track optimized for {platform}.
+    Features {analysis['audio_features']['danceability']}% danceability and {analysis['audio_features']['energy']}% energy.
+    Perfect for playlists focusing on {analysis['audio_features']['valence'] > 60 and 'uplifting' or 'deep'} vibes.
+    """
+    
+    # Generate tags
+    base_tags = ['AI Generated', 'Electronic', 'Optimized']
+    if trending_tags:
+        base_tags.extend(trending_tags)
+    
+    # Platform-specific optimizations
+    platform_specific = {
+        'Spotify': {
+            'playlist_categories': ['Chill Vibes', 'Deep Focus', 'Electronic Mix'],
+            'editorial_notes': 'Perfect for study and relaxation playlists',
+            'mood_target': 'Chill/Energetic blend'
+        },
+        'SoundCloud': {
+            'community_tags': ['indie electronic', 'lofi beats', 'ambient'],
+            'related_artists': ['Tycho', 'Bonobo', 'ODESZA'],
+            'genre_specific': 'Future Bass / Chillwave'
+        },
+        'Apple Music': {
+            'curator_notes': 'Ideal for curated editorial playlists',
+            'mood_station': 'Focus Flow',
+            'genre_station': 'Electronic Essentials'
+        },
+        'YouTube Music': {
+            'video_keywords': ['chill music', 'study beats', 'lofi hip hop'],
+            'thumbnail_suggestions': 'Minimalist aesthetic with gradient colors',
+            'description_seo': 'Best chill music for studying and relaxation'
+        }
+    }
+    
+    return {
+        'title': title,
+        'artist': artist,
+        'genre': analysis['audio_features']['danceability'] > 70 and 'Dance' or 'Chill',
+        'description': description.strip(),
+        'tags': base_tags[:10],  # Limit to 10 tags
+        'platform_specific': platform_specific,
+        'optimized_for': platform,
+        'optimization_score': analysis['algorithmic_fit_score']
+    }
+
+def get_trending_tags():
+    """Get list of trending tags"""
+    return [
+        'lofi beats', 'study music', 'chill vibes', 'ambient', 'downtempo',
+        'future bass', 'chillwave', 'vaporwave', 'electronic', 'indie',
+        'upbeat', 'relaxing', 'focus', 'meditation', 'workout'
+    ]
+
+def create_waveform_data(duration):
+    """Create simulated waveform data for visualization"""
+    points = min(100, duration)
+    return [random.uniform(-1, 1) for _ in range(points)]
+
+=== config.py ===
+# Configuration constants for Prompt Composer
+
+# Music genres
+GENRES = [
+    'electronic', 'pop', 'rock', 'hip-hop', 'jazz', 'classical',
+    'blues', 'country', 'folk', 'reggae', 'metal', 'punk',
+    'indie', 'ambient', 'house', 'techno', 'trance', 'dubstep'
+]
+
+# Mood descriptors
+MOODS = [
+    'energetic', 'chill', 'happy', 'sad', 'angry', 'romantic',
+    'mysterious', 'uplifting', 'dark', 'dreamy', 'aggressive',
+    'peaceful', 'epic', 'intimate', 'nostalgic'
+]
+
+# Tempo ranges by genre (BPM)
+TEMPO_RANGES = {
+    'ambient': (60, 90),
+    'chill': (70, 100),
+    'house': (115, 130),
+    'techno': (120, 140),
+    'trance': (130, 150),
+    'dubstep': (140, 150),
+    'hip-hop': (85, 115),
+    'pop': (100, 130),
+    'rock': (110, 140),
+    'metal': (120, 180),
+    'jazz': (80, 140),
+    'classical': (60, 200),
+    'electronic': (90, 140)
+}
+
+# Digital Service Providers (DSPs)
+DSP_PLATFORMS = [
+    'Spotify',
+    'SoundCloud',
+    'Apple Music',
+    'YouTube Music'
+]
+
+# Algorithm optimization targets
+ALGORITHM_TARGETS = {
+    'Spotify': {
+        'loudness_lufs': -14,
+        'skip_threshold': 30,  # seconds
+        'hook_timing': 25,  # seconds
+        'energy_curve': [0.3, 0.5, 0.8, 0.6, 0.9, 0.7, 1.0, 0.4]
+    },
+    'SoundCloud': {
+        'loudness_lufs': -12,
+        'skip_threshold': 20,
+        'hook_timing': 15,
+        'energy_curve': [0.4, 0.6, 0.9, 0.7, 1.0, 0.8, 0.9, 0.5]
+    },
+    'Apple Music': {
+        'loudness_lufs': -16,
+        'skip_threshold': 30,
+        'hook_timing': 30,
+        'energy_curve': [0.3, 0.5, 0.8, 0.6, 0.9, 0.7, 1.0, 0.4]
+    },
+    'YouTube Music': {
+        'loudness_lufs': -13,
+        'skip_threshold': 15,
+        'hook_timing': 10,
+        'energy_curve': [0.5, 0.7, 1.0, 0.8, 1.0, 0.9, 1.0, 0.6]
+    }
+}
+
+# Audio analysis parameters
+AUDIO_FEATURES_RANGES = {
+    'danceability': (0, 100),
+    'energy': (0, 100),
+    'valence': (0, 100),
+    'acousticness': (0, 100),
+    'instrumentalness': (0, 100),
+    'speechiness': (0, 100)
+}
+
+# Metadata templates
+TITLE_TEMPLATES = [
+    "{mood} {genre}",
+    "Midnight {genre}",
+    "{genre} Dreams",
+    "Electric {mood}",
+    "{genre} Revolution",
+    "Lost in {genre}",
+    "{mood} Sessions",
+    "Digital {genre}",
+    "Cosmic {genre}",
+    "Urban {genre}"
+]
+
+DESCRIPTION_TEMPLATES = [
+    "A carefully crafted {genre} track optimized for {platform}. Features {danceability}% danceability and {energy}% energy.",
+    "Experience the perfect blend of {mood} vibes with this {genre} masterpiece. Optimized for maximum algorithmic compatibility on {platform}.",
+    "This {genre} track delivers {energy}% energy with {danceability}% danceability. Perfect for {platform} playlists.",
+    "Immerse yourself in this {mood} {genre} creation. Designed to perform exceptionally well on {platform}'s recommendation algorithms.",
+    "A standout {genre} piece with {danceability}% danceability. Algorithmically optimized for {platform} discovery."
+]
+
+=== requirements.txt ===
+streamlit
+pandas
+numpy
+plotly
+requests
+python-dotenv