Create app.py

app.py

@@ -0,0 +1,548 @@
+import gradio as gr
+import json
+import re
+import random
+from typing import Dict, List, Tuple
+
+# 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)']
+        }
+
+    def analyze_description(self, description: str) -> Dict[str, List[str]]:
+        """Enhanced analysis with anime and electronic music focus"""
+        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']
+        }
+        
+        for pattern, keywords in drum_keywords.items():
+            if any(keyword in desc for keyword in keywords):
+                elements['drums'].append(pattern)
+        
+        if 'drum' in desc and not elements['drums']:
+            elements['drums'].extend(['kick', 'snare', 'hihat'])
+            
+        # 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'],
+            'chiptu ne': ['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')
+            
+        # 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)
+        
+        # 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
+        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)}',
+            '',
+        ]
+        
+        if len(patterns) == 1:
+            code_lines.append(patterns[0])
+        else:
+            code_lines.append('stack(')
+            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)
+        
+        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
+
+# 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"""
+    if not description.strip():
+        return "", "Please describe your music first! 🎵", ""
+    
+    try:
+        code, analysis = generator.generate_code(description, tempo, style)
+        success_msg = "🎉 Music code generated successfully! Copy it to use in Strudel."
+        return code, success_msg, analysis
+    except Exception as e:
+        error_msg = f"❌ Error generating music: {str(e)}"
+        return "", error_msg, ""
+
+def add_magic(code):
+    """Add variations to existing code"""
+    if not code.strip():
+        return code, "Generate some code first! 🎼"
+    
+    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, "")
+
+# 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;
+}
+
+/* Button styling */
+.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;
+}
+
+/* Input styling */
+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;
+}
+
+/* Gradio component styling */
+.gr-form {
+    background: var(--card-bg) !important;
+    backdrop-filter: blur(10px) !important;
+    border: 1px solid rgba(255, 255, 255, 0.1) !important;
+    border-radius: 20px !important;
+    padding: 1.5rem !important;
+    margin: 1rem 0 !important;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3) !important;
+}
+
+/* Animations */
+@keyframes sparkle {
+    0%, 100% { opacity: 1; transform: scale(1); }
+    50% { opacity: 0.5; transform: scale(1.2); }
+}
+
+.sparkle::after {
+    content: "✨";
+    animation: sparkle 2s infinite;
+}
+</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"
+            )
+    
+    # Examples section
+    gr.Markdown("### 🎨 Try These Anime-Inspired Examples")
+    
+    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!
+        """)
+    
+    # Event handlers
+    generate_btn.click(
+        fn=generate_music,
+        inputs=[description, tempo, style],
+        outputs=[code_output, status_output, analysis_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
+    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>
+    """)
+
+# Launch configuration
+if __name__ == "__main__":
+    app.launch(
+        share=False,
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )