Update app.py

app.py

@@ -65,197 +65,50 @@ def GenerateGroove():
 
     print('Done!')
     print('=' * 70)
-
-    fn = os.path.basename(input_midi.name)
-    fn1 = fn.split('.')[0]
-
-    input_num_tokens = max(4, min(128, input_num_tokens))
-
-    print('-' * 70)
-    print('Input file name:', fn)
-    print('Req num toks:', input_num_tokens)
-    print('Conditioning type:', input_conditioning_type)
-    print('Strip notes:', input_strip_notes)
-    print('-' * 70)
-
-    #===============================================================================
-    raw_score = TMIDIX.midi2single_track_ms_score(input_midi.name)
     
-    #===============================================================================
-    # Enhanced score notes
-    
-    escore_notes = TMIDIX.advanced_score_processor(raw_score, return_enhanced_score_notes=True)[0]
+    print('Loading Google Magenta Groove processed MIDIs...')
+    all_scores = TMIDIX.Tegridy_Any_Pickle_File_Reader('Google_Magenta_Groove_8675_Select_Processed_MIDIs')
+
+    print('Done!')
+    print('=' * 70)
     
-    no_drums_escore_notes = [e for e in escore_notes if e[6] < 80]
+    print('=' * 70)
     
-    if len(no_drums_escore_notes) > 0:
+    drums_score_idx = random.randint(0, len(all_scores))
+    drums_score_fn = all_scores[drums_score_idx][0]
+    drums_score = all_scores[drums_score_idx][1]
     
-        #=======================================================
-        # PRE-PROCESSING
-        
-        #===============================================================================
-        # Augmented enhanced score notes
-        
-        no_drums_escore_notes = TMIDIX.augment_enhanced_score_notes(no_drums_escore_notes)
-        
-        cscore = TMIDIX.chordify_score([1000, no_drums_escore_notes])
-        
-        clean_cscore = []
-        
-        for c in cscore:
-            pitches = []
-            cho = []
-            for cc in c:
-                if cc[4] not in pitches:
-                    cho.append(cc)
-                    pitches.append(cc[4])
-        
-            clean_cscore.append(cho)
-        
-        #=======================================================
-        # FINAL PROCESSING
-        
-        melody_chords = []
-        chords = []
-        times = [0]
-        durs = []
-        
-        #=======================================================
-        # MAIN PROCESSING CYCLE
-        #=======================================================
-        
-        pe = clean_cscore[0][0]
-        
-        first_chord = True
-        
-        for c in clean_cscore:
-        
-            # Chords
-        
-            c.sort(key=lambda x: x[4], reverse=True)
-        
-            tones_chord = sorted(set([cc[4] % 12 for cc in c]))
-        
-            try:
-                chord_token = TMIDIX.ALL_CHORDS_SORTED.index(tones_chord)
-            except:
-                checked_tones_chord = TMIDIX.check_and_fix_tones_chord(tones_chord)
-                chord_token = TMIDIX.ALL_CHORDS_SORTED.index(checked_tones_chord)
-        
-            melody_chords.extend([chord_token+384])
-        
-            if input_strip_notes:
-              if len(tones_chord) > 1:
-                chords.extend([chord_token+384])
-        
-            else:
-              chords.extend([chord_token+384])
-        
-            if first_chord:
-                    melody_chords.extend([0])
-                    first_chord = False
-        
-            for e in c:
-        
-                #=======================================================
-                # Timings...
-        
-                time = e[1]-pe[1]
-        
-                dur = e[2]
-        
-                if time != 0 and time % 2 != 0:
-                    time += 1
-                if dur % 2 != 0:
-                    dur += 1
-        
-                delta_time = int(max(0, min(255, time)) / 2)
-        
-                # Durations
-        
-                dur = int(max(0, min(255, dur)) / 2)
-        
-                # Pitches
-        
-                ptc = max(1, min(127, e[4]))
-        
-                #=======================================================
-                # FINAL NOTE SEQ
-        
-                # Writing final note asynchronously
-        
-                if delta_time != 0:
-                    melody_chords.extend([delta_time, dur+128, ptc+256])
-                    if input_strip_notes:
-                      if len(c) > 1:
-                        times.append(delta_time)
-                        durs.append(dur+128)
-                    else:
-                        times.append(delta_time)
-                        durs.append(dur+128)
-                else:
-                    melody_chords.extend([dur+128, ptc+256])
-        
-                pe = e
-        
+    print('Drums score index', drums_score_idx)
+    print('Drums score name', drums_score_fn)
+    print('Drums score length', len(drums_score))
+    print('=' * 70)
+
     #==================================================================
 
     print('=' * 70)
     
-    print('Sample output events', melody_chords[:5])
+    print('Sample input events', drums_score[:5])
     print('=' * 70)
     print('Generating...')
 
-    output = []
+    num_prime_chords = 7
+    
+    outy = []
     
-    max_chords_limit = 8
-    temperature=0.9
-    num_memory_tokens=4096
+    for d in drums_score[:num_prime_chords]:
 
-    output = []
+        outy.extend(d)
     
-    idx = 0
+    for i in tqdm.tqdm(range(num_prime_chords, len(drums_score))):
     
-    for c in chords[:input_num_tokens]:
-     
-        output.append(c)
+        outy.extend(drums_score[i])
     
-        if input_conditioning_type == 'Chords-Times' or input_conditioning_type == 'Chords-Times-Durations':
-          output.append(times[idx])
+        if i == num_prime_chords:
+          outy.append(256+8)
     
-        if input_conditioning_type == 'Chords-Times-Durations':
-          output.append(durs[idx])
-
-        x = torch.tensor([output] * 1, dtype=torch.long, device='cuda')
-        
-        o = 0
-        
-        ncount = 0
-        
-        while o < 384 and ncount < max_chords_limit:
-          with ctx:
-            out = model.generate(x[-num_memory_tokens:],
-                                1,
-                                temperature=temperature,
-                                return_prime=False,
-                                verbose=False)
-        
-          o = out.tolist()[0][0]
-        
-          if 256 <= o < 384:
-            ncount += 1
-        
-          if o < 384:
-            x = torch.cat((x, out), 1)
-        
-        outy =  x.tolist()[0][len(output):]
-          
-        output.extend(outy)
+        out = generate_chords(outy)
     
-        idx += 1
-
-        if idx == len(chords[:input_num_tokens])-1:
-            break
+        outy.extend(out)
 
     print('=' * 70)
     print('Done!')