Upload TMIDIX.py

TMIDIX.py

@@ -51,7 +51,7 @@ r'''############################################################################
 
 ###################################################################################
 
-__version__ = "25.4.11"
+__version__ = "25.4.30"
 
 print('=' * 70)
 print('TMIDIX Python module')
@@ -3874,7 +3874,7 @@ def fix_monophonic_score_durations(monophonic_score):
         nmt = monophonic_score[i+1][1]
 
         if note[1]+note[2] >= nmt:
-          note_dur = nmt-note[1]-1
+          note_dur = max(1, nmt-note[1]-1)
         else:
           note_dur = note[2]
 
@@ -3892,7 +3892,7 @@ def fix_monophonic_score_durations(monophonic_score):
         nmt = monophonic_score[i+1][0]
 
         if note[0]+note[1] >= nmt:
-          note_dur = nmt-note[0]-1
+          note_dur = max(1, nmt-note[0]-1)
         else:
           note_dur = note[1]
 
@@ -11338,13 +11338,27 @@ def system_memory_utilization(return_dict=False):
 
 ###################################################################################
 
+def system_cpus_utilization(return_dict=False):
+
+    if return_dict:
+        return {'num_cpus': psutil.cpu_count(),
+                'cpus_util': psutil.cpu_percent()
+                }
+
+    else:
+        print('Number of CPUs:', psutil.cpu_count())
+        print('CPUs utilization:', psutil.cpu_percent())
+
+###################################################################################
+
 def create_files_list(datasets_paths=['./'],
                       files_exts=['.mid', '.midi', '.kar', '.MID', '.MIDI', '.KAR'],
-                      use_md5_hashes=False,
                       max_num_files_per_dir=-1,
                       randomize_dir_files=False,
                       max_total_files=-1,
                       randomize_files_list=True,
+                      check_for_dupes=False,
+                      use_md5_hashes=False,
                       return_dupes=False,
                       verbose=True
                      ):
@@ -11360,8 +11374,13 @@ def create_files_list(datasets_paths=['./'],
     filez_set = defaultdict(None)
     dupes_list = []
  
-    for dataset_addr in tqdm.tqdm(datasets_paths, disable=not verbose):
-        for dirpath, dirnames, filenames in os.walk(dataset_addr):
+    for dataset_addr in datasets_paths:
+        
+        print('=' * 70)
+        print('Processing', dataset_addr)
+        print('=' * 70)
+        
+    for dirpath, dirnames, filenames in tqdm.tqdm(os.walk(dataset_addr), disable=not verbose):
             
             if randomize_dir_files:
                 random.shuffle(filenames)
@@ -11374,22 +11393,27 @@ def create_files_list(datasets_paths=['./'],
                 
             for file in filenames[:max_num_files]:
                 if file.endswith(files_exts):
-                    if use_md5_hashes:
-                        md5_hash = hashlib.md5(open(os.path.join(dirpath, file), 'rb').read()).hexdigest()
-                        
-                        if md5_hash not in filez_set:
-                            filez_set[md5_hash] = os.path.join(dirpath, file)
-                        
+                    if check_for_dupes:
+                    
+                        if use_md5_hashes:
+                            md5_hash = hashlib.md5(open(os.path.join(dirpath, file), 'rb').read()).hexdigest()
+                            
+                            if md5_hash not in filez_set:
+                                filez_set[md5_hash] = os.path.join(dirpath, file)
+                            
+                            else:
+                                dupes_list.append(os.path.join(dirpath, file))
+                                
                         else:
-                            dupes_list.append(os.path.join(dirpath, file))
+                            if file not in filez_set:
+                                filez_set[file] = os.path.join(dirpath, file)
                             
+                            else:
+                                dupes_list.append(os.path.join(dirpath, file))
                     else:
-                        if file not in filez_set:
-                            filez_set[file] = os.path.join(dirpath, file)
-                        
-                        else:
-                            dupes_list.append(os.path.join(dirpath, file))                           
-                        
+                        fpath = os.path.join(dirpath, file)
+                        filez_set[fpath] = fpath                              
+
     filez = list(filez_set.values())
 
     if verbose:
@@ -12847,7 +12871,7 @@ def convert_escore_notes_pitches_chords_signature(signature, convert_to_full_cho
 
     pitches_counts = [c for c in signature if -1 < c[0] < 128]
     chords_counts = [c for c in signature if 127 < c[0] < len(SRC_CHORDS)+128]
-    drums_counts = [[c[0]-cdiff, c[1]] for c in signature if len(SRC_CHORDS)+127 < c[0] < len(SRC_CHORDS)+256]
+    drums_counts = [[c[0]+cdiff, c[1]] for c in signature if len(SRC_CHORDS)+127 < c[0] < len(SRC_CHORDS)+256]
     bad_chords_count = [c for c in signature if c[0] == -1]
 
     new_chords_counts = []
@@ -12865,6 +12889,157 @@ def convert_escore_notes_pitches_chords_signature(signature, convert_to_full_cho
 
 ###################################################################################
 
+def convert_bytes_in_nested_list(lst, encoding='utf-8', errors='ignore'):
+    
+    new_list = []
+    
+    for item in lst:
+        if isinstance(item, list):
+            new_list.append(convert_bytes_in_nested_list(item))
+            
+        elif isinstance(item, bytes):
+            new_list.append(item.decode(encoding, errors=errors))
+            
+        else:
+            new_list.append(item)
+            
+    return new_list
+
+###################################################################################
+
+def mult_pitches(pitches, min_oct=4, max_oct=6):
+    
+    tones_chord = sorted(set([p % 12 for p in pitches]))
+
+    mult_ptcs = []
+
+    for t in tones_chord:
+        for i in range(min_oct, max_oct):
+            mult_ptcs.append((i*12)+t)
+
+    return mult_ptcs
+
+###################################################################################
+
+def find_next(pitches, cur_ptc):
+
+    i = 0
+
+    for i, p in enumerate(pitches):
+        if p != cur_ptc:
+            break
+
+    return i
+
+###################################################################################
+
+def ordered_groups(data, key_index):
+   
+    def keyfunc(sublist):
+        return sublist[key_index]
+    
+    groups = []
+    
+    for key, group in groupby(data, key=keyfunc):
+        groups.append((key, list(group)))
+        
+    return groups
+
+###################################################################################
+
+def merge_melody_notes(escore_notes, pitches_idx=4, max_dur=255):
+
+    groups = ordered_groups(escore_notes, pitches_idx)
+
+    merged_melody_notes = []
+
+    for i, (k, g) in enumerate(groups[:-1]):
+        
+        if len(g) == 1:
+            merged_melody_notes.extend(g)
+
+        else:
+            dur = min(max_dur, groups[i+1][1][0][1] - g[0][1])
+            
+            merged_melody_notes.append(['note',
+                                        g[0][1],
+                                        dur,
+                                        g[0][3],
+                                        g[0][4],
+                                        g[0][5],
+                                        g[0][6]
+                                        ])
+            
+    return merged_melody_notes
+
+###################################################################################
+
+def add_expressive_melody_to_enhanced_score_notes(escore_notes,
+                                                  melody_start_chord=0,
+                                                  melody_notes_max_duration=255,
+                                                  melody_channel=3,
+                                                  melody_patch=40,
+                                                  melody_max_velocity=120,
+                                                  acc_max_velocity=90,
+                                                  return_melody=False
+                                                  ):
+
+
+    score = copy.deepcopy(escore_notes)
+
+    adjust_score_velocities(score, acc_max_velocity)
+
+    cscore = chordify_score([1000, score])
+
+    melody_pitches = [72]
+    
+    for i, c in enumerate(cscore[melody_start_chord:]):
+        
+        pitches = [e[4] for e in c if e[3] != 9]
+    
+        if pitches:
+            cptc = find_closest_value(mult_pitches(pitches), melody_pitches[-1])[0]
+            melody_pitches.append(cptc)
+    
+    song_f = []
+    mel_f = []
+    
+    idx = 1
+    
+    for i, c in enumerate(cscore[:-1]):
+        pitches = [e[4] for e in c if e[3] != 9]
+    
+        if pitches and i >= melody_start_chord:
+            dur = min(cscore[i+1][0][1] - c[0][1], melody_notes_max_duration)
+            
+            mel_f.append(['note', 
+                          c[0][1], 
+                          dur, 
+                          melody_channel, 
+                          60+(melody_pitches[idx] % 24), 
+                          100 + ((melody_pitches[idx] % 12) * 2), 
+                          melody_patch
+                         ])
+            idx += 1
+            
+        song_f.extend(c)
+
+    song_f.extend(cscore[-1])
+
+    adjust_score_velocities(mel_f, melody_max_velocity)
+    
+    song_f = sorted(merge_melody_notes(mel_f, max_dur=melody_notes_max_duration) + song_f,
+                    key=lambda x: x[1]
+                    )
+
+    if return_melody:
+        return mel_f
+
+    else:
+        return song_f
+
+###################################################################################
+
 print('Module loaded!')
 print('=' * 70)
 print('Enjoy! :)')