Update app.py

app.py

@@ -1,752 +1,255 @@
 import gradio as gr
-import json
-import re
 import random
-from typing import Dict, List, Tuple
 
-# Music generation logic
+# Simple music generation logic
 class StrudelGenerator:
     def __init__(self):
-        self.instrument_patterns = {
-            'drums': {
-                'kick': '"bd*4"',
-                'snare': '"~ sd ~ sd"',
-                'hihat': '"hh*8"',
-                'techno_kick': '"bd*4"',
-                'house_kick': '"bd ~ ~ ~ bd ~ ~ ~"',
-                'breakbeat': '"bd ~ sd ~ bd sd ~ sd"',
-                'trap': '"bd ~ ~ bd ~ sd ~ ~"',
-                'dnb': '"bd ~ ~ ~ sd ~ bd sd"'
-            },
-            'bass': {
-                'basic': '"c2 [~ c2] f2 [~ f2]"',
-                'funk': '"c2 ~ c2 ~ f2 ~ f2 ~"',
-                'walking': '"c2 e2 g2 c3 f2 a2 c3 f3".slow(2)',
-                'techno': '"c2*4"',
-                'wobble': '"c2 c2 f2 f2".sound("sawtooth").lpf(sine.range(200,800))',
-                'deep': '"c1 ~ f1 ~ g1 ~ c1 ~".slow(2)'
-            },
-            'chords': {
-                'jazz': '"<c\'maj7 f\'maj7 g\'7 c\'maj7>".voicing()',
-                'basic': '"<C^7 F^7 G^7 C^7>".voicing()',
-                'ambient': '"<c\'maj e\'min f\'maj g\'maj>".voicing()',
-                'emotional': '"<c\'min f\'maj g\'maj a\'min>".voicing()',
-                'uplifting': '"<C^7 F^7 Am7 G^7>".voicing()'
-            },
-            'melody': {
-                'basic': '"c5 d5 e5 f5 g5 a5 b5 c6".slow(2)',
-                'ambient': '"c5 d5 e5 f5 g5 a5 b5 c6".slow(4)',
-                'fast': '"c5 d5 e5 f5 g5 a5 b5 c6"',
-                'anime': '"c5 e5 g5 c6 b5 g5 e5 c5".slow(1.5)',
-                'chiptune': '"c6 d6 e6 f6 g6 a6 b6 c7"'
-            },
-            'arpeggios': {
-                'basic': '"c4 e4 g4 c5".fast(2)',
-                'dreamy': '"c4 e4 g4 b4 c5 b4 g4 e4".slow(2)',
-                'energetic': '"c4 e4 g4 c5".fast(4)'
-            }
-        }
-        
-        self.style_effects = {
-            'lofi': ['.room(0.7)', '.lpf(2000)', '.hpf(100)', '.gain(0.6)'],
-            'techno': ['.room(0.2)', '.lpf(sine.range(400,2000))', '.distort(0.1)'],
-            'house': ['.room(0.4)', '.lpf(3000)', '.compress(0.8)'],
-            'ambient': ['.room(0.9)', '.size(0.8)', '.lpf(1000)', '.gain(0.4)'],
-            'jazz': ['.room(0.6)', '.lpf(4000)', '.compress(0.6)'],
-            'cyberpunk': ['.room(0.3)', '.distort(0.2)', '.lpf(sine.range(300,1500))'],
-            'anime': ['.room(0.5)', '.lpf(3500)', '.delay(0.125)', '.gain(0.7)'],
-            'chiptune': ['.room(0.1)', '.lpf(8000)', '.bitcrush(8)', '.gain(0.8)']
+        self.patterns = {
+            'drums': ['"bd*4"', '"bd ~ sd ~"', '"bd*2 sd*2"'],
+            'bass': ['"c2 [~ c2] f2 [~ f2]"', '"c2*4"', '"c1 ~ f1 ~"'],
+            'chords': ['"<C^7 F^7 G^7 C^7>".voicing()', '"<c\'maj7 f\'maj7 g\'7 c\'maj7>".voicing()'],
+            'melody': ['"c5 d5 e5 f5"', '"c5 e5 g5 c6"']
         }
 
-    def analyze_description(self, description: str) -> Dict[str, List[str]]:
-        """Enhanced analysis with anime and electronic music focus"""
+    def generate_code(self, description: str, tempo: int = 120) -> str:
+        """Generate simple Strudel code"""
         desc = description.lower()
-        elements = {
-            'drums': [],
-            'bass': [],
-            'chords': [],
-            'melody': [],
-            'arpeggios': [],
-            'style': [],
-            'mood': []
-        }
-        
-        # Enhanced drum detection
-        drum_keywords = {
-            'kick': ['kick', 'bass drum', 'bd'],
-            'snare': ['snare', 'sd', 'clap'],
-            'hihat': ['hi-hat', 'hihat', 'hh', 'cymbal'],
-            'trap': ['trap', '808'],
-            'dnb': ['drum and bass', 'dnb', 'breakbeat'],
-            'techno_kick': ['techno', 'four on the floor'],
-            'house_kick': ['house']
-        }
+        patterns = []
         
-        for pattern, keywords in drum_keywords.items():
-            if any(keyword in desc for keyword in keywords):
-                elements['drums'].append(pattern)
+        # Simple keyword detection
+        if any(word in desc for word in ['drum', 'beat', 'kick']):
+            patterns.append(random.choice(self.patterns['drums']) + '.gain(0.8)')
         
-        if 'drum' in desc and not elements['drums']:
-            elements['drums'].extend(['kick', 'snare', 'hihat'])
+        if any(word in desc for word in ['bass', 'low']):
+            patterns.append(random.choice(self.patterns['bass']) + '.sound("sawtooth").gain(0.6)')
             
-        # Enhanced bass detection
-        bass_keywords = {
-            'wobble': ['wobble', 'dubstep', 'bass drop'],
-            'deep': ['deep bass', 'sub bass'],
-            'funk': ['funk', 'slap bass'],
-            'walking': ['walking bass', 'jazz bass'],
-            'techno': ['techno bass', 'driving bass']
-        }
-        
-        for pattern, keywords in bass_keywords.items():
-            if any(keyword in desc for keyword in keywords):
-                elements['bass'].append(pattern)
-                
-        if 'bass' in desc and not elements['bass']:
-            elements['bass'].append('basic')
-                
-        # Enhanced harmony detection
-        chord_keywords = {
-            'emotional': ['emotional', 'sad', 'melancholic', 'dramatic'],
-            'uplifting': ['uplifting', 'happy', 'energetic', 'positive'],
-            'jazz': ['jazz', 'sophisticated', 'complex'],
-            'ambient': ['ambient', 'atmospheric', 'spacey']
-        }
-        
-        for pattern, keywords in chord_keywords.items():
-            if any(keyword in desc for keyword in keywords):
-                elements['chords'].append(pattern)
-                
-        if any(word in desc for word in ['chord', 'harmony', 'piano']) and not elements['chords']:
-            elements['chords'].append('basic')
-                
-        # Enhanced melody detection
-        melody_keywords = {
-            'anime': ['anime', 'japanese', 'kawaii', 'manga'],
-            'chiptune': ['8-bit', 'chiptune', 'retro', 'game'],
-            'ambient': ['ethereal', 'floating', 'dreamy'],
-            'fast': ['fast', 'rapid', 'quick', 'energetic']
-        }
-        
-        for pattern, keywords in melody_keywords.items():
-            if any(keyword in desc for keyword in keywords):
-                elements['melody'].append(pattern)
-                
-        if any(word in desc for word in ['melody', 'lead', 'tune']) and not elements['melody']:
-            elements['melody'].append('basic')
+        if any(word in desc for word in ['chord', 'harmony', 'piano']):
+            patterns.append(random.choice(self.patterns['chords']) + '.sound("piano").gain(0.4)')
             
-        # Arpeggio detection
-        if any(word in desc for word in ['arpeggio', 'arpeggiated', 'broken chord']):
-            if 'dreamy' in desc or 'floating' in desc:
-                elements['arpeggios'].append('dreamy')
-            elif 'energetic' in desc or 'fast' in desc:
-                elements['arpeggios'].append('energetic')
-            else:
-                elements['arpeggios'].append('basic')
-                
-        # Style detection
-        styles = ['lofi', 'techno', 'house', 'ambient', 'jazz', 'cyberpunk', 'anime', 'chiptune', 'trap', 'dubstep']
-        for style in styles:
-            if style in desc:
-                elements['style'].append(style)
-                
-        return elements
-
-    def generate_code(self, description: str, tempo: int = 120, style: str = None) -> Tuple[str, str]:
-        """Generate Strudel code and return code + analysis"""
-        elements = self.analyze_description(description)
+        if any(word in desc for word in ['melody', 'lead', 'tune']):
+            patterns.append(random.choice(self.patterns['melody']) + '.sound("sine").gain(0.5)')
         
-        # Use provided style or detected style
-        if style and style.lower() != 'auto-detect':
-            main_style = style.lower()
-        elif elements['style']:
-            main_style = elements['style'][0]
-        else:
-            main_style = 'basic'
-            
-        patterns = []
-        analysis_parts = []
-        
-        # Build patterns based on analysis
-        for category in ['drums', 'bass', 'chords', 'melody', 'arpeggios']:
-            for element in elements[category]:
-                if category in self.instrument_patterns and element in self.instrument_patterns[category]:
-                    pattern = self.instrument_patterns[category][element]
-                    
-                    # Add appropriate sound and effects
-                    if category == 'bass':
-                        pattern += '.sound("sawtooth").lpf(800)'
-                        analysis_parts.append(f"🎸 Bass: {element}")
-                    elif category == 'chords':
-                        pattern += '.sound("piano")'
-                        analysis_parts.append(f"🎹 Chords: {element}")
-                    elif category == 'melody':
-                        pattern += '.sound("sine").lpf(2000)'
-                        analysis_parts.append(f"🎵 Melody: {element}")
-                    elif category == 'arpeggios':
-                        pattern += '.sound("triangle").lpf(3000)'
-                        analysis_parts.append(f"🌸 Arpeggios: {element}")
-                    elif category == 'drums':
-                        analysis_parts.append(f"🥁 Drums: {element}")
-                        
-                    # Add gain
-                    if category == 'drums':
-                        pattern += '.gain(0.7)'
-                    else:
-                        pattern += '.gain(0.4)'
-                        
-                    patterns.append(pattern)
-        
-        # If no patterns generated, create default
+        # Default if nothing detected
         if not patterns:
             patterns = [
                 '"bd ~ sd ~".gain(0.7)',
                 '"<C^7 F^7 G^7 C^7>".voicing().sound("piano").gain(0.4)'
             ]
-            analysis_parts = ["🥁 Basic drums", "🎹 Simple chords"]
-        
-        # Build final code
-        code_lines = [
-            f'// 🎵 Generated from: "{description}"',
-            f'// 🎭 Style: {style or main_style}, ⏱️ Tempo: {tempo} BPM',
-            f'// 🎨 Elements: {", ".join(analysis_parts)}',
-            '',
-        ]
         
+        # Build code
         if len(patterns) == 1:
-            code_lines.append(patterns[0])
+            code = patterns[0]
         else:
-            code_lines.append('stack(')
+            code = "stack(\n"
             for i, pattern in enumerate(patterns):
-                comma = ',' if i < len(patterns) - 1 else ''
-                code_lines.append(f'  {pattern}{comma}')
-            code_lines.append(')')
-            
-        code_lines.append(f'.cpm({tempo})')
-        
-        # Add style-specific effects
-        if main_style in self.style_effects:
-            effects = self.style_effects[main_style]
-            for effect in effects[:2]:  # Limit effects to avoid overload
-                code_lines.append(effect)
+                comma = "," if i < len(patterns) - 1 else ""
+                code += f"  {pattern}{comma}\n"
+            code += ")"
         
-        analysis = f"**Detected Elements:** {', '.join(analysis_parts)}\n**Style:** {main_style}"
-        
-        return '\n'.join(code_lines), analysis
-
-    def add_variation(self, code: str) -> str:
-        """Add random variations to existing code"""
-        if not code.strip():
-            return code
-            
-        variations = [
-            ".sometimes(x=>x.rev())",
-            ".every(4, x=>x.fast(2))",
-            ".rarely(x=>x.gain(0.1))",
-            ".jux(x=>x.rev())",
-            ".every(8, x=>x.slow(2))",
-            ".sometimes(x=>x.ply(2))",
-            ".degradeBy(0.1)",
-            ".when(rand.range(0,1) > 0.7, x=>x.lpf(500))"
-        ]
-        
-        variation = random.choice(variations)
-        return code + variation
+        code += f".cpm({tempo})"
+        return code
 
-# Initialize generator
 generator = StrudelGenerator()
 
-# Example descriptions with anime themes
-examples = {
-    "🌸 Kawaii Lofi": "Soft kawaii lofi with gentle piano chords, mellow drums, and a dreamy floating melody",
-    "⚡ Cyberpunk Action": "High energy cyberpunk techno with driving bass, glitchy effects, and dramatic synths",
-    "🎮 8-bit Adventure": "Retro chiptune with bouncy 8-bit melody, simple drums, and nostalgic video game vibes",
-    "🌙 Anime Ballad": "Emotional anime ballad with beautiful piano, soft strings, and a soaring melody",
-    "🔥 Epic Battle": "Intense battle music with powerful drums, dramatic chords, and heroic melody",
-    "💫 Future Bass Drop": "Melodic future bass with emotional buildup, punchy drums, and ethereal pads",
-    "🌊 Peaceful Ambient": "Tranquil ambient soundscape with gentle pads, soft percussion, and floating tones",
-    "🎪 Funky Anime OP": "Upbeat anime opening with funky bass, energetic drums, and catchy melody"
-}
-
-def generate_music(description, tempo, style):
-    """Main generation function"""
+def generate_music(description, tempo):
+    """Generate music code"""
     if not description.strip():
-        return "", "Please describe your music first! 🎵", ""
+        return "// Please describe your music first!"
     
-    try:
-        code, analysis = generator.generate_code(description, tempo, style)
-        success_msg = "🎉 Music code generated successfully! Click the Play button below to hear it!"
-        return code, success_msg, analysis
-    except Exception as e:
-        error_msg = f"❌ Error generating music: {str(e)}"
-        return "", error_msg, ""
+    code = generator.generate_code(description, tempo)
+    return code
 
-def add_magic(code):
-    """Add variations to existing code"""
-    if not code.strip():
-        return code, "Generate some code first! 🎼"
+# Create simple interface
+with gr.Blocks(title="🎵 Strudel Generator") as app:
     
-    try:
-        new_code = generator.add_variation(code)
-        return new_code, "✨ Added magical variation!"
-    except Exception as e:
-        return code, f"❌ Error adding variation: {str(e)}"
-
-def load_example(example_key):
-    """Load example description"""
-    return examples.get(example_key, "")
-
-def create_strudel_player():
-    """Create HTML component with Strudel.js player"""
-    return gr.HTML("""
-    <div id="strudel-container" style="
-        background: linear-gradient(135deg, rgba(255, 107, 157, 0.1), rgba(168, 85, 247, 0.1));
-        border: 2px solid rgba(255, 107, 157, 0.3);
-        border-radius: 20px;
+    gr.HTML("""
+    <div style='text-align: center; margin-bottom: 30px;'>
+        <h1 style='color: #FF6B9D; font-size: 2.5rem; margin: 0;'>🎵 Strudel Music Generator</h1>
+        <p style='color: #666; font-size: 1.1rem;'>Describe your music and generate Strudel code!</p>
+    </div>
+    """)
+    
+    # Simple input
+    description = gr.Textbox(
+        label="Describe your music",
+        placeholder="e.g., 'upbeat drums with piano chords'",
+        lines=2
+    )
+    
+    tempo = gr.Slider(60, 180, 120, step=5, label="Tempo (BPM)")
+    
+    generate_btn = gr.Button("🚀 Generate Code", variant="primary")
+    
+    # Code output
+    code_output = gr.Code(
+        label="Generated Strudel Code",
+        language="javascript",
+        lines=8
+    )
+    
+    # Simple audio player
+    gr.HTML("""
+    <div id="player" style='
+        background: linear-gradient(135deg, #FF6B9D, #A855F7);
         padding: 20px;
-        margin: 10px 0;
-        backdrop-filter: blur(10px);
-    ">
-        <div style="text-align: center; margin-bottom: 15px;">
-            <h3 style="color: #FF6B9D; margin: 0 0 10px 0;">🎵 Strudel Audio Player</h3>
-            <p style="color: #E2E8F0; margin: 0; opacity: 0.8;">Generate code above, then click play to hear your music!</p>
-        </div>
-        
-        <div id="strudel-controls" style="text-align: center; margin-bottom: 15px;">
-            <button id="play-btn" onclick="playStrudel()" style="
-                background: linear-gradient(45deg, #FF6B9D, #A855F7);
-                color: white;
-                border: none;
-                border-radius: 25px;
-                padding: 12px 24px;
-                margin: 5px;
-                font-weight: 600;
-                cursor: pointer;
-                transition: all 0.3s ease;
-                box-shadow: 0 4px 15px rgba(255, 107, 157, 0.4);
-            ">▶️ Play</button>
-            
-            <button id="stop-btn" onclick="stopStrudel()" style="
-                background: linear-gradient(45deg, #EF4444, #F59E0B);
-                color: white;
-                border: none;
-                border-radius: 25px;
-                padding: 12px 24px;
-                margin: 5px;
-                font-weight: 600;
-                cursor: pointer;
-                transition: all 0.3s ease;
-                box-shadow: 0 4px 15px rgba(239, 68, 68, 0.4);
-            ">⏹️ Stop</button>
-            
-            <button id="volume-btn" onclick="toggleVolume()" style="
-                background: linear-gradient(45deg, #06B6D4, #3B82F6);
-                color: white;
-                border: none;
-                border-radius: 25px;
-                padding: 12px 24px;
-                margin: 5px;
-                font-weight: 600;
-                cursor: pointer;
-                transition: all 0.3s ease;
-                box-shadow: 0 4px 15px rgba(6, 182, 212, 0.4);
-            ">🔊 Volume</button>
-        </div>
-        
-        <div id="strudel-status" style="
-            text-align: center;
-            color: #E2E8F0;
-            font-size: 14px;
-            opacity: 0.8;
-            margin-bottom: 10px;
-        ">Ready to play music ✨</div>
-        
-        <div id="volume-control" style="display: none; text-align: center; margin: 10px 0;">
-            <input type="range" id="volume-slider" min="0" max="100" value="70" style="
-                width: 200px;
-                height: 6px;
-                border-radius: 5px;
-                background: linear-gradient(to right, #FF6B9D, #A855F7);
-                outline: none;
-                opacity: 0.8;
-                transition: opacity 0.2s;
-            ">
-            <div style="color: #E2E8F0; font-size: 12px; margin-top: 5px;">Volume: <span id="volume-display">70</span>%</div>
+        border-radius: 15px;
+        text-align: center;
+        margin: 20px 0;
+    '>
+        <h3 style='color: white; margin: 0 0 15px 0;'>🎵 Audio Player</h3>
+        <button id="playBtn" onclick="togglePlay()" style='
+            background: white;
+            color: #FF6B9D;
+            border: none;
+            padding: 12px 30px;
+            border-radius: 25px;
+            font-size: 16px;
+            font-weight: bold;
+            cursor: pointer;
+            margin: 5px;
+            transition: all 0.3s;
+        '>▶️ Play</button>
+        <button onclick="stopPlay()" style='
+            background: rgba(255,255,255,0.8);
+            color: #FF6B9D;
+            border: none;
+            padding: 12px 30px;
+            border-radius: 25px;
+            font-size: 16px;
+            font-weight: bold;
+            cursor: pointer;
+            margin: 5px;
+            transition: all 0.3s;
+        '>⏹️ Stop</button>
+        <div id="status" style='color: white; margin-top: 10px; font-size: 14px;'>
+            Generate code and click play!
         </div>
     </div>
 
     <script>
-        let currentPattern = null;
         let isPlaying = false;
-        let audioContext = null;
-        let currentCode = '';
-        let volume = 0.7;
-        
-        function updateStatus(message, color = '#E2E8F0') {
-            const status = document.getElementById('strudel-status');
+        let playTimer = null;
+
+        function getCurrentCode() {
+            // Get code from the textarea
+            const codeArea = document.querySelector('textarea[data-testid*="code"]') || 
+                           document.querySelector('.code-container textarea') ||
+                           document.querySelector('textarea');
+            return codeArea ? codeArea.value : '';
+        }
+
+        function updateStatus(message, color = 'white') {
+            const status = document.getElementById('status');
             if (status) {
-                status.innerHTML = message;
+                status.textContent = message;
                 status.style.color = color;
             }
         }
-        
+
         function updatePlayButton(playing) {
-            const btn = document.getElementById('play-btn');
+            const btn = document.getElementById('playBtn');
             if (btn) {
-                if (playing) {
-                    btn.innerHTML = '⏸️ Pause';
-                    btn.onclick = pauseStrudel;
-                } else {
-                    btn.innerHTML = '▶️ Play';
-                    btn.onclick = playStrudel;
-                }
+                btn.textContent = playing ? '⏸️ Pause' : '▶️ Play';
             }
         }
-        
-        function getCurrentCode() {
-            // Get current code from Gradio's code component
-            const codeElements = document.querySelectorAll('textarea, .code-container code');
-            for (let element of codeElements) {
-                const text = element.textContent || element.value || '';
-                if (text && text.includes('//') && text.includes('cpm')) {
-                    return text;
-                }
+
+        function togglePlay() {
+            if (isPlaying) {
+                pausePlay();
+            } else {
+                startPlay();
             }
-            return '';
         }
-        
-        async function playStrudel() {
-            currentCode = getCurrentCode();
+
+        function startPlay() {
+            const code = getCurrentCode();
             
-            if (!currentCode || !currentCode.trim()) {
-                updateStatus('❌ No code to play! Generate some music first.', '#EF4444');
+            if (!code || code.trim() === '' || code.includes('Please describe')) {
+                updateStatus('No code to play! Generate some first.', '#ffcccc');
                 return;
             }
-            
-            try {
-                // Stop any currently playing pattern
-                if (currentPattern) {
-                    currentPattern.stop();
-                }
-                
-                // Demo mode with enhanced feedback
-                updateStatus('🎮 Demo Mode: Playing your creation...', '#06B6D4');
-                isPlaying = true;
-                updatePlayButton(true);
-                
-                // Show the code being "played"
-                const firstLine = currentCode.split('\\n').find(line => line.includes('Generated from:')) || 'Generated music';
-                console.log('Playing:', firstLine);
-                
-                // Simulate realistic playback duration
-                setTimeout(() => {
-                    updateStatus('🎵 Demo playback complete! Integrate Strudel.js for real audio.', '#FCD34D');
-                    isPlaying = false;
-                    updatePlayButton(false);
-                }, 8000);
-                
-            } catch (error) {
-                console.error('Playback error:', error);
-                updateStatus('❌ Error: ' + error.message, '#EF4444');
-                isPlaying = false;
-                updatePlayButton(false);
-            }
+
+            isPlaying = true;
+            updatePlayButton(true);
+            updateStatus('🎵 Playing your music...', '#ccffcc');
+
+            // Simulate playback for 10 seconds
+            playTimer = setTimeout(() => {
+                stopPlay();
+                updateStatus('Playback finished!', 'white');
+            }, 10000);
         }
-        
-        function pauseStrudel() {
-            if (isPlaying) {
-                isPlaying = false;
-                updatePlayButton(false);
-                updateStatus('⏸️ Music paused', '#FCD34D');
+
+        function pausePlay() {
+            isPlaying = false;
+            updatePlayButton(false);
+            updateStatus('⏸️ Paused', '#ffffcc');
+            
+            if (playTimer) {
+                clearTimeout(playTimer);
+                playTimer = null;
             }
         }
-        
-        function stopStrudel() {
-            if (currentPattern) {
-                currentPattern.stop();
-                currentPattern = null;
-            }
+
+        function stopPlay() {
             isPlaying = false;
             updatePlayButton(false);
-            updateStatus('⏹️ Music stopped', '#6B7280');
-        }
-        
-        function toggleVolume() {
-            const volumeControl = document.getElementById('volume-control');
-            if (volumeControl) {
-                volumeControl.style.display = volumeControl.style.display === 'none' ? 'block' : 'none';
+            updateStatus('⏹️ Stopped', 'white');
+            
+            if (playTimer) {
+                clearTimeout(playTimer);
+                playTimer = null;
             }
         }
-        
-        // Volume control
+
+        // Add hover effects to buttons
         document.addEventListener('DOMContentLoaded', function() {
-            const volumeSlider = document.getElementById('volume-slider');
-            const volumeDisplay = document.getElementById('volume-display');
-            
-            if (volumeSlider && volumeDisplay) {
-                volumeSlider.oninput = function() {
-                    volume = this.value / 100;
-                    volumeDisplay.textContent = this.value;
-                };
-            }
-            
-            // Anime-style button hover effects
-            const buttons = document.querySelectorAll('#strudel-controls button');
+            const buttons = document.querySelectorAll('#player button');
             buttons.forEach(btn => {
                 btn.addEventListener('mouseenter', function() {
-                    this.style.transform = 'translateY(-2px) scale(1.05)';
-                    this.style.boxShadow = '0 8px 25px rgba(255, 107, 157, 0.6)';
+                    this.style.transform = 'scale(1.05)';
+                    this.style.boxShadow = '0 5px 15px rgba(0,0,0,0.2)';
                 });
                 btn.addEventListener('mouseleave', function() {
-                    this.style.transform = 'translateY(0) scale(1)';
-                    this.style.boxShadow = '0 4px 15px rgba(255, 107, 157, 0.4)';
+                    this.style.transform = 'scale(1)';
+                    this.style.boxShadow = 'none';
                 });
             });
-            
-            updateStatus('🎵 Audio player ready! Generate code and click play!', '#06B6D4');
         });
     </script>
-    """, elem_id="strudel-player")
-
-# Custom CSS for anime theme
-anime_css = """
-<style>
-@import url('https://fonts.googleapis.com/css2?family=Poppins:wght@300;400;600;700&display=swap');
-
-:root {
-    --primary-pink: #FF6B9D;
-    --primary-purple: #A855F7;
-    --primary-blue: #3B82F6;
-    --accent-cyan: #06B6D4;
-    --accent-yellow: #FCD34D;
-    --dark-bg: #1A1B2E;
-    --darker-bg: #16213E;
-    --card-bg: rgba(255, 255, 255, 0.1);
-    --text-light: #E2E8F0;
-}
-
-.gradio-container {
-    font-family: 'Poppins', sans-serif !important;
-    background: linear-gradient(135deg, #1A1B2E 0%, #16213E 25%, #0F3460 50%, #16213E 75%, #1A1B2E 100%) !important;
-    min-height: 100vh;
-}
-
-.main-header {
-    text-align: center;
-    background: linear-gradient(45deg, var(--primary-pink), var(--primary-purple), var(--primary-blue));
-    -webkit-background-clip: text;
-    -webkit-text-fill-color: transparent;
-    background-clip: text;
-    font-size: 3rem;
-    font-weight: 700;
-    margin: 1rem 0;
-    text-shadow: 0 0 30px rgba(255, 107, 157, 0.5);
-}
-
-.subtitle {
-    text-align: center;
-    color: var(--text-light);
-    font-size: 1.2rem;
-    margin-bottom: 2rem;
-    opacity: 0.9;
-}
-
-.btn-primary {
-    background: linear-gradient(45deg, var(--primary-pink), var(--primary-purple)) !important;
-    border: none !important;
-    border-radius: 25px !important;
-    padding: 0.75rem 2rem !important;
-    font-weight: 600 !important;
-    transition: all 0.3s ease !important;
-    box-shadow: 0 4px 15px rgba(255, 107, 157, 0.4) !important;
-}
-
-.btn-primary:hover {
-    transform: translateY(-2px) !important;
-    box-shadow: 0 8px 25px rgba(255, 107, 157, 0.6) !important;
-}
-
-textarea, input {
-    background: rgba(255, 255, 255, 0.1) !important;
-    border: 2px solid transparent !important;
-    border-radius: 15px !important;
-    color: var(--text-light) !important;
-    transition: all 0.3s ease !important;
-}
-
-textarea:focus, input:focus {
-    border-color: var(--primary-pink) !important;
-    box-shadow: 0 0 20px rgba(255, 107, 157, 0.3) !important;
-}
-
-@keyframes sparkle {
-    0%, 100% { opacity: 1; transform: scale(1); }
-    50% { opacity: 0.5; transform: scale(1.2); }
-}
-</style>
-"""
-
-# Create Gradio interface
-with gr.Blocks(
-    theme=gr.themes.Soft(
-        primary_hue="pink",
-        secondary_hue="purple",
-        neutral_hue="slate"
-    ),
-    css=anime_css,
-    title="🎵 Strudel Music Generator"
-) as app:
-    
-    # Header
-    gr.HTML("""
-    <div class="main-header">🎵 Strudel Music Generator</div>
-    <div class="subtitle">Transform your musical dreams into Strudel code with anime-powered AI! ✨</div>
     """)
     
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### 🎼 Describe Your Music")
-            
-            description = gr.Textbox(
-                label="Musical Description",
-                placeholder="e.g., 'A dreamy lofi track with soft piano chords, mellow drums, and a gentle melody that feels like floating on clouds...'",
-                lines=4,
-                elem_id="description"
-            )
-            
-            with gr.Row():
-                tempo = gr.Slider(
-                    minimum=60,
-                    maximum=200,
-                    value=120,
-                    step=5,
-                    label="🎵 Tempo (BPM)"
-                )
-                
-                style = gr.Dropdown(
-                    choices=["Auto-detect", "Lofi", "Techno", "House", "Ambient", "Jazz", "Cyberpunk", "Anime", "Chiptune"],
-                    value="Auto-detect",
-                    label="🎭 Style Override"
-                )
-            
-            with gr.Row():
-                generate_btn = gr.Button(
-                    "🚀 Generate Strudel Code",
-                    variant="primary",
-                    elem_id="generate-btn"
-                )
-                magic_btn = gr.Button(
-                    "✨ Add Magic",
-                    elem_id="magic-btn"
-                )
-        
-        with gr.Column(scale=1):
-            gr.Markdown("### 🎹 Generated Strudel Code")
-            
-            code_output = gr.Code(
-                label="Your Strudel Code (Editable)",
-                language="javascript",
-                lines=15,
-                elem_id="code-output"
-            )
-            
-            status_output = gr.Textbox(
-                label="Status",
-                interactive=False,
-                elem_id="status"
-            )
-            
-            analysis_output = gr.Markdown(
-                label="🔍 Musical Analysis"
-            )
-    
-    # Audio Player Section
-    gr.Markdown("### 🎵 Audio Playback")
-    strudel_player = create_strudel_player()
-    
-    # Examples section
-    gr.Markdown("### 🎨 Try These Anime-Inspired Examples")
+    # Quick examples
+    gr.HTML("<h3 style='margin-top: 30px;'>🎨 Quick Examples:</h3>")
     
     with gr.Row():
-        example_buttons = []
-        for i, (title, desc) in enumerate(list(examples.items())[:4]):
-            btn = gr.Button(title, elem_id=f"example-{i}")
-            example_buttons.append((btn, desc))
-    
-    with gr.Row():
-        for i, (title, desc) in enumerate(list(examples.items())[4:]):
-            btn = gr.Button(title, elem_id=f"example-{i+4}")
-            example_buttons.append((btn, desc))
-    
-    # Instructions and tips
-    with gr.Accordion("🎓 Music Theory Helper & Strudel Tips", open=False):
-        gr.Markdown("""
-        **🎵 Musical Elements You Can Describe:**
-        - **Drums**: "kick drums", "snare", "hi-hats", "trap beats", "breakbeats"
-        - **Bass**: "deep bass", "funky bass", "wobble bass", "walking bass"
-        - **Harmony**: "jazz chords", "emotional chords", "uplifting progression"
-        - **Melody**: "anime melody", "8-bit tune", "ethereal lead", "fast arpeggios"
-        
-        **🎭 Styles & Moods:**
-        - **Lofi**: relaxed, mellow, nostalgic, cozy
-        - **Cyberpunk**: dark, futuristic, glitchy, intense
-        - **Anime**: emotional, dramatic, uplifting, kawaii
-        - **Chiptune**: retro, 8-bit, nostalgic, bouncy
-        
-        **⚡ Strudel Code Tips:**
-        - Use `stack()` to layer multiple patterns
-        - Add `.sound()` to choose different instruments
-        - Apply effects like `.lpf()`, `.room()`, `.delay()`
-        - Control timing with `.slow()`, `.fast()`, `.every()`
-        - Experiment with `.sometimes()` for variations
-        
-        **🎮 Pro Tips:**
-        - Be descriptive about the mood and energy you want
-        - Mention specific instruments or sounds
-        - Describe the genre or style for better results
-        - Use the "Add Magic" button for instant variations!
-        - Click the Play button to hear your generated music!
-        
-        **🎵 Audio Playbook:**
-        - Generate code first, then click the ▶️ Play button
-        - Use ⏹️ Stop to halt playback
-        - Adjust volume with the 🔊 Volume button
-        - The player works in demo mode and with full Strudel.js integration
-        """)
+        ex1 = gr.Button("🎮 Chiptune", size="sm")
+        ex2 = gr.Button("🌙 Lofi", size="sm") 
+        ex3 = gr.Button("⚡ Techno", size="sm")
+        ex4 = gr.Button("🎹 Jazz", size="sm")
     
     # Event handlers
     generate_btn.click(
         fn=generate_music,
-        inputs=[description, tempo, style],
-        outputs=[code_output, status_output, analysis_output]
+        inputs=[description, tempo],
+        outputs=[code_output]
     )
     
-    magic_btn.click(
-        fn=add_magic,
-        inputs=[code_output],
-        outputs=[code_output, status_output]
-    )
-    
-    # Example button handlers
-    for btn, desc in example_buttons:
-        btn.click(
-            fn=lambda x=desc: x,
-            outputs=[description]
-        )
-    
-    # Footer
+    # Example handlers
+    ex1.click(lambda: "8-bit chiptune with bouncy melody and simple drums", outputs=[description])
+    ex2.click(lambda: "mellow lofi with soft piano chords and gentle drums", outputs=[description])
+    ex3.click(lambda: "driving techno with heavy bass and pounding kick", outputs=[description])
+    ex4.click(lambda: "smooth jazz with walking bass and chord progressions", outputs=[description])
+
     gr.HTML("""
-    <div style='text-align: center; margin-top: 2rem; opacity: 0.7; color: #E2E8F0;'>
-        <p>Made with 💖 for National Make Music Day | Powered by Strudel.js & Gradio</p>
-        <p><small>🎵 Turn your musical dreams into algorithmic reality! ✨</small></p>
+    <div style='text-align: center; margin-top: 30px; opacity: 0.7;'>
+        <p>Made for National Make Music Day 🎵</p>
     </div>
     """)
 
-# Launch configuration
 if __name__ == "__main__":
     app.launch(
         share=False,
         server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True
+        server_port=7860
     )