Update app.py

app.py

@@ -1,76 +1,120 @@
-import gradio
+import gradio as gr
 from transformers import pipeline
-            temperature=float(temperature),
-            topp=top_p,
-            rng_seed=seed
-        )    
-elif score is not None and chord_progression.strip() == "":        
-# Generate using the uploaded MIDI file as a prompt
-        generated_score = ml.predict(
-            score=score,  # Use the uploaded MIDI as the score prompt
-            nb_tokens=int(nb_tokens),
-            temperature=float(temperature),
-            topp=top_p,
-            rng_seed=seed
-        )    
-else:        
-# Generate with specific chord progression
-        generated_score = ml.predict_chords(
-            chord_progression,
-            score=score,  # Use the uploaded MIDI as the score prompt
-            time_signature=time_signature,
-            temperature=temperature,
-            topp=top_p,
-            rng_seed=seed
-        )
-    chord_repr = generated_score.to_chord_repr()
-    # Save the generated score as a MIDI file
-    temp_midi_file = tempfile.NamedTemporaryFile(suffix=".mid", delete=False)
-    midi_path = temp_midi_file.name
-    generated_score.to_midi(midi_path, tempo=tempo, time_signature=time_signature)
-    # Convert MIDI to WAV then WAV to MP3 for playback
-    temp_wav_file = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
-    temp_mp3_file = tempfile.NamedTemporaryFile(suffix=".mp3", delete=False)
-    wav_path = temp_wav_file.name
-    mp3_path = temp_mp3_file.name
-    FluidSynth("/usr/share/sounds/sf2/FluidR3_GM.sf2").midi_to_audio(midi_path, wav_path)
-    os.system(f'ffmpeg -i {wav_path} -acodec libmp3lame -y -loglevel quiet -stats {mp3_path}')
-    # Remove the temporary WAV file
-    os.remove(wav_path)
-    return mp3_path, midi_path, chord_repr, tempo_message
-def musiclang(midi_file, chord_progression, tempo, temperature, nb_tokens, bar_range):
-    exception = None
-    mp3_path, midi_path, chord_repr, tempo_message = None, None, None, ""    
-try:
-        mp3_path, midi_path, chord_repr, tempo_message = inner_loop(midi_file, chord_progression, tempo, temperature, nb_tokens, bar_range)    
-except Exception as e:
-        exception = "Error : " + e.__class__.__name__ + " " + str(e)    
-# Return the MP3 path for Gradio to display and the MIDI file path for download    
-return mp3_path, midi_path, exception
-
-with gr.Blocks() as demo:    
-# Introductory text
+import tempfile, os
+from midi2audio import FluidSynth
+
+# --- Music Generation Logic (API-like Function) ---
+
+def generate_music_api(midi_data=None, chord_progression=None, tempo=120, temperature=0.95, nb_tokens=512, bar_range="0-4"):
+    try:
+        # Load the MusicLang Predict model (replace with actual loading code)
+        ml = ...  # Example: ml = pipeline("music-generation", model="your-musiclang-predict-model")
+
+        # Handle different generation scenarios based on inputs
+        if midi_data is not None and chord_progression.strip() != "":
+            # Continue sequence with chord progression
+            generated_score = ml.continue_sequence(
+                midi_data,
+                chord_progression=chord_progression,
+                nb_tokens=int(nb_tokens),
+                temperature=float(temperature),
+                # ... other parameters
+            )
+        elif midi_data is not None and chord_progression.strip() == "":
+            # Generate using the uploaded MIDI file as a prompt
+            generated_score = ml.predict(
+                midi_data,  # Use the uploaded MIDI as the prompt
+                nb_tokens=int(nb_tokens),
+                temperature=float(temperature),
+                # ... other parameters
+            )
+        else:
+            # Generate with specific chord progression
+            generated_score = ml.predict_chords(
+                chord_progression,
+                # ... other parameters
+            )
+
+        # Save generated files to temporary locations
+        temp_midi_file = tempfile.NamedTemporaryFile(suffix=".mid", delete=False)
+        midi_path = temp_midi_file.name
+        generated_score.to_midi(midi_path, tempo=tempo, time_signature=time_signature)  # Assuming time_signature is defined
+
+        temp_mp3_file = tempfile.NamedTemporaryFile(suffix=".mp3", delete=False)
+        mp3_path = temp_mp3_file.name
+        # ... (convert MIDI to MP3 using FluidSynth and FFmpeg)
+
+        # Read binary data from the temporary files
+        with open(mp3_path, 'rb') as f_mp3:
+            mp3_binary = f_mp3.read()
+
+        with open(midi_path, 'rb') as f_midi:
+            midi_binary = f_midi.read()
+
+        # Remove temporary files
+        os.remove(mp3_path)
+        os.remove(midi_path)
+
+        return {
+            "mp3": mp3_binary,
+            "midi": midi_binary,
+            "chord_repr": chord_repr,  # Assuming chord_repr is still needed
+            "tempo_message": tempo_message  # Assuming tempo_message is still needed
+        }
+
+    except Exception as e:
+        return {"error": str(e)}
+
+# --- Gradio Interface ---
+
+def musiclang_gradio(midi_file, chord_progression, tempo, temperature, nb_tokens, bar_range):
+    midi_data = None
+    if midi_file:
+        with open(midi_file.name, "rb") as f:
+            midi_data = f.read()
+
+    api_response = generate_music_api(midi_data=midi_data, chord_progression=chord_progression, tempo=tempo, temperature=temperature, nb_tokens=nb_tokens, bar_range=bar_range)
+
+    if "error" in api_response:
+        return None, None, api_response["error"]
+
+    # Create temporary files for Gradio
+    mp3_path = tempfile.NamedTemporaryFile(suffix=".mp3", delete=False).name
+    midi_path = tempfile.NamedTemporaryFile(suffix=".mid", delete=False).name
+
+    # Write binary data to temporary files
+    with open(mp3_path, "wb") as f:
+        f.write(api_response["mp3"])
+
+    with open(midi_path, "wb") as f:
+        f.write(api_response["midi"])
+
+    return mp3_path, midi_path, None
+
+with gr.Blocks() as demo:
+    # Introductory text
     gr.Markdown("""
     # Controllable Symbolic Music Generation with MusicLang Predict
     [MusicLang Predict](https://github.com/musiclang/musiclang_predict) offers advanced controllability features and high-quality music generation by manipulating symbolic music.
     You can for example use it to continue your composition with a specific chord progression.
     """)
-    with gr.Row():        
-with gr.Column():            
-with gr.Row():
+
+    with gr.Row():
+        with gr.Column():
+            with gr.Row():
                 midi_file = gr.File(label="Prompt MIDI File (Optional)", type="filepath", file_types=[".mid", ".midi"],
-                                    elem_id='midi_file_input')                
-with gr.Column():
-                    bar_range = gr.Textbox(label="Bar Range of input file (eg: 0-4 for first four bars)", placeholder="0-4",
-                                           value="0-4", elem_id='bar_range_input')
-                    nb_tokens = gr.Number(label="Nb Tokens",
-                                          value=512, minimum=256, maximum=2048, step=256, elem_id='nb_tokens_input')
-                    temperature = gr.Slider(
-                        label="Temperature",
-                        value=0.95,
-                        visible=False,
-                        minimum=0.1, maximum=1.0, step=0.1, elem_id='temperature_input')
-                    tempo = gr.Slider(label="Tempo", value=120, minimum=60, maximum=240, step=1, elem_id='tempo_input')
+                                    elem_id='midi_file_input')
+            with gr.Column():
+                bar_range = gr.Textbox(label="Bar Range of input file (eg: 0-4 for first four bars)", placeholder="0-4",
+                                       value="0-4", elem_id='bar_range_input')
+                nb_tokens = gr.Number(label="Nb Tokens",
+                                      value=512, minimum=256, maximum=2048, step=256, elem_id='nb_tokens_input')
+                temperature = gr.Slider(
+                    label="Temperature",
+                    value=0.95,
+                    visible=False,
+                    minimum=0.1, maximum=1.0, step=0.1, elem_id='temperature_input')
+                tempo = gr.Slider(label="Tempo", value=120, minimum=60, maximum=240, step=1, elem_id='tempo_input')
             with gr.Row():
                 chord_progression = gr.Textbox(
                     label="Chord Progression (Optional)",
@@ -81,13 +125,15 @@ with gr.Column():
             info_message = gr.Textbox(label="Info Message", elem_id='info_message_output')
             generated_music = gr.Audio(label="Preview generated Music", elem_id='generated_music_output')
             generated_midi = gr.File(label="Download MIDI", elem_id='generated_midi_output')
+
             generate_btn.click(
-                fn=musiclang,
+                fn=musiclang_gradio,
                 inputs=[midi_file, chord_progression, tempo, temperature, nb_tokens, bar_range],
                 outputs=[generated_music, generated_midi, info_message]
-            )            
-    with gr.Row():        
-with gr.Column():
+            )
+
+    with gr.Row():
+        with gr.Column():
             gr.Markdown("## Examples")
             gr.Examples(
                 examples=[["/home/user/app/bach_847.mid", "", 120, 0.95, 512, "0-4"],
@@ -100,7 +146,8 @@ with gr.Column():
                           ],
                 inputs=[midi_file, chord_progression, tempo, temperature, nb_tokens, bar_range],
                 outputs=[generated_music, generated_midi, info_message],
-                fn=musiclang,
+                fn=musiclang_gradio,
                 cache_examples=True,
             )
+
 demo.launch()