Update app.py

app.py

@@ -26,343 +26,103 @@ in_space = os.getenv("SYSTEM") == "spaces"
 
 #==========================================================================================================
 
-def match_midi(midi, max_match_ratio, progress=gr.Progress()):
+def find_midi(title, artist):
   
     print('=' * 70)
     print('Loading MIDI file...')
     
     #==================================================
     
-    score = MIDI.midi2score(midi)
+    print('Searching titles...Please wait...')
+    random.shuffle(AUX_DATA)
     
-    events_matrix = []
+    titles_index = []
     
-    track_count = 0
+    for A in AUX_DATA:
+      titles_index.append(A[0])
     
-    for s in score:
+    search_string = ''
     
-        if track_count > 0:
-            track = s
-            track.sort(key=lambda x: x[1])
-            events_matrix.extend(track)
-        else:
-            midi_ticks = s
+    if enter_desired_song_title != '' and enter_desired_artist != '':
+      search_string = enter_desired_song_title + ' --- ' + enter_desired_artist
     
-        track_count += 1
+    else:
+      search_string = enter_desired_song_title + enter_desired_artist
     
-    events_matrix.sort(key=lambda x: x[1])
+    search_match = process.extract(query=search_string, choices=titles_index, limit=1)
+    search_index = titles_index.index(search_match[0][0])
     
-    mult_pitches_counts = []
-    
-    for i in range(-6, 6):
-    
-      events_matrix1 = []
-    
-      for e in events_matrix:
-    
-        ev = copy.deepcopy(e)
-    
-        if e[0] == 'note':
-            if e[3] == 9:
-                ev[4] = ((e[4] % 128) + 128)
-            else:
-              ev[4] = ((e[4] % 128) + i)
-    
-            events_matrix1.append(ev)
-    
-      pitches_counts = [[y[0],y[1]] for y in Counter([y[4] for y in events_matrix1 if y[0] == 'note']).most_common()]
-      pitches_counts.sort(key=lambda x: x[0], reverse=True)
-    
-      mult_pitches_counts.append(pitches_counts)
-    
-    patches_list = sorted(list(set([y[3] for y in events_matrix if y[0] == 'patch_change'])))
-    
-    
-    #==================================================
-    
-    ms_score = MIDI.midi2ms_score(midi)
-    
-    ms_events_matrix = []
-    
-    itrack1 = 1
-    
-    while itrack1 < len(ms_score):
-        for event in ms_score[itrack1]:
-            if event[0] == 'note':
-                ms_events_matrix.append(event)
-        itrack1 += 1
-    
-    ms_events_matrix.sort(key=lambda x: x[1])
-    
-    
-    chords = []
-    pe = ms_events_matrix[0]
-    cho = []
-    for e in ms_events_matrix:
-        if (e[1] - pe[1]) == 0:
-          if e[3] != 9:
-            if (e[4] % 12) not in cho:
-              cho.append(e[4] % 12)
-        else:
-          if len(cho) > 0:
-            chords.append(sorted(cho))
-          cho = []
-          if e[3] != 9:
-            if (e[4] % 12) not in cho:
-              cho.append(e[4] % 12)
-    
-        pe = e
-    
-    if len(cho) > 0:
-        chords.append(sorted(cho))
-    
-    ms_chords_counts = sorted([[list(key), val] for key,val in Counter([tuple(c) for c in chords if len(c) > 1]).most_common()], reverse=True, key = lambda x: x[1])
-    
-    times = []
-    pt = ms_events_matrix[0][1]
-    start = True
-    for e in ms_events_matrix:
-        if (e[1]-pt) != 0 or start == True:
-            times.append((e[1]-pt))
-            start = False
-        pt = e[1]
-    
-    durs = [e[2] for e in ms_events_matrix]
-    vels = [e[5] for e in ms_events_matrix]
-    
-    avg_time = int(sum(times) / len(times))
-    avg_dur = int(sum(durs) / len(durs))
-    
-    mode_time = statistics.mode(times)
-    mode_dur = statistics.mode(durs)
-    
-    median_time = int(statistics.median(times))
-    median_dur = int(statistics.median(durs))
-    
-    #==================================================
-    
-    print('=' * 70)
     print('Done!')
     print('=' * 70)
-    
-    #==========================================================================================================
+    print('Selected title:', AUX_DATA[search_index][0])
+    print('=' * 70)
 
-    #@title MIDI Pitches Search
+    outy = AUX_DATA[search_index][1]
 
-    #@markdown Match ratio control option
-    
-    maximum_match_ratio_to_search_for = max_match_ratio #@param {type:"slider", min:0, max:1, step:0.01}
-    
-    #@markdown MIDI pitches search options
-    
-    pitches_counts_cutoff_threshold_ratio = 0 #@param {type:"slider", min:0, max:1, step:0.05}
-    search_transposed_pitches = False #@param {type:"boolean"}
-    skip_exact_matches = False #@param {type:"boolean"}
-    
-    #@markdown Additional search options
-    
-    add_pitches_counts_ratios = False #@param {type:"boolean"}
-    add_timings_ratios = False #@param {type:"boolean"}
-    add_durations_ratios = False #@param {type:"boolean"}
-    
-    print('=' * 70)
-    print('MIDI Pitches Search')
+    print('Sample INTs', outy[:12])
     print('=' * 70)
     
-    final_ratios = []
-    
-    for d in progress.tqdm(meta_data):
-    
-
-        p_counts = d[1][10][1]
-        p_counts.sort(reverse = True, key = lambda x: x[1])
-        max_p_count = p_counts[0][1]
-        trimmed_p_counts = [y for y in p_counts if y[1] >= (max_p_count * pitches_counts_cutoff_threshold_ratio)]
-        total_p_counts = sum([y[1] for y in trimmed_p_counts])
-    
-        if search_transposed_pitches:
-          search_pitches = mult_pitches_counts
-        else:
-          search_pitches = [mult_pitches_counts[6]]
-    
-        #===================================================
-    
-        ratios_list = []
+    if len(outy) != 0:
     
-        #===================================================
+      song = outy
+      song_f = []
     
-        atrat = [0]
+      time = 0
+      dur = 0
+      vel = 90
+      pitch = 0
+      channel = 0
     
-        if add_timings_ratios:
+      patches = [-1] * 16
     
-          source_times = [avg_time,
-                          median_time,
-                          mode_time]
+      channels = [0] * 16
+      channels[9] = 1
     
-          match_times = meta_data[0][1][3][1]
+      for ss in song:
     
-          times_ratios = []
+          if 0 <= ss < 256:
     
-          for i in range(len(source_times)):
-            maxtratio = max(source_times[i], match_times[i])
-            mintratio = min(source_times[i], match_times[i])
-            times_ratios.append(mintratio / maxtratio)
+              time += ss * 16
     
-          avg_times_ratio = sum(times_ratios) / len(times_ratios)
+          if 256 <= ss < 2304:
     
-          atrat[0] = avg_times_ratio
+              dur = ((ss-256) // 8) * 16
+              vel = (((ss-256) % 8)+1) * 15
     
-        #===================================================
+          if 2304 <= ss < 18945:
     
-        adrat = [0]
+              patch = (ss-2304) // 129
     
-        if add_durations_ratios:
+              if patch < 128:
     
-          source_durs = [avg_dur,
-                          median_dur,
-                          mode_dur]
+                  if patch not in patches:
+                    if 0 in channels:
+                        cha = channels.index(0)
+                        channels[cha] = 1
+                    else:
+                        cha = 15
     
-          match_durs = meta_data[0][1][4][1]
+                    patches[cha] = patch
+                    channel = patches.index(patch)
+                  else:
+                    channel = patches.index(patch)
     
-          durs_ratios = []
+              if patch == 128:
+                  channel = 9
     
-          for i in range(len(source_durs)):
-            maxtratio = max(source_durs[i], match_durs[i])
-            mintratio = min(source_durs[i], match_durs[i])
-            durs_ratios.append(mintratio / maxtratio)
+              pitch = (ss-2304) % 129
     
-          avg_durs_ratio = sum(durs_ratios) / len(durs_ratios)
+              song_f.append(['note', time, dur, channel, pitch, vel, patch ])
     
-          adrat[0] = avg_durs_ratio
+    patches = [0 if x==-1 else x for x in patches]
     
-        #===================================================
-    
-        for m in search_pitches:
-    
-          sprat = []
-    
-          m.sort(reverse = True, key = lambda x: x[1])
-          max_pitches_count = m[0][1]
-          trimmed_pitches_counts = [y for y in m if y[1] >= (max_pitches_count * pitches_counts_cutoff_threshold_ratio)]
-          total_pitches_counts = sum([y[1] for y in trimmed_pitches_counts])
-    
-          same_pitches = set([T[0] for T in trimmed_p_counts]) & set([m[0] for m in trimmed_pitches_counts])
-          num_same_pitches = len(same_pitches)
-    
-          if num_same_pitches == len(trimmed_pitches_counts):
-            same_pitches_ratio = (num_same_pitches / len(trimmed_p_counts))
-          else:
-            same_pitches_ratio = (num_same_pitches / max(len(trimmed_p_counts), len(trimmed_pitches_counts)))
-    
-          if skip_exact_matches:
-            if same_pitches_ratio == 1:
-              same_pitches_ratio = 0
-    
-          sprat.append(same_pitches_ratio)
-    
-          #===================================================
-    
-          spcrat = [0]
-    
-          if add_pitches_counts_ratios:
-    
-            same_trimmed_p_counts = sorted([T for T in trimmed_p_counts if T[0] in same_pitches], reverse = True)
-            same_trimmed_pitches_counts = sorted([T for T in trimmed_pitches_counts if T[0] in same_pitches], reverse = True)
-    
-            same_trimmed_p_counts_ratios = [[s[0], s[1] / total_p_counts] for s in same_trimmed_p_counts]
-            same_trimmed_pitches_counts_ratios = [[s[0], s[1] / total_pitches_counts] for s in same_trimmed_pitches_counts]
-    
-            same_pitches_counts_ratios = []
-    
-            for i in range(len(same_trimmed_p_counts_ratios)):
-              mincratio = min(same_trimmed_p_counts_ratios[i][1], same_trimmed_pitches_counts_ratios[i][1])
-              maxcratio = max(same_trimmed_p_counts_ratios[i][1], same_trimmed_pitches_counts_ratios[i][1])
-              same_pitches_counts_ratios.append([same_trimmed_p_counts_ratios[i][0], mincratio / maxcratio])
-    
-            same_counts_ratios = [s[1] for s in same_pitches_counts_ratios]
-    
-            if len(same_counts_ratios) > 0:
-              avg_same_pitches_counts_ratio = sum(same_counts_ratios) / len(same_counts_ratios)
-            else:
-              avg_same_pitches_counts_ratio = 0
-    
-            spcrat[0] = avg_same_pitches_counts_ratio
-    
-          #===================================================
-    
-          r_list = [sprat[0]]
-    
-          if add_pitches_counts_ratios:
-            r_list.append(spcrat[0])
-    
-          if add_timings_ratios:
-            r_list.append(atrat[0])
-    
-          if add_durations_ratios:
-            r_list.append(adrat[0])
-    
-          ratios_list.append(r_list)
-    
-        #===================================================
-    
-        avg_ratios_list = []
-    
-        for r in ratios_list:
-          avg_ratios_list.append(sum(r) / len(r))
-    
-        #===================================================
-    
-        final_ratio = max(avg_ratios_list)
-    
-        if final_ratio > maximum_match_ratio_to_search_for:
-            final_ratio = 0
-    
-        final_ratios.append(final_ratio)
-    
-        #===================================================
-    
-    max_ratio = max(final_ratios)
-    max_ratio_index = final_ratios.index(max_ratio)
-    
-    print('FOUND')
-    print('=' * 70)
-    print('Match ratio', max_ratio)
-    print('MIDI file name', meta_data[max_ratio_index][0])
-    print('=' * 70)
-    
-    fn = meta_data[max_ratio_index][0]
-
-    #==========================================================================================================
-
-    md = meta_data[max_ratio_index]
-
-    mid_seq = md[1][17:-1]
-    mid_seq_ticks = md[1][16][1]
-    mdata = md[1][:16]
-
-    txt_mdata = ''
+    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,
+                                                            output_signature = 'Giant Music Transformer',
+                                                            output_file_name = '/content/Giant-Music-Transformer-Music-Composition_'+str(i),
+                                                            track_name='Project Los Angeles',
+                                                            list_of_MIDI_patches=patches
+                                                            )
 
-    txt_mdata += '==============================================================' + chr(10)
-    txt_mdata += 'MIDI MATCH RATIO: ' + str(max_ratio) + chr(10)
-    txt_mdata += '==============================================================' + chr(10)
-    txt_mdata += 'MIDI MATCH MD5 HASH: ' + str(fn) + chr(10)
-    txt_mdata += '==============================================================' + chr(10)
-
-    for m in mdata:
-        txt_mdata += str(m[0]) + ': ' + str(m[1])
-        txt_mdata += chr(10)
-
-    txt_mdata += '==============================================================' + chr(10)
-
-    for m in [d for d in md[1][16:] if d[0] != 'note']:
-        txt_mdata += str(m)
-        txt_mdata += chr(10)
-
-    txt_mdata += '==============================================================' + chr(10)
-    txt_mdata += 'MIDI MATCH RATIO: ' + str(max_ratio) + chr(10)
-    txt_mdata += '==============================================================' + chr(10)
-    txt_mdata += 'MIDI MATCH MD5 HASH: ' + str(fn) + chr(10)
-    txt_mdata += '==============================================================' + chr(10)
     
     x = []
     y = []
@@ -425,9 +185,8 @@ if __name__ == "__main__":
 
         gr.Markdown("# Upload MIDI")
 
-        maximum_match_ratio = gr.Slider(0.5, 1, value=1.0, label="Maximum match ratio to search for", info="Lower this value to see less precise matches")
-        
-        input_midi = gr.File(label="Input MIDI", file_types=[".midi", ".mid", ".kar"], type="binary")
+        artist = gr.Textbox()
+        title = gr.Textbox()
 
         gr.Markdown("# Match results")