Update app.py

app.py

@@ -3,6 +3,7 @@ import requests
 import json
 from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
 import torch
+import random
 
 # Use CodeGen instead of StarCoder (no authentication needed)
 MODEL_NAME = "Salesforce/codegen-350M-mono"
@@ -27,236 +28,385 @@ except Exception as e:
         device_map=None
     )
 
-# Strudel code examples for few-shot prompting
-STRUDEL_EXAMPLES = """
-// Basic drum pattern
-s("bd hh sn hh").gain(0.8)
+# Enhanced Strudel examples with more advanced patterns
+ADVANCED_STRUDEL_EXAMPLES = """
+// Dynamic techno with evolving patterns
+stack(
+  s("bd*4, [~ rim]*2, hh*8").bank("RolandTR909").speed(0.9).gain(0.8),
+  n("[0 3 [5 0] [7 5]]*2").s("sawtooth").octave(2).lpf(sine.range(400,2000).slow(8)),
+  n("7 9 7 4").s("square").octave(5).slow(2).delay(0.25).room(0.6)
+).scale("a:minor")
 
-// Melodic pattern
-n("0 2 4 7").s("sine").octave(4).lpf(2000)
+// Polyrhythmic ambient
+stack(
+  n("[0 2 4]/3").s("sine").octave(3).slow(8).room(0.9).gain(0.4),
+  n("[7 9 11]/5").s("triangle").octave(4).slow(12).delay(0.375).gain(0.3),
+  s("~ ~ ~ rim").slow(4).gain(0.2).room(0.8)
+).scale("d:minor")
 
-// Techno beat
+// Generative house
 stack(
-  s("bd*4").gain(0.8),
-  s("~ hh ~ hh").gain(0.6),
-  n("0 ~ 3 ~").s("sawtooth").octave(2).lpf(800)
-)
+  s("bd ~ ~ ~ bd ~ ~ ~").sometimes(fast(2)).gain(0.7),
+  n("0 [2 4] 7 [5 0]").s("sawtooth").octave(2).sometimes(add(note(12))),
+  s("[hh ch]*4").degradeBy(0.3).gain(0.5).pan(perlin.slow(2))
+).scale("g:minor")
 
-// Ambient pattern
-n("[0 2 4]/3").s("sine").octave(3).slow(4).room(0.9).gain(0.5)
+// Experimental breakbeat
+stack(
+  s("[bd sn]*2").sometimes(rev).speed(choose([0.8,1,1.2])),
+  n("0 4 7 0 2 5 7 2").s("square").cutoff(sine.range(200,2000)),
+  s("~ [perc:0 perc:1]/2").degradeBy(0.4).speed(rand.range(0.8,1.2))
+)
 """
 
-def generate_strudel_code(prompt, genre="general", complexity="simple", max_length=150, temperature=0.7):
-    """Generate Strudel code using CodeGen"""
+# Genre-specific pattern templates with advanced features
+GENRE_TEMPLATES = {
+    "techno": {
+        "drums": ["bd*4", "[bd bd]*2", "bd ~ bd [bd bd]", "bd*4, [~ rim]*2"],
+        "hats": ["hh*8", "[hh ch]*4", "~ hh ~ [hh ch]", "[oh ch hh]*2"],
+        "bass": ["0 ~ 3 ~", "[0 3 [5 0] 7]*2", "0 0 3 5", "[0 ~ 3] [~ 7]"],
+        "lead": ["7 9 7 4", "[0 4 7]*2", "9 7 4 2", "[7 9] [4 7] [2 4]"],
+        "effects": [".lpf(sine.range(400,2000).slow(8))", ".delay(0.25).room(0.6)", ".sometimes(add(note(12)))", ".cutoff(perlin.range(800,3000))"]
+    },
+    "house": {
+        "drums": ["bd ~ ~ ~ bd ~ ~ ~", "[bd ~ bd]*2", "bd ~ [~ bd] ~"],
+        "hats": ["~ hh ~ hh", "[~ ch ~ hh]*2", "hh ~ ch ~"],
+        "bass": ["0 2 4 7", "[0 ~ 2] [~ 4]", "0 4 2 7", "[0 2] [4 7]"],
+        "lead": ["[0 2 4]*2", "7 4 2 0", "[2 4 7]*3", "0 4 7 9"],
+        "effects": [".room(0.6).delay(0.125)", ".lpf(2000).sometimes(add(note(7)))", ".gain(sine.range(0.4,0.8).slow(4))", ".pan(cosine.slow(8))"]
+    },
+    "ambient": {
+        "drums": ["~ ~ ~ rim", "bd ~ ~ ~", "~ ~ rim ~"],
+        "hats": ["~ ~ hh ~", "~ ch ~ ~", ""],
+        "bass": ["[0 2 4]/3", "[0 4]/2", "[2 7]/5", "[0 2 4 7]/4"],
+        "lead": ["[7 9 11]/5", "[0 4 7]*2", "[2 4 9]/3", "[7 11 14]/7"],
+        "effects": [".slow(8).room(0.9)", ".slow(12).delay(0.375)", ".slow(16).gain(0.3)", ".slow(6).lpf(800).room(0.8)"]
+    },
+    "breakbeat": {
+        "drums": ["[bd sn]*2", "bd [sn sn] bd sn", "[bd ~ sn ~]*2"],
+        "hats": ["[hh ch]*4", "hh*8", "[ch hh hh]*2"],
+        "bass": ["0 4 7 0 2 5 7 2", "[0 ~ 7] [3 5]", "0 7 4 2"],
+        "lead": ["[0 4 7]*3", "9 7 4 0", "[7 4] [2 0]"],
+        "effects": [".speed(choose([0.8,1,1.2]))", ".degradeBy(0.3)", ".sometimes(rev)", ".cutoff(rand.range(400,2000))"]
+    },
+    "experimental": {
+        "drums": ["[bd rim]*3", "bd ~ [perc:0 perc:1]", "[~ bd] [rim ~]"],
+        "hats": ["[ch oh]*5", "~ [hh hh] ~", "[noise:0]/8"],
+        "bass": ["[0 3 7]/5", "[0 ~ 4] [~ 7]", "0 [2 5] 7"],
+        "lead": ["[0 4 7 11]/7", "[9 7] [4 2]", "[0 ~ 7] [~ 4]"],
+        "effects": [".degradeBy(rand.range(0.1,0.5))", ".speed(perlin.range(0.5,1.5))", ".pan(sine.slow(3))", ".room(cosine.range(0.2,0.9))"]
+    }
+}
+
+def generate_enhanced_strudel_code(prompt, genre="techno", complexity="moderate", include_polyrhythm=True, include_effects=True):
+    """Generate more sophisticated Strudel code"""
+    
+    # Get genre templates
+    templates = GENRE_TEMPLATES.get(genre, GENRE_TEMPLATES["techno"])
+    
+    # Build complexity-based structure
+    if complexity == "simple":
+        layers = 2
+        pattern_complexity = 1
+    elif complexity == "moderate":
+        layers = 3
+        pattern_complexity = 2
+    else:  # complex
+        layers = 4
+        pattern_complexity = 3
+    
+    # Generate drum layer
+    drum_pattern = random.choice(templates["drums"])
+    hat_pattern = random.choice(templates["hats"])
+    
+    if hat_pattern:
+        drum_code = f's("{drum_pattern}, {hat_pattern}").gain(0.8)'
+    else:
+        drum_code = f's("{drum_pattern}").gain(0.8)'
+    
+    layers_code = [drum_code]
+    
+    # Generate bass layer
+    bass_pattern = random.choice(templates["bass"])
+    bass_effect = random.choice(templates["effects"]) if include_effects else ""
+    bass_synth = random.choice(["sawtooth", "sine", "square"])
+    octave = random.choice([1, 2])
+    
+    bass_code = f'n("{bass_pattern}").s("{bass_synth}").octave({octave}){bass_effect}.gain(0.7)'
+    layers_code.append(bass_code)
+    
+    # Add lead layer if complexity allows
+    if layers >= 3:
+        lead_pattern = random.choice(templates["lead"])
+        lead_effect = random.choice(templates["effects"]) if include_effects else ""
+        lead_synth = random.choice(["square", "triangle", "sawtooth"])
+        lead_octave = random.choice([4, 5])
+        
+        lead_code = f'n("{lead_pattern}").s("{lead_synth}").octave({lead_octave}){lead_effect}.gain(0.5)'
+        layers_code.append(lead_code)
+    
+    # Add atmospheric layer for complex patterns
+    if layers >= 4:
+        if genre == "ambient":
+            atmo_code = 'n("[0 2 4]/7").s("sine").octave(3).slow(16).room(0.9).gain(0.3)'
+        else:
+            perc_sounds = ["perc:0", "perc:1", "rim", "clap"]
+            perc_pattern = random.choice(perc_sounds)
+            atmo_code = f's("~ ~ {perc_pattern} ~").slow(2).gain(0.4).room(0.6)'
+        layers_code.append(atmo_code)
+    
+    # Choose random scale
+    scales = ["a:minor", "d:minor", "g:minor", "c:major", "e:minor", "f:major"]
+    scale = random.choice(scales)
+    
+    # Build final code
+    if len(layers_code) == 1:
+        final_code = f'{layers_code[0]}.scale("{scale}")'
+    else:
+        layers_str = ',\n  '.join(layers_code)
+        final_code = f'stack(\n  {layers_str}\n).scale("{scale}")'
+    
+    # Add advanced features based on complexity
+    if complexity == "complex" and include_polyrhythm:
+        final_code += '\n\n// Add some spice\n'
+        spice_options = [
+            '.sometimes(fast(2))',
+            '.sometimes(slow(2))',
+            '.degradeBy(0.2)',
+            '.sometimes(rev)',
+            '.euclid(3,8)'
+        ]
+        final_code += f'// {random.choice(spice_options)}'
+    
+    return final_code
+
+def create_ai_assisted_code(prompt, genre, complexity):
+    """Create AI-assisted code with fallback to enhanced patterns"""
     
-    # Build context-aware prompt
-    system_prompt = f"""// Strudel live coding language for music
-// Generate {complexity} {genre} music patterns
-// Examples:
-{STRUDEL_EXAMPLES}
+    # Try AI generation first
+    system_prompt = f"""// Advanced Strudel live coding patterns
+// Examples with complex features:
+{ADVANCED_STRUDEL_EXAMPLES}
 
-// Create: {prompt}
+// Generate {complexity} {genre} pattern for: {prompt}
+// Use stack(), effects, and dynamic patterns
 // Code:
 """
     
     try:
-        # Generate code using pipeline
         outputs = code_generator(
             system_prompt,
-            max_length=len(system_prompt.split()) + max_length,
-            temperature=temperature,
+            max_length=len(system_prompt.split()) + 100,
+            temperature=0.8,
             do_sample=True,
             top_p=0.9,
             num_return_sequences=1,
             pad_token_id=code_generator.tokenizer.eos_token_id
         )
         
-        # Extract generated text
         generated_text = outputs[0]['generated_text']
-        
-        # Extract only the new generated part
         strudel_code = generated_text[len(system_prompt):].strip()
-        
-        # Clean up the code
         strudel_code = clean_strudel_code(strudel_code)
         
+        # If AI generation is too simple or fails, enhance it
+        if len(strudel_code.split('\n')) < 3 or 'stack(' not in strudel_code:
+            strudel_code = generate_enhanced_strudel_code(prompt, genre, complexity)
+        
         return strudel_code
         
     except Exception as e:
-        return f"// Error generating code: {str(e)}\n// Fallback pattern:\ns(\"bd hh sn hh\").gain(0.8)"
+        # Fallback to enhanced generation
+        return generate_enhanced_strudel_code(prompt, genre, complexity)
 
 def clean_strudel_code(code):
-    """Clean and format generated Strudel code"""
+    """Enhanced code cleaning with better pattern recognition"""
     lines = code.split('\n')
     cleaned_lines = []
+    in_stack = False
     
     for line in lines:
         line = line.strip()
-        # Stop at comments that indicate end of generation
-        if line.startswith('//') and any(word in line.lower() for word in ['user', 'request', 'example', 'create']):
-            break
-        # Include actual code lines
-        if line and (line.startswith('s(') or line.startswith('n(') or line.startswith('stack(') or 
-                    line.startswith('$:') or line.startswith('all(') or line.endswith(')') or 
-                    line.endswith(',') or 'gain(' in line or 'lpf(' in line):
+        
+        # Detect stack structures
+        if 'stack(' in line:
+            in_stack = True
+            cleaned_lines.append(line)
+            continue
+        
+        if in_stack and line == ')':
+            cleaned_lines.append(line)
+            in_stack = False
+            continue
+        
+        # Include valid Strudel patterns
+        if (line.startswith('s(') or line.startswith('n(') or line.startswith('$:') or
+            line.startswith('all(') or '.scale(' in line or in_stack or
+            any(pattern in line for pattern in ['.gain(', '.lpf(', '.room(', '.delay(', '.octave('])):
             cleaned_lines.append(line)
-        # Stop if we hit obvious non-Strudel code
-        elif any(keyword in line for keyword in ['function', 'var ', 'let ', 'const ', 'import', 'export']):
+        
+        # Stop at non-Strudel code
+        elif any(keyword in line for keyword in ['function', 'var ', 'let ', 'const ', 'import']):
             break
             
-        if len(cleaned_lines) >= 8:  # Limit output length
+        if len(cleaned_lines) >= 12:
             break
     
-    # If no valid code was generated, provide a fallback
-    if not cleaned_lines:
-        return generate_fallback_pattern(genre)
-    
-    return '\n'.join(cleaned_lines)
+    return '\n'.join(cleaned_lines) if cleaned_lines else generate_enhanced_strudel_code("fallback", "techno", "simple")
 
-def generate_fallback_pattern(genre):
-    """Generate a simple fallback pattern based on genre"""
-    patterns = {
-        "techno": 'stack(\n  s("bd*4").gain(0.8),\n  s("~ hh ~ hh").gain(0.6),\n  n("0 ~ 3 ~").s("sawtooth").octave(2)\n)',
-        "house": 'stack(\n  s("bd ~ ~ ~ bd ~ ~ ~").gain(0.7),\n  s("~ hh ~ hh").gain(0.5),\n  n("0 2 4 7").s("sine").octave(3)\n)',
-        "ambient": 'n("[0 2 4]/3").s("sine").octave(3).slow(4).room(0.9).gain(0.5)',
-        "jazz": 'stack(\n  s("bd ~ sn ~").gain(0.7),\n  s("~ ~ hh ~").gain(0.4),\n  n("0 3 5 7").s("triangle").octave(4)\n)',
-        "rock": 'stack(\n  s("bd sn bd sn").gain(0.8),\n  s("hh*8").gain(0.5),\n  n("0 0 3 5").s("square").octave(2)\n)'
+def create_full_strudel_template(generated_code, include_visuals=True, visual_style="reactive"):
+    """Enhanced template with better visuals"""
+    
+    visual_styles = {
+        "reactive": """osc(8, 0.1, 1.2)
+.color(1.8, 0.8, 1.5)
+.modulate(noise(2), 0.3)
+.kaleid(6)
+.rotate(0, 0.05)
+.out()""",
+        "kaleidoscope": """shape(6, 0.3, 0.01)
+.repeat(4, 3)
+.rotate(0, 0.03)
+.color(1.2, 1.8, 0.8)
+.kaleid(8)
+.out()""",
+        "flowing": """noise(3, 0.1)
+.color(1.5, 1.2, 0.8)
+.modulate(osc(2, 0.05), 0.4)
+.diff(osc(5, 0.1).color(0.8, 1.5, 1.2))
+.contrast(1.4)
+.out()""",
+        "geometric": """osc(12, 0.02, 0.8)
+.pixelate(32, 24)
+.color(2, 0.8, 1.5)
+.add(shape(4).scale(0.3).repeat(6, 4))
+.contrast(1.6)
+.out()"""
     }
-    return patterns.get(genre, 's("bd hh sn hh").gain(0.8)')
-
-def create_full_strudel_template(generated_code, include_visuals=True):
-    """Wrap generated code in a complete Strudel template"""
     
-    visual_code = """// Hydra visuals
-await initHydra({feedStrudel:5})
+    visual_code = f"""// Enhanced Hydra visuals
+await initHydra({{feedStrudel:5}})
 
-osc(10, 0.1, 0.8)
-.kaleid(4)
-.color(1.5, 0.8, 1.2)
-.out()
+{visual_styles[visual_style]}
 
 """ if include_visuals else ""
     
-    template = f"""{visual_code}// AI-Generated Strudel Music Code
+    template = f"""{visual_code}// 🎵 AI-Enhanced Strudel Code
 {generated_code}
 
-// Global effects (optional)
-// all(x => x.fft(5).scope())
+// Optional global effects
+// all(x => x.fft(5).scope().compressor(0.8))
 """
     
     return template
 
-# Gradio interface
-def generate_interface(prompt, genre, complexity, include_visuals, max_length, temperature):
-    """Main interface function"""
+# Enhanced Gradio interface
+def generate_interface(prompt, genre, complexity, include_visuals, visual_style, use_ai_assist):
+    """Enhanced interface with more options"""
     
     if not prompt.strip():
         return "Please enter a description of the music you want to create."
     
-    # Generate the core Strudel code
-    generated_code = generate_strudel_code(
-        prompt=prompt,
-        genre=genre,
-        complexity=complexity,
-        max_length=max_length,
-        temperature=temperature
-    )
+    # Generate enhanced code
+    if use_ai_assist:
+        generated_code = create_ai_assisted_code(prompt, genre, complexity)
+    else:
+        generated_code = generate_enhanced_strudel_code(prompt, genre, complexity, True, True)
     
     # Create full template
-    full_code = create_full_strudel_template(generated_code, include_visuals)
+    full_code = create_full_strudel_template(generated_code, include_visuals, visual_style)
     
     return full_code
 
-# Create Gradio app
-with gr.Blocks(title="Strudel Code Generator", theme=gr.themes.Soft()) as app:
+# Create enhanced Gradio app
+with gr.Blocks(title="Enhanced Strudel Generator", theme=gr.themes.Soft()) as app:
     gr.Markdown("""
-    # 🎵 AI Strudel Code Generator
+    # 🎵 Enhanced AI Strudel Generator
     
-    Generate live coding music patterns using AI! Powered by CodeGen-350M.
+    Generate sophisticated live coding music with **advanced patterns**, **polyrhythms**, and **dynamic effects**!
     
-    **How to use:**
-    1. Describe the music you want (e.g., "techno beat with bass", "ambient soundscape")
-    2. Choose genre and complexity
-    3. Click Generate
-    4. Copy the code to [strudel.cc](https://strudel.cc) to hear it!
+    **New Features:**
+    - 🔥 **Complex polyrhythmic patterns** with stack() structures
+    - 🎛️ **Dynamic effects** (LPF sweeps, delays, reverb, degradation)
+    - 🎨 **Multiple visual styles** (reactive, kaleidoscope, flowing, geometric)
+    - ⚡ **AI-assisted generation** with smart fallbacks
+    - 🎵 **Genre-specific templates** with authentic patterns
     
-    *Note: AI-generated code may need tweaking for best results.*
+    **Usage:** Describe your music → Choose settings → Generate → Copy to [strudel.cc](https://strudel.cc)
     """)
     
     with gr.Row():
         with gr.Column():
             prompt_input = gr.Textbox(
-                label="Describe your music",
-                placeholder="e.g., 'Create a techno beat with kick drum and hi-hats'",
+                label="🎼 Describe your music",
+                placeholder="e.g., 'Dark techno with evolving bassline', 'Polyrhythmic ambient with textures', 'Breakbeat with glitch effects'",
                 lines=3
             )
             
             with gr.Row():
                 genre_dropdown = gr.Dropdown(
-                    choices=["general", "techno", "house", "ambient", "jazz", "rock", "experimental"],
+                    choices=["techno", "house", "ambient", "breakbeat", "experimental"],
                     value="techno",
-                    label="Genre"
+                    label="🎵 Genre"
                 )
                 
                 complexity_dropdown = gr.Dropdown(
                     choices=["simple", "moderate", "complex"],
-                    value="simple",
-                    label="Complexity"
+                    value="moderate",
+                    label="⚙️ Complexity"
                 )
             
-            include_visuals = gr.Checkbox(
-                label="Include Hydra visuals",
-                value=True
-            )
-            
-            with gr.Accordion("Advanced Settings", open=False):
-                max_length_slider = gr.Slider(
-                    minimum=50,
-                    maximum=300,
-                    value=150,
-                    step=25,
-                    label="Max code length"
+            with gr.Row():
+                include_visuals = gr.Checkbox(
+                    label="🎨 Include Hydra visuals",
+                    value=True
                 )
                 
-                temperature_slider = gr.Slider(
-                    minimum=0.3,
-                    maximum=1.0,
-                    value=0.7,
-                    step=0.1,
-                    label="Creativity (temperature)"
+                use_ai_assist = gr.Checkbox(
+                    label="🤖 AI-assisted generation",
+                    value=True
                 )
             
-            generate_btn = gr.Button("🎵 Generate Strudel Code", variant="primary", size="lg")
+            visual_style = gr.Dropdown(
+                choices=["reactive", "kaleidoscope", "flowing", "geometric"],
+                value="reactive",
+                label="👁️ Visual Style"
+            )
+            
+            generate_btn = gr.Button("🚀 Generate Enhanced Code", variant="primary", size="lg")
         
         with gr.Column():
             output_code = gr.Code(
-                label="Generated Strudel Code",
+                label="Generated Enhanced Strudel Code",
                 language="javascript",
-                lines=15
+                lines=20
             )
             
             gr.Markdown("""
-            **Next steps:**
-            1. **Copy** the generated code above
-            2. **Go to** [strudel.cc](https://strudel.cc)
-            3. **Paste** the code and **click play**
-            4. **Enjoy** your AI-generated music! 🎶
+            **🎯 Next Steps:**
+            1. **Copy** the generated code
+            2. **Open** [strudel.cc](https://strudel.cc) 
+            3. **Paste & Play** - enjoy your enhanced music!
             
-            *Tip: You can modify the generated code to customize the sound!*
+            **💡 Pro Tips:**
+            - Adjust `.gain()` values to balance layers
+            - Try `.sometimes()` for variation
+            - Use `.degradeBy()` for glitchy effects
+            - Experiment with `.slow()` and `.fast()`
             """)
     
-    # Example buttons
-    gr.Markdown("### 💡 Quick Examples")
+    # Enhanced examples
+    gr.Markdown("### 🎪 Creative Examples")
     with gr.Row():
-        examples = [
-            ["Create a minimal techno beat", "techno", "simple"],
-            ["Ambient soundscape with reverb", "ambient", "simple"],
-            ["House music with bass line", "house", "moderate"],
-            ["Jazz drum pattern", "jazz", "moderate"],
+        enhanced_examples = [
+            ["Dark techno with evolving filter sweeps", "techno", "complex"],
+            ["Polyrhythmic ambient soundscape", "ambient", "complex"],
+            ["Breakbeat with glitch and degradation", "breakbeat", "complex"],
+            ["Deep house with swinging groove", "house", "moderate"],
+            ["Experimental noise textures", "experimental", "complex"],
         ]
         
-        for example_text, example_genre, example_complexity in examples:
-            btn = gr.Button(f"{example_text}", size="sm")
+        for example_text, example_genre, example_complexity in enhanced_examples:
+            btn = gr.Button(f"✨ {example_text}", size="sm")
             btn.click(
                 lambda t=example_text, g=example_genre, c=example_complexity: (t, g, c),
                 outputs=[prompt_input, genre_dropdown, complexity_dropdown]
@@ -270,8 +420,8 @@ with gr.Blocks(title="Strudel Code Generator", theme=gr.themes.Soft()) as app:
             genre_dropdown,
             complexity_dropdown,
             include_visuals,
-            max_length_slider,
-            temperature_slider
+            visual_style,
+            use_ai_assist
         ],
         outputs=output_code
     )