app.py

import ast
import shutil
import gradio as gr
import numpy as np
from matplotlib import pyplot as plt
from mido import Message, MidiFile, MidiTrack
import os
import subprocess
from music21 import converter, note, interval
from pydub import AudioSegment
import hexachords

BASE_DIR = os.path.dirname(os.path.abspath(__file__))

class HexachordApp:

    def __init__(self):
        self._hexachord = hexachords.Hexachord()
        self._hexachord_base_sequence = None
        self.ui = None
        self.on_huggingface = "HUGGINGFACE_SPACE" in os.environ

    def is_fsynth_installed(self):
        """ Check to make sure fluidsynth exists in the PATH """
        for path in os.environ['PATH'].split(os.pathsep):
            f = os.path.join(path, 'fluidsynth')
            if os.path.exists(f) and os.access(f, os.X_OK):
                print('fluidsynth is installed')
                return True
        print('fluidsynth is NOT installed')
        return False

    def generate_chords(self, note_names, itvl):
        # Placeholder for your actual chord generation function
        # Assuming hexachord is a list of MIDI note numbers
        interval_21 = 'P5'
        if itvl == 'fourth':
            interval_21 = 'P4'
        self._hexachord_base_sequence = self._hexachord.generate_chord_sequence(note_names, intrvl=interval_21)
        return self._hexachord_base_sequence

    def generate_realizations(self):
        # returns 3 triples of midipath, piano roll, audio player
        reals = self._hexachord.generate_3_chords_realizations(self._hexachord_base_sequence)
        midi_path1 = self.create_midi(reals[0], "real1.mid")
        piano_roll_path1 = self.generate_piano_roll(reals[0], "real1.png")
        audio_path1 = self.convert_midi_to_audio(midi_path1, "real1")
        midi_path2 = self.create_midi(reals[1], "real2.mid")
        piano_roll_path2 = self.generate_piano_roll(reals[1], "real2.png")
        audio_path2 = self.convert_midi_to_audio(midi_path2, "real2")
        midi_path3 = self.create_midi(reals[2], "real3.mid")
        piano_roll_path3 = self.generate_piano_roll(reals[2], "real3.png")
        audio_path3 = self.convert_midi_to_audio(midi_path3, "real3")
        return midi_path1, piano_roll_path1, audio_path1, midi_path2, piano_roll_path2, audio_path2, midi_path3, piano_roll_path3, audio_path3

    def create_midi(self, chords, file_name):
        mid = MidiFile()
        track = MidiTrack()
        mid.tracks.append(track)
        delta_time = 480 * 4
        for i_chord, chord in enumerate(chords):
            for i, note in enumerate(chord):
                if i == 0 and i_chord != 0:
                    track.append(Message('note_on', note=note.pitch.midi, velocity=64, time=1))
                else:
                    track.append(Message('note_on', note=note.pitch.midi, velocity=64, time=0))
            for i, note in enumerate(chord):
                if i==0:
                    track.append(Message('note_off', note=note.pitch.midi, velocity=0, time=delta_time - 1))
                else:
                    track.append(Message('note_off', note=note.pitch.midi, velocity=0, time=0))
        midi_path = os.path.join(BASE_DIR, file_name)
        mid.save(midi_path)
        return midi_path


    def convert_midi_to_audio(self, midi_path, file_name):
        if not shutil.which("fluidsynth"):
            try:
                subprocess.run(["apt-get", "update"], check=True)
                subprocess.run(["apt-get", "install", "-y", "fluidsynth"], check=True)
            except Exception as e:
                return f"Error installing Fluidsynth: {str(e)}"
        wav_path = os.path.join(BASE_DIR, file_name + ".wav")
        mp3_path = os.path.join(BASE_DIR, file_name + ".mp3")
        soundfont_path = os.path.join(BASE_DIR, "soundfont.sf2")
        if not os.path.exists(soundfont_path):
            return "Error: SoundFont file not found. Please provide a valid .sf2 file."
        try:
            subprocess.run(["fluidsynth", "-ni", soundfont_path, midi_path, "-F", wav_path, "-r", "44100"], check=True)
            AudioSegment.converter = "ffmpeg"
            audio = AudioSegment.from_wav(wav_path)
            audio.export(mp3_path, format="mp3")
            return mp3_path
        except Exception as e:
            return f"Error converting MIDI to audio: {str(e)}"

    def generate_png(self, midi_file, output_file_name):
        self._hexachord.midi_to_png(midi_file, output_file_name)

    def generate_piano_roll(self, chords, label):
        fig, ax = plt.subplots(figsize=(8, 4))

        for i, chord in enumerate(chords):
            for note in chord:
                ax.broken_barh([(i * 1, 0.8)], (note.pitch.midi - 0.4, 0.8), facecolors='blue')

        ax.set_xlabel("Chord Progression")
        ax.set_ylabel("MIDI Note Number")
        min_min_chords = 128
        max_max_chords = 0
        for ch in chords:
            for note in ch:
                if note.pitch.midi < min_min_chords:
                    min_min_chords = note.pitch.midi
                if note.pitch.midi > max_max_chords:
                    max_max_chords = note.pitch.midi
        ax.set_yticks(range(min_min_chords, max_max_chords + 1, 2))
        ax.set_xticks(range(len(chords)))
        ax.set_xticklabels([f"Chord {i + 1}" for i in range(len(chords))])

        plt.grid(True, linestyle='--', alpha=0.5)
        plt.savefig(label)
        return label

    def launch_score_editor(self, midi_path):
        try:
            score = converter.parse(midi_path)
            score.show('musicxml')
            return "Opened MIDI file in the default score editor!"
        except Exception as e:
            return f"Error opening score editor: {str(e)}"

    def process_hexachord(self, hexachord_str, itvl):
        try:
            notes = [note.Note(n) for n in hexachord_str.split()]
            if len(notes) != 6 or len(set(notes)) != 6:
                return "Please enter exactly 6 unique MIDI note numbers."
        except ValueError:
            return "Invalid input. Enter 6 MIDI note numbers separated by spaces."
        chords = self.generate_chords(notes, itvl)
        midi_path = self.create_midi(chords, "base_chords.mid")
        piano_roll_path = self.generate_piano_roll(chords, "base_chords.png")
        # score_path = self.generate_png (midi_path, "score_base_chords.png")
        audio_path = self.convert_midi_to_audio(midi_path, "base_chords")

        return midi_path, piano_roll_path, audio_path

    def render(self):
        with gr.Blocks() as ui:
            gr.Markdown("# Hexachord-based Chord Generator")

            with gr.Tabs():
                with gr.TabItem("Hexachord Generator"):
                    with gr.Row():
                        hexachord_selector = gr.Dropdown(label="Select Known Hexachord",
                                                         choices=self.get_known_hexachords_choice(), value=None, interactive=True)
                        hexachord_input = gr.Textbox(
                            label="Enter 6 notes (pitchclass plus octave, separated by spaces)",
                            value="C3 D3 E3 G3 A3 B3",
                            interactive = True
                        )
                        interval_switch = gr.Radio(
                            choices=["fourth", "fifth"],
                            label="Select Interval",
                            value="fifth"
                        )
                        generate_button = gr.Button("Generate Chords")
                    midi_output = gr.File(label="Download MIDI File")
                    # piano_roll_output = gr.Image(label="Piano Roll Visualization")
                    score_output = gr.Image(label="Score Visualization")
                    audio_output = gr.Audio(label="Play Generated Chords", value=None, interactive=False)

                    hexachord_selector.change(
                        fn=self.get_selected_hexachord,
                        inputs=[hexachord_selector],
                        outputs=[hexachord_input]
                    )
                    # generate_button.click(
                    #     fn=self.process_hexachord,
                    #     inputs=[hexachord_selector, interval_switch],
                    #     outputs=[midi_output, score_output, audio_output]
                    # )

                    generate_button.click(
                        fn=self.process_hexachord,
                        inputs=[hexachord_input, interval_switch],
                        # outputs=[midi_output, piano_roll_output, audio_output]
                        outputs = [midi_output, score_output, audio_output]
                    )
                # Pressing Enter in the textbox also triggers processing
                    hexachord_input.submit(
                        fn=self.process_hexachord,
                        inputs=[hexachord_input, interval_switch],
                        outputs=[midi_output, score_output, audio_output]
                    )

                with gr.TabItem("Alternative Chord Realizations"):
                    gr.Markdown("Alternative Chord Realizations")

                    realization_button = gr.Button("Generate Alternative Realizations")
                    realization_outputs = []

                    for i in range(3):  # Three alternative realizations
                        with gr.Group():
                            gr.Markdown(f"#### Realization {i + 1}")
                            midi_output = gr.File(label="Download MIDI File")
                            piano_roll = gr.Image(label=f"Piano Roll {i + 1}")
                            audio_player = gr.Audio(label=f"Play Chords {i + 1}", interactive=False)
                            realization_outputs.append((midi_output, piano_roll, audio_player))

                    # Clicking the button triggers realization generation
                    realization_button.click(
                        fn=self.generate_realizations,
                        inputs=[],
                        outputs=[output for trip in realization_outputs for output in trip]
                    )

                with gr.TabItem("Settings"):
                    gr.Markdown("### Configuration Options")
                    setting_1 = gr.Checkbox(label="Enable Advanced Mode")
                    setting_2 = gr.Slider(0, 100, label="Complexity Level")
        self.ui = ui

    def get_known_hexachords_choice(self):
        return self._hexachord.known_hexachords

    def get_selected_hexachord(self, x):
        # lambda x: {"Hexachord 1": "C3 D3 E3 G3 A3 B3", "Hexachord 2": "D3 E3 F3 A3 B3 C4",
        #            "Hexachord 3": "E3 G3 A3 C4 D4 F4"}.get(x, "")
        item = x[x.index('['):x.index(']')+1]
        int_array = np.array(ast.literal_eval(item))
        hexa_string = ''
        start_note = note.Note('C3')
        for i in int_array:
            add_note = start_note.transpose(int(i))
            hexa_string = hexa_string + ' ' + add_note.nameWithOctave
        return hexa_string


def launch_app():
    hex = HexachordApp()
    hex.is_fsynth_installed()
    hex.render()
    if hex.on_huggingface:
        hex.ui.launch(server_name="0.0.0.0", server_port=7860)
    else:
        hex.ui.launch()


launch_app()