Update app.py

app.py

@@ -1,7 +1,175 @@
+"""
+NotaGen Gradio Inference App for HuggingFace Spaces
+
+This app provides a simple interface for generating symbolic music using NotaGen.
+It accepts three parameters (period, composer, instrumentation) and returns ABC notation.
+
+The ABC notation can then be processed by WeaveMuse locally for XML/PDF conversion.
+"""
+
 import gradio as gr
+import torch
+import logging
+import traceback
+from weavemuse.tools.notagen_tool import NotaGenTool
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize the NotaGen tool
+# This will use GPU if available in the HuggingFace Space
+device = "cuda" if torch.cuda.is_available() else "cpu"
+logger.info(f"Initializing NotaGen tool on device: {device}")
+
+try:
+    notagen_tool = NotaGenTool(device=device)
+    logger.info("✅ NotaGen tool initialized successfully!")
+except Exception as e:
+    logger.error(f"❌ Failed to initialize NotaGen tool: {e}")
+    logger.error(traceback.format_exc())
+    notagen_tool = None
+
+
+def generate_abc(period: str, composer: str, instrumentation: str) -> str:
+    """
+    Generate ABC notation using NotaGen.
+    
+    Args:
+        period: Musical period (e.g., Baroque, Classical, Romantic)
+        composer: Composer style (e.g., Bach, Mozart, Chopin)
+        instrumentation: Instruments (e.g., Piano, Violin, Orchestra)
+    
+    Returns:
+        ABC notation string or error message
+    """
+    if notagen_tool is None:
+        error_msg = "❌ NotaGen tool not initialized. Please check server logs."
+        logger.error(error_msg)
+        return error_msg
+    
+    try:
+        logger.info(f"Generating ABC for: {period}-{composer}-{instrumentation}")
+        
+        # Call the NotaGen tool's forward method
+        # This will return a formatted string with file paths
+        result = notagen_tool.forward(
+            period=period,
+            composer=composer,
+            instrumentation=instrumentation
+        )
+        
+        # Extract just the ABC content from the result
+        # The result contains file paths and other info, but we only need the ABC
+        if "Error:" in result:
+            logger.error(f"Generation error: {result}")
+            return result
+        
+        # Parse the result to extract ABC content
+        # The result format is: "Successfully generated...\n\nABC notation preview:\n```\n{abc}```"
+        if "ABC notation preview:" in result:
+            abc_start = result.find("```\n") + 4
+            abc_end = result.rfind("\n```")
+            if abc_start > 3 and abc_end > abc_start:
+                abc_content = result[abc_start:abc_end]
+                logger.info(f"✅ Successfully generated ABC notation ({len(abc_content)} chars)")
+                return abc_content
+        
+        # If we can't parse it, return the full result
+        logger.warning("Could not parse ABC from result, returning full result")
+        return result
+        
+    except Exception as e:
+        error_msg = f"❌ Error during generation: {str(e)}\n\n{traceback.format_exc()}"
+        logger.error(error_msg)
+        return error_msg
+
+
+# Create Gradio interface
+with gr.Blocks(title="NotaGen - Symbolic Music Generation") as demo:
+    gr.Markdown("""
+    # 🎵 NotaGen - Symbolic Music Generation
+    
+    Generate symbolic music in ABC notation format using NotaGen.
+    
+    This space returns only the **ABC notation** as text. For conversion to PDF, XML, or MIDI,
+    use the WeaveMuse package locally or through its API.
+    
+    ### Usage
+    1. Select a musical **period** (e.g., Baroque, Classical, Romantic)
+    2. Choose a **composer** style (e.g., Bach, Mozart, Chopin)
+    3. Specify **instrumentation** (Piano recommended for best results)
+    4. Click **Generate** to receive ABC notation
+    
+    The generated ABC can be processed by WeaveMuse for full music score rendering.
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            period_input = gr.Textbox(
+                label="Musical Period",
+                placeholder="e.g., Classical, Romantic, Baroque",
+                value="Classical"
+            )
+            composer_input = gr.Textbox(
+                label="Composer Style",
+                placeholder="e.g., Mozart, Chopin, Bach",
+                value="Mozart"
+            )
+            instrumentation_input = gr.Textbox(
+                label="Instrumentation",
+                placeholder="e.g., Piano, Violin, Orchestra",
+                value="Piano"
+            )
+            generate_btn = gr.Button("🎼 Generate ABC Notation", variant="primary")
+        
+        with gr.Column():
+            output_text = gr.Textbox(
+                label="Generated ABC Notation",
+                placeholder="ABC notation will appear here...",
+                lines=20,
+                max_lines=30
+            )
+    
+    gr.Examples(
+        examples=[
+            ["Classical", "Mozart", "Piano"],
+            ["Romantic", "Chopin", "Piano"],
+            ["Baroque", "Bach", "Piano"],
+            ["Classical", "Beethoven", "Piano"],
+            ["Romantic", "Liszt", "Piano"],
+        ],
+        inputs=[period_input, composer_input, instrumentation_input],
+        label="Example Prompts"
+    )
+    
+    # Connect the button to the function
+    generate_btn.click(
+        fn=generate_abc,
+        inputs=[period_input, composer_input, instrumentation_input],
+        outputs=output_text,
+        api_name="infer"  # Important: This creates the /infer endpoint
+    )
+    
+    gr.Markdown("""
+    ---
+    ### About
+    
+    **NotaGen** is a symbolic music generation model that creates music in ABC notation format.
+    
+    - **ABC Notation**: A text-based music notation format that can be converted to PDF, MIDI, XML, etc.
+    - **Model**: Uses the quantized NotaGen model for efficient inference
+    - **Integration**: Designed to work seamlessly with WeaveMuse for full music generation pipelines
+    
+    **Note**: This space only generates ABC notation. For complete score rendering (PDF, MP3, etc.),
+    use WeaveMuse locally or via its remote tools.
+    """)
 
-def greet(name):
-    return "Hello " + name + "!!"
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",  # Allow external access
+        server_port=7860,        # Default HF Spaces port
+        share=False              # No need to share, HF handles this
+    )