Update app.py

app.py

@@ -282,42 +282,129 @@ def generate_working_strudel_code(prompt, genre="techno", complexity="moderate")
     
     return f"{comment_line}\n{base_pattern}"
 
-def create_visual_code(style="reactive"):
-    """Create working visual code"""
-    visual_styles = {
-        "reactive": """osc(8, 0.1, 1.2)
-.color(1.8, 0.8, 1.5)
-.modulate(noise(2), 0.3)
+def create_visual_code(style="reactive", genre="techno"):
+    """Create working visual code with genre-appropriate randomization"""
+    
+    # Genre-specific visual styles
+    genre_visuals = {
+        "techno": [
+            """osc(12, 0.1, 0.8)
+.color(2, 0.5, 1.5)
+.kaleid(4)
+.rotate(0, 0.1)
+.out()""",
+            """shape(4, 0.5, 0.01)
+.repeat(4, 3)
+.color(1.8, 0.8, 2)
 .kaleid(6)
 .out()""",
-        "kaleidoscope": """shape(6, 0.3, 0.01)
-.repeat(3, 2)
-.rotate(0, 0.03)
-.color(1.2, 1.8, 0.8)
+            """osc(16, 0.05, 1)
+.pixelate(24, 18)
+.color(2, 1, 0.8)
+.contrast(1.8)
+.out()"""
+        ],
+        "house": [
+            """osc(6, 0.1, 1.2)
+.color(1.5, 1.8, 0.8)
+.modulate(noise(2), 0.2)
 .kaleid(8)
 .out()""",
-        "flowing": """noise(3, 0.1)
-.color(1.5, 1.2, 0.8)
-.modulate(osc(2, 0.05), 0.4)
-.contrast(1.4)
+            """shape(6, 0.4, 0.02)
+.repeat(3, 2)
+.rotate(0, 0.05)
+.color(1.2, 1.5, 1.8)
+.out()""",
+            """noise(2, 0.1)
+.color(1.8, 1.2, 1.5)
+.modulate(osc(3, 0.08), 0.3)
+.kaleid(4)
+.out()"""
+        ],
+        "ambient": [
+            """noise(3, 0.05)
+.color(0.8, 1.5, 1.8)
+.modulate(osc(1, 0.1), 0.4)
+.contrast(1.2)
+.out()""",
+            """osc(4, 0.02, 1.5)
+.color(1.2, 1.8, 1.5)
+.modulate(noise(1), 0.5)
+.kaleid(3)
 .out()""",
-        "geometric": """osc(12, 0.02, 0.8)
+            """shape(8, 0.2, 0.005)
+.repeat(2, 2)
+.color(0.8, 1.8, 1.2)
+.rotate(0, 0.02)
+.out()"""
+        ],
+        "breakbeat": [
+            """osc(20, 0.2, 0.5)
+.pixelate(16, 12)
+.color(2, 1.5, 0.5)
+.contrast(2)
+.out()""",
+            """shape(3, 0.8, 0.05)
+.repeat(6, 4)
+.color(1.8, 2, 1)
+.kaleid(5)
+.out()""",
+            """noise(4, 0.3)
+.color(2, 1.8, 0.8)
+.modulate(osc(8, 0.1), 0.6)
+.pixelate(20, 15)
+.out()"""
+        ],
+        "experimental": [
+            """noise(5, 0.4)
+.color(2, 0.8, 1.8)
+.modulate(osc(15, 0.3), 0.8)
+.pixelate(8, 6)
+.contrast(2.5)
+.out()""",
+            """osc(25, 0.4, 0.2)
+.color(1.8, 2, 0.5)
+.kaleid(12)
+.rotate(0, 0.2)
+.out()""",
+            """shape(7, 0.9, 0.1)
+.repeat(8, 6)
+.color(2, 1, 2)
+.modulate(noise(6), 0.7)
+.out()"""
+        ],
+        "hiphop": [
+            """osc(8, 0.1, 1)
+.color(1.8, 1.5, 0.8)
 .pixelate(32, 24)
-.color(2, 0.8, 1.5)
 .contrast(1.6)
+.out()""",
+            """shape(4, 0.6, 0.02)
+.repeat(4, 3)
+.color(2, 1.8, 1)
+.kaleid(4)
+.out()""",
+            """noise(3, 0.2)
+.color(1.5, 1.8, 0.8)
+.modulate(osc(4, 0.1), 0.3)
+.pixelate(28, 20)
 .out()"""
+        ]
     }
-    return visual_styles.get(style, visual_styles["reactive"])
+    
+    # Get random visual from genre-specific options
+    visuals = genre_visuals.get(genre, genre_visuals["techno"])
+    return random.choice(visuals)
 
-def create_complete_strudel_code(generated_code, include_visuals=True, visual_style="reactive"):
-    """Create complete, working Strudel code"""
+def create_complete_strudel_code(generated_code, include_visuals=True, genre="techno"):
+    """Create complete, working Strudel code with random visuals"""
     
     visual_code = ""
     if include_visuals:
         visual_code = f"""// Hydra visuals
 await initHydra({{feedStrudel:5}})
 
-{create_visual_code(visual_style)}
+{create_visual_code("random", genre)}
 
 """
     
@@ -336,61 +423,11 @@ def generate_interface(prompt, genre, complexity, include_visuals, visual_style,
     if not prompt.strip():
         return "Please enter a description of the music you want to create."
     
-    if use_ai:
-        # Use AI generation with better examples
-        system_prompt = f"""Generate working Strudel live coding pattern for: {prompt}
-Genre: {genre}, Complexity: {complexity}
-
-Example Strudel patterns:
-s("bd*4, hh*8").gain(0.8)
-stack(s("bd ~ sn ~"), n("0 2 4").s("sine").octave(3).gain(0.7))
-n("[0 3 5 7]*2").s("sawtooth").octave(2).lpf(1200).gain(0.8).scale("a:minor")
-
-Generate a {complexity} {genre} pattern:"""
-        
-        try:
-            outputs = code_generator(
-                system_prompt,
-                max_length=len(system_prompt.split()) + 80,
-                temperature=0.8,
-                do_sample=True,
-                top_p=0.9,
-                num_return_sequences=1
-            )
-            
-            generated_text = outputs[0]['generated_text']
-            strudel_code = generated_text[len(system_prompt):].strip()
-            
-            # Clean the AI output more thoroughly
-            lines = strudel_code.split('\n')
-            clean_lines = []
-            for line in lines[:8]:  # Limit to 8 lines
-                line = line.strip()
-                # More robust pattern matching for Strudel code
-                if line and (line.startswith('s(') or line.startswith('n(') or line.startswith('stack(') or 
-                           '.gain(' in line or '.s(' in line or '.octave(' in line or '.scale(' in line or
-                           line.endswith(')') or line.endswith(',') or '.lpf(' in line):
-                    clean_lines.append(line)
-                # Stop at obvious non-Strudel patterns
-                elif any(stop_word in line.lower() for stop_word in ['function', 'var ', 'let ', 'const ', 'import', '//']):
-                    break
-            
-            if clean_lines:
-                strudel_code = '\n'.join(clean_lines)
-                strudel_code = f"// AI Generated: {prompt}\n{strudel_code}"
-            else:
-                # Fallback to curated patterns if AI fails
-                strudel_code = generate_working_strudel_code(prompt, genre, complexity)
-        except Exception as e:
-            # Fallback to curated patterns if AI fails
-            print(f"AI generation failed: {e}")
-            strudel_code = generate_working_strudel_code(prompt, genre, complexity)
-    else:
-        # Use curated pattern generation
-        strudel_code = generate_working_strudel_code(prompt, genre, complexity)
-    
-    # Create complete working template
-    complete_code = create_complete_strudel_code(strudel_code, include_visuals, visual_style)
+    # Always use curated pattern generation (removed AI for simplicity and speed)
+    strudel_code = generate_working_strudel_code(prompt, genre, complexity)
+    
+    # Create complete working template with random visuals based on genre
+    complete_code = create_complete_strudel_code(strudel_code, include_visuals, genre)
     
     return complete_code
 
@@ -403,9 +440,9 @@ with gr.Blocks(title="Working Strudel Generator", theme=gr.themes.Soft()) as app
     
     ✅ **Premium curated patterns** - professional quality sounds  
     🎛️ **Real Strudel syntax** - copy & paste ready  
-    🎨 **Reactive Hydra visuals** included  
+    🎨 **Random genre-specific visuals** - different every time!  
     🎵 **6 genres** with authentic patterns  
-    🤖 **Optional AI** (recommended: keep AI off for speed)
+    ⚡ **Instant generation** - no waiting!
     
     **Usage:** Describe music → Generate → Copy to [strudel.cc](https://strudel.cc) → Play!
     """)
@@ -436,19 +473,8 @@ with gr.Blocks(title="Working Strudel Generator", theme=gr.themes.Soft()) as app
                     label="🎨 Include visuals",
                     value=True
                 )
-                
-                use_ai = gr.Checkbox(
-                    label="🤖 Use AI (slower)",
-                    value=False
-                )
-            
-            visual_style = gr.Dropdown(
-                choices=["reactive", "kaleidoscope", "flowing", "geometric"],
-                value="reactive",
-                label="👁️ Visual Style"
-            )
             
-            generate_btn = gr.Button("🎵 Generate Premium Code", variant="primary", size="lg")
+            generate_btn = gr.Button("Generate Code", variant="primary", size="lg")
         
         with gr.Column():
             output_code = gr.Code(
@@ -496,8 +522,8 @@ with gr.Blocks(title="Working Strudel Generator", theme=gr.themes.Soft()) as app
             genre_dropdown,
             complexity_dropdown,
             include_visuals,
-            visual_style,
-            use_ai
+            gr.State("random"),  # dummy visual_style
+            gr.State(False)      # dummy use_ai
         ],
         outputs=output_code
     )