Update app.py

app.py

@@ -1,18 +1,31 @@
 import gradio as gr
 import requests
 import json
-from transformers import AutoTokenizer, AutoModelForCausalLM
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
 import torch
 
-# Initialize StarCoder model and tokenizer
-MODEL_NAME = "bigcode/starcoder"
-tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-model = AutoModelForCausalLM.from_pretrained(
-    MODEL_NAME,
-    torch_dtype=torch.float16,
-    device_map="auto",
-    trust_remote_code=True
-)
+# Use CodeGen instead of StarCoder (no authentication needed)
+MODEL_NAME = "Salesforce/codegen-350M-mono"
+
+# Initialize model with pipeline for easier usage
+try:
+    code_generator = pipeline(
+        "text-generation",
+        model=MODEL_NAME,
+        tokenizer=MODEL_NAME,
+        torch_dtype=torch.float16,
+        device_map="auto" if torch.cuda.is_available() else None,
+        trust_remote_code=True
+    )
+except Exception as e:
+    print(f"Error loading model: {e}")
+    # Fallback to CPU if GPU fails
+    code_generator = pipeline(
+        "text-generation",
+        model=MODEL_NAME,
+        tokenizer=MODEL_NAME,
+        device_map=None
+    )
 
 # Strudel code examples for few-shot prompting
 STRUDEL_EXAMPLES = """
@@ -33,40 +46,35 @@ stack(
 n("[0 2 4]/3").s("sine").octave(3).slow(4).room(0.9).gain(0.5)
 """
 
-def generate_strudel_code(prompt, genre="general", complexity="simple", max_length=200, temperature=0.7):
-    """Generate Strudel code using StarCoder"""
+def generate_strudel_code(prompt, genre="general", complexity="simple", max_length=150, temperature=0.7):
+    """Generate Strudel code using CodeGen"""
     
     # Build context-aware prompt
-    system_prompt = f"""// Strudel is a live coding language for music
-// Generate {complexity} {genre} music code using Strudel syntax
+    system_prompt = f"""// Strudel live coding language for music
+// Generate {complexity} {genre} music patterns
 // Examples:
 {STRUDEL_EXAMPLES}
 
-// User request: {prompt}
-// Generated Strudel code:
+// Create: {prompt}
+// Code:
 """
     
     try:
-        # Tokenize input
-        inputs = tokenizer.encode(system_prompt, return_tensors="pt")
+        # Generate code using pipeline
+        outputs = code_generator(
+            system_prompt,
+            max_length=len(system_prompt.split()) + max_length,
+            temperature=temperature,
+            do_sample=True,
+            top_p=0.9,
+            num_return_sequences=1,
+            pad_token_id=code_generator.tokenizer.eos_token_id
+        )
         
-        # Generate code
-        with torch.no_grad():
-            outputs = model.generate(
-                inputs,
-                max_length=len(inputs[0]) + max_length,
-                temperature=temperature,
-                do_sample=True,
-                top_p=0.95,
-                pad_token_id=tokenizer.eos_token_id,
-                stop_strings=["//", "\n\n"],
-                num_return_sequences=1
-            )
-        
-        # Decode output
-        generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        # Extract generated text
+        generated_text = outputs[0]['generated_text']
         
-        # Extract only the generated part
+        # Extract only the new generated part
         strudel_code = generated_text[len(system_prompt):].strip()
         
         # Clean up the code
@@ -75,7 +83,7 @@ def generate_strudel_code(prompt, genre="general", complexity="simple", max_leng
         return strudel_code
         
     except Exception as e:
-        return f"Error generating code: {str(e)}"
+        return f"// Error generating code: {str(e)}\n// Fallback pattern:\ns(\"bd hh sn hh\").gain(0.8)"
 
 def clean_strudel_code(code):
     """Clean and format generated Strudel code"""
@@ -84,33 +92,56 @@ def clean_strudel_code(code):
     
     for line in lines:
         line = line.strip()
-        # Stop at common completion indicators
-        if line.startswith('//') and any(word in line.lower() for word in ['user', 'request', 'example']):
+        # 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
-        if line and not line.startswith('//'):
+        # 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):
             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']):
+            break
+            
+        if len(cleaned_lines) >= 8:  # Limit output length
+            break
     
-    return '\n'.join(cleaned_lines[:10])  # Limit to 10 lines
+    # If no valid code was generated, provide a fallback
+    if not cleaned_lines:
+        return generate_fallback_pattern(genre)
+    
+    return '\n'.join(cleaned_lines)
+
+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)'
+    }
+    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
+    visual_code = """// Hydra visuals
 await initHydra({feedStrudel:5})
 
 osc(10, 0.1, 0.8)
 .kaleid(4)
 .color(1.5, 0.8, 1.2)
 .out()
+
 """ if include_visuals else ""
     
-    template = f"""{visual_code}
-// Generated Strudel Music Code
+    template = f"""{visual_code}// AI-Generated Strudel Music Code
 {generated_code}
 
-// Global effects
-all(x => x.fft(5).scope())
+// Global effects (optional)
+// all(x => x.fft(5).scope())
 """
     
     return template
@@ -137,17 +168,19 @@ def generate_interface(prompt, genre, complexity, include_visuals, max_length, t
     return full_code
 
 # Create Gradio app
-with gr.Blocks(title="Strudel Code Generator", theme=gr.themes.Monochrome()) as app:
+with gr.Blocks(title="Strudel Code Generator", theme=gr.themes.Soft()) as app:
     gr.Markdown("""
-    # 🎵 Strudel Code Generator
+    # 🎵 AI Strudel Code Generator
     
-    Generate live coding music patterns using AI! Powered by StarCoder.
+    Generate live coding music patterns using AI! Powered by CodeGen-350M.
     
     **How to use:**
-    1. Describe the music you want (e.g., "techno beat with bass", "ambient soundscape", "jazz drums")
+    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!
+    
+    *Note: AI-generated code may need tweaking for best results.*
     """)
     
     with gr.Row():
@@ -161,7 +194,7 @@ with gr.Blocks(title="Strudel Code Generator", theme=gr.themes.Monochrome()) as
             with gr.Row():
                 genre_dropdown = gr.Dropdown(
                     choices=["general", "techno", "house", "ambient", "jazz", "rock", "experimental"],
-                    value="general",
+                    value="techno",
                     label="Genre"
                 )
                 
@@ -179,49 +212,51 @@ with gr.Blocks(title="Strudel Code Generator", theme=gr.themes.Monochrome()) as
             with gr.Accordion("Advanced Settings", open=False):
                 max_length_slider = gr.Slider(
                     minimum=50,
-                    maximum=500,
-                    value=200,
-                    step=50,
+                    maximum=300,
+                    value=150,
+                    step=25,
                     label="Max code length"
                 )
                 
                 temperature_slider = gr.Slider(
-                    minimum=0.1,
+                    minimum=0.3,
                     maximum=1.0,
                     value=0.7,
                     step=0.1,
                     label="Creativity (temperature)"
                 )
             
-            generate_btn = gr.Button("🎵 Generate Strudel Code", variant="primary")
+            generate_btn = gr.Button("🎵 Generate Strudel Code", variant="primary", size="lg")
         
         with gr.Column():
             output_code = gr.Code(
                 label="Generated Strudel Code",
                 language="javascript",
-                lines=20
+                lines=15
             )
             
             gr.Markdown("""
             **Next steps:**
-            1. Copy the generated code
-            2. Go to [strudel.cc](https://strudel.cc)
-            3. Paste and run the code
-            4. Enjoy your AI-generated music! 🎶
+            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! 🎶
+            
+            *Tip: You can modify the generated code to customize the sound!*
             """)
     
     # Example buttons
-    gr.Markdown("### Quick Examples")
+    gr.Markdown("### 💡 Quick Examples")
     with gr.Row():
         examples = [
-            ["Create a minimal techno beat with kick and hi-hats", "techno", "simple"],
-            ["Ambient soundscape with reverb and slow patterns", "ambient", "moderate"],
-            ["Jazz-inspired drum pattern with syncopation", "jazz", "moderate"],
-            ["Experimental glitchy electronic music", "experimental", "complex"],
+            ["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"],
         ]
         
         for example_text, example_genre, example_complexity in examples:
-            btn = gr.Button(f"💡 {example_text[:30]}...")
+            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]
@@ -243,8 +278,4 @@ with gr.Blocks(title="Strudel Code Generator", theme=gr.themes.Monochrome()) as
 
 # Launch the app
 if __name__ == "__main__":
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True
-    )
+    app.launch()