added smallmuse and movements

format_conversions.py

@@ -1,5 +1,7 @@
 import copy
 import os
+from pathlib import Path
+
 from music21 import converter, musicxml, stream, note, chord, clef
 import verovio
 import shutil
@@ -61,6 +63,24 @@ class Format_Converter:
         exporter = musicxml.m21ToXml.GeneralObjectExporter(score)
         return exporter.parse().decode('utf-8')  # parse() returns bytes
 
+    @classmethod
+    def xml_to_svg_file(cls, tk, musicxml, output_file):
+        try:
+            mei_str = cls.xml_to_mei_string(tk, musicxml)
+            # Load MEI and render SVG
+            tk.loadData(mei_str)
+            svg = tk.renderToSVGFile(output_file)
+            return output_file
+        except Exception as e:
+            print("error in midi_to_svg_file")
+            # return f"<p style='color:red'>Error: {e}</p>"
+            return output_file
+
+    @classmethod
+    def midi_to_svg_file(cls, tk, midi_path, output_file):
+        musicxml = cls.midi_to_musicxml_string_two_staves(midi_path)
+        return cls.xml_to_svg_file(tk, musicxml, output_file)
+
     @classmethod
     def xml_to_mei_string(cls, tk, xmlstring):
         tk.loadData(xmlstring)
@@ -79,20 +99,7 @@ class Format_Converter:
         except Exception as e:
             return f"<p style='color:red'>Error: {e}</p>"
 
-    @classmethod
-    def midi_to_svg_file(cls, tk, midi_path, output_file):
-        try:
-            # Convert MIDI to MEI using music21
-            musicxml = cls.midi_to_musicxml_string_two_staves(midi_path)
-            mei_str = cls.xml_to_mei_string(tk, musicxml)
-            # Load MEI and render SVG
-            tk.loadData(mei_str)
-            svg = tk.renderToSVGFile(output_file)
-            return output_file
-        except Exception as e:
-            print("error in midi_to_svg_file")
-            # return f"<p style='color:red'>Error: {e}</p>"
-            return output_file
+
 
     @classmethod
     def m21_to_xml(cls, m21):
@@ -138,6 +145,33 @@ class Format_Converter:
         except Exception as e:
             return f"Error converting MIDI to audio: {str(e)}"
 
+def musescore_midi_to_svg(midi_path, svg_path, mscore_path="/Applications/MuseScore 4.app/Contents/MacOS/mscore"):
+    subprocess.run([mscore_path, midi_path, "-o", svg_path, "-T"], check=True)
+
+def musescore_midi_to_musicxml(
+        midi_path: str,
+        output_path: str = None,
+        musescore_path: str = "/Applications/MuseScore 4.app/Contents/MacOS/mscore"
+):
+    midi_file = Path(midi_path)
+    if not midi_file.exists():
+        raise FileNotFoundError(f"MIDI file not found: {midi_path}")
+
+    if output_path is None:
+        output_path = midi_file.with_suffix(".musicxml")
+    else:
+        output_path = Path(output_path)
+
+    command = [musescore_path, str(midi_file), "-o", str(output_path)]
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=True)
+        print("✅ MuseScore conversion successful.")
+        print(f"➡️ Output: {output_path}")
+    except subprocess.CalledProcessError as e:
+        print("❌ MuseScore conversion failed.")
+        print("stderr:", e.stderr)
+        print("stdout:", e.stdout)
+        raise
 
 if __name__ == '__main__':
     svg_string = Format_Converter().midi_to_svg(verovio.toolkit(), 'output.mid')

legacy/essai_voices.py

@@ -0,0 +1,52 @@
+import os
+from pathlib import Path
+import subprocess
+from mido import MidiFile, MidiTrack, Message, MetaMessage
+
+def convert_midi_to_svg(midi_path, svg_path, mscore_path="/Applications/MuseScore 4.app/Contents/MacOS/mscore"):
+    subprocess.run([mscore_path, midi_path, "-o", svg_path, "-T", "-S", "../musescore_style.mss"], check=True)
+
+def convert_midi_to_musicxml(
+        midi_path: str,
+        output_path: str = None,
+        musescore_path: str = "/Applications/MuseScore 4.app/Contents/MacOS/mscore"
+):
+    midi_file = Path(midi_path)
+    if not midi_file.exists():
+        raise FileNotFoundError(f"MIDI file not found: {midi_path}")
+
+    if output_path is None:
+        output_path = midi_file.with_suffix(".musicxml")
+    else:
+        output_path = Path(output_path)
+
+    command = [musescore_path, str(midi_file), "-o", str(output_path)]
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=True)
+        print("✅ MuseScore conversion successful.")
+        print(f"➡️ Output: {output_path}")
+    except subprocess.CalledProcessError as e:
+        print("❌ MuseScore conversion failed.")
+        print("stderr:", e.stderr)
+        print("stdout:", e.stdout)
+        raise
+
+def remove_tempo_from_svg(svg_path, output_path=None):
+    with open(svg_path, "r", encoding="utf-8") as f:
+        lines = f.readlines()
+    cleaned_lines = [
+        line for line in lines
+        if "tempo" not in line.lower() and "♩" not in line
+    ]
+    output_path = output_path or svg_path.replace(".svg", "_notempo.svg")
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.writelines(cleaned_lines)
+    print(f"✅ Tempo removed. Saved to: {output_path}")
+    return output_path
+
+# Example usage:
+# convert_midi_to_musicxml("movement0.mid",output_path= "movement0.musicxml")
+# with open("movement0.musicxml", "r", encoding="utf-8") as f:
+#     xml_string = f.read()
+convert_midi_to_musicxml("../movement5.mid",output_path= "../MSmovement5.svg")
+remove_tempo_from_svg("../MSmovement5-1.svg", "../NTMSmovement5-1.svg")

movements.py

@@ -0,0 +1,44 @@
+import os
+import random
+
+from mido import MidiFile, Message, MidiTrack
+from music21 import note, stream, interval, meter, chord
+from ortools.sat.python import cp_model
+
+from hexachords import Hexachord
+from smallmuse.temporals import NoteList, TemporalNote
+
+
+class Movement:
+    def __init__(self, h):
+        self.hexachord = h
+
+    def generate_movements(self, param):
+        reals = self.hexachord.generate_3_chords_realizations(self.hexachord._base_sequence)
+        mvts_templates = []
+        for index_of_chord in range(6):
+            chords = [real[index_of_chord] for real in reals]
+            mvts_templates.append(chords)
+        return mvts_templates
+
+if __name__ == '__main__':
+    hexa = Hexachord()
+    note_names = ["C3", "Eb3", "E3", "F#3", "G3", "Bb3"]
+    notes = [note.Note(n) for n in note_names]
+    cs1 = hexa.generate_base_sequence(notes, intrvl="P4")
+    print (cs1)
+    move = Movement(hexa)
+    mvmts= move.generate_movements(1)
+    movement = random.choice(mvmts)
+    # make a temporallist
+    nl = NoteList()
+    for i_chord, chord in enumerate(movement):
+        for note in chord:
+            nl.add_note(TemporalNote(note.pitch.midi, i_chord * 4, 4))
+    nl.join_notes()
+    # nl.show()
+    nl.apply_rules()
+    print('after rules')
+    nl.save_midi('output.mid')
+    nl.show()
+

mscore/Dockerfile_mscore

@@ -0,0 +1,23 @@
+FROM --platform=linux/amd64 python:3.10-slim
+
+ENV DEBIAN_FRONTEND=noninteractive
+FROM --platform=linux/amd64 python:3.10-slim
+
+# Install dependencies needed for MuseScore AppImage
+RUN apt-get update && apt-get install -y \
+    wget \
+    libqt5gui5 \
+    libqt5svg5 \
+    libpulse0 \
+    fontconfig \
+    fuse \
+    && apt-get clean
+
+# Download and extract MuseScore 3.6.2 AppImage
+WORKDIR /tmp
+RUN wget https://github.com/musescore/MuseScore/releases/download/v3.6.2/MuseScore-3.6.2.548021370-x86_64.AppImage -O mscore.AppImage \
+    && chmod +x mscore.AppImage \
+    && ./mscore.AppImage --appimage-extract \
+    && mv squashfs-root /opt/mscore \
+    && ln -s /opt/mscore/AppRun /usr/bin/mscore \
+    && rm mscore.AppImage

mscore/app_mscore.py

@@ -0,0 +1,41 @@
+import os
+import subprocess
+import gradio as gr
+from pathlib import Path
+MSCORE_BIN = "/opt/squashfs-root/bin/mscore"
+APPIMAGE = "/opt/mscore.AppImage"
+EXTRACT_DIR = "/opt/squashfs-root"
+
+def extract_musescore():
+    if not Path(MSCORE_BIN).exists():
+        print("🔧 Extracting MuseScore AppImage...")
+        subprocess.run([APPIMAGE, "--appimage-extract"], cwd="/opt", check=True)
+
+def convert_and_render(midi_path_str):
+    midi_path = Path(midi_path_str)
+    svg_path = midi_path.with_suffix(".svg")
+    result = subprocess.run([
+        MSCORE_BIN,
+        str(midi_path),
+        "-o", str(svg_path)
+    ], capture_output=True, text=True)
+    if result.returncode != 0:
+        return f"❌ MuseScore failed: {result.stderr}", None
+    return "✅ Conversion successful", svg_path.read_text()
+
+iface = gr.Interface(
+    fn=convert_and_render,
+    inputs=gr.File(type="filepath", label="Upload MIDI file"),
+    outputs=["text", gr.HTML(label="Rendered SVG")],
+    title="MIDI to SVG Viewer via MuseScore"
+)
+
+def launch_app():
+    if "HUGGINGFACE_SPACE" in os.environ:
+        iface.launch(server_name="0.0.0.0", server_port=7860, share=True)
+    else:
+        iface.launch(server_name="0.0.0.0", server_port=7860)
+
+
+launch_app()
+

smallmuse/temporals.py

@@ -0,0 +1,132 @@
+import random
+
+from mido import MidiFile, MidiTrack, Message
+
+class TemporalNote:
+    start_time = 0
+    end_time = 0
+    pitch = 60
+
+    def __init__(self, pitch, start_time, duration):
+        self.pitch = pitch
+        self.start_time = start_time
+        self.end_time = start_time + duration
+
+    def duration(self):
+        return self.end_time - self.start_time
+
+    def set_duration(self, dur):
+        self.end_time = self.start_time + dur
+
+    def __str__(self):
+        return f"{self.pitch} @ [{self.start_time}, {self.end_time}]"
+
+    def __repr__(self):
+        return f"{self.pitch} @ [{self.start_time}, {self.end_time}]"
+
+
+class NoteList:
+    notes = []
+
+    def add_note(self, tmp):
+        self.notes.append(tmp)
+        self.resort()
+
+    def remove_note(self, note):
+        self.notes.remove(note)
+
+    def resort(self):
+        self.notes.sort(key=lambda note: (note.start_time, note.duration()))
+
+    def show(self):
+        for note in self.notes:
+            print(note)
+
+    # joins adjacent notes with same pitch
+    def join_notes(self):
+        keep_going = True
+        while (keep_going):
+            keep_going = False
+            for i, note in enumerate(self.notes):
+                # is there another note starting where i end ?
+                candidates = self.get_notes_starting_at(note.end_time)
+                candidates = [cnote for cnote in candidates if cnote.pitch == note.pitch and cnote != note]
+                if len(candidates) == 0:
+                    continue
+                max_end = max(candidates, key=lambda x: x.end_time).end_time
+                # remove all candidates and sets the max dur to the current note
+                for cand in candidates:
+                    self.remove_note(cand)
+                note.set_duration(max_end - note.start_time)
+                keep_going = True
+                break
+
+    def get_notes_starting_at(self, start):
+        return [n for n in self.notes if n.start_time == start]
+
+    def get_notes_within(self, start, end):
+        return [n for n in self.notes if n.start_time <= end and n.end_time >= start]
+
+    def get_polyphony_at(self, time_point):
+        # how many notes are played at that moment ?
+        return len([note for note in self.notes if note.start_time < time_point and note.end_time > time_point])
+
+    def apply_rules(self):
+        for i in range(20):
+            if random.random(1,100) > 50:
+                self.apply_rule_remove()
+            else:
+                self.apply_rule_split()
+
+    def apply_rule_remove(self):
+        a_note = random.choice(self.notes)
+        notes_within = self.get_notes_within(a_note.start_time, a_note.end_time)
+        maxp = 0
+        for note in notes_within:
+            maxp = max(maxp, self.get_polyphony_at(note.start_time))
+            maxp = max(maxp, self.get_polyphony_at(note.end_time))
+        # print(f"note {a_note} has polyphony {maxp}")
+        if maxp > 2:
+            self.remove_note(a_note)
+
+    def apply_rule_split(self):
+        a_note = random.choice(self.notes)
+        notes_within = self.get_notes_within(a_note.start_time, a_note.end_time)
+        maxp = 0
+        for note in notes_within:
+            maxp = max(maxp, self.get_polyphony_at(note.start_time))
+            maxp = max(maxp, self.get_polyphony_at(note.end_time))
+        # print(f"note {a_note} has polyphony {maxp}")
+        if maxp > 2:
+            self.remove_note(a_note)
+
+    def save_midi(self, file_name):
+        mid = MidiFile()
+        track = MidiTrack()
+        mid.tracks.append(track)
+        click_per_beats = 480
+        message_list = []
+        for note in self.notes:
+            message_list.append(Message('note_on', note=note.pitch, velocity=64, time=(int)(click_per_beats * note.start_time)))
+            message_list.append(Message('note_off', note=note.pitch, velocity=0, time=(int)(click_per_beats * note.end_time)))
+        message_list.sort(key= lambda msg: msg.time)
+        last_event_time = 0
+        for msg in message_list:
+            delta_time = msg.time - last_event_time
+            last_event_time = msg.time
+            msg.time = delta_time
+            track.append(msg)
+        mid.save(file_name)
+        return file_name
+
+
+if __name__ == '__main__':
+    nl = NoteList()
+    nl.add_note(TemporalNote(60, 0, 4))
+    nl.add_note(TemporalNote(62, 2, 4))
+    nl.add_note(TemporalNote(64, 1, 2))
+    nl.add_note(TemporalNote(65, 0, 4))
+    nl.add_note(TemporalNote(67, 1, 3))
+    nl.add_note(TemporalNote(68, 2, 3))
+    # nl.show()
+    nl.save_midi('nl_output.mid')

verovio_app/Dockerfile_Verovio

@@ -0,0 +1,39 @@
+FROM python:3.12
+
+# Install pip + Gradio dependencies
+RUN apt-get update && apt-get install -y \
+    swig \
+    g++ \
+    cmake \
+    make \
+    libglib2.0-dev \
+    libxml2-dev \
+    libzip-dev \
+    libcurl4-openssl-dev \
+    fluidsynth \
+    libfluidsynth-dev \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+# Install Python packages
+RUN pip install --upgrade pip
+#RUN pip install verovio
+#RUN python3 -c "import verovio, sys; sys.stderr.write('✅ Verovio version: ' + verovio.toolkit().getVersion() + '\n')"
+#RUN pip install gradio
+#RUN pip install music21
+
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+# Copy app and MEI file
+WORKDIR /app
+COPY . .
+
+# Change ownership to user id 1000 (default HF user)
+RUN chown -R 1000:1000 /app
+
+# Switch to user id 1000 (non-root, for HF)
+USER 1000
+
+RUN which fluidsynth && fluidsynth --version || echo "❌ Fluidsynth not found"
+
+CMD ["python3", "app.py"]

verovio_app/app_verovio.py

@@ -0,0 +1,234 @@
+import ast
+import gradio as gr
+import numpy as np
+from mido import Message, MidiFile, MidiTrack
+import os
+from music21 import converter, note, stream, chord, tempo, meter
+import hexachords
+from format_conversions import Format_Converter
+import verovio
+import subprocess
+
+from legacy.essai_mido_to_xml import midi_path
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+def get_verovio_resource_path():
+    for path in verovio.__path__:
+        candidate = os.path.join(path, "data")
+        if os.path.exists(candidate):
+            return candidate
+    return None
+
+# Initialize the Verovio toolkit with rendering options
+tk = verovio.toolkit()
+resource_path = get_verovio_resource_path()
+print(f"resource path: {os.listdir(resource_path)}")
+print("[Debug] Using resource path:", resource_path)
+if resource_path:
+    try:
+        tk.setResourcePath(resource_path)
+    except Exception as e:
+        print("[Error] Failed to set resourcePath:", e)
+tk.setOptions({
+    "adjustPageWidth": True,
+    "header": 'none',  # This disables the rendering of the title
+    "scale": 70,
+    "adjustPageHeight": True,
+    "landscape": False,
+})
+print(tk.getOptions())
+
+class HexachordApp:
+
+    def __init__(self):
+        self._hexachord = hexachords.Hexachord()
+        self.ui = None
+        self.on_huggingface = "HUGGINGFACE_SPACE" in os.environ
+
+    def is_fsynth_installed(self):
+        try:
+            subprocess.run(["fluidsynth", "--version"], check=True)
+            print('fluidsynth is installed')
+            return True
+        except Exception:
+            print('fluidsynth is NOT installed')
+            return False
+
+    def generate_chords(self, note_names, itvl):
+        interval_21 = 'P5'
+        if itvl == 'fourth':
+            interval_21 = 'P4'
+        return self._hexachord.generate_base_sequence(note_names, intrvl=interval_21)
+
+    def generate_realizations(self):
+        # returns triples of midipath, score image, audio player
+        reals = self._hexachord.generate_3_chords_realizations(self._hexachord._base_sequence)
+        all_paths = []
+        fm = Format_Converter()
+        for i, real in enumerate(reals):
+            midi_path = f"real{i}.mid"
+            all_paths.append(self.create_midi_file(real, midi_path))
+            all_paths.append(fm.midi_to_svg_file(tk, midi_path, f"real{i}.svg"))
+            all_paths.append(fm.convert_midi_to_audio(midi_path, f"real{i}"))
+        return tuple(all_paths)
+
+    def create_midi_file(self, chords, file_name, duration_in_quarter_lengths=4.0, tempo_bpm=120, time_signature="4/4"):
+        midi_path = os.path.join(BASE_DIR, file_name)
+        self._hexachord.save_chords_to_midi_file(chords, midi_path)
+        return file_name
+
+    def generate_svg(self, midi_file, output_file_name):
+        return Format_Converter().midi_to_svg_file(tk, midi_file, output_file_name)
+
+    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 build_octave_dependent_notes_from_string(self, note_string):
+        start_octave = 3
+        notes = []
+        previous_note = None
+        for nn in note_string.split():
+            n = note.Note(nn)
+            n.octave = start_octave
+            if previous_note is not None and n.pitch.midi < previous_note.pitch.midi:
+                n.octave = n.octave + 1
+                start_octave += 1
+            notes.append(n)
+            previous_note = n
+        return notes
+
+    def process_hexachord(self, hexachord_str, itvl):
+        try:
+            notes = self.build_octave_dependent_notes_from_string(hexachord_str)
+            if len(notes) != 6 or len(set(notes)) != 6:
+                return "Please enter exactly 6 unique notes."
+        except ValueError:
+            return "Invalid input. Enter 6 notes separated by spaces."
+        fm = Format_Converter()
+        chords = self.generate_chords(notes, itvl)
+        midi_path = self.create_midi_file(chords, "../base_chords.mid")
+        score_path = fm.midi_to_svg_file(tk, midi_path, "score_base_chords.svg")
+        audio_path = fm.convert_midi_to_audio(midi_path, "base_chords")
+        return (midi_path, score_path, audio_path) + self.generate_realizations()
+
+    def generate_movements(self):
+        # take 2 realizations of the same root
+        everyone = ()
+        for index_of_chord in range(6):
+            chords = [real[index_of_chord] for real in self._hexachord._realizations]
+            fm = Format_Converter()
+            midi_path = self.create_midi_file(chords, f"movement{index_of_chord}.mid")
+            score_path = fm.midi_to_svg_file(tk, midi_path, f"movement{index_of_chord}.svg")
+            audio_path = fm.convert_midi_to_audio(midi_path, f"movement{index_of_chord}")
+            everyone = everyone + (midi_path, score_path, audio_path)
+        return everyone
+
+    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 pitchclasses, separated by spaces",
+                            value="C D E G A B",
+                            interactive = True
+                        )
+                        interval_switch = gr.Radio(
+                            choices=["fourth", "fifth"],
+                            label="Select Interval",
+                            value="fifth"
+                        )
+                        generate_button = gr.Button("Generate Chords")
+                    with gr.Row():
+                        gr.Markdown(f"#### base chords")
+                        midi_output = gr.File(label="Download MIDI File", scale=1)
+                        score_output = gr.Image(label="Score Visualization", scale=3)
+                        audio_output = gr.Audio(label="Play Generated Chords", value=None, interactive=False, scale=3)
+                    realization_outputs = [midi_output, score_output, audio_output]
+                    for i in range(3):  # Three alternative realizations
+                        with gr.Row():
+                            gr.Markdown(f"#### Realization {i + 1}")
+                            midi_output = gr.File(label="Download MIDI File", scale=1)
+                            piano_roll = gr.Image(label=f"Piano Roll {i + 1}", scale=3)
+                            audio_player = gr.Audio(label=f"Play Chords {i + 1}", interactive=False, scale=3)
+                            realization_outputs += (midi_output, piano_roll, audio_player)
+
+                    hexachord_selector.change(
+                        fn=self.get_selected_hexachord,
+                        inputs=[hexachord_selector],
+                        outputs=[hexachord_input]
+                    )
+                    generate_button.click(
+                        fn=self.process_hexachord,
+                        inputs=[hexachord_input, interval_switch],
+                        # outputs=[midi_output, piano_roll_output, audio_output]
+                        outputs = realization_outputs
+                    )
+                # Pressing Enter in the textbox also triggers processing
+                    hexachord_input.submit(
+                        fn=self.process_hexachord,
+                        inputs=[hexachord_input, interval_switch],
+                        outputs=realization_outputs
+                    )
+
+                with gr.TabItem("Movements"):
+                    gr.Markdown("Movements")
+                    with gr.Row():
+                        generate_mvmt_button = gr.Button("Generate Movements")
+                    realization_outputs = []
+                    for i in range(6):  # Three alternative realizations
+                        with gr.Row():
+                            gr.Markdown(f"#### Movement {i + 1}")
+                            midi_output = gr.File(label="Download MIDI File", scale=1)
+                            piano_roll = gr.Image(label=f"Piano Roll {i + 1}", scale=3)
+                            audio_player = gr.Audio(label=f"Play Chords {i + 1}", interactive=False, scale=3)
+                            realization_outputs += (midi_output, piano_roll, audio_player)
+                    generate_mvmt_button.click(
+                        fn=self.generate_movements,
+                        inputs=[],
+                        outputs = realization_outputs
+                    )
+
+                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, share=True)
+    else:
+        hex.ui.launch(server_name="0.0.0.0", server_port=7860)
+
+
+launch_app()
+

verovio_app/hexachords.py

@@ -0,0 +1,195 @@
+import os
+
+from mido import MidiFile, Message, MidiTrack
+from music21 import note, stream, interval, meter, chord
+from ortools.sat.python import cp_model
+
+class Hexachord:
+    known_hexachords = [
+        "6-1	[0,1,2,3,4,5]	Chromatic hexachord",
+        "6-7	[0,1,2,6,7,8]	Two-semitone tritone scale",
+        "6-Z17A	[0,1,2,4,7,8]	All-trichord hexachord",
+        "6-20	[0,1,4,5,8,9]	Augmented scale, Ode-to-Napoleon hexachord",
+        "6-Z24A	[0,1,3,4,6,8]	Minor major eleventh chord",
+        "6-Z24B	[0,2,4,5,7,8]	Half-diminished eleventh chord",
+        "6-Z25A	[0,1,3,5,6,8]	Major eleventh chord",
+        "6-Z26	[0,1,3,5,7,8]	Major ninth sharp eleventh chord",
+        "6-27B	[0,2,3,5,6,9]	Diminished eleventh chord",
+        "6-Z28	[0,1,3,5,6,9]	Augmented major eleventh chord",
+        "6-Z29	[0,2,3,6,7,9]	Bridge chord",
+        "6-30B	[0,2,3,6,8,9]	Petrushka chord, tritone scale",
+        "6-32	[0,2,4,5,7,9]	Diatonic hexachord, minor eleventh chord",
+        "6-33B	[0,2,4,6,7,9]	Dominant eleventh chord",
+        "6-34A	[0,1,3,5,7,9]	Mystic chord",
+        "6-34B	[0,2,4,6,8,9]	Augmented eleventh chord, dominant sharp eleventh chord, Prélude chord",
+        "6-35	[0,2,4,6,8,T]	Whole tone scale",
+        "6-Z44A	[0,1,2,5,6,9]	Schoenberg hexachord",
+        "6-Z46A	[0,1,2,4,6,9]	Scale of harmonics",
+        "6-Z47B	[0,2,3,4,7,9]	Blues scale"]
+    _base_sequence = None
+    _realizations = []
+
+    def generate_chord_sequence_from_midi_pitches(self, list_of_mp, intrvl="P5"):
+        return self.generate_base_sequence([note.Note(mp).nameWithOctave for mp in list_of_mp], intrvl=intrvl)
+
+    def generate_base_sequence(self, six_notes, intrvl="P5"):
+        fifth = interval.Interval(intrvl)  # Perfect fifth
+        all_pc = [n.pitch.pitchClass for n in six_notes]
+        all_chords = []
+        for n in six_notes:
+            ch = chord.Chord([n])
+            current_note = n
+            while len(ch) < 6:
+                current_note = fifth.transposeNote(current_note)
+                if current_note.pitch.pitchClass in all_pc and current_note not in ch:
+                    while interval.Interval(noteStart=ch[-1], noteEnd=current_note).semitones > (12 + 7):
+                        current_note = current_note.transpose(-12)
+                    ch.add(current_note)
+            all_chords.append(ch)
+        self._base_sequence = all_chords
+        return all_chords
+
+    def generate_3_chords_realizations(self, chord_seq):
+        # lower each of the top to notes by 2 ocatves
+        res1 = []
+        res2 = []
+        res3 = []
+        for ch in chord_seq:
+            new_ch = chord.Chord()
+            for i, n in enumerate(ch.notes):
+                if i == 4 or i == 5:
+                    new_ch.add(n.transpose(-24))
+                else:
+                    new_ch.add(n)
+            res1.append(new_ch)
+        for ch in chord_seq:
+            new_ch = chord.Chord()
+            for i, n in enumerate(ch.notes):
+                if i == 4 or i == 5:
+                    new_ch.add(n.transpose(-24))
+                elif i == 3:
+                    new_ch.add(n.transpose(-12))
+                else:
+                    new_ch.add(n)
+            res2.append(new_ch)
+        for ch in chord_seq:
+            new_ch = chord.Chord()
+            for i, n in enumerate(ch.notes):
+                if i == 4 or i == 5:
+                    new_ch.add(n.transpose(-24))
+                elif i == 3 or i == 2:
+                    new_ch.add(n.transpose(-12))
+                else:
+                    new_ch.add(n)
+            res3.append(new_ch)
+        self._realizations =  res1, res2, res3
+        return self._realizations
+
+    def chords_to_m21(self, chords):
+        s = stream.Stream()
+        s.append(meter.TimeSignature("4/4"))
+        for c in chords:
+            ch = chord.Chord(c)
+            ch.duration.quarterLength = 4
+            s.append(ch)
+        return s
+
+    def chords_to_m21_voices(self, chords):
+        s = stream.Stream()
+        s.append(meter.TimeSignature("4/4"))
+        for i_chord, c in enumerate(chords):
+            for chord_note in c:
+                n = note.Note(chord_note.pitch)
+                n.duration.quarterLength = 4
+                s.insert(i_chord * 4, n)
+        return s
+
+    def save_chords_to_midi_file(self, chords, file_name):
+        m21 = self.chords_to_m21_voices(chords)
+        m21.write('midi', file_name)
+        return file_name
+
+    def alternate_chords(self, s1, s2):
+        """Create a new stream alternating between chords from s1 and s2"""
+        new_stream = stream.Stream()
+
+        # Get chords from both streams
+        chords1 = list(s1.getElementsByClass(chord.Chord))
+        chords2 = list(s2.getElementsByClass(chord.Chord))
+
+        # Interleave chords from s1 and s2
+        for c1, c2 in zip(chords1, chords2):
+            new_stream.append(c1)
+            new_stream.append(c2)
+        return new_stream
+
+    def optimize_voice_leading(self, chord_sequence):
+        model = cp_model.CpModel()
+        octave_variables = {}
+        movement_vars = []
+
+        # Define variables and domains (allowing octave shifts)
+        for i, ch in enumerate(chord_sequence):
+            for n in ch.notes:
+                var_name = f"chord_{i}_note_{n.nameWithOctave}"
+                octave_variables[var_name] = model.NewIntVar(n.octave - 1, n.octave + 1,
+                                                             var_name)  # Allow octave shifts
+        spread_vars = []
+        # Add constraints to minimize movement between chords
+        for i in range(len(chord_sequence) - 1):
+            max_octave = model.NewIntVar(0, 10, "max_pitch" + str(i))
+            min_octave = model.NewIntVar(0, 10, "min_pitch" + str(i))
+            for n in chord_sequence[i]:
+                v = octave_variables[f"chord_{i}_note_{n.nameWithOctave}"]
+                # model.Add(max_pitch >= v)  # max_pitch must be at least as high as any note
+                # model.Add(min_pitch <= v)  # min_pitch must
+            spread_var = max_octave - min_octave
+            spread_vars.append(spread_var)
+        for i in range(len(chord_sequence) - 1):
+            for n1, n2 in zip(chord_sequence[i].notes, chord_sequence[i + 1].notes):
+                var1 = octave_variables[f"chord_{i}_note_{n1.nameWithOctave}"]
+                var2 = octave_variables[f"chord_{i + 1}_note_{n2.nameWithOctave}"]
+                # Define movement variable
+                movement_var = model.NewIntVar(0, 36, f"movement_{i}_{n1.name}")
+                model.AddAbsEquality(movement_var, var2 - var1)
+                # Track movement variable in objective function
+                movement_vars.append(movement_var)
+        # Define objective: minimize sum of all movement values
+        model.Minimize(sum(spread_vars))
+        # obj_var = sum(movement_vars)
+        # model.Minimize(obj_var)
+        # Solve
+        solver = cp_model.CpSolver()
+        solver.Solve(model)
+        # print(solver.Value(obj_var))
+        # for v in variables:
+        #     print(v)
+        #     print(variables[v].Proto().domain)
+        #     print(solver.Value(variables[v]))
+        # Apply changes to music21 chord sequence
+        optimized_chords = []
+        for i, ch in enumerate(chord_sequence):
+            new_chord = chord.Chord(
+                [note.Note(f"{n.name}{solver.Value(octave_variables[f'chord_{i}_note_{n.nameWithOctave}'])}")
+                 for n in ch.notes])
+            optimized_chords.append(new_chord)
+
+        return optimized_chords
+
+
+if __name__ == '__main__':
+    hexa = Hexachord()
+    note_names = ["C3", "Eb3", "E3", "F#3", "G3", "Bb3"]
+    notes = [note.Note(n) for n in note_names]
+    cs1 = hexa.generate_base_sequence(notes, intrvl="P4")
+    # cs1 = generate_chord_sequence(["E3", "G3", "Ab3", "B3", "C4", "Eb4"])
+    # cs2 = generate_chord_sequence(["C3", "F3", "F#3", "A3", "B4", "E4"])
+    # alternation = alternate_chords(cs1, cs2)
+    # alternation.write('midi',"alternation.mid")
+
+    hexa.save_chords_to_midi_file(cs1, 'temp.mid')
+    # optimized = optimize_voice_leading([c1, c2, c3])
+    optimized = hexa.optimize_voice_leading(cs1)
+    stream1 = stream.Stream(optimized)
+    stream1.show('text')
+    # stream1.write('midi', "optimized.mid")