adding audio componenet

demos/melodyflow_api.py

@@ -60,6 +60,31 @@ MAX_QUEUE_SIZE = 100
 MAX_CONCURRENT_BATCHES = 2  # Number of concurrent batch processors
 
 
+class FileCleaner:
+    """Simple file cleaner for temporary audio files"""
+    def __init__(self, file_lifetime: float = 3600):
+        self.file_lifetime = file_lifetime
+        self.files = []
+
+    def add(self, path: tp.Union[str, Path]):
+        self._cleanup()
+        self.files.append((time.time(), Path(path)))
+
+    def _cleanup(self):
+        now = time.time()
+        for time_added, path in list(self.files):
+            if now - time_added > self.file_lifetime:
+                if path.exists():
+                    path.unlink()
+                self.files.pop(0)
+            else:
+                break
+
+
+# Global file cleaner
+file_cleaner = FileCleaner()
+
+
 @dataclass
 class GenerationRequest:
     """Represents a single generation request"""
@@ -405,6 +430,97 @@ def predict_concurrent(model: str, text: str, solver: str = "euler",
         raise gr.Error(f"Generation failed: {str(e)}")
 
 
+def predict_concurrent_ui(model: str, text: str, solver: str = "euler", 
+                         steps: int = 50, target_flowstep: float = 0.0,
+                         regularize: bool = False, regularization_strength: float = 0.0,
+                         duration: float = 10.0, melody: tp.Optional[str] = None) -> str:
+    """
+    UI-optimized predict function that returns audio file path for Gradio Audio component
+    """
+    
+    # Adjust steps for melody editing
+    if melody is not None:
+        steps = steps // 2 if solver == "midpoint" else steps // 5
+    
+    # Submit request to batch processor
+    future = batch_processor.submit_request(
+        text=text,
+        melody=melody, 
+        solver=solver,
+        steps=steps,
+        target_flowstep=target_flowstep,
+        regularize=regularize,
+        regularization_strength=regularization_strength,
+        duration=duration,
+        model=model
+    )
+    
+    # Wait for result with timeout
+    try:
+        result = future.result(timeout=120)  # 2 minute timeout
+        
+        # Convert base64 result to audio file for UI
+        if isinstance(result, dict) and "audio" in result:
+            print(f"✅ Received audio result, converting to file...")
+            
+            # Decode base64 and save to temporary file
+            import base64
+            from tempfile import NamedTemporaryFile
+            
+            audio_data = base64.b64decode(result["audio"])
+            with NamedTemporaryFile(mode="wb", suffix=".wav", delete=False) as temp_file:
+                temp_file.write(audio_data)
+                temp_file_path = temp_file.name
+            
+            file_cleaner.add(temp_file_path)  # Add to cleanup queue
+            print(f"🎵 Audio saved to: {temp_file_path}")
+            return temp_file_path
+        else:
+            raise gr.Error("No audio data received")
+            
+    except TimeoutError:
+        print("⏰ Request timeout")
+        raise gr.Error("Request timeout - server is overloaded")
+    except Exception as e:
+        print(f"💥 Exception: {str(e)}")
+        raise gr.Error(f"Generation failed: {str(e)}")
+
+
+def predict_concurrent(model: str, text: str, solver: str = "euler", 
+                      steps: int = 50, target_flowstep: float = 0.0,
+                      regularize: bool = False, regularization_strength: float = 0.0,
+                      duration: float = 10.0, melody: tp.Optional[str] = None) -> dict:
+    """
+    API predict function that returns base64 audio data (for API endpoints)
+    """
+    
+    # Adjust steps for melody editing
+    if melody is not None:
+        steps = steps // 2 if solver == "midpoint" else steps // 5
+    
+    # Submit request to batch processor
+    future = batch_processor.submit_request(
+        text=text,
+        melody=melody, 
+        solver=solver,
+        steps=steps,
+        target_flowstep=target_flowstep,
+        regularize=regularize,
+        regularization_strength=regularization_strength,
+        duration=duration,
+        model=model
+    )
+    
+    # Wait for result with timeout
+    try:
+        result = future.result(timeout=120)  # 2 minute timeout
+        return result
+    except TimeoutError:
+        raise gr.Error("Request timeout - server is overloaded")
+    except Exception as e:
+        raise gr.Error(f"Generation failed: {str(e)}")
+
+
 def create_optimized_interface():
     """Create Gradio interface optimized for concurrent usage"""
     
@@ -436,10 +552,10 @@ def create_optimized_interface():
                 generate_btn = gr.Button("Generate", variant="primary")
                 
             with gr.Column():
-                output = gr.JSON(label="Generated Audio")
+                output = gr.Audio(label="Generated Audio")
         
         generate_btn.click(
-            fn=predict_concurrent,
+            fn=predict_concurrent_ui,
             inputs=[model, text, solver, steps, gr.State(0.0), 
                    gr.State(False), gr.State(0.0), duration, melody],
             outputs=output,
@@ -447,7 +563,7 @@ def create_optimized_interface():
         )
         
         gr.Examples(
-            fn=predict_concurrent,
+            fn=predict_concurrent_ui,
             examples=[
                 [f"{MODEL_PREFIX}melodyflow-t24-30secs", 
                  "80s electronic track with melodic synthesizers",