app.py

#=========================================================================
# https://huggingface.co/spaces/asigalov61/Parsons-Code-Melody-Transformer
#=========================================================================

import time as reqtime
import datetime
from pytz import timezone

import copy

import gradio as gr

from x_transformer_1_23_2 import *
import random

from midi_to_colab_audio import midi_to_colab_audio
import TMIDIX

import matplotlib.pyplot as plt
    
# =================================================================================================

# =================================================================================================

def Generate_Melody(input_parsons_code, 
                   input_first_note_duration, 
                   iinput_first_note_MIDI_pitch,
                 ):
    
    print('=' * 70)
    print('Req start time: {:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now(PDT)))
    start_time = reqtime.time()

    print('-' * 70)
    print('Requested settings:')
    print('-' * 70)
    print('Parsons code:', input_parsons_code)
    print('First note duration:', input_first_note_duration)
    print('First note MIDI pitch:', iinput_first_note_MIDI_pitch)
    print('-' * 70)

    #===============================================================================
    raw_score = TMIDIX.midi2single_track_ms_score(input_midi.name)
    
    #===============================================================================
    # Enhanced score notes
    
    raw_escore = TMIDIX.advanced_score_processor(raw_score, return_enhanced_score_notes=True)[0]
    
    if len(raw_escore) > 0:
    
        #===============================================================================
        # Augmented enhanced score notes
        
        src_escore = TMIDIX.recalculate_score_timings(TMIDIX.augment_enhanced_score_notes([e for e in raw_escore if e[6] < 80]))

        src_cscore = TMIDIX.chordify_score([1000, src_escore])
        
        src_melody = [c[0] for c in src_cscore][:256]

        if input_transform == 'Flip Melody':
            src_melody = TMIDIX.flip_enhanced_score_notes(src_melody)
            
        elif input_transform == 'Reverse Melody':
            src_melody = TMIDIX.reverse_enhanced_score_notes(src_melody)

        mel_avg_time = TMIDIX.escore_notes_averages(src_melody)[0]
        
        src_melody_pitches = [p[4] for p in src_melody]
        
        src_harm_tones_chords = TMIDIX.harmonize_enhanced_melody_score_notes(src_melody)
        
        #===============================================================================
        
        matched_songs = [a for a in all_songs if a[2] == max(32, len(src_melody))]
        
        random.shuffle(matched_songs)

        max_match_ratio = -1
        max_match_ratios_count = len(matched_songs)

        if input_find_best_match:
            new_song, max_match_ratio, max_match_ratios_count = find_similar_song(matched_songs, src_melody)
        else:
            new_song = random.choice(matched_songs)
        
        print('Selected Monster Mono Melodies MIDI:', new_song[0])
        print('Selected melody match ratio:', max_match_ratio)
        print('Selected melody instrument:', TMIDIX.Number2patch[new_song[1]], '(', new_song[1], ')')
        print('Melody notes count:', new_song[2])
        print('Matched melodies pool count', max_match_ratios_count)
        
        MIDI_Summary = 'Selected Monster Mono Melodies MIDI: ' + str(new_song[0]) + '\n'
        MIDI_Summary += 'Selected melody match ratio: ' + str(max_match_ratio) + '\n'
        MIDI_Summary += 'Selected melody instrument: ' + str(TMIDIX.Number2patch[new_song[1]]) + ' (' + str(new_song[1]) + ')' + '\n'
        MIDI_Summary += 'Melody notes count: ' + str(new_song[2]) + '\n'
        MIDI_Summary += 'Matched melodies pool count: ' + str(max_match_ratios_count)

        fn1 += '_' + str(new_song[0]) + '_' + str(TMIDIX.Number2patch[new_song[1]]) + '_' + str(new_song[1]) + '_' + str(new_song[2])
        
        trg_patch = new_song[1]
        
        trg_song = copy.deepcopy(new_song[3])
        
        mix_avg_time = TMIDIX.escore_notes_averages(trg_song)[0]
        mix_mel_avg_time = TMIDIX.escore_notes_averages([e for e in trg_song if e[6] == trg_patch])[0]
        
        TMIDIX.adjust_score_velocities(trg_song, 95)
        
        cscore = TMIDIX.chordify_score([1000, trg_song])
        
        print('=' * 70)
        print('Done loading source and target MIDIs...!')
        print('=' * 70)
        print('Mixing...')

        mixed_song = []
        
        midx = 0
        next_note_dtime = 255
        
        for i, c in enumerate(cscore):
            cho = copy.deepcopy(c)
            
            patches = sorted(set([e[6] for e in c]))
            
            if trg_patch in patches:

                if input_adjust_melody_notes_durations:
                    if midx < len(src_melody)-1:
                        next_note_dtime = src_melody[midx+1][1] - src_melody[midx][1]
                    else:
                        next_note_dtime = 255
                    
                mixed_song.extend(mix_chord(c, src_harm_tones_chords[midx], trg_patch, src_melody_pitches[midx], next_note_dtime))
                
                midx += 1
            
            else:
                if input_adjust_accompaniment_notes_durations:
                    if i < len(cscore)-1:
                        next_note_dtime = cscore[i+1][0][1] - cscore[i][0][1]
                    else:
                        next_note_dtime = 255
                
                mixed_song.extend(mix_chord(cho, src_harm_tones_chords[midx], trg_patch, src_melody_pitches[midx], next_note_dtime))

            if midx == len(src_melody):
                break      

        print('=' * 70)
        print('Done!')
        print('=' * 70)

        #===============================================================================

        if input_output_as_solo_piano:
            
            csong = TMIDIX.chordify_score([1000, mixed_song])

            mixed_song = []

            for c in csong:
                
                pitches = [e[4] for e in c if e[6] == trg_patch]
                
                for cc in c:
                    
                    ccc = copy.deepcopy(cc)
                    
                    if cc[3] != 9: 
                        if cc[6] == trg_patch:
                            ccc[3] = 3
                            ccc[6] = 0
                            mixed_song.append(ccc)
                            
                        else:
                            if cc[4] not in pitches:
                                ccc[3] = 0
                                ccc[6] = 0
                                mixed_song.append(ccc)
                                pitches.append(cc[4])
            
                    else:
                        mixed_song.append(ccc)    
                    
        if input_remove_drums:
            mixed_song = [e for e in mixed_song if e[3] != 9]

        if input_output_tempo == 'Mix':
    
            time_k = mel_avg_time / mix_avg_time
    
            mixed_song = TMIDIX.adjust_escore_notes_timings(mixed_song, time_k)

        elif input_output_tempo == 'Source Melody':
            
            time_k = mel_avg_time / mix_mel_avg_time
    
            mixed_song = TMIDIX.adjust_escore_notes_timings(mixed_song, time_k)

        if input_transform == 'Flip Mix':
            mixed_song = TMIDIX.flip_enhanced_score_notes(mixed_song)
            
        elif input_transform == 'Reverse Mix':
            mixed_song = TMIDIX.reverse_enhanced_score_notes(mixed_song)        

        if input_transpose_value != 0:
            mixed_song = TMIDIX.transpose_escore_notes(mixed_song, input_transpose_value)

        if input_transpose_to_C4:
            mixed_song = TMIDIX.transpose_escore_notes_to_pitch(mixed_song)
            
        #===============================================================================
        print('Rendering results...')
        
        print('=' * 70)
        print('Sample INTs', mixed_song[:5])
        print('=' * 70)
        
        output_score, patches, overflow_patches = TMIDIX.patch_enhanced_score_notes(mixed_song)

        detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(output_score,
                                                                  output_signature = 'Harmonic Melody MIDI Mixer',
                                                                  output_file_name = fn1,
                                                                  track_name='Project Los Angeles',
                                                                  list_of_MIDI_patches=patches,
                                                                  timings_multiplier=16
                                                                  )
        
        new_fn = fn1+'.mid'
                
        
        audio = midi_to_colab_audio(new_fn, 
                            soundfont_path=soundfont,
                            sample_rate=16000,
                            volume_scale=10,
                            output_for_gradio=True
                            )
        
        print('Done!')
        print('=' * 70)
    
        #========================================================
    
        output_midi_title = str(fn1)
        output_midi_summary = str(MIDI_Summary)
        output_midi = str(new_fn)
        output_audio = (16000, audio)

        for o in output_score:
            o[1] *= 16
            o[2] *= 16
        
        output_plot = TMIDIX.plot_ms_SONG(output_score, plot_title=output_midi_title, return_plt=True)
    
        print('Output MIDI file name:', output_midi)
        print('Output MIDI title:', output_midi_title)
        print('Output MIDI summary:', MIDI_Summary)
        print('=' * 70) 
        
    
        #========================================================
        
        print('-' * 70)
        print('Req end time: {:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now(PDT)))
        print('-' * 70)
        print('Req execution time:', (reqtime.time() - start_time), 'sec')
    
        return output_midi_title, output_midi_summary, output_midi, output_audio, output_plot

# =================================================================================================

if __name__ == "__main__":
    
    PDT = timezone('US/Pacific')
    
    print('=' * 70)
    print('App start time: {:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now(PDT)))
    print('=' * 70)

    soundfont = "SGM-v2.01-YamahaGrand-Guit-Bass-v2.7.sf2"

    app = gr.Blocks()
    
    with app:
        
        gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>Parsons Code Melody Transformer</h1>")
        gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>Generate unique melodies from Parsons codes</h1>")
        gr.Markdown(
            "![Visitors](https://api.visitorbadge.io/api/visitors?path=asigalov61.Parsons-Code-Melody-Transformer&style=flat)\n\n"
            "This is a demo for Clean Melodies subset of Tegridy MIDI Dataset\n\n"
            "Check out [Tegridy MIDI Dataset](https://github.com/asigalov61/Tegridy-MIDI-Dataset) on GitHub!\n\n"
        )
        
        gr.Markdown("## Enter Parsons code below")
        
        input_parsons_code = gr.Textbox(label="Enter your Parsons code here",
                                        info="Make sure your code starts with *",
                                        lines=1,
                                        value="*",
                                        ),

        gr.Markdown("## Select generation options")
                
        input_first_note_duration = gr.Slider(1, 127, value=15, step=1, label="First note duration value")
        iinput_first_note_MIDI_pitch = gr.Slider(1, 127, value=60, step=1, label="First note MIDI pitch")
         
        run_btn = gr.Button("Generate melody", variant="primary")
        clear_btn = gr.ClearButton(components=[input_parsons_code])

        gr.Markdown("## Output results")

        output_midi_title = gr.Textbox(label="Output MIDI title")
        output_midi_summary = gr.Textbox(label="Output MIDI summary")
        output_audio = gr.Audio(label="Output MIDI audio", format="mp3", elem_id="midi_audio")
        output_plot = gr.Plot(label="Output MIDI score plot")
        output_midi = gr.File(label="Output MIDI file", file_types=[".mid"])

        run_event = run_btn.click(Generate_Melody, [input_parsons_code, 
                                                   input_first_note_duration, 
                                                   iinput_first_note_MIDI_pitch,
                                                  ],
                                                [output_midi_title, output_midi_summary, output_midi, output_audio, output_plot])

        gr.Examples(
            [["*UUUUUUUDDDDDDDUUUUUUUDDDDDDDUUUUUUUDDDDDDDUUUUUUUDDDDDDDUUUUUUU", 15, 60],
            ],
            [input_parsons_code, 
            input_first_note_duration, 
            iinput_first_note_MIDI_pitch,
            ],
            [output_midi_title, output_midi_summary, output_midi, output_audio, output_plot],
            Generate_Melody,
            cache_examples=True,
        )
        
        app.queue().launch()