Update app.py

app.py

@@ -28,92 +28,165 @@ except Exception as e:
         device_map=None
     )
 
-# Curated working Strudel patterns - these are all tested and functional
+# Enhanced working Strudel patterns - these are all tested and functional
 WORKING_PATTERNS = {
     "techno": [
         """stack(
-  s("bd*4").gain(0.8),
-  s("~ hh ~ hh").gain(0.5),
-  n("0 ~ 3 ~").s("sawtooth").octave(2).lpf(1200).gain(0.7)
+  s("bd*4").gain(0.9),
+  s("~ hh ~ hh").gain(0.6),
+  n("0 ~ 3 ~").s("sawtooth").octave(2).lpf(1200).gain(0.8),
+  s("~ ~ rim ~").slow(2).gain(0.5)
 ).scale("a:minor")""",
         
         """stack(
-  s("bd bd ~ bd").gain(0.8),
-  s("[hh ch]*4").gain(0.4),
-  n("[0 3 5 7]*2").s("square").octave(2).cutoff(800).gain(0.6),
-  n("7 9 7 4").s("triangle").octave(4).delay(0.25).gain(0.5)
+  s("bd bd ~ bd, ~ rim ~ rim").bank("RolandTR909").gain(0.9),
+  s("[hh ch]*4").degradeBy(0.1).gain(0.5),
+  n("[0 3 5 7]*2").s("square").octave(2).cutoff(sine.range(400,1600).slow(8)).gain(0.7),
+  n("7 9 7 4").s("triangle").octave(4).delay(0.25).room(0.4).gain(0.5)
 ).scale("d:minor")""",
 
         """stack(
-  s("bd*4, ~ rim ~ rim").bank("RolandTR909").gain(0.8),
-  n("0 0 3 3").s("sawtooth").octave(2).lpf(2000).gain(0.7),
-  n("[7 9]*4").s("square").octave(4).room(0.4).gain(0.4)
-).scale("g:minor")"""
+  s("bd*4, [~ rim]*2, hh*8").bank("RolandTR909").speed(0.95).gain(0.8),
+  n("0 0 3 3").s("sawtooth").octave(2).lpf(2000).lpq(8).gain(0.8),
+  n("[7 9]*4").s("square").octave(4).room(0.5).cutoff(1800).gain(0.4),
+  s("~ ~ ~ clap").slow(2).gain(0.6).room(0.3)
+).scale("g:minor")""",
+
+        """stack(
+  s("bd*4").sometimes(fast(2)).gain(0.9),
+  s("hh*8").degradeBy(0.2).gain(0.4),
+  n("[0 3 [5 0] 7]*2").s("sawtooth").octave(2).lpf(sine.range(600,2400).slow(4)).gain(0.8),
+  n("0 7 4 2").s("triangle").octave(5).delay(0.125).room(0.6).gain(0.5)
+).scale("e:minor")"""
     ],
     
     "house": [
         """stack(
-  s("bd ~ ~ ~ bd ~ ~ ~").gain(0.7),
+  s("bd ~ ~ ~ bd ~ ~ ~").gain(0.8),
   s("~ hh ~ hh").gain(0.5),
-  n("0 2 4 7").s("sine").octave(3).room(0.6).gain(0.6)
+  n("0 2 4 7").s("sine").octave(3).room(0.6).gain(0.7),
+  s("~ ~ ~ clap").gain(0.6)
 ).scale("c:major")""",
 
         """stack(
-  s("bd ~ [~ bd] ~").gain(0.8),
-  s("[~ ch ~ hh]*2").gain(0.4),
-  n("[0 4 7]*2").s("sawtooth").octave(2).lpf(1500).gain(0.7),
-  n("0 7 4 2").s("triangle").octave(4).delay(0.125).gain(0.4)
+  s("bd ~ [~ bd] ~").sometimes(fast(2)).gain(0.8),
+  s("[~ ch ~ hh]*2").pan(sine.slow(4)).gain(0.4),
+  n("[0 4 7]*2").s("sawtooth").octave(2).lpf(1500).gain(0.8),
+  n("0 7 4 2").s("triangle").octave(4).delay(0.125).room(0.5).gain(0.5)
 ).scale("f:major")""",
 
         """stack(
-  s("bd ~ ~ ~ bd ~ ~ ~").sometimes(fast(2)).gain(0.7),
-  n("[0 2] [4 7] [2 4] [7 0]").s("sine").octave(2).gain(0.6),
-  s("hh*8").degradeBy(0.3).gain(0.3)
-).scale("g:major")"""
+  s("bd ~ ~ ~ bd ~ ~ ~").gain(0.8),
+  n("[0 2] [4 7] [2 4] [7 0]").s("sine").octave(2).lpf(2000).gain(0.7),
+  s("hh*8").degradeBy(0.3).pan(cosine.slow(6)).gain(0.4),
+  s("~ ~ clap ~").room(0.4).gain(0.6)
+).scale("g:major")""",
+
+        """stack(
+  s("bd ~ [bd ~] [~ bd] ~").gain(0.8),
+  s("~ hh ~ [hh ch]").gain(0.5),
+  n("0 4 7 9").s("sawtooth").octave(2).sometimes(add(note(12))).lpf(1800).gain(0.7),
+  n("[2 4]*4").s("triangle").octave(4).delay(0.25).gain(0.4)
+).scale("d:major")"""
     ],
     
     "ambient": [
         """stack(
-  s("~ ~ ~ rim").slow(2).gain(0.3).room(0.8),
-  n("[0 2 4]/3").s("sine").octave(3).slow(4).room(0.9).gain(0.5),
-  n("[7 9 11]/5").s("triangle").octave(4).slow(8).delay(0.375).gain(0.3)
+  s("~ ~ ~ rim").slow(4).gain(0.3).room(0.9),
+  n("[0 2 4]/3").s("sine").octave(3).slow(8).room(0.9).lpf(800).gain(0.6),
+  n("[7 9 11]/5").s("triangle").octave(4).slow(12).delay(0.5).room(0.8).gain(0.4),
+  n("[0 4]/7").s("sawtooth").octave(2).slow(16).lpf(400).gain(0.3)
 ).scale("d:minor")""",
 
         """stack(
-  n("0 2 4 7").s("sine").octave(2).slow(8).room(0.9).gain(0.4),
-  n("[4 7 9]/7").s("triangle").octave(4).slow(12).delay(0.5).gain(0.3),
-  s("~ ~ rim ~").slow(4).gain(0.2).room(0.9)
+  n("0 2 4 7").s("sine").octave(2).slow(16).room(0.9).lpf(600).gain(0.5),
+  n("[4 7 9]/7").s("triangle").octave(4).slow(12).delay(0.75).room(0.9).gain(0.4),
+  s("~ ~ rim ~").slow(8).gain(0.2).room(0.9),
+  n("[11 14]/11").s("sine").octave(5).slow(20).gain(0.3)
 ).scale("a:minor")""",
 
-        """n("[0 4 7 11]/4").s("sine").octave(3).slow(8).room(0.9).lpf(800).gain(0.6).scale("e:minor")"""
+        """n("[0 4 7 11]/4").s("sine").octave(3).slow(12).room(0.9).lpf(perlin.range(400,1200).slow(8)).gain(0.7).scale("e:minor")""",
+
+        """stack(
+  n("[0 2]/5").s("sine").octave(2).slow(16).room(0.9).gain(0.4),
+  n("[4 7]/7").s("triangle").octave(4).slow(20).delay(1).room(0.9).gain(0.3),
+  s("~ ~ ~ [rim vinyl]").slow(8).gain(0.2).room(0.9)
+).scale("f:major")"""
     ],
     
     "breakbeat": [
         """stack(
-  s("[bd sn]*2").sometimes(rev).gain(0.8),
-  s("[hh ch]*4").degradeBy(0.2).gain(0.5),
-  n("0 4 7 0").s("square").octave(2).cutoff(1000).gain(0.7)
+  s("[bd sn]*2").sometimes(rev).speed(0.9).gain(0.9),
+  s("[hh ch]*4").degradeBy(0.3).gain(0.6),
+  n("0 4 7 0").s("square").octave(2).cutoff(1000).gain(0.8),
+  s("~ [perc:0 perc:1] ~").gain(0.4)
 ).scale("a:minor")""",
 
         """stack(
-  s("bd [sn sn] bd sn").speed(0.9).gain(0.8),
-  n("[0 ~ 7] [3 5]").s("sawtooth").octave(2).lpf(1500).gain(0.6),
-  s("hh*8").sometimes(fast(2)).gain(0.4)
-).scale("d:minor")"""
+  s("bd [sn sn] bd sn").speed(0.85).gain(0.9),
+  n("[0 ~ 7] [3 5]").s("sawtooth").octave(2).lpf(1500).gain(0.7),
+  s("hh*8").sometimes(fast(2)).degradeBy(0.2).gain(0.5),
+  s("~ ~ [perc:2 perc:3] ~").gain(0.5)
+).scale("d:minor")""",
+
+        """stack(
+  s("[bd ~ sn ~]*2").sometimes(rev).gain(0.9),
+  s("[hh ch oh]*3").degradeBy(0.4).pan(perlin.slow(2)).gain(0.5),
+  n("[0 7 4 2]*2").s("square").octave(2).cutoff(rand.range(600,1800)).gain(0.7)
+).scale("g:minor")"""
     ],
     
     "experimental": [
         """stack(
-  s("[bd rim]*3").degradeBy(0.4).gain(0.7),
-  n("[0 3 7]/5").s("square").octave(2).cutoff(perlin.range(400,2000)).gain(0.6),
-  s("~ [hh hh] ~").pan(sine.slow(3)).gain(0.4)
+  s("[bd rim]*3").degradeBy(0.5).speed(perlin.range(0.8,1.2)).gain(0.8),
+  n("[0 3 7]/5").s("square").octave(2).cutoff(perlin.range(400,2000)).gain(0.7),
+  s("~ [hh hh] ~").pan(sine.slow(3)).degradeBy(0.6).gain(0.5),
+  s("[noise:0]/16").gain(0.2).hpf(2000)
 ).scale("g:minor")""",
 
         """stack(
-  s("bd ~ [perc:0 perc:1]").speed(rand.range(0.8,1.2)).gain(0.7),
-  n("0 [2 5] 7").s("sawtooth").octave(2).sometimes(add(note(12))).gain(0.6),
-  s("[ch oh]*5").degradeBy(0.5).gain(0.3)
-).scale("f#:minor")"""
+  s("bd ~ [perc:0 perc:1]").speed(rand.range(0.7,1.3)).gain(0.8),
+  n("0 [2 5] 7").s("sawtooth").octave(2).sometimes(add(note(12))).cutoff(sine.range(300,1500)).gain(0.7),
+  s("[ch oh]*5").degradeBy(0.7).pan(cosine.slow(2)).gain(0.4),
+  n("[9 11]/9").s("triangle").octave(5).delay(0.75).gain(0.3)
+).scale("f#:minor")""",
+
+        """stack(
+  s("[bd ~ rim]*2").rev().degradeBy(0.4).gain(0.8),
+  n("[0 4 7]/7").s("square").octave(2).cutoff(perlin.range(200,2000)).sometimes(fast(4)).gain(0.6),
+  s("~ [vinyl:0 vinyl:1]/8").gain(0.3).hpf(1500)
+).scale("bb:minor")"""
+    ],
+
+    "hiphop": [
+        """stack(
+  s("bd ~ sn ~").gain(0.9),
+  s("hh ~ hh hh ~ hh ~ hh").gain(0.5),
+  n("0 0 3 5").s("sawtooth").octave(2).lpf(1000).gain(0.8),
+  s("~ ~ ~ [clap clap]").slow(2).gain(0.6)
+).scale("c:minor")""",
+
+        """stack(
+  s("bd ~ [bd sn] ~").gain(0.9),
+  s("[hh ch]*4").degradeBy(0.1).gain(0.5),
+  n("[0 3 5]*2").s("square").octave(2).lpf(800).gain(0.8),
+  s("~ ~ clap ~").room(0.3).gain(0.7),
+  s("~ [perc:0]/4 ~ [perc:1]/4").gain(0.4)
+).scale("a:minor")""",
+
+        """stack(
+  s("bd ~ sn [~ bd]").sometimes(fast(2)).gain(0.9),
+  s("hh*8").degradeBy(0.2).gain(0.4),
+  n("0 ~ 3 ~").s("sawtooth").octave(2).lpf(1200).sometimes(add(note(7))).gain(0.8),
+  s("~ ~ [clap rim] ~").gain(0.6).room(0.4)
+).scale("d:minor")""",
+
+        """stack(
+  s("[bd bd] ~ sn ~").gain(0.9),
+  s("~ hh ~ [hh ch hh]").gain(0.5),
+  n("[0 3] [5 0] [7 3] [5 0]").s("sine").octave(2).lpf(1500).gain(0.7),
+  s("~ ~ clap ~").delay(0.125).gain(0.7)
+).scale("g:minor")"""
     ]
 }
 
@@ -124,11 +197,12 @@ def get_random_working_pattern(genre, complexity="moderate"):
     if complexity == "simple":
         # Return simpler single-line patterns
         simple_patterns = {
-            "techno": 's("bd*4").gain(0.8)',
-            "house": 's("bd ~ ~ ~ bd ~ ~ ~").gain(0.7)', 
-            "ambient": 'n("[0 2 4]/3").s("sine").octave(3).slow(4).room(0.9).gain(0.5).scale("d:minor")',
-            "breakbeat": 's("[bd sn]*2").gain(0.8)',
-            "experimental": 's("bd ~ [perc:0 perc:1]").degradeBy(0.4).gain(0.7)'
+            "techno": 's("bd*4, hh*8").gain(0.8)',
+            "house": 's("bd ~ ~ ~ bd ~ ~ ~, ~ hh ~ hh").gain(0.7)', 
+            "ambient": 'n("[0 2 4]/3").s("sine").octave(3).slow(8).room(0.9).gain(0.6).scale("d:minor")',
+            "breakbeat": 's("[bd sn]*2, hh*8").speed(0.9).gain(0.8)',
+            "experimental": 's("bd ~ [perc:0 perc:1]").degradeBy(0.4).speed(rand.range(0.8,1.2)).gain(0.7)',
+            "hiphop": 's("bd ~ sn ~, hh ~ hh hh ~ hh ~ hh").gain(0.8)'
         }
         return simple_patterns.get(genre, simple_patterns["techno"])
     
@@ -151,7 +225,7 @@ def create_variations(base_pattern, genre):
         variations.append(base_pattern.replace(".gain(0.8)", ".gain(0.8).room(0.4)"))
     
     # Scale variations
-    scales = ["a:minor", "d:minor", "g:minor", "c:major", "f:major", "e:minor"]
+    scales = ["a:minor", "d:minor", "g:minor", "c:major", "f:major", "e:minor", "bb:minor", "f#:minor"]
     for scale in scales:
         if scale not in base_pattern:
             new_pattern = base_pattern
@@ -172,29 +246,33 @@ def generate_working_strudel_code(prompt, genre="techno", complexity="moderate")
     base_pattern = get_random_working_pattern(genre, complexity)
     
     # Create variations based on prompt keywords
-    if any(word in prompt.lower() for word in ["fast", "speed", "quick", "rapid"]):
+    if any(word in prompt.lower() for word in ["fast", "speed", "quick", "rapid", "energetic"]):
         if "sometimes(fast(2))" not in base_pattern:
             base_pattern = base_pattern.replace(".gain(", ".sometimes(fast(2)).gain(")
     
-    if any(word in prompt.lower() for word in ["slow", "chill", "ambient", "relaxed"]):
+    if any(word in prompt.lower() for word in ["slow", "chill", "ambient", "relaxed", "calm"]):
         if ".slow(" not in base_pattern:
             base_pattern = base_pattern.replace(".gain(", ".slow(2).gain(")
     
-    if any(word in prompt.lower() for word in ["reverb", "space", "room", "hall"]):
+    if any(word in prompt.lower() for word in ["reverb", "space", "room", "hall", "spacious"]):
         if ".room(" not in base_pattern:
-            base_pattern = base_pattern.replace(".gain(", ".room(0.6).gain(")
+            base_pattern = base_pattern.replace(".gain(", ".room(0.7).gain(")
     
-    if any(word in prompt.lower() for word in ["delay", "echo", "repeat"]):
+    if any(word in prompt.lower() for word in ["delay", "echo", "repeat", "dub"]):
         if ".delay(" not in base_pattern:
             base_pattern = base_pattern.replace(".gain(", ".delay(0.25).gain(")
     
-    if any(word in prompt.lower() for word in ["filter", "sweep", "cutoff", "lpf"]):
+    if any(word in prompt.lower() for word in ["filter", "sweep", "cutoff", "lpf", "filtered"]):
         if ".lpf(" not in base_pattern and ".cutoff(" not in base_pattern:
-            base_pattern = base_pattern.replace(".gain(", ".lpf(1200).gain(")
+            base_pattern = base_pattern.replace(".gain(", ".lpf(sine.range(400,1600).slow(8)).gain(")
     
-    if any(word in prompt.lower() for word in ["glitch", "degraded", "broken", "corrupt"]):
+    if any(word in prompt.lower() for word in ["glitch", "degraded", "broken", "corrupt", "dirty"]):
         if ".degradeBy(" not in base_pattern:
-            base_pattern = base_pattern.replace(".gain(", ".degradeBy(0.3).gain(")
+            base_pattern = base_pattern.replace(".gain(", ".degradeBy(0.4).gain(")
+    
+    if any(word in prompt.lower() for word in ["pan", "stereo", "wide", "spatial"]):
+        if ".pan(" not in base_pattern:
+            base_pattern = base_pattern.replace(".gain(", ".pan(sine.slow(4)).gain(")
     
     # Add comment based on prompt
     comment_line = f"// {prompt[:50]}{'...' if len(prompt) > 50 else ''}"
@@ -256,21 +334,22 @@ def generate_interface(prompt, genre, complexity, include_visuals, visual_style,
         return "Please enter a description of the music you want to create."
     
     if use_ai:
-        # Use AI generation
+        # Use AI generation with better examples
         system_prompt = f"""Generate working Strudel live coding pattern for: {prompt}
 Genre: {genre}, Complexity: {complexity}
 
-Example patterns:
-s("bd*4").gain(0.8)
-stack(s("bd ~ ~ ~"), n("0 2 4").s("sine").octave(3))
+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")
 
-Pattern:"""
+Generate a {complexity} {genre} pattern:"""
         
         try:
             outputs = code_generator(
                 system_prompt,
-                max_length=len(system_prompt.split()) + 50,
-                temperature=0.7,
+                max_length=len(system_prompt.split()) + 80,
+                temperature=0.8,
                 do_sample=True,
                 top_p=0.9,
                 num_return_sequences=1
@@ -279,26 +358,32 @@ Pattern:"""
             generated_text = outputs[0]['generated_text']
             strudel_code = generated_text[len(system_prompt):].strip()
             
-            # Clean the AI output
+            # Clean the AI output more thoroughly
             lines = strudel_code.split('\n')
             clean_lines = []
-            for line in lines[:5]:  # Limit to 5 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 line.endswith(')')):
+                           '.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 random if AI fails
+                # Fallback to curated patterns if AI fails
                 strudel_code = generate_working_strudel_code(prompt, genre, complexity)
-        except:
-            # Fallback to random if AI fails
+        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 random generation
+        # Use curated pattern generation
         strudel_code = generate_working_strudel_code(prompt, genre, complexity)
     
     # Create complete working template
@@ -311,12 +396,13 @@ with gr.Blocks(title="Working Strudel Generator", theme=gr.themes.Soft()) as app
     gr.Markdown("""
     # 🎵 CODEL: Strudel Code Generator
     
-    Generate Strudel live coding patterns! 
+    Generate high-quality Strudel live coding patterns! 
     
-    ✅ **All patterns tested and functional**  
+    ✅ **Premium curated patterns** - professional quality sounds  
     🎛️ **Real Strudel syntax** - copy & paste ready  
-    🎨 **Working Hydra visuals** included  
-    🎵 **Genre-specific patterns** that actually sound good  
+    🎨 **Reactive Hydra visuals** included  
+    🎵 **6 genres** with authentic patterns  
+    🤖 **Optional AI generation** for creative variations
     
     **Usage:** Describe music → Generate → Copy to [strudel.cc](https://strudel.cc) → Play!
     """)
@@ -331,7 +417,7 @@ with gr.Blocks(title="Working Strudel Generator", theme=gr.themes.Soft()) as app
             
             with gr.Row():
                 genre_dropdown = gr.Dropdown(
-                    choices=["techno", "house", "ambient", "breakbeat", "experimental"],
+                    choices=["techno", "house", "ambient", "breakbeat", "experimental", "hiphop"],
                     value="techno",
                     label="🎵 Genre"
                 )
@@ -359,11 +445,11 @@ with gr.Blocks(title="Working Strudel Generator", theme=gr.themes.Soft()) as app
                 label="👁️ Visual Style"
             )
             
-            generate_btn = gr.Button("🎵 Generate Working Code", variant="primary", size="lg")
+            generate_btn = gr.Button("🎵 Generate Premium Code", variant="primary", size="lg")
         
         with gr.Column():
             output_code = gr.Code(
-                label="✅ Working Strudel Code (Ready to Copy)",
+                label="✅ Premium Strudel Code (Ready to Copy)",
                 language="javascript",
                 lines=18
             )
@@ -374,26 +460,26 @@ with gr.Blocks(title="Working Strudel Generator", theme=gr.themes.Soft()) as app
             2. **Go to** [strudel.cc](https://strudel.cc)
             3. **Paste** and **click the play button** ▶️
             
-            **🔧 Customization:**
-            - Change `.gain()` values (0.1 to 1.0)
-            - Try different scales: "a:minor", "c:major", etc.
-            - Adjust `.lpf()` for filter sweeps
-            - Add `.room()` for reverb
+            **🔧 Pro Tips:**
+            - Change `.gain()` values (0.1 to 1.0) to balance levels
+            - Try different scales: "a:minor", "c:major", "d:minor"
+            - Use `.sometimes()` for variation: `.sometimes(fast(2))`
+            - Add effects: `.room()`, `.delay()`, `.lpf()`, `.degradeBy()`
             """)
     
-    # Working examples
-    gr.Markdown("### 🎪 Tested Examples (Guaranteed to Work)")
+    # Enhanced examples
+    gr.Markdown("### 🎪 Premium Examples (Pro Quality)")
     with gr.Row():
         working_examples = [
-            ["Fast techno with kick and hats", "techno", "moderate"],
-            ["Chill ambient soundscape", "ambient", "simple"],
-            ["Driving house beat", "house", "moderate"],
-            ["Glitchy breakbeat", "breakbeat", "complex"],
-            ["Experimental textures", "experimental", "complex"],
+            ["Driving techno with filter sweeps", "techno", "complex"],
+            ["Deep house with swing", "house", "moderate"],
+            ["Ethereal ambient soundscape", "ambient", "complex"],
+            ["Crunchy hip-hop beat", "hiphop", "moderate"],
+            ["Glitchy experimental textures", "experimental", "complex"],
         ]
         
         for example_text, example_genre, example_complexity in working_examples:
-            btn = gr.Button(f"✅ {example_text}", size="sm")
+            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]