Upload TMIDIX.py

TMIDIX.py

@@ -51,7 +51,7 @@ r'''############################################################################
 
 ###################################################################################
 
-__version__ = "25.7.8"
+__version__ = "25.9.22"
 
 print('=' * 70)
 print('TMIDIX Python module')
@@ -1485,10 +1485,13 @@ import multiprocessing
 
 from itertools import zip_longest
 from itertools import groupby
+from itertools import cycle
+from itertools import product
 
 from collections import Counter
 from collections import defaultdict
 from collections import OrderedDict
+from collections import deque
 
 from operator import itemgetter
 
@@ -1498,6 +1501,9 @@ from difflib import SequenceMatcher as SM
 
 import statistics
 import math
+from math import gcd
+
+from functools import reduce
 
 import matplotlib.pyplot as plt
 
@@ -3903,7 +3909,8 @@ def chordify_score(score,
 
 def fix_monophonic_score_durations(monophonic_score,
                                    min_notes_gap=1,
-                                   min_notes_dur=1
+                                   min_notes_dur=1,
+                                   extend_durs=False
                                    ):
   
     fixed_score = []
@@ -3918,7 +3925,11 @@ def fix_monophonic_score_durations(monophonic_score,
         if note[1]+note[2] >= nmt:
           note_dur = max(1, nmt-note[1]-min_notes_gap)
         else:
-          note_dur = note[2]
+            if extend_durs:
+                note_dur = max(1, nmt-note[1]-min_notes_gap)
+
+            else:
+                note_dur = note[2]
 
         new_note = [note[0], note[1], note_dur] + note[3:]
         
@@ -3936,9 +3947,13 @@ def fix_monophonic_score_durations(monophonic_score,
         nmt = monophonic_score[i+1][0]
 
         if note[0]+note[1] >= nmt:
-          note_dur = max(1, nmt-note[0]-min_notes_gap)
+            note_dur = max(1, nmt-note[0]-min_notes_gap)
         else:
-          note_dur = note[1]
+            if extend_durs:
+                note_dur = max(1, nmt-note[0]-min_notes_gap)
+
+            else:
+                note_dur = note[1]
           
         new_note = [note[0], note_dur] + note[2:]
         
@@ -3952,8 +3967,6 @@ def fix_monophonic_score_durations(monophonic_score,
 
 ###################################################################################
 
-from itertools import product
-
 ALL_CHORDS = [[0], [7], [5], [9], [2], [4], [11], [10], [8], [6], [3], [1], [0, 9], [2, 5],
               [4, 7], [7, 10], [2, 11], [0, 3], [6, 9], [1, 4], [8, 11], [5, 8], [1, 10],
               [3, 6], [0, 4], [5, 9], [7, 11], [0, 7], [0, 5], [2, 10], [2, 7], [2, 9],
@@ -7128,7 +7141,8 @@ def escore_notes_to_binary_matrix(escore_notes,
                                   channel=0, 
                                   patch=0,
                                   flip_matrix=False,
-                                  reverse_matrix=False
+                                  reverse_matrix=False,
+                                  encode_velocities=False
                                   ):
 
   escore = [e for e in escore_notes if e[3] == channel and e[6] == patch]
@@ -7152,14 +7166,17 @@ def escore_notes_to_binary_matrix(escore_notes,
         duration = max(1, duration)
         chan = max(0, min(15, chan))
         pitch = max(0, min(127, pitch))
-        velocity = max(0, min(127, velocity))
+        velocity = max(1, min(127, velocity))
         pat = max(0, min(128, pat))
 
         if channel == chan and patch == pat:
 
           for t in range(time, min(time + duration, time_range)):
-
-            escore_matrix[t][pitch] = 1
+            if encode_velocities:
+                escore_matrix[t][pitch] = velocity
+                
+            else:
+                escore_matrix[t][pitch] = 1
 
     if flip_matrix:
 
@@ -7183,7 +7200,8 @@ def escore_notes_to_binary_matrix(escore_notes,
 def binary_matrix_to_original_escore_notes(binary_matrix, 
                                            channel=0, 
                                            patch=0, 
-                                           velocity=-1
+                                           velocity=-1,
+                                           decode_velocities=False
                                            ):
 
   result = []
@@ -7222,8 +7240,11 @@ def binary_matrix_to_original_escore_notes(binary_matrix,
 
   for r in result:
     
-    if velocity == -1:
-      vel = max(40, r[2])
+    if velocity == -1 and not decode_velocities:
+        vel = max(40, r[2])
+        
+    if decode_velocities:
+        vel = r[3]
 
     original_escore_notes.append(['note', r[0], r[1], channel, r[2], vel, patch])
 
@@ -8048,7 +8069,7 @@ def solo_piano_escore_notes(escore_notes,
                             keep_drums=False,
                             ):
 
-  cscore = chordify_score([1000, escore_notes])
+  cscore = chordify_score([1000, copy.deepcopy(escore_notes)])
 
   sp_escore_notes = []
 
@@ -9720,7 +9741,14 @@ def escore_notes_to_text_description(escore_notes,
                                      song_name='', 
                                      artist_name='',
                                      timings_divider=16,
+                                     return_feat_dict=False,
+                                     return_feat_dict_vals=False
                                     ):
+    
+    #==============================================================================
+    
+    feat_dict = {}
+    feat_dict_vals = {}
 
     #==============================================================================
 
@@ -9734,6 +9762,9 @@ def escore_notes_to_text_description(escore_notes,
     
     elif song_time_min >= 2.5:
         song_length = 'long'
+        
+    feat_dict['song_len'] = song_length.capitalize()
+    feat_dict_vals['song_len'] = song_time_min
 
     #==============================================================================
 
@@ -9745,18 +9776,25 @@ def escore_notes_to_text_description(escore_notes,
         if len(escore_times) == len(set(escore_times)):
             comp_type = 'monophonic melody'
             ctype = 'melody'
+            ctv = 0
         
         elif len(escore_times) >= len(set(escore_times)) and 1 in Counter(escore_times).values():
             comp_type = 'melody and accompaniment'
             ctype = 'song'
+            ctv = 1
         
         elif len(escore_times) >= len(set(escore_times)) and 1 not in Counter(escore_times).values():
             comp_type = 'accompaniment'
             ctype = 'song'
+            ctv = 2
     
     else:
         comp_type = 'drum track'
         ctype = 'drum track'
+        ctv = 3
+        
+    feat_dict['song_type'] = comp_type.capitalize()
+    feat_dict_vals['song_type'] = ctv
 
     #==============================================================================
 
@@ -9771,6 +9809,13 @@ def escore_notes_to_text_description(escore_notes,
         nd_patches_counts = Counter([p for p in all_patches if p < 128]).most_common()
 
         dominant_instrument = alpha_str(Number2patch[nd_patches_counts[0][0]])
+        
+        feat_dict['most_com_instr'] = instruments
+        feat_dict_vals['most_com_instr'] = [p for p in patches if p < 128]
+        
+    else:
+        feat_dict['most_com_instr'] = None
+        feat_dict_vals['most_com_instr'] = []
 
     if 128 in patches:
         drums_present = True
@@ -9778,9 +9823,16 @@ def escore_notes_to_text_description(escore_notes,
         drums_pitches = [e[4] for e in escore_notes if e[3] == 9]
 
         most_common_drums = [alpha_str(Notenum2percussion[p[0]]) for p in Counter(drums_pitches).most_common(3) if p[0] in Notenum2percussion]
+        
+        feat_dict['most_com_drums'] = most_common_drums
+        feat_dict_vals['most_com_drums'] = [p[0] for p in Counter(drums_pitches).most_common(3)]
 
     else:
         drums_present = False
+        
+        feat_dict['most_com_drums'] = None
+        
+        feat_dict_vals['most_com_drums'] = []
 
     #==============================================================================
 
@@ -9790,60 +9842,111 @@ def escore_notes_to_text_description(escore_notes,
     
     if pitches:
         key = SEMITONES[statistics.mode(pitches) % 12]
+        
+        feat_dict['key'] = key.title()
+        feat_dict_vals['key'] = statistics.mode(pitches) % 12
+        
+    else:
+        feat_dict['key'] = None
+        feat_dict_vals['key'] = -1
 
     #==============================================================================
     
     scale = ''
     mood = ''
     
+    feat_dict['scale'] = None
+    feat_dict['mood'] = None
+    feat_dict_vals['scale'] = -1
+    feat_dict_vals['mood'] = -1
+    
     if pitches:
     
         result = escore_notes_scale(escore_notes)
         
         scale = result[0]
         mood = result[1].split(' ')[0].lower()
+        
+        feat_dict['scale'] = scale.title()
+        feat_dict['mood'] = mood.title()
+        
+        res = escore_notes_scale(escore_notes, return_scale_indexes=True)
+        feat_dict_vals['scale'] = res[0]            
+        feat_dict_vals['mood'] = res[1]
 
     #==============================================================================
-    
+        
+    feat_dict['rythm'] = None
+    feat_dict['tempo'] = None
+    feat_dict['tone'] = None
+    feat_dict['dynamics'] = None
+
+    feat_dict_vals['rythm'] = -1
+    feat_dict_vals['tempo'] = -1
+    feat_dict_vals['tone'] = -1
+    feat_dict_vals['dynamics'] = -1
+
     if pitches:
     
         escore_averages = escore_notes_averages(escore_notes, return_ptcs_and_vels=True)
 
         if escore_averages[0] < (128 / timings_divider):
             rythm = 'fast'
+            ryv = 0
         
         elif (128 / timings_divider) <= escore_averages[0] <= (192 / timings_divider):
             rythm = 'average'
+            ryv = 1
         
         elif escore_averages[0] > (192 / timings_divider):
             rythm = 'slow'
+            ryv = 2
         
         if escore_averages[1] < (256 / timings_divider):
             tempo = 'fast'
+            tev = 0
         
         elif (256 / timings_divider) <= escore_averages[1] <= (384 / timings_divider):
             tempo = 'average'
+            tev = 1
         
         elif escore_averages[1] > (384 / timings_divider):
             tempo = 'slow'
+            tev = 2
         
         if escore_averages[2] < 50:
             tone = 'bass'
+            tov = 0
         
         elif 50 <= escore_averages[2] <= 70:
             tone = 'midrange'
+            tov = 1
         
         elif escore_averages[2] > 70:
             tone = 'treble'
+            tov = 2
         
         if escore_averages[3] < 64:
             dynamics = 'quiet'
+            dyn = 0
         
         elif 64 <= escore_averages[3] <= 96:
             dynamics = 'average'
+            dyn = 1
         
         elif escore_averages[3] > 96:
             dynamics = 'loud'
+            dyn = 2
+            
+        feat_dict['rythm'] = rythm.title()
+        feat_dict['tempo'] = tempo.title()
+        feat_dict['tone'] = tone.title()
+        feat_dict['dynamics'] = dynamics.title()
+        
+        feat_dict_vals['rythm'] = ryv
+        feat_dict_vals['tempo'] = tev
+        feat_dict_vals['tone'] = tov
+        feat_dict_vals['dynamics'] = dyn
 
     #==============================================================================
             
@@ -9851,6 +9954,12 @@ def escore_notes_to_text_description(escore_notes,
  
     lead_melodies = []
     base_melodies = []
+    
+    feat_dict['lead_mono_mels'] = None
+    feat_dict['base_mono_mels'] = None
+    
+    feat_dict_vals['lead_mono_mels'] = []
+    feat_dict_vals['base_mono_mels'] = []
  
     if mono_melodies:
             
@@ -9860,15 +9969,19 @@ def escore_notes_to_text_description(escore_notes,
             
             if mel[0] in LEAD_INSTRUMENTS and escore_avgs[3] > 60:
                 lead_melodies.append([Number2patch[mel[0]], mel[1]])
+                feat_dict_vals['lead_mono_mels'].append(mel[0])
 
             elif mel[0] in BASE_INSTRUMENTS and escore_avgs[3] <= 60:
                 base_melodies.append([Number2patch[mel[0]], mel[1]])
+                feat_dict_vals['base_mono_mels'].append(mel[0])
     
         if lead_melodies:
             lead_melodies.sort(key=lambda x: x[1], reverse=True)
+            feat_dict['lead_mono_mels'] = lead_melodies
             
         if base_melodies:
             base_melodies.sort(key=lambda x: x[1], reverse=True)
+            feat_dict['base_mono_mels'] = base_melodies
 
     #==============================================================================
         
@@ -10055,8 +10168,20 @@ def escore_notes_to_text_description(escore_notes,
         description += '\n'
         
     #==============================================================================
-
-    return description
+        
+    final_feat_dict = []
+        
+    if return_feat_dict:
+        final_feat_dict.append(feat_dict)
+    
+    if return_feat_dict_vals:
+        final_feat_dict.append(feat_dict_vals)
+        
+    if return_feat_dict or return_feat_dict_vals:
+        return final_feat_dict
+    
+    else:
+        return description
 
 ###################################################################################
 
@@ -11288,7 +11413,7 @@ def multiprocessing_wrapper(function, data_list, verbose=True):
         
         results = []
         
-        for result in tqdm.tqdm(pool.imap_unordered(function, data_list),
+        for result in tqdm.tqdm(pool.imap(function, data_list),
                                 total=len(data_list),
                                 disable=not verbose
                                 ):
@@ -13604,6 +13729,1304 @@ PERCUSSION_GROUPS = {
 
 ###################################################################################
 
+def escore_notes_to_expanded_binary_matrix(escore_notes, 
+                                           channel=0, 
+                                           patch=0,
+                                           flip_matrix=False,
+                                           reverse_matrix=False,
+                                           encode_velocities=True
+                                          ):
+
+  escore = [e for e in escore_notes if e[3] == channel and e[6] == patch]
+
+  if escore:
+    last_time = escore[-1][1]
+    last_notes = [e for e in escore if e[1] == last_time]
+    max_last_dur = max([e[2] for e in last_notes])
+
+    time_range = last_time+max_last_dur
+
+    escore_matrix = []
+
+    escore_matrix = [[(0, 0)] * 128 for _ in range(time_range)]
+
+    for note in escore:
+
+        etype, time, duration, chan, pitch, velocity, pat = note
+
+        time = max(0, time)
+        duration = max(1, duration)
+        chan = max(0, min(15, chan))
+        pitch = max(0, min(127, pitch))
+        velocity = max(1, min(127, velocity))
+        pat = max(0, min(128, pat))
+
+        if channel == chan and patch == pat:
+
+          count = 0
+          
+          for t in range(time, min(time + duration, time_range)):
+            if encode_velocities:
+                escore_matrix[t][pitch] = velocity, count
+
+            else:
+                escore_matrix[t][pitch] = 1, count
+            count += 1
+
+    if flip_matrix:
+
+      temp_matrix = []
+
+      for m in escore_matrix:
+        temp_matrix.append(m[::-1])
+
+      escore_matrix = temp_matrix
+
+    if reverse_matrix:
+      escore_matrix = escore_matrix[::-1]
+
+    return escore_matrix
+
+  else:
+    return None
+
+###################################################################################
+
+def transpose_list(lst):
+    return [list(row) for row in zip(*lst)]
+
+###################################################################################
+
+def chunk_list(lst, size):
+    return [lst[i:i + size] for i in range(0, len(lst), size)]
+
+###################################################################################
+
+def flip_list_rows(lst):
+    return [row[::-1] for row in lst]
+
+###################################################################################
+
+def flip_list_columns(lst):
+    return lst[::-1]
+
+###################################################################################
+
+def exists(sub, lst):
+    sub_len = len(sub)
+    return any(lst[i:i + sub_len] == sub for i in range(len(lst) - sub_len + 1))
+
+###################################################################################
+
+def exists_noncontig(sub, lst):
+    it = iter(lst)
+    return all(x in it for x in sub)
+
+###################################################################################
+
+def exists_ratio(sub, lst, ratio):
+    matches = sum(x in set(lst) for x in sub)
+    return matches / len(sub) >= ratio
+    
+###################################################################################
+
+def top_k_list_value(lst, k, reverse=True):
+    return sorted(lst, reverse=reverse)[k]
+
+###################################################################################
+
+def top_k_list_values(lst, k, reverse=True):
+    return sorted(lst, reverse=reverse)[:k]
+
+###################################################################################
+
+def concat_rows(lst_A, lst_B):
+    return [a + b for a, b in zip(lst_A, lst_B)]
+
+###################################################################################
+
+def concat_cols(lst_A, lst_B):
+    return [[ra + rb for ra, rb in zip(a, b)] for a, b in zip(lst_A, lst_B)]
+
+###################################################################################
+
+def chunk_by_threshold_mode(nums, threshold=0, normalize=False):
+
+    if not nums:
+        return []
+
+    chunks = []
+    chunk = []
+    freq = defaultdict(int)
+    max_freq = 0
+    mode_val = None
+
+    def try_add_and_validate(value):
+
+        nonlocal max_freq, mode_val
+
+        chunk.append(value)
+        freq[value] += 1
+        new_max_freq = max_freq
+        candidate_mode = mode_val
+
+        if freq[value] > new_max_freq:
+            new_max_freq = freq[value]
+            candidate_mode = value
+
+        mode = candidate_mode
+        valid = True
+
+        for v in chunk:
+            if abs(v - mode) > threshold:
+                valid = False
+                break
+
+        if not valid:
+            
+            chunk.pop()
+            freq[value] -= 1
+            if freq[value] == 0:
+                del freq[value]
+                
+            return False
+
+        max_freq = new_max_freq
+        mode_val = mode
+        return True
+
+    for num in nums:
+        if not chunk:
+            chunk.append(num)
+            freq[num] = 1
+            mode_val = num
+            max_freq = 1
+            
+        else:
+            if not try_add_and_validate(num):
+                if normalize:
+                    normalized_chunk = [mode_val] * len(chunk)
+                    chunks.append(normalized_chunk)
+                
+                else:
+                    chunks.append(chunk[:])
+
+                chunk.clear()
+                freq.clear()
+                
+                chunk.append(num)
+                freq[num] = 1
+                mode_val = num
+                max_freq = 1
+
+    if chunk:
+        if normalize:
+            normalized_chunk = [mode_val] * len(chunk)
+            chunks.append(normalized_chunk)
+            
+        else:
+            chunks.append(chunk)
+
+    return chunks
+
+###################################################################################
+
+def proportional_adjust(values, target_sum, threshold):
+
+    n = len(values)
+    if n == 0:
+        return []
+
+    locked_idx = [i for i, v in enumerate(values) if v < threshold]
+    adj_idx    = [i for i in range(n) if i not in locked_idx]
+
+    locked_sum       = sum(values[i] for i in locked_idx)
+    adj_original_sum = sum(values[i] for i in adj_idx)
+    adj_target_sum   = target_sum - locked_sum
+
+    def _proportional_scale(idxs, original, target):
+
+        scaled_vals = {i: original[i] * (target / sum(original[i] for i in idxs))
+                       if sum(original[i] for i in idxs) > 0 else 0
+                       for i in idxs}
+        
+        floored = {i: math.floor(scaled_vals[i]) for i in idxs}
+        rem = target - sum(floored.values())
+
+        fracs = sorted(
+            ((scaled_vals[i] - floored[i], i) for i in idxs),
+            key=lambda x: (x[0], -x[1]),
+            reverse=True
+        )
+        
+        for _, idx in fracs[:rem]:
+            floored[idx] += 1
+            
+        result = original.copy()
+        
+        for i in idxs:
+            result[i] = floored[i]
+            
+        return result
+
+    if not adj_idx:
+        if locked_sum == target_sum:
+            return values.copy()
+
+        return _proportional_scale(locked_idx, values, target_sum)
+
+    if adj_target_sum < 0:
+        return _proportional_scale(range(n), values, target_sum)
+
+    if adj_original_sum == 0:
+        base = adj_target_sum // len(adj_idx)
+        rem  = adj_target_sum - base * len(adj_idx)
+        result = values.copy()
+        
+        for j, idx in enumerate(sorted(adj_idx)):
+            increment = base + (1 if j < rem else 0)
+            result[idx] = values[idx] + increment
+            
+        return result
+
+    result = values.copy()
+    scaled = {i: values[i] * (adj_target_sum / adj_original_sum) for i in adj_idx}
+    floored = {i: math.floor(scaled[i]) for i in adj_idx}
+    floor_sum = sum(floored.values())
+    rem = adj_target_sum - floor_sum
+
+    fracs = sorted(
+        ((scaled[i] - floored[i], i) for i in adj_idx),
+        key=lambda x: (x[0], -x[1]),
+        reverse=True
+    )
+    
+    for _, idx in fracs[:rem]:
+        floored[idx] += 1
+
+    for i in adj_idx:
+        result[i] = floored[i]
+
+    return result
+
+###################################################################################
+
+def advanced_align_escore_notes_to_bars(escore_notes, 
+                                        bar_dtime=200,
+                                        dtimes_adj_thresh=4,
+                                        min_dur_gap=0
+                                       ):
+
+    #========================================================
+
+    escore_notes = recalculate_score_timings(escore_notes)
+
+    cscore = chordify_score([1000, escore_notes])
+
+    #========================================================
+
+    dtimes = [0] + [min(199, b[1]-a[1]) for a, b in zip(escore_notes[:-1], escore_notes[1:]) if b[1]-a[1] != 0]
+
+    score_times = sorted(set([e[1] for e in escore_notes]))
+
+    #========================================================
+
+    dtimes_chunks = []
+    
+    time = 0
+    dtime = []
+    
+    for i, dt in enumerate(dtimes):
+        time += dt
+        dtime.append(dt)
+
+        if time >= bar_dtime:
+            dtimes_chunks.append(dtime)
+            
+            time = 0
+            dtime = []
+    
+    dtimes_chunks.append(dtime)
+
+    #========================================================
+
+    fixed_times = []
+    
+    time = 0
+    
+    for i, dt in enumerate(dtimes_chunks):
+    
+        adj_dt = proportional_adjust(dt, 
+                                     bar_dtime, 
+                                     dtimes_adj_thresh
+                                    )
+    
+        for t in adj_dt:
+    
+            time += t
+    
+            fixed_times.append(time)
+
+    #========================================================
+
+    output_score = []
+    
+    for i, c in enumerate(cscore):
+        
+        cc = copy.deepcopy(c)
+        time = fixed_times[i]
+    
+        for e in cc:
+            e[1] = time
+    
+            output_score.append(e)
+
+    #========================================================
+
+    output_score = fix_escore_notes_durations(output_score, 
+                                              min_notes_gap=min_dur_gap
+                                             )
+
+    #========================================================
+
+    return output_score
+
+###################################################################################
+
+def check_monophonic_melody(escore_notes, 
+                            times_idx=1, 
+                            durs_idx=2
+                           ):
+
+    bcount = 0
+    
+    for i in range(len(escore_notes)-1):
+        if escore_notes[i][times_idx]+escore_notes[i][durs_idx] > escore_notes[i+1][times_idx]:
+            bcount += 1
+
+    return bcount / len(escore_notes)
+
+###################################################################################
+
+def longest_common_chunk(list1, list2):
+    
+    base, mod = 257, 10**9 + 7
+    max_len = min(len(list1), len(list2))
+    
+    def get_hashes(seq, size):
+
+        h, power = 0, 1
+        hashes = set()
+        
+        for i in range(size):
+            h = (h * base + seq[i]) % mod
+            power = (power * base) % mod
+            
+        hashes.add(h)
+        
+        for i in range(size, len(seq)):
+            h = (h * base - seq[i - size] * power + seq[i]) % mod
+            hashes.add(h)
+            
+        return hashes
+
+    def find_match(size):
+
+        hashes2 = get_hashes(list2, size)
+        h, power = 0, 1
+        
+        for i in range(size):
+            h = (h * base + list1[i]) % mod
+            power = (power * base) % mod
+            
+        if h in hashes2:
+            return list1[:size]
+            
+        for i in range(size, len(list1)):
+            h = (h * base - list1[i - size] * power + list1[i]) % mod
+            if h in hashes2:
+                return list1[i - size + 1:i + 1]
+                
+        return []
+
+    left, right = 0, max_len
+    result = []
+    
+    while left <= right:
+        mid = (left + right) // 2
+        chunk = find_match(mid)
+        
+        if chunk:
+            result = chunk
+            left = mid + 1
+        else:
+            
+            right = mid - 1
+            
+    return result
+
+###################################################################################
+
+def detect_plateaus(data, min_len=2, tol=0.0):
+
+    plateaus = []
+    n = len(data)
+    if n < min_len:
+        return plateaus
+
+    min_deque = deque()
+    max_deque = deque()
+
+    start = 0
+    idx = 0
+
+    while idx < n:
+        v = data[idx]
+
+        if not isinstance(v, (int, float)) or math.isnan(v):
+
+            if idx - start >= min_len:
+                plateaus.append(data[start:idx])
+
+            idx += 1
+            start = idx
+            min_deque.clear()
+            max_deque.clear()
+            
+            continue
+
+        while max_deque and data[max_deque[-1]] <= v:
+            max_deque.pop()
+            
+        max_deque.append(idx)
+
+        while min_deque and data[min_deque[-1]] >= v:
+            min_deque.pop()
+            
+        min_deque.append(idx)
+
+        if data[max_deque[0]] - data[min_deque[0]] > tol:
+
+            if idx - start >= min_len:
+                plateaus.append(data[start:idx])
+
+            start = idx
+            
+            min_deque.clear()
+            max_deque.clear()
+
+            max_deque.append(idx)
+            min_deque.append(idx)
+
+        idx += 1
+
+    if n - start >= min_len:
+        plateaus.append(data[start:n])
+
+    return plateaus
+
+###################################################################################
+
+def alpha_str_to_toks(s, shift=0, add_seos=False):
+
+    tokens = []
+
+    if add_seos:
+        tokens = [53+shift]
+    
+    for char in s:
+        if char == ' ':
+            tokens.append(52+shift)
+            
+        elif char.isalpha():
+            base = 0 if char.isupper() else 26
+            offset = ord(char.upper()) - ord('A')
+            token = (base + offset + shift) % 52  # wrap A–Z/a–z
+            tokens.append(token)
+            
+    if add_seos:       
+        tokens.append(53+shift)
+        
+    return tokens
+
+###################################################################################
+
+def toks_to_alpha_str(tokens, shift=0, sep=''):
+
+    chars = []
+    
+    for token in tokens:
+        if token == 53+shift:
+            continue
+            
+        elif token == 52+shift:
+            chars.append(' ')
+            
+        elif 0 <= token <= 25:
+            original = (token - shift) % 52
+            chars.append(chr(ord('A') + original))
+            
+        elif 26 <= token <= 51:
+            original = (token - shift) % 52
+            chars.append(chr(ord('a') + (original - 26)))
+
+    return sep.join(chars)
+
+###################################################################################
+
+def insert_caps_newlines(text):
+
+    if bool(re.search(r'\b[A-Z][a-z]+\b', text)):
+        pattern = re.compile(r'\s+(?=[A-Z])')
+
+        return pattern.sub('\n', text)
+
+###################################################################################
+
+def insert_newlines(text, every=4):
+
+    count = 0
+    result = []
+
+    for char in text:
+        result.append(char)
+        
+        if char == '\n':
+            count += 1
+            
+            if count % every == 0:
+                result.append('\n')
+
+    return ''.join(result)
+
+###################################################################################
+
+def symmetric_match_ratio(list_a, list_b, threshold=0):
+
+    a_sorted = sorted(list_a)
+    b_sorted = sorted(list_b)
+
+    i, j = 0, 0
+    matches = 0
+    
+    used_a = set()
+    used_b = set()
+
+    while i < len(a_sorted) and j < len(b_sorted):
+        diff = abs(a_sorted[i] - b_sorted[j])
+        
+        if diff <= threshold:
+            matches += 1
+            used_a.add(i)
+            used_b.add(j)
+            i += 1
+            j += 1
+            
+        elif a_sorted[i] < b_sorted[j]:
+            i += 1
+            
+        else:
+            j += 1
+
+    avg_len = (len(list_a) + len(list_b)) / 2
+    
+    return matches / avg_len if avg_len > 0 else 0.0
+
+###################################################################################
+
+def escore_notes_to_chords(escore_notes, 
+                           use_full_chords=False,
+                           repair_bad_chords=True,
+                           skip_pitches=False,
+                           convert_pitches=True,
+                           shift_chords=False,
+                           return_tones_chords=False
+                          ):
+
+    if use_full_chords:
+        CHORDS = ALL_CHORDS_FULL
+
+    else:
+        CHORDS = ALL_CHORDS_SORTED
+
+    sp_score = solo_piano_escore_notes(escore_notes)
+
+    cscore = chordify_score([1000, sp_score])
+
+    chords = []
+
+    for c in cscore:
+        pitches = sorted(set([e[4] for e in c]))
+
+        tones_chord = sorted(set([p % 12 for p in pitches]))
+
+        if repair_bad_chords:
+            if tones_chord not in CHORDS:
+                tones_chord = check_and_fix_tones_chord(tones_chord, 
+                                                        use_full_chords=use_full_chords
+                                                       )
+            
+        if return_tones_chords:
+            if convert_pitches:
+                chords.append(tones_chord)
+
+            else:
+                if len(pitches) > 1:
+                    chords.append(tones_chord)
+
+                else:
+                    chords.append([-pitches[0]])
+                    
+        else:
+            if skip_pitches:
+                if tones_chord in CHORDS:
+                    cho_tok = CHORDS.index(tones_chord)
+
+                else:
+                    cho_tok = -1
+
+                if len(pitches) > 1:
+                    chords.append(cho_tok)
+
+            else:
+                if tones_chord in CHORDS:
+                    cho_tok = CHORDS.index(tones_chord)
+
+                else:
+                    cho_tok = -1
+
+                if cho_tok != -1:
+                    if convert_pitches:
+                        if shift_chords:
+                            if len(pitches) > 1:
+                                chords.append(cho_tok+12)
+        
+                            else:
+                                chords.append(pitches[0] % 12)
+                                
+                        else:
+                            chords.append(cho_tok)
+        
+                    else:
+                        if len(pitches) > 1:
+                            chords.append(cho_tok+128)
+        
+                        else:
+                            chords.append(pitches[0])
+
+    return chords
+
+###################################################################################
+
+def replace_chords_in_escore_notes(escore_notes,
+                                   chords_list=[-1],
+                                   use_full_chords=False,
+                                   use_shifted_chords=False
+                                  ):
+
+    if use_full_chords:
+        CHORDS = ALL_CHORDS_FULL
+
+    else:
+        CHORDS = ALL_CHORDS_SORTED
+
+    if use_shifted_chords:
+        shift = 12
+
+    else:
+        shift = 0
+
+    if min(chords_list) >= 0 and max(chords_list) <= len(CHORDS)+shift:
+
+        chords_list_iter = cycle(chords_list)
+
+        nd_score = [e for e in escore_notes if e[3] != 9]
+        d_score = [e for e in escore_notes if e[3] == 9]
+    
+        cscore = chordify_score([1000, nd_score])
+    
+        new_score = []
+    
+        for i, c in enumerate(cscore):
+
+            cur_chord = next(chords_list_iter)
+    
+            cc = copy.deepcopy(c)
+    
+            if use_shifted_chords:
+                if cur_chord < 12:
+                    sub_tones_chord = [cur_chord]
+    
+                else:
+                    sub_tones_chord = CHORDS[cur_chord-12]
+            else:
+                sub_tones_chord = CHORDS[cur_chord]
+                
+            stcho = cycle(sub_tones_chord)
+
+            if len(sub_tones_chord) > len(c):
+                cc = [copy.deepcopy(e) for e in cc for _ in range(len(sub_tones_chord))]
+                
+            pseen = []
+    
+            for e in cc:
+                st = next(stcho)
+                new_pitch = ((e[4] // 12) * 12) + st
+
+                if [new_pitch, e[6]] not in pseen:
+                    e[4] = new_pitch
+                    
+                    new_score.append(e)
+                    pseen.append([new_pitch, e[6]])
+                    
+        final_score = sorted(new_score+d_score, key=lambda x: x[1])
+
+        return final_score
+
+    else:
+        return []
+
+###################################################################################
+
+class Cell:
+    def __init__(self, cost, segments, gaps, prev_dir):
+        self.cost = cost
+        self.segments = segments
+        self.gaps = gaps
+        self.prev_dir = prev_dir
+
+def align_integer_lists(seq1, seq2):
+
+    n, m = len(seq1), len(seq2)
+    
+    if n == 0:
+        return [None]*m, seq2.copy(), sum(abs(x) for x in seq2)
+    if m == 0:
+        return seq1.copy(), [None]*n, sum(abs(x) for x in seq1)
+
+    priority = {'diag': 0, 'up': 1, 'left': 2}
+
+    dp = [
+        [Cell(cost=math.inf, segments=math.inf, gaps=math.inf, prev_dir='') for _ in range(m+1)]
+        for _ in range(n+1)
+    ]
+    dp[0][0] = Cell(cost=0, segments=0, gaps=0, prev_dir='')
+
+    for i in range(1, n+1):
+        prev = dp[i-1][0]
+        new_cost = prev.cost + abs(seq1[i-1])
+        new_seg  = prev.segments + (1 if prev.prev_dir != 'up' else 0)
+        new_gaps = prev.gaps + 1
+        dp[i][0]  = Cell(new_cost, new_seg, new_gaps, 'up')
+
+    for j in range(1, m+1):
+        prev = dp[0][j-1]
+        new_cost = prev.cost + abs(seq2[j-1])
+        new_seg  = prev.segments + (1 if prev.prev_dir != 'left' else 0)
+        new_gaps = prev.gaps + 1
+        dp[0][j] = Cell(new_cost, new_seg, new_gaps, 'left')
+
+    for i in range(1, n+1):
+        for j in range(1, m+1):
+            a, b = seq1[i-1], seq2[j-1]
+
+            c0 = dp[i-1][j-1]
+            cand_diag = Cell(
+                cost     = c0.cost + abs(a - b),
+                segments = c0.segments,
+                gaps     = c0.gaps,
+                prev_dir = 'diag'
+            )
+
+            c1 = dp[i-1][j]
+            seg1 = c1.segments + (1 if c1.prev_dir != 'up' else 0)
+            cand_up = Cell(
+                cost     = c1.cost + abs(a),
+                segments = seg1,
+                gaps     = c1.gaps + 1,
+                prev_dir = 'up'
+            )
+
+            c2 = dp[i][j-1]
+            seg2 = c2.segments + (1 if c2.prev_dir != 'left' else 0)
+            cand_left = Cell(
+                cost     = c2.cost + abs(b),
+                segments = seg2,
+                gaps     = c2.gaps + 1,
+                prev_dir = 'left'
+            )
+
+            best = min(
+                (cand_diag, cand_up, cand_left),
+                key=lambda c: (c.cost, c.segments, c.gaps, priority[c.prev_dir])
+            )
+            dp[i][j] = best
+
+    aligned1 = []
+    aligned2 = []
+    i, j = n, m
+    
+    while i > 0 or j > 0:
+        cell = dp[i][j]
+        
+        if cell.prev_dir == 'diag':
+            aligned1.append(seq1[i-1])
+            aligned2.append(seq2[j-1])
+            i, j = i-1, j-1
+            
+        elif cell.prev_dir == 'up':
+            aligned1.append(seq1[i-1])
+            aligned2.append(None)
+            i -= 1
+            
+        else:
+            aligned1.append(None)
+            aligned2.append(seq2[j-1])
+            j -= 1
+
+    aligned1.reverse()
+    aligned2.reverse()
+    
+    total_cost = int(dp[n][m].cost)
+    
+    return aligned1, aligned2, total_cost
+
+###################################################################################
+
+def most_common_delta_time(escore_notes):
+    
+    dscore = delta_score_notes(escore_notes)
+    
+    dtimes = [t[1] for t in dscore if t[1] != 0]
+    
+    cdtime, count = Counter(dtimes).most_common(1)[0]
+
+    return [cdtime, count / len(dtimes)]
+
+###################################################################################
+
+def delta_tones(escore_notes, 
+                ptcs_idx=4
+               ):
+    
+    pitches = [p[ptcs_idx] for p in escore_notes]
+    tones = [p % 12 for p in pitches]
+
+    return [b-a for a, b in zip(tones[:-1], tones[1:])]
+    
+###################################################################################
+
+def find_divisors(val, 
+                  reverse=False
+                 ):
+  
+    if val == 0:
+        return []
+
+    n = abs(val)
+    divisors = set()
+
+    for i in range(1, int(n**0.5) + 1):
+        if n % i == 0:
+            divisors.add(i)
+            divisors.add(n // i)
+
+    return sorted(divisors, reverse=reverse)
+
+###################################################################################
+
+def find_common_divisors(values, 
+                         reverse=False
+                        ):
+   
+    if not values:
+        return []
+
+    non_zero = [abs(v) for v in values if v != 0]
+    if not non_zero:
+        return []
+
+    overall_gcd = reduce(gcd, non_zero)
+
+    divisors = set()
+    
+    for i in range(1, int(overall_gcd**0.5) + 1):
+        if overall_gcd % i == 0:
+            divisors.add(i)
+            divisors.add(overall_gcd // i)
+
+    return sorted(divisors, reverse=reverse)
+
+###################################################################################
+
+def strings_dict(list_of_strings, 
+                 verbose=False
+                ):
+
+    str_set = set()
+    
+    for st in tqdm.tqdm(list_of_strings, disable=not verbose):
+        for cha in st:
+            str_set.add(cha)
+
+    str_lst = sorted(str_set)
+
+    str_dic = dict(zip(str_lst, range(len(str_lst))))
+    rev_str_dic = {v: k for k, v in str_dic.items()}
+
+    return str_dic, rev_str_dic
+
+###################################################################################
+
+def chords_common_tones_chain(chords, 
+                              use_full_chords=False
+                             ):
+
+    if use_full_chords:
+        CHORDS = ALL_CHORDS_FULL
+
+    else:
+        CHORDS = ALL_CHORDS_SORTED
+
+    tones_chords = [CHORDS[c] for c in chords if 0 <= c < len(CHORDS)]
+
+    n = len(tones_chords)
+    
+    if not tones_chords:
+        return []
+        
+    if n < 2:
+        return tones_chords
+
+    result = []
+
+    for i in range(n):
+        if i == 0:
+            common = set(tones_chords[0]) & set(tones_chords[1])
+            
+        elif i == n - 1:
+            common = set(tones_chords[n - 2]) & set(tones_chords[n - 1])
+            
+        else:
+            common = set(tones_chords[i - 1]) & set(tones_chords[i]) & set(tones_chords[i + 1])
+
+        result.append(min(common) if common else -1)
+
+    return result
+
+###################################################################################
+
+def tones_chord_to_int(tones_chord, 
+                       reverse_bits=True
+                      ):
+
+    cbits = tones_chord_to_bits(tones_chord, 
+                                reverse=reverse_bits
+                               )
+
+    cint = bits_to_int(cbits)
+    
+    return cint
+
+###################################################################################
+
+def int_to_tones_chord(integer, 
+                       reverse_bits=True
+                      ):
+
+    integer = integer % 4096
+
+    cbits = int_to_bits(integer)
+
+    if reverse_bits:
+        cbits.reverse()
+
+    tones_chord = bits_to_tones_chord(cbits)
+
+    return tones_chord
+
+###################################################################################
+
+def fix_bad_chords_in_escore_notes(escore_notes,
+                                   use_full_chords=False,
+                                   return_bad_chords_count=False
+                                  ):
+
+    if use_full_chords:
+        CHORDS = ALL_CHORDS_FULL
+
+    else:
+        CHORDS = ALL_CHORDS_SORTED
+
+    bcount = 0
+
+    if escore_notes:
+
+        chords = chordify_score([1000, escore_notes])
+
+        fixed_chords = []
+    
+        for c in chords:
+            c.sort(key=lambda x: x[3])
+    
+            if len(c) > 1:
+    
+                groups = groupby(c, key=lambda x: x[3])
+        
+                for cha, gr in groups:
+
+                    if cha != 9:
+    
+                        gr = list(gr)
+                        
+                        tones_chord = sorted(set([p[4] % 12 for p in gr]))
+            
+                        if tones_chord not in CHORDS:
+                            tones_chord = check_and_fix_tones_chord(tones_chord, 
+                                                                    use_full_chords=use_full_chords
+                                                                   )
+                    
+                            bcount += 1
+            
+                        ngr = []
+                        
+                        for n in gr:
+                            if n[4] % 12 in tones_chord:
+                                ngr.append(n)
+            
+                        fixed_chords.extend(ngr)
+
+                    else:
+                        fixed_chords.extend(gr)
+                        
+    
+            else:
+                fixed_chords.extend(c)
+                
+        fixed_chords.sort(key=lambda x: (x[1], -x[4]))
+
+        if return_bad_chords_count:
+            return fixed_chords, bcount
+
+        else:
+            return fixed_chords
+            
+    else:
+        if return_bad_chords_count:
+            return escore_notes, bcount
+
+        else:
+            return escore_notes
+        
+###################################################################################
+        
+def remove_events_from_escore_notes(escore_notes,
+                                    ele_idx=2,
+                                    ele_vals=[1],
+                                    chan_idx=3,
+                                    skip_drums=True
+                                    ):
+
+    new_escore_notes = []
+    
+    for e in escore_notes:
+        if skip_drums:
+            if e[ele_idx] not in ele_vals or e[chan_idx] == 9:
+                new_escore_notes.append(e)
+
+        else:
+            if e[ele_idx] not in ele_vals:
+                new_escore_notes.append(e)
+
+    return new_escore_notes
+        
+###################################################################################
+
+def flatten_spikes(arr):
+    
+    if len(arr) < 3:
+        return arr[:]
+
+    result = arr[:]
+    
+    for i in range(1, len(arr) - 1):
+        prev, curr, next_ = arr[i - 1], arr[i], arr[i + 1]
+
+        if (prev <= next_ and (curr > prev and curr > next_)) or \
+           (prev >= next_ and (curr < prev and curr < next_)):
+            result[i] = max(min(prev, next_), min(max(prev, next_), curr))
+            
+    return result
+        
+###################################################################################
+
+def flatten_spikes_advanced(arr, window=1):
+    
+    if len(arr) < 3:
+        return arr[:]
+
+    result = arr[:]
+    n = len(arr)
+
+    def is_spike(i):
+        left = arr[i - window:i]
+        right = arr[i + 1:i + 1 + window]
+        
+        if not left or not right:
+            return False
+
+        avg_left = sum(left) / len(left)
+        avg_right = sum(right) / len(right)
+
+        if arr[i] > avg_left and arr[i] > avg_right:
+            return True
+
+        if arr[i] < avg_left and arr[i] < avg_right:
+            return True
+        
+        return False
+
+    for i in range(window, n - window):
+        if is_spike(i):
+            neighbors = arr[i - window:i] + arr[i + 1:i + 1 + window]
+            result[i] = int(sorted(neighbors)[len(neighbors) // 2])
+
+    return result
+        
+###################################################################################
+
+def add_smooth_melody_to_enhanced_score_notes(escore_notes,
+                                              melody_channel=3,
+                                              melody_patch=40,
+                                              melody_start_chord=0,
+                                              min_notes_gap=0,
+                                              exclude_durs=[1],
+                                              adv_flattening=True,
+                                              extend_durs=True,
+                                              max_mel_vels=127,
+                                              max_acc_vels=80,
+                                              return_melody=False
+                                             ):
+
+    escore_notes1 = remove_duplicate_pitches_from_escore_notes(escore_notes)
+    
+    escore_notes2 = fix_escore_notes_durations(escore_notes1, 
+                                               min_notes_gap=min_notes_gap
+                                              )
+    
+    escore_notes3 = fix_bad_chords_in_escore_notes(escore_notes2)
+    
+    escore_notes4 = remove_events_from_escore_notes(escore_notes3, 
+                                                    ele_vals=exclude_durs
+                                                   )
+    
+    escore_notes5 = add_expressive_melody_to_enhanced_score_notes(escore_notes4,
+                                                                  melody_channel=melody_channel, 
+                                                                  melody_patch=melody_patch, 
+                                                                  melody_start_chord=melody_start_chord,
+                                                                  return_melody=True,
+                                                                 )
+    
+    mel_score = remove_events_from_escore_notes(escore_notes5,
+                                                ele_vals=exclude_durs
+                                               )
+    
+    pitches = [p[4] for p in mel_score]
+    
+    if adv_flattening:
+        res = flatten_spikes_advanced(pitches)
+
+    else:
+        res = flatten_spikes(pitches)
+    
+    mel_score3 = copy.deepcopy(mel_score)
+    
+    for i, e in enumerate(mel_score3):
+        e[4] = res[i]
+    
+    mel_score3 = fix_monophonic_score_durations(merge_melody_notes(mel_score3),
+                                                extend_durs=extend_durs
+                                               )
+
+    adjust_score_velocities(mel_score3, max_mel_vels)
+    adjust_score_velocities(escore_notes4, max_acc_vels)
+
+    if return_melody:
+        return sorted(mel_score3, key=lambda x: (x[1], -x[4]))
+
+    else:
+        return sorted(mel_score3 + escore_notes4, key=lambda x: (x[1], -x[4]))
+    
+###################################################################################
+
+def sorted_chords_to_full_chords(chords):
+
+    cchords = []
+    
+    for c in chords:
+        tones_chord = ALL_CHORDS_SORTED[c]
+
+        if tones_chord not in ALL_CHORDS_FULL:
+            tones_chord = check_and_fix_tones_chord(tones_chord)
+
+        cchords.append(ALL_CHORDS_FULL.index(tones_chord))
+
+    return cchords
+
+###################################################################################
+
+def full_chords_to_sorted_chords(chords):
+
+    cchords = []
+    
+    for c in chords:
+        tones_chord = ALL_CHORDS_FULL[c]
+
+        if tones_chord not in ALL_CHORDS_SORTED:
+            tones_chord = check_and_fix_tones_chord(tones_chord, use_full_chords=False)
+
+        cchords.append(ALL_CHORDS_SORTED.index(tones_chord))
+
+    return cchords
+
+###################################################################################
+
+def chords_to_escore_notes(chords,
+                           use_full_chords=False,
+                           chords_dtime=500,
+                           add_melody=True,
+                           add_texture=True,
+                          ):
+
+    if use_full_chords:
+        CHORDS = ALL_CHORDS_FULL
+
+    else:
+        CHORDS = ALL_CHORDS_SORTED
+
+    score = []
+
+    dtime = 0
+
+    dur = chords_dtime
+
+    for c in chords:
+
+        if add_melody:
+            score.append(['note', dtime, dur, 3, CHORDS[c][0]+72, 115+CHORDS[c][0], 40])
+
+        for cc in CHORDS[c]:
+            score.append(['note', dtime, dur, 0, cc+48, 30+cc+48, 0])
+
+            if random.randint(0, 1) and add_texture:
+                score.append(['note', dtime, dur, 0, cc+60, 20+cc+60, 0])    
+            
+        dtime += chords_dtime
+
+    return score
+
+###################################################################################
+
 print('Module loaded!')
 print('=' * 70)
 print('Enjoy! :)')