Upload TMIDIX.py

TMIDIX.py

@@ -51,7 +51,7 @@ r'''############################################################################
 
 ###################################################################################
 
-__version__ = "25.8.22"
+__version__ = "25.8.27"
 
 print('=' * 70)
 print('TMIDIX Python module')
@@ -1485,10 +1485,12 @@ import multiprocessing
 
 from itertools import zip_longest
 from itertools import groupby
+from itertools import cycle
 
 from collections import Counter
 from collections import defaultdict
 from collections import OrderedDict
+from collections import deque
 
 from operator import itemgetter
 
@@ -8056,7 +8058,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 = []
 
@@ -11400,7 +11402,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
                                 ):
@@ -14057,6 +14059,380 @@ def advanced_align_escore_notes_to_bars(escore_notes,
 
 ###################################################################################
 
+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,
+                           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 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:
+            cho_tok = CHORDS.index(tones_chord)
+            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 []
+
+###################################################################################
+
 print('Module loaded!')
 print('=' * 70)
 print('Enjoy! :)')