Update app.py

app.py

@@ -1,17 +1,20 @@
 import random
+import argparse
+import os
+import glob
+import rtmidi
 import gradio as gr
 import numpy as np
-import rtmidi
 import MIDI
 import base64
 import io
-import os
+import soundfile as sf  # Placeholder for audio rendering
 from huggingface_hub import hf_hub_download
 from midi_synthesizer import MidiSynthesizer
 
 MAX_SEED = np.iinfo(np.int32).max
+in_space = os.getenv("SYSTEM") == "spaces"
 
-# Example song data (simplified from original)
 SONG_DATA = {
     "title": "Do You Believe in Love",
     "progression": ["G", "D", "Em", "C"],
@@ -22,42 +25,95 @@ class MIDIDeviceManager:
     def __init__(self):
         self.midiout = rtmidi.MidiOut()
         self.midiin = rtmidi.MidiIn()
-        
-    def get_available_devices(self):
-        return self.midiout.get_ports() or ["No MIDI devices"]
+
+    def get_output_devices(self):
+        return self.midiout.get_ports() or ["No MIDI output devices"]
+
+    def get_input_devices(self):
+        return self.midiin.get_ports() or ["No MIDI input devices"]
 
     def get_device_info(self):
-        devices = self.get_available_devices()
-        return "\n".join([f"Port {i}: {name}" for i, name in enumerate(devices)]) if devices else "No MIDI devices detected"
+        out_devices = self.get_output_devices()
+        in_devices = self.get_input_devices()
+        out_info = "\n".join([f"Out Port {i}: {name}" for i, name in enumerate(out_devices)]) if out_devices else "No MIDI output devices detected"
+        in_info = "\n".join([f"In Port {i}: {name}" for i, name in enumerate(in_devices)]) if in_devices else "No MIDI input devices detected"
+        return f"Output Devices:\n{out_info}\n\nInput Devices:\n{in_info}"
+
+    def close(self):
+        if self.midiout.is_port_open():
+            self.midiout.close_port()
+        if self.midiin.is_port_open():
+            self.midiin.close_port()
+        del self.midiout
+        del self.midiin
 
 class MIDIManager:
     def __init__(self):
         self.soundfont_path = hf_hub_download(repo_id="skytnt/midi-model", filename="soundfont.sf2")
         self.synthesizer = MidiSynthesizer(self.soundfont_path)
         self.loaded_midi = {}  # midi_id: (file_path, midi_obj)
-        self.modified_files = []
+        self.modified_files = []  # Stores (midi_base64, audio_base64) tuples
         self.is_playing = False
+        self.instruments = self.random_instrument_set()
+        self.drum_beat = self.create_drum_beat()
+        self.starter_midi = self.create_starter_midi()
         self.example_files = self.load_example_midis()
+        self.loaded_midi["starter"] = ("Starter MIDI", self.starter_midi)
+        self.preload_default_midi()
+
+    def random_instrument_set(self):
+        instrument_pool = [0, 24, 32, 48]  # Piano, Guitar, Bass, Strings
+        return random.sample(instrument_pool, 4)
+
+    def create_drum_beat(self):
+        return [(36, 100, 0), (42, 80, 50), (38, 90, 100), (42, 80, 150)]  # Kick, hi-hat, snare, hi-hat
+
+    def create_starter_midi(self):
+        midi = MIDI.MIDIFile(5)  # 4 instruments + 1 drum track
+        for i, inst in enumerate(self.instruments):
+            midi.addTrack()
+            midi.addProgramChange(i, 0, 0, inst)
+            for t in range(0, 400, 100):
+                note = random.randint(60, 84)  # C4 to C6
+                midi.addNote(i, 0, note, t, 100, 100)
+        midi.addTrack()
+        for note, vel, time in self.drum_beat:
+            midi.addNote(4, 9, note, time, 100, vel)
+        return midi
+
+    def preload_default_midi(self):
+        default_path = "default.mid"
+        if os.path.exists(default_path):
+            midi_id = "default"
+            midi = MIDI.load(default_path)
+            self.loaded_midi[midi_id] = (default_path, midi)
+            midi_data, audio_data = self.generate_variation(midi_id)
+            self.play_with_loop(midi_data)
 
     def load_example_midis(self):
         examples = {}
-        example_dir = "examples"
-        if os.path.exists(example_dir):
-            for file in os.listdir(example_dir):
-                if file.endswith(".mid") or file.endswith(".midi"):
-                    midi_id = f"example_{len(examples)}"
-                    file_path = os.path.join(example_dir, file)
-                    examples[midi_id] = (file_path, MIDI.load(file_path))
-        if not examples:
-            midi = MIDI.MIDIFile(1)
-            midi.addTrack()
-            midi.addNote(0, 0, 60, 0, 100, 100)  # Default C4
-            examples["example_0"] = ("Simple C4.mid", midi)
+        for file_path in glob.glob("*.mid") + glob.glob("*.midi"):
+            if file_path == "default.mid":
+                continue
+            midi_id = f"example_{len(examples)}"
+            midi = MIDI.load(file_path)
+            new_midi = MIDI.MIDIFile(5)
+            notes, _ = self.extract_notes_and_instruments(midi)
+            for i, inst in enumerate(self.instruments):
+                new_midi.addTrack()
+                new_midi.addProgramChange(i, 0, 0, inst)
+                for note, vel, time in notes:
+                    new_midi.addNote(i, 0, note, time, 100, vel)
+            new_midi.addTrack()
+            for note, vel, time in self.drum_beat:
+                new_midi.addNote(4, 9, note, time, 100, vel)
+            examples[midi_id] = (file_path, new_midi)
+        self.loaded_midi.update(examples)
         return examples
 
     def load_midi(self, file_path):
         midi = MIDI.load(file_path)
-        midi_id = f"midi_{len(self.loaded_midi) - len(self.example_files)}"
+        midi_id = f"midi_{len(self.loaded_midi) - len(self.example_files) - 1}"
         self.loaded_midi[midi_id] = (file_path, midi)
         return midi_id
 
@@ -74,7 +130,7 @@ class MIDIManager:
 
     def generate_variation(self, midi_id, length_factor=2, variation=0.3):
         if midi_id not in self.loaded_midi:
-            return None
+            return None, None
         _, midi = self.loaded_midi[midi_id]
         notes, instruments = self.extract_notes_and_instruments(midi)
         new_notes = []
@@ -94,11 +150,22 @@ class MIDIManager:
             for note, vel, time in new_notes:
                 new_midi.addNote(i, 0, note, time, 100, vel)
         
-        output = io.BytesIO()
-        new_midi.writeFile(output)
-        midi_data = base64.b64encode(output.getvalue()).decode('utf-8')
-        self.modified_files.append(midi_data)
-        return midi_data
+        midi_output = io.BytesIO()
+        new_midi.writeFile(midi_output)
+        midi_data = base64.b64encode(midi_output.getvalue()).decode('utf-8')
+        
+        temp_midi = 'temp.mid'
+        with open(temp_midi, 'wb') as f:
+            f.write(midi_output.getvalue())
+        audio_output = io.BytesIO()
+        # Placeholder for audio rendering; needs fluidsynth or similar
+        self.synthesizer.play_midi(new_midi)
+        audio_data = None  # See Notes below
+        if os.path.exists(temp_midi):
+            os.remove(temp_midi)
+        
+        self.modified_files.append((midi_data, audio_data))
+        return midi_data, audio_data
 
     def apply_synth_effect(self, midi_data, effect, intensity):
         midi = MIDI.load(io.BytesIO(base64.b64decode(midi_data)))
@@ -107,11 +174,22 @@ class MIDIManager:
             for track in midi.tracks:
                 for event in track.events:
                     event.time = int(event.time * factor)
-        output = io.BytesIO()
-        midi.writeFile(output)
-        midi_data = base64.b64encode(output.getvalue()).decode('utf-8')
-        self.modified_files.append(midi_data)
-        return midi_data
+        
+        midi_output = io.BytesIO()
+        midi.writeFile(midi_output)
+        midi_data = base64.b64encode(midi_output.getvalue()).decode('utf-8')
+        
+        temp_midi = 'temp.mid'
+        with open(temp_midi, 'wb') as f:
+            f.write(midi_output.getvalue())
+        audio_output = io.BytesIO()
+        self.synthesizer.play_midi(midi)
+        audio_data = None  # Placeholder
+        if os.path.exists(temp_midi):
+            os.remove(temp_midi)
+        
+        self.modified_files.append((midi_data, audio_data))
+        return midi_data, audio_data
 
     def play_with_loop(self, midi_data):
         self.is_playing = True
@@ -124,101 +202,131 @@ class MIDIManager:
         self.is_playing = False
         return "Stopping..."
 
-midi_manager = MIDIDeviceManager()
-midi_processor = MIDIManager()
-
 def create_download_list():
     html = "<h3>Downloads</h3><ul>"
-    for i, data in enumerate(midi_processor.modified_files):
-        html += f'<li><a href="data:audio/midi;base64,{data}" download="midi_{i}.mid">MIDI {i}</a></li>'
+    for i, (midi_data, audio_data) in enumerate(midi_processor.modified_files):
+        html += f'<li><a href="data:audio/midi;base64,{midi_data}" download="midi_{i}.mid">MIDI {i}</a>'
+        if audio_data:
+            html += f' | <a href="data:audio/wav;base64,{audio_data}" download="audio_{i}.wav">Audio {i}</a>'
+        html += '</li>'
     html += "</ul>"
     return html
 
 def get_midi_choices():
     return [(os.path.basename(path), midi_id) for midi_id, (path, _) in midi_processor.loaded_midi.items()]
 
-with gr.Blocks(theme=gr.themes.Soft()) as app:
-    gr.Markdown("<h1>🎵 MIDI Composer 🎵</h1>")
-    
-    with gr.Tabs():
-        # Tab 1: Upload MIDI
-        with gr.Tab("Upload MIDI"):
-            midi_files = gr.File(label="Upload MIDI Files", file_count="multiple")
-            loaded_display = gr.HTML(value="No files loaded")
-            output = gr.Audio(label="Generated Preview", type="bytes", autoplay=True)
-            
-            def load_and_generate(files):
-                html = "<h3>Loaded Files</h3>"
-                midi_data = None
-                for file in files or []:
-                    midi_id = midi_processor.load_midi(file.name)
-                    html += f"<div>{file.name} <button onclick=\"remove_midi('{midi_id}')\">X</button></div>"
-                    midi_data = midi_processor.generate_variation(midi_id)  # Auto-generate
-                return html, (io.BytesIO(base64.b64decode(midi_data)) if midi_data else None), get_midi_choices()
-            
-            midi_files.change(load_and_generate, inputs=[midi_files], 
-                            outputs=[loaded_display, output, gr.State(get_midi_choices())])
-
-        # Tab 2: Generate & Perform
-        with gr.Tab("Generate & Perform"):
-            midi_select = gr.Dropdown(label="Select MIDI", choices=get_midi_choices(), value=None)
-            length_factor = gr.Slider(1, 5, value=2, step=1, label="Length Factor")
-            variation = gr.Slider(0, 1, value=0.3, label="Variation")
-            generate_btn = gr.Button("Generate")
-            effect = gr.Radio(["tempo"], label="Synth Effect", value="tempo")
-            intensity = gr.Slider(0, 1, value=0.5, label="Effect Intensity")
-            apply_btn = gr.Button("Apply Effect")
-            stop_btn = gr.Button("Stop Playback")
-            output = gr.Audio(label="Preview", type="bytes", autoplay=True)
-            status = gr.Textbox(label="Status", value="Ready")
-            midi_device = gr.Dropdown(label="MIDI Output Device", choices=midi_manager.get_available_devices(), type="index")
-            tempo = gr.Slider(label="Tempo (BPM)", minimum=40, maximum=200, value=120, step=1)
-
-            def update_dropdown(choices):
-                return gr.update(choices=choices)
-            
-            gr.State(get_midi_choices()).change(update_dropdown, inputs=[gr.State()], outputs=[midi_select])
-            
-            def generate(midi_id, length, var):
-                if not midi_id:
-                    return None, "Select a MIDI file"
-                midi_data = midi_processor.generate_variation(midi_id, length, var)
-                midi_processor.play_with_loop(midi_data)
-                return io.BytesIO(base64.b64decode(midi_data)), "Playing"
-            
-            def apply_effect(midi_data, fx, inten):
-                if not midi_data:
-                    return None, "Generate a MIDI first"
-                new_data = midi_processor.apply_synth_effect(midi_data.decode('utf-8'), fx, inten)
-                midi_processor.play_with_loop(new_data)
-                return io.BytesIO(base64.b64decode(new_data)), "Playing"
-            
-            generate_btn.click(generate, inputs=[midi_select, length_factor, variation], 
-                              outputs=[output, status])
-            apply_btn.click(apply_effect, inputs=[output, effect, intensity], 
-                           outputs=[output, status])
-            stop_btn.click(midi_processor.stop_playback, inputs=None, outputs=[status])
-
-        # Tab 3: Downloads
-        with gr.Tab("Downloads"):
-            downloads = gr.HTML(value="No files yet")
-            def update_downloads(*args):
-                return create_download_list()
-            gr.on(triggers=[midi_files.change, generate_btn.click, apply_btn.click], 
-                  fn=update_downloads, inputs=None, outputs=[downloads])
-
-    gr.Markdown("""
-    <div style='text-align: center; margin-top: 20px;'>
-        <img src='https://huggingface.co/front/assets/huggingface_logo-noborder.svg' alt='Hugging Face Logo' style='width: 50px;'><br>
-        <strong>Hugging Face</strong><br>
-        <a href='https://huggingface.co/models'>Models</a> | 
-        <a href='https://huggingface.co/datasets'>Datasets</a> | 
-        <a href='https://huggingface.co/spaces'>Spaces</a> | 
-        <a href='https://huggingface.co/posts'>Posts</a> | 
-        <a href='https://huggingface.co/docs'>Docs</a> | 
-        <a href='https://huggingface.co/enterprise'>Enterprise</a> | 
-        <a href='https://huggingface.co/pricing'>Pricing</a>
-    </div>
-    """)
-
-app.queue().launch(inbrowser=True)
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=7860)
+    parser.add_argument("--share", action="store_true")
+    parser.add_argument("--batch", type=int, default=1)
+    opt = parser.parse_args()
+
+    midi_manager = MIDIDeviceManager()
+    midi_processor = MIDIManager()
+
+    with gr.Blocks(theme=gr.themes.Soft()) as app:
+        gr.Markdown("<h1>🎵 MIDI Composer 🎵</h1>")
+        
+        with gr.Tabs():
+            # Tab 1: MIDI Prompt (Main Tab)
+            with gr.Tab("MIDI Prompt"):
+                midi_files = gr.File(label="Upload MIDI Files", file_count="multiple")
+                loaded_display = gr.HTML(value="No files loaded")
+                output = gr.Audio(label="Generated Preview", type="bytes", autoplay=True)
+                
+                def load_and_generate(files):
+                    html = "<h3>Loaded Files</h3>"
+                    midi_data = None
+                    for file in files or []:
+                        midi_id = midi_processor.load_midi(file.name)
+                        html += f"<div>{file.name} <button onclick=\"remove_midi('{midi_id}')\">X</button></div>"
+                        midi_data, _ = midi_processor.generate_variation(midi_id)
+                    return html, (io.BytesIO(base64.b64decode(midi_data)) if midi_data else None), get_midi_choices(), create_download_list()
+                
+                midi_files.change(load_and_generate, inputs=[midi_files], 
+                                outputs=[loaded_display, output, gr.State(get_midi_choices()), "downloads"])
+
+            # Tab 2: Examples
+            with gr.Tab("Examples"):
+                example_select = gr.Dropdown(label="Select Example", choices=get_midi_choices(), value=None)
+                example_output = gr.Audio(label="Example Preview", type="bytes", autoplay=True)
+                
+                def load_example(midi_id):
+                    if not midi_id:
+                        return None
+                    midi_data, audio_data = midi_processor.generate_variation(midi_id)
+                    midi_processor.play_with_loop(midi_data)
+                    return io.BytesIO(base64.b64decode(midi_data)), create_download_list()
+                
+                example_select.change(load_example, inputs=[example_select], 
+                                    outputs=[example_output, "downloads"])
+                gr.State(get_midi_choices()).change(lambda choices: gr.update(choices=choices), 
+                                                  inputs=[gr.State()], outputs=[example_select])
+
+            # Tab 3: Generate & Perform
+            with gr.Tab("Generate & Perform"):
+                midi_select = gr.Dropdown(label="Select MIDI", choices=get_midi_choices(), value="starter")
+                length_factor = gr.Slider(1, 5, value=2, step=1, label="Length Factor")
+                variation = gr.Slider(0, 1, value=0.3, label="Variation")
+                generate_btn = gr.Button("Generate")
+                effect = gr.Radio(["tempo"], label="Synth Effect", value="tempo")
+                intensity = gr.Slider(0, 1, value=0.5, label="Effect Intensity")
+                apply_btn = gr.Button("Apply Effect")
+                stop_btn = gr.Button("Stop Playback")
+                output = gr.Audio(label="Preview", type="bytes", autoplay=True)
+                status = gr.Textbox(label="Status", value="Ready")
+                midi_device = gr.Dropdown(label="MIDI Output Device", choices=midi_manager.get_output_devices(), type="index")
+                tempo = gr.Slider(label="Tempo (BPM)", minimum=40, maximum=200, value=120, step=1)
+                device_info = gr.Textbox(label="Connected MIDI Devices", value=midi_manager.get_device_info(), readonly=True)
+                refresh_btn = gr.Button("🔄 Refresh MIDI Devices")
+
+                def update_dropdown(choices):
+                    return gr.update(choices=choices)
+                
+                gr.State(get_midi_choices()).change(update_dropdown, inputs=[gr.State()], outputs=[midi_select])
+                
+                def generate(midi_id, length, var):
+                    if not midi_id:
+                        return None, "Select a MIDI file", create_download_list()
+                    midi_data, audio_data = midi_processor.generate_variation(midi_id, length, var)
+                    midi_processor.play_with_loop(midi_data)
+                    return io.BytesIO(base64.b64decode(midi_data)), "Playing", create_download_list()
+                
+                def apply_effect(midi_data, fx, inten):
+                    if not midi_data:
+                        return None, "Generate a MIDI first", create_download_list()
+                    new_midi_data, audio_data = midi_processor.apply_synth_effect(midi_data.decode('utf-8'), fx, inten)
+                    midi_processor.play_with_loop(new_midi_data)
+                    return io.BytesIO(base64.b64decode(new_midi_data)), "Playing", create_download_list()
+                
+                def refresh_devices():
+                    return midi_manager.get_output_devices(), midi_manager.get_device_info()
+                
+                generate_btn.click(generate, inputs=[midi_select, length_factor, variation], 
+                                outputs=[output, status, "downloads"])
+                apply_btn.click(apply_effect, inputs=[output, effect, intensity], 
+                                outputs=[output, status, "downloads"])
+                stop_btn.click(midi_processor.stop_playback, inputs=None, outputs=[status])
+                refresh_btn.click(refresh_devices, inputs=None, outputs=[midi_device, device_info])
+
+            # Tab 4: Downloads
+            with gr.Tab("Downloads", elem_id="downloads"):
+                downloads = gr.HTML(value=create_download_list())
+
+        gr.Markdown("""
+        <div style='text-align: center; margin-top: 20px;'>
+            <img src='https://huggingface.co/front/assets/huggingface_logo-noborder.svg' alt='Hugging Face Logo' style='width: 50px;'><br>
+            <strong>Hugging Face</strong><br>
+            <a href='https://huggingface.co/models'>Models</a> | 
+            <a href='https://huggingface.co/datasets'>Datasets</a> | 
+            <a href='https://huggingface.co/spaces'>Spaces</a> | 
+            <a href='https://huggingface.co/posts'>Posts</a> | 
+            <a href='https://huggingface.co/docs'>Docs</a> | 
+            <a href='https://huggingface.co/enterprise'>Enterprise</a> | 
+            <a href='https://huggingface.co/pricing'>Pricing</a>
+        </div>
+        """)
+
+    app.queue().launch(server_port=opt.port, share=opt.share, inbrowser=True)
+    midi_manager.close()